spring解析配置文件（三）

一、从XmlBeanDefinitionReader的registerBeanDefinitions（doc,resource）开始

 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
             throws BeanDefinitionStoreException {
         try {
             Document doc = doLoadDocument(inputSource, resource);
             return registerBeanDefinitions(doc, resource);
         }

进入第5行的registerBeanDefinitions方法

 public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
         BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
         int countBefore = getRegistry().getBeanDefinitionCount();
         documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
         return getRegistry().getBeanDefinitionCount() - countBefore;
     }

第二行创建了一个bean定义文档阅读器，创建的代码如下，第三行的getRegistry()方法得到是DefaultListableBeanFactory类的实例，是个bean工厂，这个工厂在准备读取xml时创建xml阅读器的时候就已经设置进去，getBeanDefinitions方法里的代码就这一句this.beanDefinitionMap.size()，获取bean定义容器的大小，很显然对于我这里是没有的，因为还没解析xml。

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

在看看第4行的documentReader.registerBeanDefinitions这个方法

 @Override
     public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
         this.readerContext = readerContext;
         logger.debug("Loading bean definitions");
         Element root = doc.getDocumentElement();
         doRegisterBeanDefinitions(root);
     }

第5行获得了xml的根元素<beans>然后调用

doRegisterBeanDefinitions方法，并把根元素传入进入

 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 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)) {
                     return;
                 }
             }
         }

22         preProcessXml(root);
23         parseBeanDefinitions(root, this.delegate);
         postProcessXml(root);

         this.delegate = parent;
     }

第9行创建了使用createDelegate方法创建了一个BeanDefinitionParserDelegate类的实例，它内部的代码如下

 protected BeanDefinitionParserDelegate createDelegate(
             XmlReaderContext readerContext, Element root, BeanDefinitionParserDelegate parentDelegate) {

         BeanDefinitionParserDelegate delegate = new BeanDefinitionParserDelegate(readerContext);
         delegate.initDefaults(root, parentDelegate);
         return delegate;
     }

第4行的readerContext是一个XMLReaderContext，继续往下调用了initDefaults方法，初始化默认值

 public void initDefaults(Element root, BeanDefinitionParserDelegate parent) {
         populateDefaults(this.defaults, (parent != null ? parent.defaults : null), root);
         this.readerContext.fireDefaultsRegistered(this.defaults);
     }

进入populateDefaults方法

 protected void populateDefaults(DocumentDefaultsDefinition defaults, DocumentDefaultsDefinition parentDefaults, Element root) {
         String lazyInit = root.getAttribute(DEFAULT_LAZY_INIT_ATTRIBUTE);
         if (DEFAULT_VALUE.equals(lazyInit)) {
             // Potentially inherited from outer <beans> sections, otherwise falling back to false.
             lazyInit = (parentDefaults != null ? parentDefaults.getLazyInit() : FALSE_VALUE);
         }
         defaults.setLazyInit(lazyInit);

         String merge = root.getAttribute(DEFAULT_MERGE_ATTRIBUTE);
         if (DEFAULT_VALUE.equals(merge)) {
             // Potentially inherited from outer <beans> sections, otherwise falling back to false.
             merge = (parentDefaults != null ? parentDefaults.getMerge() : FALSE_VALUE);
         }
         defaults.setMerge(merge);

         String autowire = root.getAttribute(DEFAULT_AUTOWIRE_ATTRIBUTE);
         if (DEFAULT_VALUE.equals(autowire)) {
             // Potentially inherited from outer <beans> sections, otherwise falling back to 'no'.
             autowire = (parentDefaults != null ? parentDefaults.getAutowire() : AUTOWIRE_NO_VALUE);
         }
         defaults.setAutowire(autowire);

         // Don't fall back to parentDefaults for dependency-check as it's no longer supported in
         // <beans> as of 3.0. Therefore, no nested <beans> would ever need to fall back to it.
         defaults.setDependencyCheck(root.getAttribute(DEFAULT_DEPENDENCY_CHECK_ATTRIBUTE));

         if (root.hasAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE)) {
             defaults.setAutowireCandidates(root.getAttribute(DEFAULT_AUTOWIRE_CANDIDATES_ATTRIBUTE));
         }
         else if (parentDefaults != null) {
             defaults.setAutowireCandidates(parentDefaults.getAutowireCandidates());
         }

         if (root.hasAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE)) {
             defaults.setInitMethod(root.getAttribute(DEFAULT_INIT_METHOD_ATTRIBUTE));
         }
         else if (parentDefaults != null) {
             defaults.setInitMethod(parentDefaults.getInitMethod());
         }

         if (root.hasAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE)) {
             defaults.setDestroyMethod(root.getAttribute(DEFAULT_DESTROY_METHOD_ATTRIBUTE));
         }
         else if (parentDefaults != null) {
             defaults.setDestroyMethod(parentDefaults.getDestroyMethod());
         }

         defaults.setSource(this.readerContext.extractSource(root));
     }

第2行的DEFAULT_LAZY_INIT_ATTRIBUTE的值是default-lazy-init，第7行设置懒加载，还有默认的初始化方法什么的，把这些个属性全都设置到

DocumentDefaultsDefinition 中。这个方法返回后继续调用了XmlReaderContext的fireDefaultsRegistered方法，不过里面啥都没做。

接下来有回到了doRegisterBeanDefinitions方法

 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 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)) {
                     return;
                 }
             }
         }

         preProcessXml(root);
         parseBeanDefinitions(root, this.delegate);
         postProcessXml(root);

         this.delegate = parent;
     }

第11行判断当前的根元素是否是默认的命名空间，spring中存在着两种标签，一种是默认的标签，另一种是自定义标签

第12行获得profile属性，这个属性应用于对个beans标签的情况，从spring3开始的，这样我们可以写多套bean定义，特别是使用到数据源的时候，可以切换不同的数据源，想要使用哪个bean定义就激活谁，想详细了解的，可以去查查资料。

第22行是个空方法，里面什么也没做，这个地方可以进行扩展，在解析bean定义之前，可以先处理自定义的标签

