上一节分析了Spring将xml文件转换为Document对象的过程，接下来Spring会对已转换的Document对象进行解析。打开XmlBeanDefinitionReader类的registerBeanDefinitions方法。打开DefaultBeanDefinitionDocumentReader类的doRegisterBeanDefinitions方法。
1. 引言
public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException { // 1、创建documentReader对象 BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader(); // 2、读取已经注册的bean个数 int countBefore = getRegistry().getBeanDefinitionCount(); // 3、解析Document并注册BeanDefinition documentReader.registerBeanDefinitions(doc, createReaderContext(resource)); // 4、返回本次注册的bean个数 return getRegistry().getBeanDefinitionCount() - countBefore; }
该方法总共分为了四步，第三步是执行对Document对象解析和注册BeanDefinition。先来看对Document对象的解析过程。
2.doRegisterBeanDefinitions方法分析
protected void doRegisterBeanDefinitions(Element root) { // 1、创建BeanDefinitionParserDelegate对象，用来解析Element元素 BeanDefinitionParserDelegate parent = this.delegate; this.delegate = createDelegate(getReaderContext(), root, parent); // 2、解析并验证profile节点，如果配置了profile属性，则验证当前环境是否激活了对应的profile节点， // 用于多开发环境配置，该方式在开发中已不多见。 // 例如：System.setProperty("spring.profiles.active", "dev"); 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)) { return; } } } // 3、解析前置处理，空的模板方法 preProcessXml(root); // 4、解析并注册BeanDefinition parseBeanDefinitions(root, this.delegate); // 5、解析后置处理，空的模板方法 postProcessXml(root); this.delegate = parent; }
doRegisterBeanDefinitions方法并没有自己去执行对xml节点的解析而是委托给了BeanDefinitionParserDelegate，通过代理去解析xml节点。Spring的xml文件又可能包含默认命名空间和自定义命名空间，我们来看Spring是如何进行处理的。
3.parseBeanDefinitions方法简析
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) { // 1、解析默认命名空间 if (delegate.isDefaultNamespace(root)) { NodeList nl = root.getChildNodes(); for (int i = 0; i < nl.getLength(); i++) { Node node = nl.item(i); if (node instanceof Element) { Element ele = (Element) node; // 默认命名空间 if (delegate.isDefaultNamespace(ele)) { parseDefaultElement(ele, delegate); } // 自定义命名空间 else { delegate.parseCustomElement(ele); } } } } // 2、解析自定义命名空间 else { delegate.parseCustomElement(root); } }
这与上一节的xml解析分析大致相同，只是增加了对命名空间的判断，针对不同的命名空间使用不同的方法进行解析。先来看对默认命名空间中的标签的解析。
4.parseDefaultElement解析默认标签
private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) { // 1、解析import标签，并注册beanDefinition if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) { importBeanDefinitionResource(ele); } // 2、解析alias标签，并注册别名 else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) { processAliasRegistration(ele); } // 3、解析bean标签，并注册beanDefinition else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) { processBeanDefinition(ele, delegate); } // 4、解析beans标签 else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) { doRegisterBeanDefinitions(ele); } }
代码到这里，相信大家已经有所了然了，日常开发中的常见标签已经展现出来了（虽然现在提倡无配置文件，但是还是要对其原理有所了解）。parseDefaultElement方法对import、alias、bean、beans四种标签分别做了单独处理，bean标签的解析最复杂也是一个比较基础的操作，先来看对bean标签的解析，如果大家能够了解bean的解析，那么其他的解析过程相信大家都能看懂，因为相对而言要比解析bean标签简单的多。
5.解析Bean标签
/** * 解析bean标签将其转换为definition并注册到BeanDefinitionRegistry * Process the given bean element, parsing the bean definition and registering it with the registry. */ protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // 1、将解析的节点信息封装至BeanDefinitionHolder对象 // BeanDefinitionHolder-->封装了BeanDefinition,beanName以及aliases BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { // 2、装饰BeanDefinition bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder); try { // Register the final decorated instance. // 3、执行注册 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry()); } catch (BeanDefinitionStoreException ex) { getReaderContext().error("Failed to register bean definition with name '" + bdHolder.getBeanName() + "'", ele, ex); } // Send registration event. // 4、发送注册事件 getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder)); } }
可以看到Spring将解析之后的内容封装至了BeanDefinitionHolder类，该类封装了BeanDefinition,beanName以及aliases，BeanDefinition封装了bean标签的各种信息。
该方法还执行了对BeanDefinition的注册，留在下节分析。来看bean标签解析的具体过程。
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, @Nullable BeanDefinition containingBean) { // 1、解析bean的id和bean的别名 // 获取id标签属性 String id = ele.getAttribute(ID_ATTRIBUTE); // 获取name（别名）标签属性，缓存至List集合 String nameAttr = ele.getAttribute(NAME_ATTRIBUTE); List<String> aliases = new ArrayList<>(); if (StringUtils.hasLength(nameAttr)) { String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS); aliases.addAll(Arrays.asList(nameArr)); } // 如果bean的id为空，但是别名不为空的话，那么默认采用第一个别名作为beanName // 例如：<bean class="com.lyc.cn.v2.day01.Dog" name="myDog1,myDog2"/>，使用myDog1作为beanName String beanName = id; if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) { beanName = aliases.remove(0); } // 2、containingBean不为空，则检查beanName和别名是否被使用 if (containingBean == null) { checkNameUniqueness(beanName, aliases, ele); } // 3、解析bean标签，将其转换为BeanDefinition对象 AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean); // 4、如果beanDefinition且未配置bean的id属性，name属性，则为当前bean生成id和别名 // 例如：<bean class="com.lyc.cn.v2.day01.Dog"/>，<bean factory-bean="dog4"/>，<bean parent="outer"/>等 if (beanDefinition != null) { if (!StringUtils.hasText(beanName)) { try { // containingBean不为null，则当前bean是内部bean，使用BeanDefinitionReaderUtils生成beanName if (containingBean != null) { beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true); } else { // 否则，使用XmlReaderContext对象生成beanName 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类名注册一个别名。这在Spring 1.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); } } } catch (Exception ex) { error(ex.getMessage(), ele); return null; } } // 5、创建并返回BeanDefinitionHolder对象 String[] aliasesArray = StringUtils.toStringArray(aliases); return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray); } return null; }
首先对id，name属性进行解析，该过程比较简单，接下来就是对bean中其他属性的解析。来看parseBeanDefinitionElement方法。
public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, @Nullable BeanDefinition containingBean) { this.parseState.push(new BeanEntry(beanName)); // 1、解析class属性 String className = null; if (ele.hasAttribute(CLASS_ATTRIBUTE)) { className = ele.getAttribute(CLASS_ATTRIBUTE).trim(); } // 2、解析parent属性 String parent = null; if (ele.hasAttribute(PARENT_ATTRIBUTE)) { parent = ele.getAttribute(PARENT_ATTRIBUTE); } try { // 3、创建AbstractBeanDefinition对象 AbstractBeanDefinition bd = createBeanDefinition(className, parent); // 4、解析bean标签属性 parseBeanDefinitionAttributes(ele, beanName, containingBean, bd); bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT)); // 5、解析meta标签 parseMetaElements(ele, bd); // 6、解析lookup-method属性 parseLookupOverrideSubElements(ele, bd.getMethodOverrides()); // 7、解析replace-method属性 parseReplacedMethodSubElements(ele, bd.getMethodOverrides()); // 8、解析构造函数参数 parseConstructorArgElements(ele, bd); // 9、解析property属性 parsePropertyElements(ele, bd); // 10、解析qualifier属性 parseQualifierElements(ele, bd); // 11、设置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(); } return null; }
该方法涉及的细节较多，篇幅限制，只对其中比较重要比较常见的方法进行分析。分析第四步解析bean标签属性。
public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName, @Nullable BeanDefinition containingBean, AbstractBeanDefinition bd) { // 1、设置bean作用域 if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) { error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele); } else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) { bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE)); } else if (containingBean != null) { // Take default from containing bean in case of an inner bean definition. // 未明确指定bean的作用域,且当前被解析bean是内部bean的话， // 则默认使用outer bean的的作用域作为当前bean的作用域 // 例如:下面的配置，解析到inner属性时，inner未指定作用域，则使用outer的作用域，也就是prototype /** <bean id="outer" class="com.lyc.cn.v2.day01.inner.Outer" scope="prototype"> <property name="inner"> <bean id="inner" class="com.lyc.cn.v2.day01.inner.Inner"/> </property> </bean> **/ bd.setScope(containingBean.getScope()); } // 2、设置abstract属性 if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) { bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE))); } // 3、设置lazy-init(延迟加载)属性； // 如果该属性为true的话，ApplicationContext容器在初始化时不会加载该bean； // 而是在第一次向容器索取该bean时才会被初始化 String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE); if (DEFAULT_VALUE.equals(lazyInit)) { lazyInit = this.defaults.getLazyInit(); } bd.setLazyInit(TRUE_VALUE.equals(lazyInit)); // 4、设置autowire属性，此属性默认不开启 String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE); bd.setAutowireMode(getAutowireMode(autowire)); // 5、设置depends-on属性，如果BeanA依赖于BeanB，可通过depends-on属性使BeanB在BeanA之前完初始化 if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) { String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE); bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS)); } // 6、设置autowire-candidate属性，当一个接口有多个实现类时， // 配置autowire-candidate属性可以明确指定实现类是否参与自动注入 String autowireCandidate = ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE); if ("".equals(autowireCandidate) || DEFAULT_VALUE.equals(autowireCandidate)) { String candidatePattern = this.defaults.getAutowireCandidates(); if (candidatePattern != null) { String[] patterns = StringUtils.commaDelimitedListToStringArray(candidatePattern); bd.setAutowireCandidate(PatternMatchUtils.simpleMatch(patterns, beanName)); } } else { bd.setAutowireCandidate(TRUE_VALUE.equals(autowireCandidate)); } // 7、设置primary属性，当byType注入有多个类型时， // 可以指定primary="true"，提高注入的优先级，避免抛出异常 if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) { bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE))); } // 8、设置init-method，bean初始化完成后回调该方法 if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) { String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE); bd.setInitMethodName(initMethodName); } else if (this.defaults.getInitMethod() != null) { // 尝试从DocumentDefaultsDefinition对象中获取init-method属性 // DocumentDefaultsDefinition对象保存了Spring bean的一些简单设置， // 我们可以通过该类设定通用的bean属性模板 bd.setInitMethodName(this.defaults.getInitMethod()); bd.setEnforceInitMethod(false); } // 9、设置destroy-method属性，bean销毁后回调该方法 if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) { String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE); bd.setDestroyMethodName(destroyMethodName); } else if (this.defaults.getDestroyMethod() != null) { // 尝试从DocumentDefaultsDefinition对象中获取destroy-method属性 bd.setDestroyMethodName(this.defaults.getDestroyMethod()); bd.setEnforceDestroyMethod(false); } // 10、设置factory-method属性，该属性可指定静态工厂或实例工厂方法实例化bean if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) { bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE)); } // 11、设置factory-bean属性，一般和factory-method属性一起使用， // 指定工厂bean和工厂bean的工厂方法 if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) { bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE)); } return bd; }
其他的方法大家可以通过在配置文件中配置属性，debug跟踪调试，不在一一赘述。到这里Spring已经将xml中的配置信息封装至BeanDefinitionHolder对象，接下来就可以执行对bean的注册了。
另外对bean name的生成策略简单分析一下：
上面parseBeanDefinitionElement方法已经有所简介，来看一下具体过程：
public static String generateBeanName(BeanDefinition definition, BeanDefinitionRegistry registry, boolean isInnerBean) throws BeanDefinitionStoreException { // 1、获取bean的className String generatedBeanName = definition.getBeanClassName(); // 2、如果generatedBeanName为null， // 则判断其是否有parent属性或者factory-bean并生成generatedBeanName if (generatedBeanName == null) { // parent属性不为空 if (definition.getParentName() != null) { generatedBeanName = definition.getParentName() + "$child"; } // factory-bean属性不为空 else if (definition.getFactoryBeanName() != null) { generatedBeanName = definition.getFactoryBeanName() + "$created"; } } // 3、如果上述方法均无法生成generatedBeanName，则抛出异常 if (!StringUtils.hasText(generatedBeanName)) { throw new BeanDefinitionStoreException("Unnamed bean definition specifies neither " + "'class' nor 'parent' nor 'factory-bean' - can't " + "generate bean name"); } // 4、判断是否内部bean，并根据生成的generatedBeanName，拼接最终的beanName返回 String id = generatedBeanName; if (isInnerBean) { // Inner bean: generate identity hashcode suffix. // GENERATED_BEAN_NAME_SEPARATOR--># id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + ObjectUtils.getIdentityHexString(definition); } else { // Top-level bean: use plain class name. // Increase counter until the id is unique. int counter = -1; while (counter == -1 || registry.containsBeanDefinition(id)) { counter++; // GENERATED_BEAN_NAME_SEPARATOR--># id = generatedBeanName + GENERATED_BEAN_NAME_SEPARATOR + counter; } } return id; }
这一部分的代码比较多，也比较细，一时间找不到应该如何写才能让读者更清晰的了解解析过程，感兴趣的多多调试跟踪代码吧。
