IOC容器

public interface BeanFactory { /** * 用于取消引用FactoryBean实例并将其与FactoryBean创建的bean区别开来。 例如，如果名为myJndiObject的bean是FactoryBean，则获取&myJndiObject将返回工厂，而不是工厂返回的实例。 */ String FACTORY_BEAN_PREFIX = "&"; /** * 返回一个实例，该实例可以是指定bean的共享或独立的。 * 此方法允许使用Spring BeanFactory替代Singleton或Prototype设计模式。 对于Singleton bean，调用者可以保留对返回对象的引用。 * 将别名转换回相应的规范bean名称。 将询问父工厂是否在该工厂实例中找不到该bean。 */ Object getBean(String name) throws BeansException; /** * 返回一个实例，该实例可以是指定bean的共享或独立的。 */ <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException; /** * 返回一个实例，该实例可以是指定bean的共享或独立的。 * 允许指定显式构造函数自变量/工厂方法自变量，并覆盖Bean定义中指定的默认自变量（如果有）。 */ Object getBean(String name, Object... args) throws BeansException; <T> T getBean(Class<T> requiredType) throws BeansException; <T> T getBean(Class<T> requiredType, Object... args) throws BeansException; // 判断是否包含指定的bean类型 boolean containsBean(String name); /** 检查是否是单例 */ boolean isSingleton(String name) throws NoSuchBeanDefinitionException; /** * 这个Bean是原型吗？ 也就是说， getBean将始终返回独立的实例吗？ * 注意：此方法返回false不能清楚地表明一个单例对象。 它指示非独立实例，该实例也可能对应于作用域Bean。 使用isSingleton操作来显式检查共享的单例实例。 */ boolean isPrototype(String name) throws NoSuchBeanDefinitionException; /** * 检查具有给定名称的Bean是否与指定的类型匹配。 更具体地说，检查对给定名称的getBean调用是否会返回可分配给指定目标类型的对象。 * 将别名转换回相应的规范bean名称。 将询问父工厂是否在该工厂实例中找不到该bean。 * */ boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException; /** * 检查具有给定名称的Bean是否与指定的类型匹配。 更具体地说，检查对给定名称的getBean调用是否会返回可分配给指定目标类型的对象。 * 将别名转换回相应的规范bean名称。 将询问父工厂是否在该工厂实例中找不到该bean。 * */ boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException; // 获取Bean的类型 @Nullable Class<?> getType(String name) throws NoSuchBeanDefinitionException; // 获取别名 String[] getAliases(String name); }

@Override public Resource getResource(String location) { Assert.notNull(location, "Location must not be null"); // 可以用预先添加好的协议处理 for (ProtocolResolver protocolResolver : this.protocolResolvers) { Resource resource = protocolResolver.resolve(location, this); if (resource != null) { return resource; } } // 如果类路径的方式，呢需要使用ClassPathResource来得到bean文件的资源对象。 if (location.startsWith("/")) { return getResourceByPath(location); } else if (location.startsWith(CLASSPATH_URL_PREFIX)) { return new ClassPathResource(location.substring(CLASSPATH_URL_PREFIX.length()), getClassLoader()); } else { try { // Try to parse the location as a URL... // 如果为URL方式，使用URLResource作为bean文件的资源对象 URL url = new URL(location); return (ResourceUtils.isFileURL(url) ? new FileUrlResource(url) : new UrlResource(url)); } catch (MalformedURLException ex) { // No URL -> resolve as resource path. // 如果既不是classpath标识，又不是URL表示的resource定位，则调用 // 容器本身的getResourceByPath方法获取Resource return getResourceByPath(location); } } }

@Override public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException { // 将读入的xml资源进行特殊编码处理 return loadBeanDefinitions(new EncodedResource(resource)); } public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException { Assert.notNull(encodedResource, "EncodedResource must not be null"); if (logger.isInfoEnabled()) { logger.info("Loading XML bean definitions from " + encodedResource.getResource()); } Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get(); if (currentResources == null) { currentResources = new HashSet<>(4); this.resourcesCurrentlyBeingLoaded.set(currentResources); } if (!currentResources.add(encodedResource)) { throw new BeanDefinitionStoreException( "Detected cyclic loading of " + encodedResource + " - check your import definitions!"); } try { // 将资源文件转为inputStream的IO流 InputStream inputStream = encodedResource.getResource().getInputStream(); try { // 从InputStream中得到Xml的解析源 InputSource inputSource = new InputSource(inputStream); if (encodedResource.getEncoding() != null) { inputSource.setEncoding(encodedResource.getEncoding()); } // 这里是读取过程 return doLoadBeanDefinitions(inputSource, encodedResource.getResource()); } finally { // 关闭从Resource中得到的IO流 inputStream.close(); } } catch (IOException ex) { throw new BeanDefinitionStoreException( "IOException parsing XML document from " + encodedResource.getResource(), ex); } finally { currentResources.remove(encodedResource); if (currentResources.isEmpty()) { this.resourcesCurrentlyBeingLoaded.remove(); } } } // 从特定的xml文件中实际载入bean配置资源的方法 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException { try { // 将XML文件转换为DOM对象，解析过程由documentLoader实现 Document doc = doLoadDocument(inputSource, resource); // 这里是启动对Bean定义解析的详细过程，该解析过程会用到Spring的Bean配置规则。 return registerBeanDefinitions(doc, resource); } catch (BeanDefinitionStoreException ex) { throw ex; } catch (SAXParseException ex) { throw new XmlBeanDefinitionStoreException(resource.getDescription(), "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex); } catch (SAXException ex) { throw new XmlBeanDefinitionStoreException(resource.getDescription(), "XML document from " + resource + " is invalid", ex); } catch (ParserConfigurationException ex) { throw new BeanDefinitionStoreException(resource.getDescription(), "Parser configuration exception parsing XML from " + resource, ex); } catch (IOException ex) { throw new BeanDefinitionStoreException(resource.getDescription(), "IOException parsing XML document from " + resource, ex); } catch (Throwable ex) { throw new BeanDefinitionStoreException(resource.getDescription(), "Unexpected exception parsing XML document from " + resource, ex); } }

@Override public Document loadDocument(InputSource inputSource, EntityResolver entityResolver, ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception { // 创建文件解析器工厂 DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware); if (logger.isDebugEnabled()) { logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]"); } // 创建文档解析器 DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler); // 解析Spring的Bean配置资源 return builder.parse(inputSource); } protected DocumentBuilderFactory createDocumentBuilderFactory(int validationMode, boolean namespaceAware) throws ParserConfigurationException { // 创建文档解析工厂 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(namespaceAware); // 设置解析XML的校验 if (validationMode != XmlValidationModeDetector.VALIDATION_NONE) { factory.setValidating(true); if (validationMode == XmlValidationModeDetector.VALIDATION_XSD) { // Enforce namespace aware for XSD... factory.setNamespaceAware(true); try { factory.setAttribute(SCHEMA_LANGUAGE_ATTRIBUTE, XSD_SCHEMA_LANGUAGE); } catch (IllegalArgumentException ex) { ParserConfigurationException pcex = new ParserConfigurationException( "Unable to validate using XSD: Your JAXP provider [" + factory + "] does not support XML Schema. Are you running on Java 1.4 with Apache Crimson? " + "Upgrade to Apache Xerces (or Java 1.5) for full XSD support."); pcex.initCause(ex); throw pcex; } } } return factory; }

// 按照Spring 的Bean语义要求将Bean配置资源解析并转换为容器内部数据结构 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 得到BeanDefinitionDocumentReader来对xml格式的BeanDefinition解析 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); // 获取容器中注册的Bean数量 int countBefore = getRegistry().getBeanDefinitionCount(); // 解析过程入口，这里使用委派模式，BeanDefinitionDocumentReader只是个接口 // 具体的解析实现过程实现类DefaultBeanDefinitionDocumentReader完成 documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); // 统计解析的Bean数量 return getRegistry().getBeanDefinitionCount() - countBefore; }

// 根据Spring DTD对Bean的定义规则解析Bean定义Document对象 @Override public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) { // 获取Xml描述符 this.readerContext = readerContext; logger.debug("Loading bean definitions"); // 获取Document的根元素 Element root = doc.getDocumentElement(); doRegisterBeanDefinitions(root); } protected void doRegisterBeanDefinitions(Element root) { // Any nested <beans> elements will cause recursion in this method. In // order to propagate and preserve <beans> default-* attributes correctly, // keep track of the current (parent) delegate, which may be null. Create // the new (child) delegate with a reference to the parent for fallback purposes, // then ultimately reset this.delegate back to its original (parent) reference. // this behavior emulates a stack of delegates without actually necessitating one. // 具体的解析过程由BeanDefinitionParserDelegate实现，BeanDefinitionParserDelegate中定义了Spring Bean定义Xml文件的各种元素。 BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); if (this.delegate.isDefaultNamespace(root)) { String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE); if (StringUtils.hasText(profileSpec)) { String[] specifiedProfiles = StringUtils.tokenizeToStringArray( profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS); if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) { if (logger.isInfoEnabled()) { logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec + "] not matching: " + getReaderContext().getResource()); } return; } } } preProcessXml(root); parseBeanDefinitions(root, this.delegate); postProcessXml(root); this.delegate = parent; } // 使用Spirng的Bean规则从Document的根元素开始进行Bean定义的Document对象 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { // Bean定义的Document对象使用了Spring默认的XML命名空间 if (delegate.isDefaultNamespace(root)) { // 获取Bean定义的Document对象根元素的所有子节点 NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); // 获取Document节点是XML元素节点 if (node instanceof Element) { Element ele = (Element) node; // Bean定义的Document的元素节点使用的是Spring默认的XML命名空间 if (delegate.isDefaultNamespace(ele)) { // 使用SPring的Bean规则解析元素节点 parseDefaultElement(ele, delegate); } else { // 没有使用Spring默认的XMl命名空间，则使用用户自定义的解析规则解析元素节点 delegate.parseCustomElement(ele); } } } } else { // Document的根节点没有使用Spring默认的命名空间，则使用用户自定义的解析规则解析Document根节点 delegate.parseCustomElement(root); } } private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { // 如果节点元素是<Import>导入元素，进行导入解析 if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } // 如果元素是<Alias>别名元素，进行别名解析 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } // 元素节点既不是导入元素，也不是别名元素，即普通的<Bean>元素，按照Spring的Bean规则解析元素。 else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // recurse doRegisterBeanDefinitions(ele); } } // 解析<Import>导入元素，给定的导入路径加载Bean配置资源到Spring IOC容器中 protected void importBeanDefinitionResource(Element ele) { // 获取给定的导入元素的location属性 String location = ele.getAttribute(RESOURCE_ATTRIBUTE); // 如果导入元素的location属性为空，则没有导入任何资源，直接返回 if (!StringUtils.hasText(location)) { getReaderContext().error("Resource location must not be empty", ele); return; } // Resolve system properties: e.g. "${user.dir}" // 使用系统变量值解析location属性值 location = getReaderContext().getEnvironment().resolveRequiredPlaceholders(location); Set<Resource> actualResources = new LinkedHashSet<>(4); // Discover whether the location is an absolute or relative URI // 表示给定的导入元素的location是否为绝对路径 boolean absoluteLocation = false; try { absoluteLocation = ResourcePatternUtils.isUrl(location) || ResourceUtils.toURI(location).isAbsolute(); } catch (URISyntaxException ex) { // 给定的导入元素的location不是绝对路径 // cannot convert to an URI, considering the location relative // unless it is the well-known Spring prefix "classpath*:" } // Absolute or relative? // 给定的导入元素的location是绝对的 if (absoluteLocation) { try { // 使用资源读入器加载给定的路径Bean配置资源 int importCount = getReaderContext().getReader().loadBeanDefinitions(location, actualResources); if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from URL location [" + location + "]"); } } catch (BeanDefinitionStoreException ex) { getReaderContext().error( "Failed to import bean definitions from URL location [" + location + "]", ele, ex); } } else { // No URL -> considering resource location as relative to the current file. // 给定的导入元素的location是相对路径 try { int importCount; // 将给定导入元素的location封装为相对路径资源 Resource relativeResource = getReaderContext().getResource().createRelative(location); // 封装的相对路径资源存在 if (relativeResource.exists()) { // 使用资源读入器加载Bean配置资源 importCount = getReaderContext().getReader().loadBeanDefinitions(relativeResource); actualResources.add(relativeResource); } else { // 封装的相对路径资源不存在 // 获取SpringIOC容器资源读入器的基本路径 String baseLocation = getReaderContext().getResource().getURL().toString(); // 根据Spring IOC容器资源读入器的基本路径加载给定导入路径的资源 importCount = getReaderContext().getReader().loadBeanDefinitions( StringUtils.applyRelativePath(baseLocation, location), actualResources); } if (logger.isDebugEnabled()) { logger.debug("Imported " + importCount + " bean definitions from relative location [" + location + "]"); } } catch (IOException ex) { getReaderContext().error("Failed to resolve current resource location", ele, ex); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to import bean definitions from relative location [" + location + "]", ele, ex); } } Resource[] actResArray = actualResources.toArray(new Resource[actualResources.size()]); // 在解析完<Import> 元素之后，发送容器导入其他资源处理完成事件。 getReaderContext().fireImportProcessed(location, actResArray, extractSource(ele)); } protected void processAliasRegistration(Element ele) { // 获取<Alias>别名元素中name的属性值 String name = ele.getAttribute(NAME_ATTRIBUTE); // 获取<Alias>别名元素中alias的属性值 String alias = ele.getAttribute(ALIAS_ATTRIBUTE); boolean valid = true; // <Alias>别名元素的name属性值为空 if (!StringUtils.hasText(name)) { getReaderContext().error("Name must not be empty", ele); valid = false; } // <Alias>别名元素的alias属性值为空 if (!StringUtils.hasText(alias)) { getReaderContext().error("Alias must not be empty", ele); valid = false; } if (valid) { try { // 向容器的资源读入器注册别名 getReaderContext().getRegistry().registerAlias(name, alias); } catch (Exception ex) { getReaderContext().error("Failed to register alias '" + alias + "' for bean with name '" + name + "'", ele, ex); } // 在解析完<Alias>元素之后，发送容器别名处理完成事件 getReaderContext().fireAliasRegistered(name, alias, extractSource(ele)); } } // 解析Bean配置资源Document对象的普通元素 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // BeanDefinitionHolder是对BeanDefinition的封装，即Bean定义的封装类，对Document对象中<Bean>元素的解析由BeanDefinitionParserDelegate实现 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { // Register the final decorated instance. // 像Spring IOC容器注册解析得到的Bean定义，这是Bean定义向IOC容器注册的入口 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } // Send registration event. // 在完成向Spring IOC容器注册解析得到的Bean定义之后，发送注册事件。 getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }

// 解析<Bean>元素的入口 @Nullable public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) { return parseBeanDefinitionElement(ele, null); } /** * Parses the supplied {@code <bean>} element. May return {@code null} * if there were errors during parse. Errors are reported to the * {@link org.springframework.beans.factory.parsing.ProblemReporter}. */ // 解析Bean配置信息中的<Bean>元素，这个方法中主要处理<bean>元素的id，name和别名属性 @Nullable public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { // 获取<Bean>元素中的id属性值 String id = ele.getAttribute(ID_ATTRIBUTE); // 获取<Bean>元素中的name属性值 String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); // 获取bean元素中的alias属性值 List<String> aliases = new ArrayList<>(); // 将bean元素中的所有name属性值存放到别名中 if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } String beanName = id; // 如果bean元素中没有配置id属性时，将别名中的第一个值赋值给beanName if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); if (logger.isDebugEnabled()) { logger.debug("No XML 'id' specified - using '" + beanName + "' as bean name and " + aliases + " as aliases"); } } // 检查bean元素所配置的id 或者name的唯一性，containingBean标识bean，元素中是否包含子bean元素 if (containingBean == null) { // 检查bean元素所配置的id，name或者别名是否重复 checkNameUniqueness(beanName, aliases, ele); } // 详细对bean元素中配置的bean定义进行解析的地方 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { if (containingBean != null) { // 如果bean元素中没有配置id，别名或者name，且没有包含子元素，bean元素，为解析的bean生成一个唯一beanName并注册 beanName = BeanDefinitionReaderUtils.generateBeanName( beanDefinition, this.readerContext.getRegistry(), true); } else { // 如果bean元素中没有配置id，别名或者name，且包含了子元素bean元素，为解析的bean使用别名想IOC容器中注册 beanName = this.readerContext.generateBeanName(beanDefinition); // Register an alias for the plain bean class name, if still possible, // if the generator returned the class name plus a suffix. // This is expected for Spring 1.2/2.0 backwards compatibility. // 为解析的bean使用别名注册时，为了向后兼容，Spring1.2/2.0，给别名添加类名后缀 String beanClassName = beanDefinition.getBeanClassName(); if (beanClassName != null && beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() && !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) { aliases.add(beanClassName); } } if (logger.isDebugEnabled()) { logger.debug("Neither XML 'id' nor 'name' specified - " + "using generated bean name [" + beanName + "]"); } } catch (Exception ex) { error(ex.getMessage(), ele); return null; } } String[] aliasesArray = StringUtils.toStringArray(aliases); return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); } // 当解析出错时，返回null return null; } /** * Validate that the specified bean name and aliases have not been used already * within the current level of beans element nesting. */ protected void checkNameUniqueness(String beanName, List<String> aliases, Element beanElement) { String foundName = null; if (StringUtils.hasText(beanName) && this.usedNames.contains(beanName)) { foundName = beanName; } if (foundName == null) { foundName = CollectionUtils.findFirstMatch(this.usedNames, aliases); } if (foundName != null) { error("Bean name '" + foundName + "' is already used in this <beans> element", beanElement); } this.usedNames.add(beanName); this.usedNames.addAll(aliases); } /** * Parse the bean definition itself, without regard to name or aliases. May return * {@code null} if problems occurred during the parsing of the bean definition. */ // 详细对<bean>元素中配置的Bean定义其他属性进行解析 // 由于上面的方法中已经对Bean的id，naem和别名属性进行了处理 // 该方法主要处理这三个以外的其他属性数据 @Nullable public AbstractBeanDefinition parseBeanDefinitionElement( Element ele, String beanName, @Nullable BeanDefinition containingBean) { // 记录解析的bean元素 this.parseState.push(new BeanEntry(beanName)); // 这里只读取bean元素中配置的class名字，然后载入到BeanDefinition中去 // 只是记录配置的class名字，不做实例化，对象的实例化在依赖注入时完成 String className = null; if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim(); } // 如果bean元素中配置了parent属性，则获取parent属性的值 String parent = null; if (ele.hasAttribute(PARENT_ATTRIBUTE)) { parent = ele.getAttribute(PARENT_ATTRIBUTE); } try { // 根据bean元素配置的class名称和parent属性值创建BeanDefinition // 为载入Bean定义信息做准备 AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 对当前的bean元素中配置的一些属性进行解析和设置，如配置的单态singleton属性等 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); // 为bean元素解析的bean设置description信息 bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); // 对bean元素的meta属性解析 parseMetaElements(ele, bd); // 对bean元素的lookup-method属性解析 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); // 对bean元素的replaced-method属性解析 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); //解析bean元素的构造方法设置 parseConstructorArgElements(ele, bd); // 解析bean元素的property设置 parsePropertyElements(ele, bd); // 解析bean元素的qualifier属性 parseQualifierElements(ele, bd); // 为当前解析的bean设置所需的资源和依赖对象 bd.setResource(this.readerContext.getResource()); bd.setSource(extractSource(ele)); return bd; } catch (ClassNotFoundException ex) { error("Bean class [" + className + "] not found", ele, ex); } catch (NoClassDefFoundError err) { error("Class that bean class [" + className + "] depends on not found", ele, err); } catch (Throwable ex) { error("Unexpected failure during bean definition parsing", ele, ex); } finally { this.parseState.pop(); } // 解析异常返回null return null; }

// 解析property元素 public void parsePropertyElement(Element ele, BeanDefinition bd) { // 获取property元素的名字 String propertyName = ele.getAttribute(NAME_ATTRIBUTE); if (!StringUtils.hasLength(propertyName)) { error("Tag 'property' must have a 'name' attribute", ele); return; } this.parseState.push(new PropertyEntry(propertyName)); try { // 如果一个Bean中已经有同名的property存在，则不进行解析，直接返回。 // 即如果在同一个Bean中配置同名的property，则只有第一个起作用 if (bd.getPropertyValues().contains(propertyName)) { error("Multiple 'property' definitions for property '" + propertyName + "'", ele); return; } // 解析获取property的值 Object val = parsePropertyValue(ele, bd, propertyName); // 根据property的名字和值创建property实例 PropertyValue pv = new PropertyValue(propertyName, val); // 解析property元素中的属性 parseMetaElements(ele, pv); pv.setSource(extractSource(ele)); bd.getPropertyValues().addPropertyValue(pv); } finally { this.parseState.pop(); } } // 解析获取property值 @Nullable public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) { String elementName = (propertyName != null) ? "<property> element for property '" + propertyName + "'" : "<constructor-arg> element"; // Should only have one child element: ref, value, list, etc. // 获取property的所有子元素，只能是其中一种类型：ref，value，list，etc等 NodeList nl = ele.getChildNodes(); Element subElement = null; for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); // 子元素不是description和meta属性 if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) && !nodeNameEquals(node, META_ELEMENT)) { // Child element is what we're looking for. if (subElement != null) { error(elementName + " must not contain more than one sub-element", ele); } else { // 当前property元素包含子元素 subElement = (Element) node; } } } // 判断property的属性值是ref还是value，不允许即使ref又是value boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE); boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE); if ((hasRefAttribute && hasValueAttribute) || ((hasRefAttribute || hasValueAttribute) && subElement != null)) { error(elementName + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele); } // 如果属性值是ref，创建一个ref的数据对象runtimeBeanReference // 这个对象封装了ref信息 if (hasRefAttribute) { String refName = ele.getAttribute(REF_ATTRIBUTE); if (!StringUtils.hasText(refName)) { error(elementName + " contains empty 'ref' attribute", ele); } // 一个指向运行时所依赖对象的引用 RuntimeBeanReference ref = new RuntimeBeanReference(refName); // 设置这个ref的数据对象是被当前的property对象所引用 ref.setSource(extractSource(ele)); return ref; } // 如果属性是value，创建一个value的数据对象typedStringValue // 这个对象封装了value信息 else if (hasValueAttribute) { // 一个持有string类型值的对象 TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE)); // 设置这个value数据对象是被当前的property对象所引用 valueHolder.setSource(extractSource(ele)); return valueHolder; } // 如果当前property元素还是子元素 else if (subElement != null) { // 解析property的子元素 return parsePropertySubElement(subElement, bd); } else { // property属性中既不是ref，也不是value属性，解析出错返回null // Neither child element nor "ref" or "value" attribute found. error(elementName + " must specify a ref or value", ele); return null; } }

// 解析property元素中ref，value或者集合等子元素 @Nullable public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) { // 如果property没有使用spring默认的命名空间，则使用用户自定义的规则解析内嵌元素 if (!isDefaultNamespace(ele)) { return parseNestedCustomElement(ele, bd); } // 如果子元素是bean，则使用解析bean元素的方法解析 else if (nodeNameEquals(ele, BEAN_ELEMENT)) { BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd); if (nestedBd != null) { nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd); } return nestedBd; } // 如果子元素是ref，ref中只能有以下3个属性：bean、local、parent else if (nodeNameEquals(ele, REF_ELEMENT)) { // 可以不再同一个Spring配置文件中，具体请参考spring对ref的配置规则 // A generic reference to any name of any bean. String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE); boolean toParent = false; if (!StringUtils.hasLength(refName)) { // A reference to the id of another bean in a parent context. // 获取property元素中parent属性值，引用父级容器中bean refName = ele.getAttribute(PARENT_REF_ATTRIBUTE); toParent = true; if (!StringUtils.hasLength(refName)) { error("'bean' or 'parent' is required for <ref> element", ele); return null; } } if (!StringUtils.hasText(refName)) { error("<ref> element contains empty target attribute", ele); return null; } // 创建ref类型数据，指向被引用的对象 RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent); // 设置引用类型值是被当前子元素所引用 ref.setSource(extractSource(ele)); return ref; } // 如果子元素是idref，使用解析ref元素的方法解析 else if (nodeNameEquals(ele, IDREF_ELEMENT)) { return parseIdRefElement(ele); } // 如果子元素为value，使用解析value元素的方法解析 else if (nodeNameEquals(ele, VALUE_ELEMENT)) { return parseValueElement(ele, defaultValueType); } // 如果子元素是null，为property设置一个封装null值的字符串数据 else if (nodeNameEquals(ele, NULL_ELEMENT)) { // It's a distinguished null value. Let's wrap it in a TypedStringValue // object in order to preserve the source location. TypedStringValue nullHolder = new TypedStringValue(null); nullHolder.setSource(extractSource(ele)); return nullHolder; } // 如果子类是array，使用解析array集合子元素的方法解析 else if (nodeNameEquals(ele, ARRAY_ELEMENT)) { return parseArrayElement(ele, bd); } // 如果子元素是list，使用解析list集合子元素的方法解析 else if (nodeNameEquals(ele, LIST_ELEMENT)) { return parseListElement(ele, bd); } // 如果子元素为set，使用解析set集合子元素的方法解析 else if (nodeNameEquals(ele, SET_ELEMENT)) { return parseSetElement(ele, bd); } // 如果子元素是map，使用解析map集合子元素的方法解析 else if (nodeNameEquals(ele, MAP_ELEMENT)) { return parseMapElement(ele, bd); } // 如果子元素为props，使用解析props集合子元素的方法解析 else if (nodeNameEquals(ele, PROPS_ELEMENT)) { return parsePropsElement(ele); } // 既不是ref，又不是value，也不是集合，则子元素配置错误，返回null else { error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele); return null; } }

// 解析list集合子元素 public List<Object> parseListElement(Element collectionEle, @Nullable BeanDefinition bd) { // 获取list元素中的value-type属性，即获取集合元素的数据类型。 String defaultElementType = collectionEle.getAttribute(VALUE_TYPE_ATTRIBUTE); // 获取list集合元素中的所有子节点 NodeList nl = collectionEle.getChildNodes(); // spring中将list封装为ManagedList ManagedList<Object> target = new ManagedList<>(nl.getLength()); target.setSource(extractSource(collectionEle)); // 设置集合目标数据类型 target.setElementTypeName(defaultElementType); target.setMergeEnabled(parseMergeAttribute(collectionEle)); // 具体的list元素解析 parseCollectionElements(nl, target, bd, defaultElementType); return target; } protected void parseCollectionElements( NodeList elementNodes, Collection<Object> target, @Nullable BeanDefinition bd, String defaultElementType) { // 遍历集合所有节点 for (int i = 0; i < elementNodes.getLength(); i++) { Node node = elementNodes.item(i); // 节点不是description节点 if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT)) { // 将解析的元素加入集合中，递归调用下一个子元素 target.add(parsePropertySubElement((Element) node, bd, defaultElementType)); } } }

public static void registerBeanDefinition( BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) throws BeanDefinitionStoreException { // Register bean definition under primary name. // 获取解析的BeanDefinition的名称 String beanName = definitionHolder.getBeanName(); // 向IOC容器注册BeanDefinition registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition()); // Register aliases for bean name, if any. // 如果解析的BeanDefinition有别名，向容器注册别名 String[] aliases = definitionHolder.getAliases(); if (aliases != null) { for (String alias : aliases) { registry.registerAlias(beanName, alias); } } }

// 存储注册信息的BeanDefinition private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256); // 向IOC容器中注册解析的BeanDefinition @Override public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(beanDefinition, "BeanDefinition must not be null"); // 校验解析的BeanDefinition if (beanDefinition instanceof AbstractBeanDefinition) { try { ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } } BeanDefinition oldBeanDefinition; oldBeanDefinition = this.beanDefinitionMap.get(beanName); if (oldBeanDefinition != null) { if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound."); } else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) { // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE if (this.logger.isWarnEnabled()) { this.logger.warn("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } else if (!beanDefinition.equals(oldBeanDefinition)) { if (this.logger.isInfoEnabled()) { this.logger.info("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } else { if (this.logger.isDebugEnabled()) { this.logger.debug("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]"); } } this.beanDefinitionMap.put(beanName, beanDefinition); } else { if (hasBeanCreationStarted()) { // Cannot modify startup-time collection elements anymore (for stable iteration) synchronized (this.beanDefinitionMap) { this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; if (this.manualSingletonNames.contains(beanName)) { Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames); updatedSingletons.remove(beanName); this.manualSingletonNames = updatedSingletons; } } } else { // Still in startup registration phase this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); this.manualSingletonNames.remove(beanName); } this.frozenBeanDefinitionNames = null; } // 检查是否有同名的BeanDefinition已经在IOC容器中注册 if (oldBeanDefinition != null || containsSingleton(beanName)) { // 重置所有已经注册过的BeanDefinition的缓存 resetBeanDefinition(beanName); } }

public class AnnotationConfigApplicationContext extends GenericApplicationContext implements AnnotationConfigRegistry { // 保存一个读取注册的Bean定义读取器，将其设置到容器中 private final AnnotatedBeanDefinitionReader reader; // 保存一个扫描指定类路径中注册bean定义的扫描器，并将其设置到容器中 private final ClassPathBeanDefinitionScanner scanner; /** * Create a new AnnotationConfigApplicationContext that needs to be populated * through {@link #register} calls and then manually {@linkplain #refresh refreshed}. */ // 默认构造函数，初始化一个空容器，容器不包含任何Bean信息，需要在稍后通过调用其register() // 方法注册配置类，并调用refresh()方法刷新容器，出发容器对注解bean的载入、解析和注册过程。 public AnnotationConfigApplicationContext() { this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } /** * Create a new AnnotationConfigApplicationContext with the given DefaultListableBeanFactory. * @param beanFactory the DefaultListableBeanFactory instance to use for this context */ public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) { super(beanFactory); this.reader = new AnnotatedBeanDefinitionReader(this); this.scanner = new ClassPathBeanDefinitionScanner(this); } /** * Create a new AnnotationConfigApplicationContext, deriving bean definitions * from the given annotated classes and automatically refreshing the context. * @param annotatedClasses one or more annotated classes, * e.g. {@link Configuration @Configuration} classes */ public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) { this(); register(annotatedClasses); refresh(); } /** * Create a new AnnotationConfigApplicationContext, scanning for bean definitions * in the given packages and automatically refreshing the context. * @param basePackages the packages to check for annotated classes */ public AnnotationConfigApplicationContext(String... basePackages) { this(); scan(basePackages); refresh(); } /** * {@inheritDoc} * <p>Delegates given environment to underlying {@link AnnotatedBeanDefinitionReader} * and {@link ClassPathBeanDefinitionScanner} members. */ @Override public void setEnvironment(ConfigurableEnvironment environment) { super.setEnvironment(environment); this.reader.setEnvironment(environment); this.scanner.setEnvironment(environment); } /** * Provide a custom {@link BeanNameGenerator} for use with {@link AnnotatedBeanDefinitionReader} * and/or {@link ClassPathBeanDefinitionScanner}, if any. * <p>Default is {@link org.springframework.context.annotation.AnnotationBeanNameGenerator}. * <p>Any call to this method must occur prior to calls to {@link #register(Class...)} * and/or {@link #scan(String...)}. * @see AnnotatedBeanDefinitionReader#setBeanNameGenerator * @see ClassPathBeanDefinitionScanner#setBeanNameGenerator */ // 为容器的注解bean读取器和bean扫描器设置bean名称产生器 public void setBeanNameGenerator(BeanNameGenerator beanNameGenerator) { this.reader.setBeanNameGenerator(beanNameGenerator); this.scanner.setBeanNameGenerator(beanNameGenerator); getBeanFactory().registerSingleton( AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR, beanNameGenerator); } /** * Set the {@link ScopeMetadataResolver} to use for detected bean classes. * <p>The default is an {@link AnnotationScopeMetadataResolver}. * <p>Any call to this method must occur prior to calls to {@link #register(Class...)} * and/or {@link #scan(String...)}. */ // 为容器的注解bean读取器和注解bean扫描器设置作用范围元信息解析器 public void setScopeMetadataResolver(ScopeMetadataResolver scopeMetadataResolver) { this.reader.setScopeMetadataResolver(scopeMetadataResolver); this.scanner.setScopeMetadataResolver(scopeMetadataResolver); } //--------------------------------------------------------------------- // Implementation of AnnotationConfigRegistry //--------------------------------------------------------------------- /** * Register one or more annotated classes to be processed. * <p>Note that {@link #refresh()} must be called in order for the context * to fully process the new classes. * @param annotatedClasses one or more annotated classes, * e.g. {@link Configuration @Configuration} classes * @see #scan(String...) * @see #refresh() */ // 为容器注册一个被处理的注解bean,新注册的bean，必须手动调用容器的 // refresh()方法刷新容器，出发容器对新注册的bean的处理 public void register(Class<?>... annotatedClasses) { Assert.notEmpty(annotatedClasses, "At least one annotated class must be specified"); this.reader.register(annotatedClasses); } /** * Perform a scan within the specified base packages. * <p>Note that {@link #refresh()} must be called in order for the context * to fully process the new classes. * @param basePackages the packages to check for annotated classes * @see #register(Class...) * @see #refresh() */ // 扫描制定包路径及其子包下面的注解类，为了使新添加的类被处理，必须手动调用 // refresh()方法刷新容器 public void scan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); this.scanner.scan(basePackages); } ... }

<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name, @Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) { // 根据指定的注解bean定义类，创建spring容器中对注解bean的封装的数据结构 AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass); if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) { return; } abd.setInstanceSupplier(instanceSupplier); // 解析注解bean定义的作用域，若@Scope("prototype"),则bean为原型类型： // 若@Scope("singleton")，则bean为单态类型 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd); // 为注解bean定义设置作用域 abd.setScope(scopeMetadata.getScopeName()); // 为注解bean定义生成bean名称 String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry)); // 处理注解bean定义中的通用注解 AnnotationConfigUtils.processCommonDefinitionAnnotations(abd); // 如果向容器注册注解bean定义时，使用额外的限定符注解，则解析限定符注解。 // 主要是配置的关于autowring自动依赖注入装配的限定条件，即@Qualifier注解 // spring自动依赖注入装配默认是按类型装配，如果使用@Qualifier则按名称 if (qualifiers != null) { for (Class<? extends Annotation> qualifier : qualifiers) { // 如果配置了@Primary注解，设置该bean为autowring自动依赖注入装配时的首选 if (Primary.class == qualifier) { abd.setPrimary(true); } // 如果配置了@Lazy注解，则设置bean为非延迟初始化，如果没有配置 // 则该bean为预实例化 else if (Lazy.class == qualifier) { abd.setLazyInit(true); } // 如果使用了除@Primary和@Lazy以外的其他注解，则为该bean添加一个 // autowring自动依赖注入装配限定符，该bean在进行autowring // 自动依赖注入装配时，根据名称装配限定符指定的bean else { abd.addQualifier(new AutowireCandidateQualifier(qualifier)); } } } for (BeanDefinitionCustomizer customizer : definitionCustomizers) { customizer.customize(abd); } // 创建一个指定bean名称的bean定义对象，封装注解bean定义类数据 BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName); // 根据注解bean定义类中配置的作用于，创建相应的代理对象 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); // 向IOC容器注册注解bean类定义对象 BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry); }

// 解析注解bean定义类中的作用域元信息 @Override public ScopeMetadata resolveScopeMetadata(BeanDefinition definition) { ScopeMetadata metadata = new ScopeMetadata(); if (definition instanceof AnnotatedBeanDefinition) { AnnotatedBeanDefinition annDef = (AnnotatedBeanDefinition) definition; // 从注解bean定义类的属性中查找属性为scope的值，及@Scope注解的值 // annDef.getMetadata().getAnnotationAttributes方法将bean // 中所有的注解和注解的值存放在一个map集合中 AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor( annDef.getMetadata(), this.scopeAnnotationType); // 将获取到的@Scope注解的值设置到要返回的对象中 if (attributes != null) { metadata.setScopeName(attributes.getString("value")); // 获取@Scope注解中的proxyMode属性值，在创建代理对象时会用到 ScopedProxyMode proxyMode = attributes.getEnum("proxyMode"); // 如果@Scope的proxyMode属性为DEFAULT或者NO if (proxyMode == ScopedProxyMode.DEFAULT) { // 设置proxyMode为NO proxyMode = this.defaultProxyMode; } // 为返回的元数据设置proxyMode metadata.setScopedProxyMode(proxyMode); } } // 返回解析的作用域元信息对象 return metadata; }

// 处理bean定义中通用注解 static void processCommonDefinitionAnnotations(AnnotatedBeanDefinition abd, AnnotatedTypeMetadata metadata) { AnnotationAttributes lazy = attributesFor(metadata, Lazy.class); // 如果bean定义中有@Lazy注解，则将该bean预实例化属性设置为@Lazy注解的值 if (lazy != null) { abd.setLazyInit(lazy.getBoolean("value")); } else if (abd.getMetadata() != metadata) { lazy = attributesFor(abd.getMetadata(), Lazy.class); if (lazy != null) { abd.setLazyInit(lazy.getBoolean("value")); } } // 如果Bean定义有@Primary注解，则为该Bean设置为autowiring自动依赖注入装配的首选对象 if (metadata.isAnnotated(Primary.class.getName())) { abd.setPrimary(true); } // 如果Bean定义中有@DependsOn注解，则为该Bean设置所依赖的Bean名称 // 容器将确保在实例化该Bean之前首先实例化所依赖的Bean AnnotationAttributes dependsOn = attributesFor(metadata, DependsOn.class); if (dependsOn != null) { abd.setDependsOn(dependsOn.getStringArray("value")); } if (abd instanceof AbstractBeanDefinition) { AbstractBeanDefinition absBd = (AbstractBeanDefinition) abd; AnnotationAttributes role = attributesFor(metadata, Role.class); if (role != null) { absBd.setRole(role.getNumber("value").intValue()); } AnnotationAttributes description = attributesFor(metadata, Description.class); if (description != null) { absBd.setDescription(description.getString("value")); } } }

// 根据作用于为bean应用引用的代码模式 static BeanDefinitionHolder applyScopedProxyMode( ScopeMetadata metadata, BeanDefinitionHolder definition, BeanDefinitionRegistry registry) { // 获取注解bean定义类中@Scope注解的proxyMode属性值 ScopedProxyMode scopedProxyMode = metadata.getScopedProxyMode(); // 如果配置的@Scope注解的proxyMode属性值为NO，则不应用代理模式 if (scopedProxyMode.equals(ScopedProxyMode.NO)) { return definition; } // 获取配置的@Scope注解的proxyMode属性值，如果为TARGET_CLASS // 则返回true，如果为INTERFACES，则返回false boolean proxyTargetClass = scopedProxyMode.equals(ScopedProxyMode.TARGET_CLASS); // 为注册的Bean创建相应的代理对象 return ScopedProxyCreator.createScopedProxy(definition, registry, proxyTargetClass); }

public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider { private final BeanDefinitionRegistry registry; private BeanDefinitionDefaults beanDefinitionDefaults = new BeanDefinitionDefaults(); @Nullable private String[] autowireCandidatePatterns; private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator(); private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver(); private boolean includeAnnotationConfig = true; /** * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory. * @param registry the {@code BeanFactory} to load bean definitions into, in the form * of a {@code BeanDefinitionRegistry} */ // 创建一个类路径bean定义扫描器 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) { this(registry, true); } /** * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory. * <p>If the passed-in bean factory does not only implement the * {@code BeanDefinitionRegistry} interface but also the {@code ResourceLoader} * interface, it will be used as default {@code ResourceLoader} as well. This will * usually be the case for {@link org.springframework.context.ApplicationContext} * implementations. * <p>If given a plain {@code BeanDefinitionRegistry}, the default {@code ResourceLoader} * will be a {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver}. * <p>If the passed-in bean factory also implements {@link EnvironmentCapable} its * environment will be used by this reader. Otherwise, the reader will initialize and * use a {@link org.springframework.core.env.StandardEnvironment}. All * {@code ApplicationContext} implementations are {@code EnvironmentCapable}, while * normal {@code BeanFactory} implementations are not. * @param registry the {@code BeanFactory} to load bean definitions into, in the form * of a {@code BeanDefinitionRegistry} * @param useDefaultFilters whether to include the default filters for the * {@link org.springframework.stereotype.Component @Component}, * {@link org.springframework.stereotype.Repository @Repository}, * {@link org.springframework.stereotype.Service @Service}, and * {@link org.springframework.stereotype.Controller @Controller} stereotype annotations * @see #setResourceLoader * @see #setEnvironment */ // 为容器创建一个类bean定义扫描器，定指定是否使用默认的扫描过滤规则 // 即spring默认扫描配置：@Component、@Repository、@Service、@Controller // 注解的bean，同时支持javaee6的@ManagedBean和JSR-330的@Named注解 public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) { this(registry, useDefaultFilters, getOrCreateEnvironment(registry)); } /** * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory and * using the given {@link Environment} when evaluating bean definition profile metadata. * <p>If the passed-in bean factory does not only implement the {@code * BeanDefinitionRegistry} interface but also the {@link ResourceLoader} interface, it * will be used as default {@code ResourceLoader} as well. This will usually be the * case for {@link org.springframework.context.ApplicationContext} implementations. * <p>If given a plain {@code BeanDefinitionRegistry}, the default {@code ResourceLoader} * will be a {@link org.springframework.core.io.support.PathMatchingResourcePatternResolver}. * @param registry the {@code BeanFactory} to load bean definitions into, in the form * of a {@code BeanDefinitionRegistry} * @param useDefaultFilters whether to include the default filters for the * {@link org.springframework.stereotype.Component @Component}, * {@link org.springframework.stereotype.Repository @Repository}, * {@link org.springframework.stereotype.Service @Service}, and * {@link org.springframework.stereotype.Controller @Controller} stereotype annotations * @param environment the Spring {@link Environment} to use when evaluating bean * definition profile metadata * @since 3.1 * @see #setResourceLoader */ public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment) { this(registry, useDefaultFilters, environment, (registry instanceof ResourceLoader ? (ResourceLoader) registry : null)); } /** * Create a new {@code ClassPathBeanDefinitionScanner} for the given bean factory and * using the given {@link Environment} when evaluating bean definition profile metadata. * @param registry the {@code BeanFactory} to load bean definitions into, in the form * of a {@code BeanDefinitionRegistry} * @param useDefaultFilters whether to include the default filters for the * {@link org.springframework.stereotype.Component @Component}, * {@link org.springframework.stereotype.Repository @Repository}, * {@link org.springframework.stereotype.Service @Service}, and * {@link org.springframework.stereotype.Controller @Controller} stereotype annotations * @param environment the Spring {@link Environment} to use when evaluating bean * definition profile metadata * @param resourceLoader the {@link ResourceLoader} to use * @since 4.3.6 */ public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters, Environment environment, @Nullable ResourceLoader resourceLoader) { Assert.notNull(registry, "BeanDefinitionRegistry must not be null"); // 为容器设置加载bean定义的注解器 this.registry = registry; if (useDefaultFilters) { registerDefaultFilters(); } setEnvironment(environment); // 为容器设置资源加载器 setResourceLoader(resourceLoader); } /** * Return the BeanDefinitionRegistry that this scanner operates on. */ @Override public final BeanDefinitionRegistry getRegistry() { return this.registry; } /** * Set the defaults to use for detected beans. * @see BeanDefinitionDefaults */ public void setBeanDefinitionDefaults(@Nullable BeanDefinitionDefaults beanDefinitionDefaults) { this.beanDefinitionDefaults = (beanDefinitionDefaults != null ? beanDefinitionDefaults : new BeanDefinitionDefaults()); } /** * Return the defaults to use for detected beans (never {@code null}). * @since 4.1 */ public BeanDefinitionDefaults getBeanDefinitionDefaults() { return this.beanDefinitionDefaults; } /** * Set the name-matching patterns for determining autowire candidates. * @param autowireCandidatePatterns the patterns to match against */ public void setAutowireCandidatePatterns(@Nullable String... autowireCandidatePatterns) { this.autowireCandidatePatterns = autowireCandidatePatterns; } /** * Set the BeanNameGenerator to use for detected bean classes. * <p>Default is a {@link AnnotationBeanNameGenerator}. */ public void setBeanNameGenerator(@Nullable BeanNameGenerator beanNameGenerator) { this.beanNameGenerator = (beanNameGenerator != null ? beanNameGenerator : new AnnotationBeanNameGenerator()); } /** * Set the ScopeMetadataResolver to use for detected bean classes. * Note that this will override any custom "scopedProxyMode" setting. * <p>The default is an {@link AnnotationScopeMetadataResolver}. * @see #setScopedProxyMode */ public void setScopeMetadataResolver(@Nullable ScopeMetadataResolver scopeMetadataResolver) { this.scopeMetadataResolver = (scopeMetadataResolver != null ? scopeMetadataResolver : new AnnotationScopeMetadataResolver()); } /** * Specify the proxy behavior for non-singleton scoped beans. * Note that this will override any custom "scopeMetadataResolver" setting. * <p>The default is {@link ScopedProxyMode#NO}. * @see #setScopeMetadataResolver */ public void setScopedProxyMode(ScopedProxyMode scopedProxyMode) { this.scopeMetadataResolver = new AnnotationScopeMetadataResolver(scopedProxyMode); } /** * Specify whether to register annotation config post-processors. * <p>The default is to register the post-processors. Turn this off * to be able to ignore the annotations or to process them differently. */ public void setIncludeAnnotationConfig(boolean includeAnnotationConfig) { this.includeAnnotationConfig = includeAnnotationConfig; } /** * Perform a scan within the specified base packages. * @param basePackages the packages to check for annotated classes * @return number of beans registered */ public int scan(String... basePackages) { // 获取容器中已经注册的Bean个数 int beanCountAtScanStart = this.registry.getBeanDefinitionCount(); // 启动扫描器扫描给定包 doScan(basePackages); // Register annotation config processors, if necessary. // 注册注解配置Annotation config处理器 if (this.includeAnnotationConfig) { AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry); } // 返回注册的bean个数 return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart); } /** * Perform a scan within the specified base packages, * returning the registered bean definitions. * <p>This method does <i>not</i> register an annotation config processor * but rather leaves this up to the caller. * @param basePackages the packages to check for annotated classes * @return set of beans registered if any for tooling registration purposes (never {@code null}) */ // 类路径bean定义扫描器扫描给定包及其子包 protected Set<BeanDefinitionHolder> doScan(String... basePackages) { Assert.notEmpty(basePackages, "At least one base package must be specified"); // 创建一个集合，存放扫描到bean定义的封装类 Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>(); // 遍历扫描所有给定的包 for (String basePackage : basePackages) { // 调用父类classPathScanningCandidateComponentProvider的方法 // 扫描给定类路径，获取符合条件的bean定义 Set<BeanDefinition> candidates = findCandidateComponents(basePackage); // 便利扫描到的bean for (BeanDefinition candidate : candidates) { // 获取bean定义类中@Scope注解的值，即获取bean的作用域 ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate); // 为bean设置注解配置的作用于 candidate.setScope(scopeMetadata.getScopeName()); // 为bean生成名称 String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry); // 如果扫描到的bean不是spring的注解bean，则为bean的默认值 // 设置bean的自动依赖注入装配属性等 if (candidate instanceof AbstractBeanDefinition) { postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName); } // 如果扫描到的bean是spring的注解bean，则处理其通用的spring注解 if (candidate instanceof AnnotatedBeanDefinition) { // 处理注解bean中通用的注解，在分析注解bean定义类读取器时已经分析过 AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate); } // 根据bean名称检查指定的bean是否需要在容器中注册，或者在容器中冲突 if (checkCandidate(beanName, candidate)) { BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName); // 根据注解中的配置的作用域，为bean应用相应的代理模式 definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry); beanDefinitions.add(definitionHolder); // 向容器注册扫描到的bean registerBeanDefinition(definitionHolder, this.registry); } } } return beanDefinitions; }

// 保存过滤规则要包含的注解，即Spring默认的@Component、@Repository、@Service、 // @Controller注解的Bean，以及JavaEE6的@ManagedBean和JSR-330的@Named注解 private final List<TypeFilter> includeFilters = new LinkedList<>(); // 保存过滤规则要排除的注解 private final List<TypeFilter> excludeFilters = new LinkedList<>(); // 构造方法，该方法在子类ClassPathBeanDefinitionScanner的构造方法被调用 public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) { this(useDefaultFilters, new StandardEnvironment()); } // 向容器注册过滤规则 @SuppressWarnings("unchecked") protected void registerDefaultFilters() { // 向要包含的归路规则中添加@Component注解类，注意Spring中@Repository、@Service // 和Controller都是Component，因为这些注解都添加了@Component注解 this.includeFilters.add(new AnnotationTypeFilter(Component.class)); // 获取当前类的类加载器 ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader(); try { // 向要包含的过滤规则中添加javaee6的@ManagedBean注解 this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false)); logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-250 1.1 API (as included in Java EE 6) not available - simply skip. } try { // 向要包含的过滤规则添加@Named注解 this.includeFilters.add(new AnnotationTypeFilter( ((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false)); logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning"); } catch (ClassNotFoundException ex) { // JSR-330 API not available - simply skip. } } // 扫描给定类路径的包 public Set<BeanDefinition> findCandidateComponents(String basePackage) { if (this.componentsIndex != null && indexSupportsIncludeFilters()) { return addCandidateComponentsFromIndex(this.componentsIndex, basePackage); } else { return scanCandidateComponents(basePackage); } } private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) { // 创建存储扫描到的类的集合 Set<BeanDefinition> candidates = new LinkedHashSet<>(); try { Set<String> types = new HashSet<>(); for (TypeFilter filter : this.includeFilters) { String stereotype = extractStereotype(filter); if (stereotype == null) { throw new IllegalArgumentException("Failed to extract stereotype from "+ filter); } types.addAll(index.getCandidateTypes(basePackage, stereotype)); } boolean traceEnabled = logger.isTraceEnabled(); boolean debugEnabled = logger.isDebugEnabled(); for (String type : types) { // 为指定资源获取元数据读取器，元信息读取器通过汇编ASM读取资源远信息 MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type); // 如果扫描的类符合容器配置的过滤规则 if (isCandidateComponent(metadataReader)) { // 通过汇编ASM读取资源字节码中的bean定义元信息 AnnotatedGenericBeanDefinition sbd = new AnnotatedGenericBeanDefinition( metadataReader.getAnnotationMetadata()); if (isCandidateComponent(sbd)) { if (debugEnabled) { logger.debug("Using candidate component class from index: " + type); } candidates.add(sbd); } else { if (debugEnabled) { logger.debug("Ignored because not a concrete top-level class: " + type); } } } else { if (traceEnabled) { logger.trace("Ignored because matching an exclude filter: " + type); } } } } catch (IOException ex) { throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex); } return candidates; } // 判断元信息读取器读取的类是否符合容器定义的注解过滤规则 protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException { // 如果读取的类的注解在排除注解过滤规则中，返回false for (TypeFilter tf : this.excludeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return false; } } // 如果读取的类的注解在包含的注解的过滤规则中，则返回true for (TypeFilter tf : this.includeFilters) { if (tf.match(metadataReader, getMetadataReaderFactory())) { return isConditionMatch(metadataReader); } } // 如果读取的类的注解即不再排除规则，也不再包含规则，则返回false。 return false; }