第23行方法的代码如下

 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
         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);
                     }
                 }
             }
         }
         else {
             delegate.parseCustomElement(root);
         }
     }

第2行判断root是否是默认的命名空间，第3行获得根元素下的子节点，循环遍历子节点，第8行判断每个子节点是否是默认的命名空间，如果是就执行parseDefaultElement方法，否则

执行parseCustomElement方法，什么是自定义的标签呢，比如用户自己实现的标签，还有就是spring的aop，tx这类标签都是有自定义的命名空间的标签

我们进到parseCustomElement方法中看看

 public BeanDefinition parseCustomElement(Element ele, BeanDefinition containingBd) {
         String namespaceUri = getNamespaceURI(ele);
         NamespaceHandler handler = this.readerContext.getNamespaceHandlerResolver().resolve(namespaceUri);
         if (handler == null) {
             error("Unable to locate Spring NamespaceHandler for XML schema namespace [" + namespaceUri + "]", ele);
             return null;
         }
         return handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));
     }

第2行获取这个元素的命名空间，通过命名空间可以在类路径下的spring.handlers中找到对应的处理器，在spring.schemas中找到对应的xsd文件。进入resolve方法查看一下他的

代码逻辑

 @Override
     public NamespaceHandler resolve(String namespaceUri) {
         Map<String, Object> handlerMappings = getHandlerMappings();
         Object handlerOrClassName = handlerMappings.get(namespaceUri);
         if (handlerOrClassName == null) {
             return null;
         }
         else if (handlerOrClassName instanceof NamespaceHandler) {
             return (NamespaceHandler) handlerOrClassName;
         }
         else {
             String className = (String) handlerOrClassName;
             try {
                 Class<?> handlerClass = ClassUtils.forName(className, this.classLoader);
                 if (!NamespaceHandler.class.isAssignableFrom(handlerClass)) {
                     throw new FatalBeanException("Class [" + className + "] for namespace [" + namespaceUri +
                             "] does not implement the [" + NamespaceHandler.class.getName() + "] interface");
                 }
                 NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                 namespaceHandler.init();
                 handlerMappings.put(namespaceUri, namespaceHandler);
                 return namespaceHandler;
             }
             catch (ClassNotFoundException ex) {
                 throw new FatalBeanException("NamespaceHandler class [" + className + "] for namespace [" +
                         namespaceUri + "] not found", ex);
             }
             catch (LinkageError err) {
                 throw new FatalBeanException("Invalid NamespaceHandler class [" + className + "] for namespace [" +
                         namespaceUri + "]: problem with handler class file or dependent class", err);
             }
         }
     }

第3行代码getHandlerMappings（）获得所有的命名空间和处理程序的映射

 private Map<String, Object> getHandlerMappings() {
         if (this.handlerMappings == null) {
             synchronized (this) {
                 if (this.handlerMappings == null) {
                     try {
                         Properties mappings =
                                 PropertiesLoaderUtils.loadAllProperties(this.handlerMappingsLocation, this.classLoader);
                         if (logger.isDebugEnabled()) {
                             logger.debug("Loaded NamespaceHandler mappings: " + mappings);
                         }
                         Map<String, Object> handlerMappings = new ConcurrentHashMap<String, Object>(mappings.size());
                         CollectionUtils.mergePropertiesIntoMap(mappings, handlerMappings);
                         this.handlerMappings = handlerMappings;
                     }
                     catch (IOException ex) {
                         throw new IllegalStateException(
                                 "Unable to load NamespaceHandler mappings from location [" + this.handlerMappingsLocation + "]", ex);
                     }
                 }
             }
         }
         return this.handlerMappings;
     }

进入第7行看看

 public static Properties loadAllProperties(String resourceName, ClassLoader classLoader) throws IOException {
         Assert.notNull(resourceName, "Resource name must not be null");
         ClassLoader classLoaderToUse = classLoader;
         if (classLoaderToUse == null) {
             classLoaderToUse = ClassUtils.getDefaultClassLoader();
         }
         Enumeration<URL> urls = (classLoaderToUse != null ? classLoaderToUse.getResources(resourceName) :
                 ClassLoader.getSystemResources(resourceName));
         Properties props = new Properties();
         while (urls.hasMoreElements()) {
             URL url = urls.nextElement();
             URLConnection con = url.openConnection();
             ResourceUtils.useCachesIfNecessary(con);
             InputStream is = con.getInputStream();
             try {
                 if (resourceName.endsWith(XML_FILE_EXTENSION)) {
                     props.loadFromXML(is);
                 }
                 else {
                     props.load(is);
                 }
             }
             finally {
                 is.close();
             }
         }
         return props;
     }

它是通过加载器加载classpath下的META-INF/spring.handler文件，使用jdk的Properties方法加载，加载完后返回properties的实例，最后拿到对应的标签处理器

拿到命名空间处理器的类名后

 NamespaceHandler namespaceHandler = (NamespaceHandler) BeanUtils.instantiateClass(handlerClass);
                 namespaceHandler.init();
                 handlerMappings.put(namespaceUri, namespaceHandler);
                 return namespaceHandler;

第1行使用bean助手类实例化了这个命名空间处理器，并进行了初始化，加入我显示使用的是aop的命名空间，那么这个命名空间处理器是AopNamespaceHandler类的实例

它对应init方法代码如下：这个aop命名空间处理器中拥有下面这些类别的标签解析器，第一个我们是最属性的，这个解析器里提供了aop：config标签中pointcut，before之类的解析方法

第3行将初始化好的命名空间处理器放到handlerMappings中，如果下次要使用就直接可以拿到，不需要在此实例化

@Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

下面是一些bean定义解析器的继承结构，各种各样的解析器

向处理器中注册解析器

 protected final void registerBeanDefinitionParser(String elementName, BeanDefinitionParser parser) {
         this.parsers.put(elementName, parser);
     }

第2行的parsers是一个Map,用来存放bean定义解析器

得到命名空间处理器后再调用命名空间处理器的parse方法handler.parse(ele, new ParserContext(this.readerContext, this, containingBd));

