【spring源码分析】IOC容器初始化（三）

前言：在【spring源码分析】IOC容器初始化（二）中已经得到了XML配置文件的Document实例，下面分析bean的注册过程。

XmlBeanDefinitionReader#registerBeanDefinitions(Document doc, Resource resource)

 1 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
 2         // #1.创建BeanDefinitionDocumentReader对象
 3         BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
 4         // #2.获取已注册过的BeanDefinition对象个数
 5         int countBefore = getRegistry().getBeanDefinitionCount();
 6         // #3.创建XmlReaderContext对象[主要为了关联命名空间处理器]，并注册BeanDefinition
 7         documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
 8         // 返回新注册的BeanDefinition对象个数
 9         return getRegistry().getBeanDefinitionCount() - countBefore;
10     }

 分析：

  • 首先创建BeanDefinitionDocumentReader对象。
  • 获取已注册过的BeanDefinition个数。
  • 然后进入核心处理流程，注册BeanDefinition。
  • 最后返回新注册的BeanDefinition个数。

XmlBeanDefinitionReader#createBeanDefinitionDocumentReader

1 protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {
2         return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));
3     }

分析：通过反射得到BeanDefinitionDocumentReader对象。

DefaultListableBeanFactory#getBeanDefinitionCount

1     /**
2      * 存储beanName->BeanDefinition的集合map<br/>
3      * Map of bean definition objects, keyed by bean name.
4      */
5     private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);
6 
7     public int getBeanDefinitionCount() {
8         return this.beanDefinitionMap.size();
9     }

分析：逻辑简单，就是从beanDefinitionMap中获取当前的size，注意beanDefinitionMap存储的就是注册的BeanDefinition集合。

DefaultBeanDefinitionDocumentReader#registerBeanDefinitions(Document doc, XmlReaderContext readerContext)

1     public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
2         this.readerContext = readerContext;
3         logger.debug("Loading bean definitions");
4         // 获取XML Document对象的root元素
5         Element root = doc.getDocumentElement();
6         // 执行注册
7         doRegisterBeanDefinitions(root);
8     }

分析：

  • 首先获取XML Document对象的root元素。
  • 执行注册。

这里需要注意一点：registerBeanDefinitions的第二个入参，调用入口如下：

注意这里调用了XmlBeanDefinitionReader#createReaderContext：

1     /**
2      * 创建一个文档资源读取器<br/>
3      * Create the {@link XmlReaderContext} to pass over to the document reader.
4      */
5     public XmlReaderContext createReaderContext(Resource resource) {
6         return new XmlReaderContext(resource, this.problemReporter, this.eventListener,
7                 this.sourceExtractor, this, getNamespaceHandlerResolver());
8     }

分析：

这里主要关注XmlBeanDefinitionReader#getNamespaceHandlerResolver()函数：

 1 /**
 2      * 主要就是获得默认空间处理器，为后续解析标签做准备<br/>
 3      * Lazily create a default NamespaceHandlerResolver, if not set before.
 4      *
 5      * @see #createDefaultNamespaceHandlerResolver()
 6      */
 7     public NamespaceHandlerResolver getNamespaceHandlerResolver() {
 8         if (this.namespaceHandlerResolver == null) {
 9             this.namespaceHandlerResolver = createDefaultNamespaceHandlerResolver();
10         }
11         return this.namespaceHandlerResolver;
12     }
13 
14     /**
15      * Create the default implementation of {@link NamespaceHandlerResolver} used if none is specified.
16      * Default implementation returns an instance of {@link DefaultNamespaceHandlerResolver}.
17      */
18     protected NamespaceHandlerResolver createDefaultNamespaceHandlerResolver() {
19         ClassLoader cl = (getResourceLoader() != null ? getResourceLoader().getClassLoader() : getBeanClassLoader());
20         return new DefaultNamespaceHandlerResolver(cl);
21     }

分析：

