• Dubbo学习记录(六)--Spring整合Dubbo中的Dubbo配置文件流程解析(二)


    Dubbo配置文件流程解析(二)

    1. 通过AnnotatedBeanDefinitionReader来解析Multiple/Single类型上的EnableDubboConfigBindings的值(是一个@EnableDubboConfigBinding数组)
    2. 读取配置文件中Dubbo的所有配置项,根据@EnableDubboConfigBinding绑定注解的prefix前缀,匹配配置项的key, 然后将单个配置项,或者一组配置项转换成一个个type类型Class的BeanDefinition的Bean, 注入IOC容器;
    3. 然后每个XxConfig的Bean会生成对应一个DubboConfigBindingBeanPostProcessor的Bean注入IOC容器

    DubboConfigBindingBeanPostProcessor后置处理器

    DubboConfigBindingBeanPostProcessor是一个BeanPostProcessor, 利用Spring机制的前后置处理机制,所有Bean的生成,都会经过前后置处理;也就是每个BeanPostProcessor都会参与所有Bean的处理加工;

    postProcessBeforeInitialization

    Bean初始化的前置处理逻辑;

        @Override                                                                                                              
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {                    
                                                                                                                               
            // 每个XxConfig对应一个BeanPostProcessor,所以每个DubboConfigBindingBeanPostProcessor只处理对应的beanName                           
                                                                                                                               
            if (this.beanName.equals(beanName) && bean instanceof AbstractConfig) {                                            
                                                                                                                               
                AbstractConfig dubboConfig = (AbstractConfig) bean;                                                            
                // 从properties文件中获取值,并设置到dubboConfig对象中                                                                        
                bind(prefix, dubboConfig);                                                                                     
                                                                                                                               
                // 设置dubboConfig对象的name属性,设置为beanName                                                                          
                customize(beanName, dubboConfig);                                                                              
                                                                                                                               
            }                                                                                                                  
                                                                                                                               
            return bean;                                                                                                       
                                                                                                                               
        } 
        //涉及到了Spring的DataBinding;                                                                                                                     
        private void bind(String prefix, AbstractConfig dubboConfig) {                                                    
                                                                                                                          
            dubboConfigBinder.bind(prefix, dubboConfig);                                                                  
                                                                                                                          
            if (log.isInfoEnabled()) {                                                                                    
                log.info("The properties of bean [name : " + beanName + "] have been binding by prefix of " +             
                        "configuration properties : " + prefix);                                                          
            }                                                                                                             
        }                                                                                                                                                                                                                                            
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • Dubbo的每种配置都会生成相关的代表XXXDubboConfig的Bean Definition 和配套的BeanPostProcessor,Bean在经过创建之后, 会经过属性处理, 然后经过postProcessBeforeInitialization这个阶段。
    • if (this.beanName.equals(beanName) && bean instanceof AbstractConfig)
    1. 判断Bean的类型是是否为AbstractConfig(org.apache.dubbo.config)这个类是Dubbo的配置类,
    2. 判断当前种类配置Bean的名称是否和当前BeanPostProcessor的beanName属性是否相等,
    3. 相等则会将Propertis文件中的配置项的值和配置Bean的属性进行绑定,赋值;
    • 执行完@EnableDubboConfig注解的后, 只是往容器中注入了代表各种XXXDubboConfig配置类的BeanDefinition的实例, 这些DubboConfig的属性复制则是通过BeanPostProcessor来完成;

    postProcessAfterInitialization

    执行完Bean的初始化后的后置处理逻辑;

        @Override                                                                                                            
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {                   
            if (bean instanceof AbstractConfig) {                                                                            
                // 添加别名,id属性的值为别名                                                                                            
                                                                                                                             
                String id = ((AbstractConfig) bean).getId();                                                                 
                if (beanDefinitionRegistry != null && beanDefinitionRegistry instanceof DefaultListableBeanFactory) {        
                    DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanDefinitionRegistry;                
                    if (!StringUtils.isBlank(id) && !factory.hasAlias(beanName, id)) {                                       
                        beanDefinitionRegistry.registerAlias(beanName, id);                                                  
                    }                                                                                                        
                }                                                                                                            
            }                                                                                                                
            return bean;                                                                                                     
        }                                                                                                                    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    目的: 添加别名

    1. 判断Bean是否为AbstractConfig类型,即是否为Dubbo配置Bean;
    2. 判断当前实例的beanDefinitionRegistry 容器是否为空;
    3. 判断Bean的id是否为空, 以及bean的别名是否已经存在;(id是别名)
    4. id不为空, 且beanName不为空,则将beanName为Bean的名称, id为bean的别名保存起来;
    • 判断bean的别名是否已经存在
      目的: 判断别名是否存在;

      //1. 获取别名容器的迭代器;
      //2. 判断容器中是否还有别名项,没有返回false
      //3. 判断遍历的别名值 是否 和 传入的别名相等, 相等退出循环;
      //4. 在别名相等的情况, 判断bean的名称是否和别名相等, 相等则Bean的别名项已经存在
      public boolean hasAlias(String name, String alias) {
          Iterator var3 = this.aliasMap.entrySet().iterator();
      
          Entry entry;
          String registeredName;
          do {
              if (!var3.hasNext()) {
                  return false;
              }
      
              entry = (Entry)var3.next();
              registeredName = (String)entry.getValue();
          } while(!registeredName.equals(name));
      
          String registeredAlias = (String)entry.getKey();
          return registeredAlias.equals(alias) || this.hasAlias(registeredAlias, alias);
      }      
      
      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21

    afterPropertiesSet()

    这个方法是Bean生命周期中的属性填充后的一个后置属性设置阶段, 而在这个阶段中,会创建一个DefaultDubboConfigBinder对象。

    1. 当某个AbstractConfig类型的Bean,在经过DubboConfigBindingBeanPostProcessor处理时,此时Bean对象中的属性是没有值的,会利用DefaultDubboConfigBinder进行赋值。
    2. 底层就是利用Spring中的DataBinder技术,结合properties文件对对应的属性进行赋值
    3. 前置处理阶段中,会调用这个绑定器绑定数据;

    对于一个AbstractConfig类型(针对的其实是子类,比如ApplicationConfig、RegistryConfig)的Bean,每个类都有一些属性,而properties文件是一个key-value对,所以实际上DataBinder就是将属性名和properties文件中的key进行匹配,如果匹配成功,则把value赋值给属性。

    dubbo.application.name=dubbo-demo-provider1-application
    dubbo.application.logger=log4
    
    • 1
    • 2

    最终Dubbo的ApplicationConfig配置Bean的name属性值为"dubbo-demo-provider1-application", logger为 “log4”

    dubbo.protocols.p1.name=dubbo
    dubbo.protocols.p1.port=20880
    dubbo.protocols.p1.host=0.0.0.0
    
    dubbo.protocols.p2.name=http
    dubbo.protocols.p2.port=20990
    dubbo.protocols.p2.host=127.0.0.1
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    对应的配置类是 ProtocolConfig, 上述配置会生成两个实例,一个beanName为p1, name为“dubbo”,“port”为20880, host为“0.0.0.0”, multiple为true;(意味会有一个或者多个ProtocolConfig配置Bean);一个beanName为p2, name为“http”,“port”为20990, host为“127.0.0.1”, multiple为true;

    配置文件解析流程

    1. 通过AnnotatedBeanDefinitionReader来解析Multiple/Single类型上的EnableDubboConfigBindings的值(是一个@EnableDubboConfigBinding数组)
    2. 读取配置文件中Dubbo的所有配置项,根据@EnableDubboConfigBinding绑定注解的prefix前缀,匹配配置项的key, 然后将单个配置项,或者一组配置项转换成一个个type类型Class的BeanDefinition的Bean, 注入IOC容器;
    3. 然后每个XxConfig的Bean会生成对应一个DubboConfigBindingBeanPostProcessor的Bean注入IOC容器
    4. 通过BeanPostProcessor的前置处理,底层使用DataBinding技术,完成属性的赋值;
  • 相关阅读:
    CANTest 测试软件基本操作介绍
    猿创征文|【React】组件化入门学习
    java毕业设计房屋租赁系统Mybatis+系统+数据库+调试部署
    ElasticSearch入门
    SVN项目,提交Git保留之前提交记录
    网络工程师练习题
    【622. 设计循环队列】
    手写 Vuex4.x 核心(Vuex源码实现)
    惯性测量单元预积分原理与实现
    Android assets
  • 原文地址:https://blog.csdn.net/m0_54866636/article/details/126716882