进入parse方法，这个方法又调用了findParserForElement方法

 private BeanDefinitionParser findParserForElement(Element element, ParserContext parserContext) {
　　　　　　
         String localName = parserContext.getDelegate().getLocalName(element);
         BeanDefinitionParser parser = this.parsers.get(localName);
         if (parser == null) {
             parserContext.getReaderContext().fatal(
                     "Cannot locate BeanDefinitionParser for element [" + localName + "]", element);
         }
         return parser;
     }

第2行，通过这个元素拿到了它的本地名字，比如aop：config元素的本地名为config

通过config从命名空间中的解析器map容器中拿到了对应的解析器，然后调用这个aop的config解析器的parse方法

 @Override
     public BeanDefinition parse(Element element, ParserContext parserContext) {
         CompositeComponentDefinition compositeDef =
 4                 new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
         parserContext.pushContainingComponent(compositeDef);

         configureAutoProxyCreator(parserContext, element);

         List<Element> childElts = DomUtils.getChildElements(element);
         for (Element elt: childElts) {
             String localName = parserContext.getDelegate().getLocalName(elt);
             if (POINTCUT.equals(localName)) {
                 parsePointcut(elt, parserContext);
             }
             else if (ADVISOR.equals(localName)) {
                 parseAdvisor(elt, parserContext);
             }
             else if (ASPECT.equals(localName)) {
                 parseAspect(elt, parserContext);
             }
         }

         parserContext.popAndRegisterContainingComponent();
         return null;
     }

第三行创建了一个组件定义，并将它压入ParseContext上下文中的stack中

进入第7行的方法

 private void configureAutoProxyCreator(ParserContext parserContext, Element element) {
         AopNamespaceUtils.registerAspectJAutoProxyCreatorIfNecessary(parserContext, element);
     }

这个方法是在配置自动代理创建者，这个方法在配置了<aop:config>才使用，如果你配置的是<aop:aspect-autoproxy/>这个标签，就会使用AspectJAutoProxyBeanDefinitionParser这个类的解析器。回到aop：config这个标签的解析器，上面的第2行使用了AopNamespaceUtils aop命名空间助手类注册一个自动代理切面创建者，进入这个方法看看

 public static void registerAspectJAutoProxyCreatorIfNecessary(
             ParserContext parserContext, Element sourceElement) {

         BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAutoProxyCreatorIfNecessary(
5                 parserContext.getRegistry(), parserContext.extractSource(sourceElement));
         useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
         registerComponentIfNecessary(beanDefinition, parserContext);
     }

第4行调用了registerAspectJAutoProxyCreatorIfNecessary的重载方法，这个方法传入了BeanRegistry类的对象（这里的这个实例实际上是DefaultListableBeanFactory）和ParseContext包装后的可提取资源实例
进入这个方法查看一下它的代码

 public static BeanDefinition registerAspectJAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
         return registerOrEscalateApcAsRequired(AspectJAwareAdvisorAutoProxyCreator.class, registry, source);
     }

第2行传入了一个AspectJAwareAdvisorAutoProxyCreator.class类对象，暂且不管它是干啥的，继续往下看

 private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
         Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
         if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
             BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
             if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                 int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                 int requiredPriority = findPriorityForClass(cls);
                 if (currentPriority < requiredPriority) {
                     apcDefinition.setBeanClassName(cls.getName());
                 }
             }
             return null;
         }
         RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
         beanDefinition.setSource(source);
         beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
         beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
         registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
         return beanDefinition;
     }

第3行判断这个BeanFactory中的BeanDefinitionMap容器中是否存在一个key叫做AUTO_PROXY_CREATOR_BEAN_NAME

（org.springframework.aop.config.internalAutoProxyCreator）的元素，如果存在就获得他的BeanDefinition对象，并且与我们传进来的AspectJAwareAdvisorAutoProxyCreator

类名是否一样，如果一样就要根据优先级来选择其中一个作为自动创建代理类，在AopConfigUtils类中有个静态的属性list集合APC_PRIORITY_LIST，

它在静态块中初始化

 private static final List<Class<?>> APC_PRIORITY_LIST = new ArrayList<Class<?>>();

     /**
      * Setup the escalation list.
      */
     static {
         APC_PRIORITY_LIST.add(InfrastructureAdvisorAutoProxyCreator.class);
         APC_PRIORITY_LIST.add(AspectJAwareAdvisorAutoProxyCreator.class);
         APC_PRIORITY_LIST.add(AnnotationAwareAspectJAutoProxyCreator.class);
     }

我们在看看findPriorityForClass（）方法

private static int findPriorityForClass(String className) {
        for (int i = 0; i < APC_PRIORITY_LIST.size(); i++) {
            Class<?> clazz = APC_PRIORITY_LIST.get(i);
            if (clazz.getName().equals(className)) {
                return i;
            }
        }
        throw new IllegalArgumentException(
                "Class name [" + className + "] is not a known auto-proxy creator class");
    }

}

看见了，它是以这些定义的顺序进行决定优先级的，只不过在集合中越后，优先级就越高

让我们再次返回到registerOrEscalateApcAsRequired这个方法

 private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
         Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
         if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
             BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
             if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                 int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                 int requiredPriority = findPriorityForClass(cls);
                 if (currentPriority < requiredPriority) {
                     apcDefinition.setBeanClassName(cls.getName());
                 }
             }
             return null;
         }
         RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
         beanDefinition.setSource(source);
         beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
         beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
         registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
         return beanDefinition;
     }

如果容器中没有AUTO_PROXY_CREATOR_BEAN_NAME对应的自动代理器，那么就跳到第14行，创建一个AspectJAwareAdvisorAutoProxyCreator实例注入到RootBeanDefinition类中，这个类是BeanDefinition的子类，第16行设置了这个BeanDefinition的优先级，第17行设置这个BeanDefinition的角色定位，用户自己定义的bean的角色是BeanDefinition.ROLE_APPLICTION