该函数主要是获得默认空间处理器，为后续解析标签做准备。最终切入DefaultNamespaceHandlerResolver中。DefaultNamespaceHandlerResolver中有两个函数值得我们关注：

 1 public NamespaceHandler resolve(String namespaceUri) {
 2         // 获取所有已经配置的Handler映射
 3         Map<String, Object> handlerMappings = getHandlerMappings();
 4         // 根据namespaceUri获取handler信息：这里一般都是类路径
 5         Object handlerOrClassName = handlerMappings.get(namespaceUri);
 6         // 不存在
 7         if (handlerOrClassName == null) {
 8             return null;
 9         // 已经初始化
10         } else if (handlerOrClassName instanceof NamespaceHandler) {
11             return (NamespaceHandler) handlerOrClassName;
12         // 需要进行初始化
13         } else {
14             String className = (String) handlerOrClassName;
15             try {
16                 // 通过反射获得类，并创建NamespaceHandler对象
17                 Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
18                 if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
19                     throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
20                             "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
21                 }
22                 NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
23                 // 初始化NameSpaceHandler
24                 namespaceHandler.init();
25                 // 添加到缓存
26                 handlerMappings.put(namespaceUri, namespaceHandler);
27                 return namespaceHandler;
28             } catch (ClassNotFoundException ex) {
29                 throw new FatalBeanException("Could not find NamespaceHandler class [" + className +
30                         "] for namespace [" + namespaceUri + "]", ex);
31             } catch (LinkageError err) {
32                 throw new FatalBeanException("Unresolvable class definition for NamespaceHandler class [" +
33                         className + "] for namespace [" + namespaceUri + "]", err);
34             }
35         }
36     }
37 
38 private Map<String, Object> getHandlerMappings() {
39         Map<String, Object> handlerMappings = this.handlerMappings;
40         // 这里使用了double-check的方式，进行延迟加载
41         if (handlerMappings == null) {
42             synchronized (this) {
43                 handlerMappings = this.handlerMappings;
44                 if (handlerMappings == null) {
45                     if (logger.isTraceEnabled()) {
46                         logger.trace("Loading NamespaceHandler mappings from [" + this.handlerMappingsLocation + "]");
47                     }
48                     try {
49                         // 读取handlerMappingsLocation
50                         Properties mappings =
51                                 PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
52                         if (logger.isTraceEnabled()) {
53                             logger.trace("Loaded NamespaceHandler mappings: " + mappings);
54                         }
55                         // 初始化到handlerMappings中
56                         handlerMappings = new ConcurrentHashMap<>(mappings.size());
57                         CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
58                         this.handlerMappings = handlerMappings;
59                     } catch (IOException ex) {
60                         throw new IllegalStateException(
61                                 "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
62                     }
63                 }
64             }
65         }
66         return handlerMappings;
67     }

分析：

  • resolve主要是通过命名空间uri得到命名空间处理器，如果没有初始化，则会进行初始化，并缓存。
  • getHandlerMappings函数使用了Double-Check进行延迟加载，获取所有命名空间处理器。

DefaultBeanDefinitionDocumentReader#doRegisterBeanDefinitions

 1 protected void doRegisterBeanDefinitions(Element root) {
 2         // Any nested <beans> elements will cause recursion in this method. In
 3         // order to propagate and preserve <beans> default-* attributes correctly,
 4         // keep track of the current (parent) delegate, which may be null. Create
 5         // the new (child) delegate with a reference to the parent for fallback purposes,
 6         // then ultimately reset this.delegate back to its original (parent) reference.
 7         // this behavior emulates a stack of delegates without actually necessitating one.
 8 
 9         // 记录老的BeanDefinitionParserDelegate对象
10         BeanDefinitionParserDelegate parent = this.delegate;
11 
12         // 创建BeanDefinitionParserDelegate对象，并对delegate进行默认设置
13         this.delegate = createDelegate(getReaderContext(), root, parent);
14 
15         // 检测<beans/>标签的命名空间是否为空，或者是否为"http://www.springframework.org/schema/beans"
16         if (this.delegate.isDefaultNamespace(root)) {
17             // 处理profile属性
18             String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);
19             if (StringUtils.hasText(profileSpec)) {
20                 // 如果profile属性有值，则使用分隔符进行切分，因为可能有多个profile
21                 String[] specifiedProfiles = StringUtils.tokenizeToStringArray(
22                         profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);
23                 // 检测profile是否有效，如果无效，则不进行注册
24                 if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {
25                     if (logger.isInfoEnabled()) {
26                         logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +
27                                 "] not matching: " + getReaderContext().getResource());
28                     }
29                     return;
30                 }
31             }
32         }
33         // 解析xml前置处理，该方法为空，主要留给用户自定义处理，增强扩展性
34         preProcessXml(root);
35         // 核心函数，进行xml解析
36         parseBeanDefinitions(root, this.delegate);
37         // 解析xml后置处理，该方法也为空，主要留给用户自定义处理，增强扩展性
38         postProcessXml(root);
39         // 将delegate回到老的BeanDefinitionParserDelegate对象
40         this.delegate = parent;
41     }

