4.0 spring-注册解析的Bean

　　1.0 registerBeanDefinition

　　对于配置文件,解析也解析完了,装饰也装饰完了,对于得到的BeanDefinition已经可以满足后续的使用了,唯一剩下的工作就是注册了,

也就是: processBeanDefinition 方法中的

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,getReaderContext().getRegistry());

　　代码如下:

 /**
      * Process the given bean element, parsing the bean definition and registering it with
      * the registry.
      */
     protected void processBeanDefinition(Element ele,
             BeanDefinitionParserDelegate delegate) {
         // 委托BeanDefinition类的parseBeanDefinitionElement方法进行元素解析,返回Beandefinition
         // 类型的实例bdHolder 经过这个方法之后,
         // bdHolder实例已经包含了我们配置文件中的各种属性了,例如 : class,name,id,alias
         BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);
         if (bdHolder != null) {
             //当返回的bdHolder 不为空的情况下,若存在默认标签的子节点下再有自定义属性,还需要再次对自定义标签进行解析.
             bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
             try {
                 // Register the final decorated instance.
                 // 解析完成之后,需要对解析后的bdHolder 进行注册,同样注册操作委托给了BeanDefinitionUtils 的 registerBeanDefinition
                 BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder,
                         getReaderContext().getRegistry());
             }
             catch (BeanDefinitionStoreException ex) {
                 getReaderContext().error(
                         "Failed to register bean definition with name '"
                                 + bdHolder.getBeanName() + "'", ele, ex);
             }
             // Send registration event.
             // 最后发出响应事件,通知相关的监听器,这个bean已经加载完了.
             getReaderContext().fireComponentRegistered(
                     new BeanComponentDefinition(bdHolder));
         }
     }

　　我们继续追踪下去:

 /**
      * Register the given bean definition with the given bean factory.
      *
      * @param definitionHolder the bean definition including name and aliases
      * @param registry the bean factory to register with
      * @throws BeanDefinitionStoreException if registration failed
      */
     public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder,
             BeanDefinitionRegistry registry) throws BeanDefinitionStoreException {

         // Register bean definition under primary name.
         // 使用 beanName 作为唯一标示注册
         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 aliase : aliases) {
                 registry.registerAlias(beanName, aliase);
             }
         }
     }

　　从上面代码可以看出,解析的BeanDefinition都会被注册到BeanDefinitionRegister 类型的实例 register 中,而对于beanDefinition 的注册分为2部分,

1. 通过beanName 注册

2. 通过别名注册;

2.0 通过beanName 注册

　　对于使用beanDefinition的注册,或许很多人都认为是将BeanDefinition 直接放入map中就好了,使用beanName作为Key ,实际上,的确Spring的确是这么做了,只不过除此之外,它还做了点别的事情,

我们来看看代码:

 @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 {/*
                  * 注册前最后一次效验,这里的效验不同之前的XML文件效验,主要是对于AbstractBeanDefinition
                  * 属性中的methodOverrides 效验; 效验methodOverrides 是否与工厂方法并存或者methodOverrides
                  * 对应的方法根本不存在
                  */
                 ((AbstractBeanDefinition) beanDefinition).validate();
             }
             catch (BeanDefinitionValidationException ex) {
                 throw new BeanDefinitionStoreException(
                         beanDefinition.getResourceDescription(), beanName,
                         "Validation of bean definition failed", ex);
             }
         }
         // 应为beanDefinitionMap 是全局变量,这里定会存在并发
         synchronized (this.beanDefinitionMap) {
             // 处理注册已经注册的beanName情况
             BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);
             if (oldBeanDefinition != null) {
                 // 如果对应beanName已经注册 并且在配置文件中配置了beanName不能被覆盖,则抛出异常
                 if (!this.allowBeanDefinitionOverriding) {
                     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 (this.logger.isInfoEnabled()) {
                         this.logger.info("Overriding bean definition for bean '"
                                 + beanName + "': replacing [" + oldBeanDefinition
                                 + "] with [" + beanDefinition + "]");
                     }
                 }
             }
             else {
                 // 记录beanName
                 this.beanDefinitionNames.add(beanName);
                 this.frozenBeanDefinitionNames = null;
             }
             // 注册beanDefinition
             this.beanDefinitionMap.put(beanName, beanDefinition);
         }
         // 重置所有beanName 对应的缓存(清楚之前对应beanName 的缓存)
         resetBeanDefinition(beanName);
     }

　　上面代码中,我们看到对于bean在处理方式上主要做了几个步骤,

　　1. 注册前最后一次效验,这里的效验不同之前的XML文件效验,对于AbstractBeanDefinition属性中的methodOverrides 效验; 效验methodOverrides 是否与工厂方法并存或者methodOverrides

　　2. 如果对应beanName已经注册 并且在配置文件中配置了beanName不能被覆盖,则抛出异常　　3. 加入map缓存

　　4.清除解析之前对应beanName 的缓存

2. 通过别名注册BeanDefinition

　　在理解注册beanName的原理后,理解别名注册就容易多了;

代码如下:

SimpleAliasRegistry.java

 @Override
     public void registerAlias(String name, String alias) {
         Assert.hasText(name, "'name' must not be empty");
         Assert.hasText(alias, "'alias' must not be empty");
         // 如果beanName与alias 相同的话,不记录alias ,并删除对应的alias
         if (alias.equals(name)) {
             this.aliasMap.remove(alias);
         }
         else {
             // 如果alias 不允许被覆盖则抛出异常
             if (!allowAliasOverriding()) {
                 String registeredName = this.aliasMap.get(alias);
                 if (registeredName != null && !registeredName.equals(name)) {
                     throw new IllegalStateException("Cannot register alias '" + alias
                             + "' for name '" + name
                             + "': It is already registered for name '" + registeredName
                             + "'.");
                 }
             }
             // alias 循环检查, 当 A -> B 存在时, A->C->B 的时候则会抛出异常
             checkForAliasCircle(name, alias);
             // 注册alias
             this.aliasMap.put(alias, name);
         }
     }

　　经过一番波折,  最后通过getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));发出响应事件,通知相关的监听器,这个bean已经加载完了. 这里的实现只为了扩展,当程序开发员需要对注册BeanDefinition事件进行监听的时候可以通过注册监听器的方式将处理逻辑写入监听器中,目前,Spring 并没有对此事件做任何逻辑处理.