第18行向beanFactory中注册这个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");

         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<String>(this.beanDefinitionNames.size() + 1);
                     updatedDefinitions.addAll(this.beanDefinitionNames);
                     updatedDefinitions.add(beanName);
                     this.beanDefinitionNames = updatedDefinitions;
                     if (this.manualSingletonNames.contains(beanName)) {
                         Set<String> updatedSingletons = new LinkedHashSet<String>(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;
         }

         if (oldBeanDefinition != null || containsSingleton(beanName)) {
             resetBeanDefinition(beanName);
         }
     }

第10行对这个BeanDefinition进行验证，如果这个BeanDefinition有需要重载的方法，并且还存在工厂方法，那就报错，这两者不能共存。静态工厂必须创建bean的实例

什么是重载的方法，比如使用了lookup-method，replace-method这些标签，比如：

<bean id="service" class="com.test.UserService" scope="prototype" />

<bean id="userService" class="com.test.UserServiceCreator">

　　<lookup-method name="getService" bean="server" />

</bean>

我们调用UserServiceCreator的getService，取出来的值是UseService的实例，如果此时我们把UserSericeCreator设置一个静态工厂方法，修改成下面这种

<bean id="userService" class="com.test.UserServiceCreator" factory-method="createService">

　　<lookup-method name="getService" bean="server" />

</bean>

这样配置是错误的，在Spring创建bean实例的时候，spring就不知你要创建的是哪个对象了，这个id为userService的bean应该是UserServiceCreator的代理实例（方法重载会用到动态代理）还是工厂方法createService创建的UserService实例，所以只能报错。

第20行是获得老的BeanDefinition，如果存在老的BeanDefinition，就检查是否允许覆盖

第49行将定义好的BeanDefinition存到BeanFactory的beanDefinitionMap中，覆盖oldBeanDefinition

如果不存在oldBeanDefinition，那么跳到52行，判断是不是已经开始开始创建bean了，内部代码只是判断bean工厂的属性alreadyCreated集合是否不为空，为空就表示还没有开始，不为空表示开始了

第69行将BeanDefinition注册到容器中，第70行将BeanDefinition的名字注入到容器中

创建好AspectJAwareAdvisorAutoProxyCreator类的BeanDefinition后，继续调用了AopNamespaceUtils的useClassProxyingIfNecessary方法

 private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
         if (sourceElement != null) {
             boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
             if (proxyTargetClass) {
                 AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
             }
             boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
             if (exposeProxy) {
                 AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
             }
         }
     }

第3行的PROXY_TARGET_CLASS_ATTRIBUTE的值为proxy-target-class，如果这个属性为true那么就使用cglib做代理，默认为false使用JDK的动态代理

进入第5行的forceAutoProxyCreatorToUseClassProxying方法

if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            BeanDefinition definition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
        }

很显然BeanFactory中是存在AUTO_PROXY_CREATOR_BEAN_NAME的，这个key对应对象是AspectJAwareAdvisorAutoProxyCreator的BeanDefinition，前面已经说过了。

如果存在就给这个BeanDefinition添加属性值proxyTargetClass为true，表示将使用cglib进行代理，后面创建代理类的时候会再次提到

第7行判断当前是否需要暴露代理

useClassProxyingIfNecessary方法调用结束后有调用了AopNamespaceUtils的registerComponentIfNecessary方法

 private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
         if (beanDefinition != null) {
             BeanComponentDefinition componentDefinition =
                     new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
             parserContext.registerComponent(componentDefinition);
         }
     }

第4行代码内部调用了以下这个方法，它在寻找propertyValues中是否有嵌入的BeanDefinition，BeanDefinitionHolder

 private void findInnerBeanDefinitionsAndBeanReferences(BeanDefinition beanDefinition) {
         List<BeanDefinition> innerBeans = new ArrayList<BeanDefinition>();
         List<BeanReference> references = new ArrayList<BeanReference>();
         PropertyValues propertyValues = beanDefinition.getPropertyValues();
         for (int i = 0; i < propertyValues.getPropertyValues().length; i++) {
             PropertyValue propertyValue = propertyValues.getPropertyValues()[i];
             Object value = propertyValue.getValue();
             if (value instanceof BeanDefinitionHolder) {
                 innerBeans.add(((BeanDefinitionHolder) value).getBeanDefinition());
             }
             else if (value instanceof BeanDefinition) {
                 innerBeans.add((BeanDefinition) value);
             }
             else if (value instanceof BeanReference) {
                 references.add((BeanReference) value);
             }
         }
         this.innerBeanDefinitions = innerBeans.toArray(new BeanDefinition[innerBeans.size()]);
         this.beanReferences = references.toArray(new BeanReference[references.size()]);
     }

返回到上一层

 private static void registerComponentIfNecessary(BeanDefinition beanDefinition, ParserContext parserContext) {
         if (beanDefinition != null) {
             BeanComponentDefinition componentDefinition =
                     new BeanComponentDefinition(beanDefinition, AopConfigUtils.AUTO_PROXY_CREATOR_BEAN_NAME);
             parserContext.registerComponent(componentDefinition);
         }
     }

这个BeanComponentDefinition类是BeanDefinitionHolder的子类，从名字可以看出它叫BeanDefinition持有者，内部有一个beanName属性，相对应就有个BeanDefinition属性

第5行将这个复合的BeanDefinitionHolder注册到了ParseContext的一个叫containingComponents的stack中

这些方法调用完成后我们直接返回到ConfigBeanDefinitionParser类的parse方法。之前我们分析的是下面方法的第6行的configureAutoProxyCreator方法，有点绕，自己分析的时候需要结合

序列图来看源码

 public BeanDefinition parse(Element element, ParserContext parserContext) {
         CompositeComponentDefinition compositeDef =
                 new CompositeComponentDefinition(element.getTagName(), parserContext.extractSource(element));
         parserContext.pushContainingComponent(compositeDef);

         configureAutoProxyCreator(parserContext, element);

         List<Element> childElts = DomUtils.getChildElements(element);
         for (Element elt: childElts) {
             String localName = parserContext.getDelegate().getLocalName(elt);
             if (POINTCUT.equals(localName)) {
                 parsePointcut(elt, parserContext);
             }
             else if (ADVISOR.equals(localName)) {
                 parseAdvisor(elt, parserContext);
             }
             else if (ASPECT.equals(localName)) {
                 parseAspect(elt, parserContext);
             }
         }

         parserContext.popAndRegisterContainingComponent();
         return null;
     }