分析：

  • 首先记录旧的BeanDefinitionParserDelegate，然后创建一个新的BeanDefinitionParserDelegate对象，因为对BeanDefinition的解析会进行委托。
  • 检测<beans/>标签的正确性，处理profile属性。
  • preProcessXml：解析xml的前置处理，默认为空，主要留给用户自定义实现，增强扩展性；postProcessXml：解析xml的后置处理，默认也为空，同样留给用户自定义实现。
  • parseBeanDefinitions：解析xml的核心函数，将在下面进行详细分析。

DefaultBeanDefinitionDocumentReader#parseBeanDefinitions

 1 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
 2         // 如果根节点使用默认命名空间，则执行默认解析
 3         if (delegate.isDefaultNamespace(root)) {
 4             NodeList nl = root.getChildNodes();
 5             // 遍历子节点
 6             for (int i = 0; i < nl.getLength(); i++) {
 7                 Node node = nl.item(i);
 8                 if (node instanceof Element) {
 9                     Element ele = (Element) node;
10                     // 如果该节点使用默认命名空间，则执行默认解析
11                     if (delegate.isDefaultNamespace(ele)) {
12                         parseDefaultElement(ele, delegate);
13                         // 如果该节点使用非默认命名空间，则执行自定义解析
14                     } else {
15                         delegate.parseCustomElement(ele);
16                     }
17                 }
18             }
19             // 否则使用自定义解析根节点
20         } else {
21             delegate.parseCustomElement(root);
22         }
23     }

分析：

首先判断根节点是否使用默认命名空间：

  • 如果是默认命名空间，则遍历其子节点进行解析。
  • 如果不是默认命名空间，则直接使用parseCustomElement进行解析。

DefaultBeanDefinitionDocumentReader#parseDefaultElement

 1 /**
 2      * 解析默认标签
 3      *
 4      * @param ele      当前元素节点
 5      * @param delegate BeanDefinition解析委托
 6      */
 7     private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
 8         // import标签
 9         if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
10             // 主要流程获取import标签的source属性，然后通过loadBeanDefinitions加载BeanDefinition
11             importBeanDefinitionResource(ele);
12         } else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { // alias标签
13             processAliasRegistration(ele);
14         } else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { // bean标签，主要解析标签
15             processBeanDefinition(ele, delegate);
16         } else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { // beans标签
17             // recurse
18             doRegisterBeanDefinitions(ele);
19         }
20     }

分析：

默认标签的解析分为4个分支：①import；②alias；③bean；④beans标签(进行递归，再进行解析)。这里我们主要分析日常中最常用的bean标签，其他标签解析的大致流程差不多，后面进行补充。

DefaultBeanDefinitionDocumentReader#processBeanDefinition

 1 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
 2         // 进行bean标签解析
 3         // 如果解析成功，则返回BeanDefinitionHolder，BeanDefinitionHolder为name和alias的BeanDefinition对象
 4         // 如果解析失败，则返回null
 5         BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
 6         if (bdHolder != null) {
 7             // 进行标签处理，主要对bean标签的相关属性进行处理 如： p:name="测试用例"
 8             bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
 9             try {
10                 // 注册BeanDefinition
11                 // Register the final decorated instance.
12                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
13             } catch (BeanDefinitionStoreException ex) {
14                 getReaderContext().error("Failed to register bean definition with name '" +
15                         bdHolder.getBeanName() + "'", ele, ex);
16             }
17             // 发出响应时间，通知监听器，已完成该bean标签的解析
18             // Send registration event.
19             getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
20         }
21     }

分析：

  • 首先使用委托对bean标签进行基础解析(核心处理流程)。
  • 解析成功后，再处理bean标签的一些其他属性。
  • 最后注册BeanDefintion。