第8行取得了<aop:config>的子元素，我这里就一个子元素<aop:aspect>

循环遍历子元素，下面是ConfigBeanDefinitionParser类定义的标签元素

class ConfigBeanDefinitionParser implements BeanDefinitionParser {

    private static final String ASPECT = "aspect";
    private static final String EXPRESSION = "expression";
    private static final String ID = "id";
    private static final String POINTCUT = "pointcut";
    private static final String ADVICE_BEAN_NAME = "adviceBeanName";
    private static final String ADVISOR = "advisor";
    private static final String ADVICE_REF = "advice-ref";
    private static final String POINTCUT_REF = "pointcut-ref";
    private static final String REF = "ref";
    private static final String BEFORE = "before";
    private static final String DECLARE_PARENTS = "declare-parents";
    private static final String TYPE_PATTERN = "types-matching";
    private static final String DEFAULT_IMPL = "default-impl";
    private static final String DELEGATE_REF = "delegate-ref";
    private static final String IMPLEMENT_INTERFACE = "implement-interface";
    private static final String AFTER = "after";
    private static final String AFTER_RETURNING_ELEMENT = "after-returning";
    private static final String AFTER_THROWING_ELEMENT = "after-throwing";
    private static final String AROUND = "around";
    private static final String RETURNING = "returning";
    private static final String RETURNING_PROPERTY = "returningName";
    private static final String THROWING = "throwing";
    private static final String THROWING_PROPERTY = "throwingName";
    private static final String ARG_NAMES = "arg-names";
    private static final String ARG_NAMES_PROPERTY = "argumentNames";
    private static final String ASPECT_NAME_PROPERTY = "aspectName";
    private static final String DECLARATION_ORDER_PROPERTY = "declarationOrder";
    private static final String ORDER_PROPERTY = "order";
    private static final int METHOD_INDEX = 0;
    private static final int POINTCUT_INDEX = 1;
    private static final int ASPECT_INSTANCE_FACTORY_INDEX = 2;

上面这些静态常量很眼熟吧。我的测试标签是aop：aspect，所以我们直接跳到第18行，进入到parseAspect方法看看

 private void parseAspect(Element aspectElement, ParserContext parserContext) {
         String aspectId = aspectElement.getAttribute(ID);
         String aspectName = aspectElement.getAttribute(REF);

         try {
             this.parseState.push(new AspectEntry(aspectId, aspectName));
             List<BeanDefinition> beanDefinitions = new ArrayList<BeanDefinition>();
             List<BeanReference> beanReferences = new ArrayList<BeanReference>();

             List<Element> declareParents = DomUtils.getChildElementsByTagName(aspectElement, DECLARE_PARENTS);
             for (int i = METHOD_INDEX; i < declareParents.size(); i++) {
                 Element declareParentsElement = declareParents.get(i);
                 beanDefinitions.add(parseDeclareParents(declareParentsElement, parserContext));
             }

             // We have to parse "advice" and all the advice kinds in one loop, to get the
             // ordering semantics right.
             NodeList nodeList = aspectElement.getChildNodes();
             boolean adviceFoundAlready = false;
             for (int i = 0; i < nodeList.getLength(); i++) {
                 Node node = nodeList.item(i);
                 if (isAdviceNode(node, parserContext)) {
                     if (!adviceFoundAlready) {
                         adviceFoundAlready = true;
                         if (!StringUtils.hasText(aspectName)) {
                             parserContext.getReaderContext().error(
                                     "<aspect> tag needs aspect bean reference via 'ref' attribute when declaring advices.",
                                     aspectElement, this.parseState.snapshot());
                             return;
                         }
                         beanReferences.add(new RuntimeBeanReference(aspectName));
                     }
                     AbstractBeanDefinition advisorDefinition = parseAdvice(
                             aspectName, i, aspectElement, (Element) node, parserContext, beanDefinitions, beanReferences);
                     beanDefinitions.add(advisorDefinition);
                 }
             }

             AspectComponentDefinition aspectComponentDefinition = createAspectComponentDefinition(
                     aspectElement, aspectId, beanDefinitions, beanReferences, parserContext);
             parserContext.pushContainingComponent(aspectComponentDefinition);

             List<Element> pointcuts = DomUtils.getChildElementsByTagName(aspectElement, POINTCUT);
             for (Element pointcutElement : pointcuts) {
                 parsePointcut(pointcutElement, parserContext);
             }

             parserContext.popAndRegisterContainingComponent();
         }
         finally {
             this.parseState.pop();
         }
     }

第2,3行获得ID和bean的引用

第6行将ID和ref包装成一个entry压入到一个叫做parseState的stack中

第10行意思是在aspect元素下寻找declare-parents子元素，这个故事告诉我们spring的助手类真的很好用。这个标签是用于给某个类设置父类。如果对这个标签感兴趣可以去搜索相关的资料

第18行取得了aspect下的所有子元素

第22行判断当前标签是不是通知类型的标签，具体的实现代码如下

private boolean isAdviceNode(Node aNode, ParserContext parserContext) {
        if (!(aNode instanceof Element)) {
            return false;
        }
        else {
            String name = parserContext.getDelegate().getLocalName(aNode);
            return (BEFORE.equals(name) || AFTER.equals(name) || AFTER_RETURNING_ELEMENT.equals(name) ||
                    AFTER_THROWING_ELEMENT.equals(name) || AROUND.equals(name));
        }
    }

当找到通知类型的标签，如aop：before，我们跳到第33行，看看parseAdvice方法

 private AbstractBeanDefinition parseAdvice(
             String aspectName, int order, Element aspectElement, Element adviceElement, ParserContext parserContext,
             List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {

         try {
             this.parseState.push(new AdviceEntry(parserContext.getDelegate().getLocalName(adviceElement)));

             // create the method factory bean
             RootBeanDefinition methodDefinition = new RootBeanDefinition(MethodLocatingFactoryBean.class);
             methodDefinition.getPropertyValues().add("targetBeanName", aspectName);
             methodDefinition.getPropertyValues().add("methodName", adviceElement.getAttribute("method"));
             methodDefinition.setSynthetic(true);

             // create instance factory definition
             RootBeanDefinition aspectFactoryDef =
                     new RootBeanDefinition(SimpleBeanFactoryAwareAspectInstanceFactory.class);
             aspectFactoryDef.getPropertyValues().add("aspectBeanName", aspectName);
             aspectFactoryDef.setSynthetic(true);

             // register the pointcut
             AbstractBeanDefinition adviceDef = createAdviceDefinition(
                     adviceElement, parserContext, aspectName, order, methodDefinition, aspectFactoryDef,
                     beanDefinitions, beanReferences);

             // configure the advisor
             RootBeanDefinition advisorDefinition = new RootBeanDefinition(AspectJPointcutAdvisor.class);
             advisorDefinition.setSource(parserContext.extractSource(adviceElement));
             advisorDefinition.getConstructorArgumentValues().addGenericArgumentValue(adviceDef);
             if (aspectElement.hasAttribute(ORDER_PROPERTY)) {
                 advisorDefinition.getPropertyValues().add(
                         ORDER_PROPERTY, aspectElement.getAttribute(ORDER_PROPERTY));
             }

             // register the final advisor
             parserContext.getReaderContext().registerWithGeneratedName(advisorDefinition);

             return advisorDefinition;
         }
         finally {
             this.parseState.pop();
         }
     }

第9行又创建了一个RootBeanDefinition的实例

第10行将切面的id和切面的方法保存到这个RootBeanDefinition中

主要看到第21createAdviceDefinition的代码

 private AbstractBeanDefinition createAdviceDefinition(
             Element adviceElement, ParserContext parserContext, String aspectName, int order,
             RootBeanDefinition methodDef, RootBeanDefinition aspectFactoryDef,
             List<BeanDefinition> beanDefinitions, List<BeanReference> beanReferences) {

         RootBeanDefinition adviceDefinition = new RootBeanDefinition(getAdviceClass(adviceElement, parserContext));
         adviceDefinition.setSource(parserContext.extractSource(adviceElement));
         //添加切面名
         adviceDefinition.getPropertyValues().add(ASPECT_NAME_PROPERTY, aspectName);
         adviceDefinition.getPropertyValues().add(DECLARATION_ORDER_PROPERTY, order);
         //判断是否存在returning属性
         if (adviceElement.hasAttribute(RETURNING)) {
             adviceDefinition.getPropertyValues().add(
                     RETURNING_PROPERTY, adviceElement.getAttribute(RETURNING));
         }
         if (adviceElement.hasAttribute(THROWING)) {
             adviceDefinition.getPropertyValues().add(
                     THROWING_PROPERTY, adviceElement.getAttribute(THROWING));
         }
           //判断是否有参数
         if (adviceElement.hasAttribute(ARG_NAMES)) {
             adviceDefinition.getPropertyValues().add(
                     ARG_NAMES_PROPERTY, adviceElement.getAttribute(ARG_NAMES));
         }

         ConstructorArgumentValues cav = adviceDefinition.getConstructorArgumentValues();
         cav.addIndexedArgumentValue(METHOD_INDEX, methodDef);

         Object pointcut = parsePointcutProperty(adviceElement, parserContext);
         if (pointcut instanceof BeanDefinition) {
             cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcut);
             beanDefinitions.add((BeanDefinition) pointcut);
         }
         else if (pointcut instanceof String) {
             RuntimeBeanReference pointcutRef = new RuntimeBeanReference((String) pointcut);
             cav.addIndexedArgumentValue(POINTCUT_INDEX, pointcutRef);
             beanReferences.add(pointcutRef);
         }

         cav.addIndexedArgumentValue(ASPECT_INSTANCE_FACTORY_INDEX, aspectFactoryDef);

         return adviceDefinition;
     }

第28行从这个通知元素中解析切点引用pointcut-ref，如果你在这个通知标签中使用的pointcut属性，那么会返回一个BeanDefinition类型

讲了这么多BeanDefinition，这个BeanDefinition到底是个什么东西，BeanDefinition翻译过来就是bean定义的意思，相当于将xml文件中定义的Bean

翻译成java代码，如<bean id="hello" class="com.test.Hello" scope="singleton" />在BeanDefinition这个类中会都会有相对应的属性，它也有id

有className，有scope，有initMethodName，有destroyMethodName这些个属性，就相当于把xml定义的bean翻译成java代码。

通知类型的标签设置完成后，我们再看看pointcut的解析

 private AbstractBeanDefinition parsePointcut(Element pointcutElement, ParserContext parserContext) {
         String id = pointcutElement.getAttribute(ID);
         String expression = pointcutElement.getAttribute(EXPRESSION);

         AbstractBeanDefinition pointcutDefinition = null;

         try {
             this.parseState.push(new PointcutEntry(id));
             pointcutDefinition = createPointcutDefinition(expression);
             pointcutDefinition.setSource(parserContext.extractSource(pointcutElement));

             String pointcutBeanName = id;
             if (StringUtils.hasText(pointcutBeanName)) {
                 parserContext.getRegistry().registerBeanDefinition(pointcutBeanName, pointcutDefinition);
             }
             else {
                 pointcutBeanName = parserContext.getReaderContext().registerWithGeneratedName(pointcutDefinition);
             }

             parserContext.registerComponent(
                     new PointcutComponentDefinition(pointcutBeanName, pointcutDefinition, expression));
         }
         finally {
             this.parseState.pop();
         }

         return pointcutDefinition;
     }

第9行创建了一个属性className为AspectJExpressionPointcut的BeanDefinition，具体这个拿来干嘛的，到后面使用到的时候再说，一路debug过来，定义了一大堆的BeanDefinition

都是为后面创建bean做准备

第14行把创建的切点BeanDefinition注册到BeanFactory中

至此可以发现，所谓的xml的解析，都是将相应的配置信息解析出来封装成一个叫做BeanDefinition的对象，最后注册到BeanFactory的BeanDefinitionMap的map容器中

aop：config解析完成后，我们看看bean标签的解析，bean是属于默认的命名空间中定义的标签，解析时使用的DefaultBeanDefinitionDocumentReader类的parseDefaultElement方法