BeanDefinitionParserDelegate#parseBeanDefinitionElement

 1 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {
 2         return parseBeanDefinitionElement(ele, null);
 3     }
 4 
 5 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) {
 6         // 解析id和name属性
 7         String id = ele.getAttribute(ID_ATTRIBUTE);
 8         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
 9 
10         // 计算别名集合
11         List<String> aliases = new ArrayList<>();
12         if (StringUtils.hasLength(nameAttr)) {
13             String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);
14             aliases.addAll(Arrays.asList(nameArr));
15         }
16 
17         // beanName，优先使用id
18         String beanName = id;
19         // 若beanName为空，则使用alias的第一个
20         if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {
21             // 将alias第一个元素移除别名集合
22             beanName = aliases.remove(0);
23             if (logger.isTraceEnabled()) {
24                 logger.trace("No XML 'id' specified - using '" + beanName +
25                         "' as bean name and " + aliases + " as aliases");
26             }
27         }
28 
29         // 检查beanName的唯一性
30         if (containingBean == null) {
31             checkNameUniqueness(beanName, aliases, ele);
32         }
33 
34         // 解析bean标签的属性，构造AbstractBeanDefinition
35         AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
36         if (beanDefinition != null) {
37             // 如果beanName为空
38             if (!StringUtils.hasText(beanName)) {
39                 try {
40                     // 如果containingBean不为null
41                     if (containingBean != null) {
42                         // 生成唯一的beanName
43                         beanName = BeanDefinitionReaderUtils.generateBeanName(
44                                 beanDefinition, this.readerContext.getRegistry(), true);
45                     } else {
46                         // 生成唯一的beanName
47                         beanName = this.readerContext.generateBeanName(beanDefinition);
48                         // Register an alias for the plain bean class name, if still possible,
49                         // if the generator returned the class name plus a suffix.
50                         // This is expected for Spring 1.2/2.0 backwards compatibility.
51                         // 判断beanName是否被使用
52                         String beanClassName = beanDefinition.getBeanClassName();
53                         if (beanClassName != null &&
54                                 beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&
55                                 !this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {
56                             aliases.add(beanClassName);
57                         }
58                     }
59                     if (logger.isTraceEnabled()) {
60                         logger.trace("Neither XML 'id' nor 'name' specified - " +
61                                 "using generated bean name [" + beanName + "]");
62                     }
63                 } catch (Exception ex) {
64                     error(ex.getMessage(), ele);
65                     return null;
66                 }
67             }
68             // 创建BeanDefinitionHolder对象
69             String[] aliasesArray = StringUtils.toStringArray(aliases);
70             return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
71         }
72 
73         return null;
74     }

分析： 

  • 获取bean标签的id与name属性，spring在解析bean的时候，优先使用的id值。
  • 检查beanName的唯一性，如果不唯一，则会报错。
  • (核心)解析bean的属性，构造AbstractBeanDefinition对象。
  • 如果beanDefiniton对象的beanName为空，还要为其生成一个beanName，为注册BeanDefinition做准备。
  • 最后返回BeanDefinitionHolder对象。

BeanDefinitionParserDelegate#parseBeanDefinitionElement

 1 public AbstractBeanDefinition parseBeanDefinitionElement(
 2             Element ele, String beanName, @Nullable BeanDefinition containingBean) {
 3 
 4         // 为解析bean元素加一个状态
 5         this.parseState.push(new BeanEntry(beanName));
 6 
 7         // 解析class属性
 8         String className = null;
 9         if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
10             className = ele.getAttribute(CLASS_ATTRIBUTE).trim();
11         }
12         // 解析parent属性
13         String parent = null;
14         if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
15             parent = ele.getAttribute(PARENT_ATTRIBUTE);
16         }
17 
18         try {
19             // 创建承载属性的AbstractBeanDefinition对象
20             AbstractBeanDefinition bd = createBeanDefinition(className, parent);
21             // 解析bean的各种默认属性
22             parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
23             // 提取description
24             bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));
25 
26             // 这里会解析bean标签内部的很多子元素，放入bd中
27 
28             // #1.解析元数据 <meta/>
29             parseMetaElements(ele, bd);
30             // #2.解析lookup-method属性 <lookup-method/>
31             // lookup-method:获取器注入，把一个方法声明为返回某种类型的bean，但方法的实际返回的bean是在配置文件里配置的
32             parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
33 
34             // #3.解析replace-method属性 <replace-method/>
35             // replace-method:可在运行时调用新的方法替换现有的方法，还能动态的更新原有方法的逻辑
36             parseReplacedMethodSubElements(ele, bd.getMethodOverrides());
37 
38             // #4.解析构造函数参数 <constructor-arg/>
39             parseConstructorArgElements(ele, bd);
40             // #5.解析property子元素 <property/>
41             parsePropertyElements(ele, bd);
42             // #6.解析qualifier子元素 <qualifier/>
43             parseQualifierElements(ele, bd);
44 
45             // 设置resource
46             bd.setResource(this.readerContext.getResource());
47             bd.setSource(extractSource(ele));
48 
49             return bd;
50         } catch (ClassNotFoundException ex) {
51             error("Bean class [" + className + "] not found", ele, ex);
52         } catch (NoClassDefFoundError err) {
53             error("Class that bean class [" + className + "] depends on not found", ele, err);
54         } catch (Throwable ex) {
55             error("Unexpected failure during bean definition parsing", ele, ex);
56         } finally {
57             this.parseState.pop();
58         }
59 
60         return null;
61     }

分析：

  • 首先获取bean标签的class和parent属性，用于创建承载属性的AbstractBeanDefinition对象[由这两个属性就可以创建AbstractBeanDefinition对象了]。
  • 接下来就是对bean标签进行各种解析，并将解析的数据赋值到AbstractBeanDefinition中。