 private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {
         if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {
             importBeanDefinitionResource(ele);
         }
         else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {
             processAliasRegistration(ele);
         }
         else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {
             processBeanDefinition(ele, delegate);
         }
         else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {
             // recurse
             doRegisterBeanDefinitions(ele);
         }
     }

我们解析的是bean标签，所以直接跳到第8行，看看processBeanDefinition方法

 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
         BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
         if (bdHolder != null) {
             bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
             try {
                 // Register the final decorated instance.
                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
             }
             catch (BeanDefinitionStoreException ex) {
                 getReaderContext().error("Failed to register bean definition with name '" +
                         bdHolder.getBeanName() + "'", ele, ex);
             }
             // Send registration event.
             getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
         }
     }

进入第2行的parseBeanDefinitionElement

 public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
         String id = ele.getAttribute(ID_ATTRIBUTE);//取得bean标签的id
         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//取得Bean标签的name属性

         List<String> aliases = new ArrayList<String>();
         if (StringUtils.hasLength(nameAttr)) {
             String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);//将name属性的到的名字按，分割，并作为别名
             aliases.addAll(Arrays.asList(nameArr));
         }

         String beanName = id;
         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");
             }
         }

         if (containingBean == null) {
             checkNameUniqueness(beanName, aliases, ele);
         }

         AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
         if (beanDefinition != null) {
             if (!StringUtils.hasText(beanName)) {
                 try {
                     if (containingBean != null) {
                         beanName = BeanDefinitionReaderUtils.generateBeanName(
                                 beanDefinition, this.readerContext.getRegistry(), true);
                     }
                     else {
                         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.
                         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);
         }

         return null;
     }

第12表示，如果存在id和name，并且id没有值，name有值，那么就取name的第一个name值做为beanName

第21行，对beanName和别名进行检查，BeanDefinitionParserDelegate类中有个usedNames容器，这个容器用于保存已经使用了的beanName，所以这个方法是在检查是否有重复定义的beanName或者别名

第24行又将bean标签翻译成了一个BeanDefinition，它是怎么翻译的等下再说，先往下看

第29行，如果这个bean没有指定beanName，那么就自己生成一个，一般是这个bean类的类名加上#在加一个数字，这个数字是从零开始的，这个数字要看这个bean是BeanFactory中的第几个没有写beanName的bean了，他叫什么，这不是重点，我们一般也不会去写个没有beanName的bean，不写beanName的情况一般是给spring通过类型来自动注入

下面开始讲讲它是怎么解析成BeanDefinition的

 String className = null;
         if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
             className = ele.getAttribute(CLASS_ATTRIBUTE).trim();//获得class属性定义的className
         }

         try {
             String parent = null;
             if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
                 parent = ele.getAttribute(PARENT_ATTRIBUTE); //如果有parent属性就获取到parent属性的值
             }
             AbstractBeanDefinition bd = createBeanDefinition(className, parent);//创建一个BeanDefinition对象

             parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
             bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));//如果这个bean元素有description子标签，获得他的值设置到BeanDefinition中

             parseMetaElements(ele, bd);//解析元标签<meta key="" value="">，当需要用到的时候，可以用过BeanDefinition的getAttribute(key)获得
             parseLookupOverrideSubElements(ele, bd.getMethodOverrides());//解析bean标签中是够含有lookup-method标签，如果有就设置到methodOverrides中
             parseReplacedMethodSubElements(ele, bd.getMethodOverrides());//解析replace-method标签

             parseConstructorArgElements(ele, bd);//解析构造器参数
             parsePropertyElements(ele, bd);//解析property标签
             parseQualifierElements(ele, bd);//解析qualifier

             bd.setResource(this.readerContext.getResource());
             bd.setSource(extractSource(ele));

             return bd;

看到第13行，这个方法是用来解析bean定义的属性的

 public AbstractBeanDefinition parseBeanDefinitionAttributes(Element ele, String beanName,
             BeanDefinition containingBean, AbstractBeanDefinition bd) {

         if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {//如果存在singleton这个属性，就解析，当不做任何处理，提示用户过时了，应该使用scope来代替
             error("Old 1.x 'singleton' attribute in use - upgrade to 'scope' declaration", ele);
         }
         else if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {//如果存在scope属性就取得取得他的值，并设置到BeanDefinition中
             bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
         }
         else if (containingBean != null) {
             // Take default from containing bean in case of an inner bean definition.
             bd.setScope(containingBean.getScope());
         }

         if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
             bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
         }

         String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
         if (DEFAULT_VALUE.equals(lazyInit)) {
             lazyInit = this.defaults.getLazyInit();
         }
         bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

         String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
         bd.setAutowireMode(getAutowireMode(autowire));

         String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
         bd.setDependencyCheck(getDependencyCheck(dependencyCheck));

         if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
             String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
             bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, MULTI_VALUE_ATTRIBUTE_DELIMITERS));
         }

         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));
         }

         if (ele.hasAttribute(PRIMARY_ATTRIBUTE)) {
             bd.setPrimary(TRUE_VALUE.equals(ele.getAttribute(PRIMARY_ATTRIBUTE)));
         }

         if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
             String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
             if (!"".equals(initMethodName)) {
                 bd.setInitMethodName(initMethodName);
             }
         }
         else {
             if (this.defaults.getInitMethod() != null) {
                 bd.setInitMethodName(this.defaults.getInitMethod());
                 bd.setEnforceInitMethod(false);
             }
         }

         if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
             String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
             bd.setDestroyMethodName(destroyMethodName);
         }
         else {
             if (this.defaults.getDestroyMethod() != null) {
                 bd.setDestroyMethodName(this.defaults.getDestroyMethod());
                 bd.setEnforceDestroyMethod(false);
             }
         }

         if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
             bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
         }
         if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
             bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
         }

         return bd;
     }