BeanDefinitionParserDelegate#createBeanDefinition

 1 protected AbstractBeanDefinition createBeanDefinition(@Nullable String className, @Nullable String parentName)
 2             throws ClassNotFoundException {
 3 
 4         return BeanDefinitionReaderUtils.createBeanDefinition(
 5                 parentName, className, this.readerContext.getBeanClassLoader());
 6     }
 7 
 8 
 9 //BeanDefinitionReaderUtils#creatBeanDefinition
10 
11 public static AbstractBeanDefinition createBeanDefinition(
12             @Nullable String parentName, @Nullable String className, @Nullable ClassLoader classLoader) throws ClassNotFoundException {
13 
14         // 创建GenericBeanDefinition对象
15         GenericBeanDefinition bd = new GenericBeanDefinition();
16         // 设置parentName
17         bd.setParentName(parentName);
18         // 在className不为空的情况下，进行相关属性的设置
19         if (className != null) {
20             // 如果classLoader不为空，这里就会直接通过反射加载类 ？为了提升速度
21             if (classLoader != null) {
22                 bd.setBeanClass(ClassUtils.forName(className, classLoader));
23             }
24             // 设置beanClassName的名字
25             else {
26                 bd.setBeanClassName(className);
27             }
28         }
29         return bd;
30     }

分析：

BeanDefinition的创建是通过BeanDefinitionReaderUtils#createBeanDefinition方法实现的，代码逻辑简单，主要注意生成的BeanDefinition对象是GenericBeanDefinition。

BeanDefinitionParserDelegate#parseBeanDefinitionAttributes

 1 public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
 2                                                                 @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) {
 3         // 如果有singleton属性则抛出异常，因为singleton属性已进行升级
 4         if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
 5             error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
 6             // 解析scope属性
 7         } else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
 8             bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
 9             // 如果BeanDefinition不为空，则使用当前BeanDefinition的scope
10         } else if (containingBean != null) {
11             // Take default from containing bean in case of an inner bean definition.
12             bd.setScope(containingBean.getScope());
13         }
14         // 解析abstract属性
15         if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
16             bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
17         }
18 
19         // 解析lazy-init属性 lazy-init属性默认为false
20         String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
21         if (isDefaultValue(lazyInit)) {
22             lazyInit = this.defaults.getLazyInit();
23         }
24         bd.setLazyInit(TRUE_VALUE.equals(lazyInit));
25 
26         // 解析autowire属性
27         String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
28         bd.setAutowireMode(getAutowireMode(autowire));
29 
30         // 解析depends-on属性
31         if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
32             String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
33             bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
34         }
35 
36         // 解析autowire-candidate属性
37         String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE);
38         if (isDefaultValue(autowireCandidate)) {
39             String candidatePattern = this.defaults.getAutowireCandidates();
40             if (candidatePattern != null) {
41                 String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern);
42                 bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName));
43             }
44         } else {
45             bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate));
46         }
47 
48         // 解析primary属性
49         if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
50             bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
51         }
52 
53         // 解析init-method属性 设置bean的初始值方法
54         if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
55             String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
56             bd.setInitMethodName(initMethodName);
57         } else if (this.defaults.getInitMethod() != null) {
58             bd.setInitMethodName(this.defaults.getInitMethod());
59             bd.setEnforceInitMethod(false);
60         }
61 
62         // 解析destroy-method属性
63         if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
64             String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
65             bd.setDestroyMethodName(destroyMethodName);
66         } else if (this.defaults.getDestroyMethod() != null) {
67             bd.setDestroyMethodName(this.defaults.getDestroyMethod());
68             bd.setEnforceDestroyMethod(false);
69         }
70 
71         // 解析factory-method属性
72         if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
73             bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
74         }
75         // 解析factory-bean属性
76         if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
77             bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
78         }
79 
80         return bd;
81     }

分析：

该函数是对bean标签的默认属性做解析，最终解析后的值封装在BeanDefinition中，代码逻辑简单，函数中已给出相应注释。这里要注意一点lazy-init属性的默认值为false。

介于篇幅原因，这里不在分析bean标签默认属性的解析过程，后续会对一些重要的方法进行补充，下面将分析BeanDefinition的注册过程。

总结

本文主要分析了BeanDefinition注册之前的一些准备工作，还未进入核心流程，后面将进入BeanDefinition注册的核心流程。

ps：笔者希望每篇文章不要写太长，尽量做到短小精悍。

by Shawn Chen，2018.12.8日，下午。

posted @ 2018-12-08 15:13  developer_chan  阅读(520)  评论(0)  编辑  收藏  举报