将bean标签中所有的属性进行读取，有定义的就读过来设置到BeanDefinition中，如果没有的自然是使用默认值，解析完bean标签上的属性后，自然还有解析bean

标签里面的子标签，这里选择其中解析property解析下，下面是部分源码

 String propertyName = ele.getAttribute(NAME_ATTRIBUTE);//获取property标签上的那么属性
         if (!StringUtils.hasLength(propertyName)) {
             error("Tag 'property' must have a 'name' attribute", ele);
             return;
         }
         this.parseState.push(new PropertyEntry(propertyName));
         try {
             if (bd.getPropertyValues().contains(propertyName)) {
                 error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
                 return;
             }
             Object val = parsePropertyValue(ele, bd, propertyName);
             PropertyValue pv = new PropertyValue(propertyName, val);//将属性值和对应的value打包成一个PropertyValue
             parseMetaElements(ele, pv);
             pv.setSource(extractSource(ele));
             bd.getPropertyValues().addPropertyValue(pv);//将包含属性值和值得propertyValue设置到BeanDefinition中

我们看到第12行内部的部分代码

 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.setSource(extractSource(ele));
             return ref;
         }
         else if (hasValueAttribute) {
             TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
             valueHolder.setSource(extractSource(ele));
             return valueHolder;
         }

第2行去获得ref属性的值，并且把这个值包装成一个RuntimeBeanReference对象

第11行，如果不是个ref类型的值（value属性指定的值）就被包装成TypedStringValue类型的对象。

回到processBeanDefinition方法

 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
         BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
         if (bdHolder != null) {
             bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
             try {
                 // Register the final decorated instance.
                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
             }
             catch (BeanDefinitionStoreException ex) {
                 getReaderContext().error("Failed to register bean definition with name '" +
                         bdHolder.getBeanName() + "'", ele, ex);
             }
             // Send registration event.
             getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));
         }
     }

第四行又对BeanDefinitionHolder做了些装饰，这个方法的作用，主要是用来解析bean中嵌套的自定标签，如<bean id="" class=""><mytag:test /></bean>

在这里顺便再分析一下bean中construct-arg的解析方式

 public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
         String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);//获取index属性的值
         String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);//获取type属性的值
         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//获取name属性的值
         if (StringUtils.hasLength(indexAttr)) {
             try {
                 int index = Integer.parseInt(indexAttr);
                 if (index < 0) {
                     error("'index' cannot be lower than 0", ele);
                 }
                 else {
                     try {
                         this.parseState.push(new ConstructorArgumentEntry(index));
                         Object value = parsePropertyValue(ele, bd, null);//这段代码和解析property标签的方式一样，对ref的值包装成RuntimeBeanReference实例，value包装成TypeStringValue的实例
                         ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
                         if (StringUtils.hasLength(typeAttr)) {
                             valueHolder.setType(typeAttr);
                         }
                         if (StringUtils.hasLength(nameAttr)) {
                             valueHolder.setName(nameAttr);
                         }
                         valueHolder.setSource(extractSource(ele));
                         if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
                             error("Ambiguous constructor-arg entries for index " + index, ele);
                         }
                         else {
                             bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
                         }
                     }
                     finally {
                         this.parseState.pop();
                     }
                 }
             }
             catch (NumberFormatException ex) {
                 error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
             }
         }
         else {
             try {
                 this.parseState.push(new ConstructorArgumentEntry());
                 Object value = parsePropertyValue(ele, bd, null);
                 ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
                 if (StringUtils.hasLength(typeAttr)) {
                     valueHolder.setType(typeAttr);
                 }
                 if (StringUtils.hasLength(nameAttr)) {
                     valueHolder.setName(nameAttr);
                 }
                 valueHolder.setSource(extractSource(ele));
                 bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
             }
             finally {
                 this.parseState.pop();
             }
         }
     }

其实和解析property相同的套路，不同在与，property的是将返回回来的value用添加到了BeanDefinition的propertyValues属性中，而构造器标签对value的封装使用了

ConstructorArgumentValues.ValueHolder值持有者来封装，并把这个值存放到BeanDefinition的

indexedArgumentValue属性中

一切都准备就绪了，各种属性都设置到为了BeanDefinition中了，那么剩下的就是注册到BeanFactory中了

 public static void registerBeanDefinition(
             BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
             throws BeanDefinitionStoreException {

         // Register bean definition under primary name.
         String beanName = definitionHolder.getBeanName();
         registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

         // Register aliases for bean name, if any.
         String[] aliases = definitionHolder.getAliases();
         if (aliases != null) {
             for (String alias : aliases) {
                 registry.registerAlias(beanName, alias);
             }
         }
     }

看到第7行的代码有没有似曾相识的感觉，我们在分析aop：config的时候就已经分析过了，如果忘记了往上翻，这里就不再重复说了，现在主要是看第13的代码，别名的注册

 public void registerAlias(String name, String alias) {
         Assert.hasText(name, "'name' must not be empty");
         Assert.hasText(alias, "'alias' must not be empty");
         if (alias.equals(name)) {//如果别名和beanName相同，那么就删掉它，不需要别名
             this.aliasMap.remove(alias);
         }
         else {
             String registeredName = this.aliasMap.get(alias);//如果这个别名已经存在就拿出对应的beanName
             if (registeredName != null) {
                 if (registeredName.equals(name)) {//如果对应的beanName是相同的，那么就无需再次注册了
                     // An existing alias - no need to re-register
                     return;
                 }
                 if (!allowAliasOverriding()) {//如果不相等，就判断是否允许别名覆盖
                     throw new IllegalStateException("Cannot register alias '" + alias + "' for name '" +
                             name + "': It is already registered for name '" + registeredName + "'.");
                 }
             }
             checkForAliasCircle(name, alias);
             this.aliasMap.put(alias, name);
         }
     }

第19行进行别名循环依赖检查，如果出现a能找到b，b又能找c，c又能找到a就会出错

当xml中所有的标签解析成BeanDefinition后，xml的解析工作也就结束了，接下来要做的事情就是创建bean了。