2.Dubbo源码分析----Dubbo在Spring Boot启动时如何运行的

最新推荐文章于 2023-05-22 18:37:10 发布

szhlcy

最新推荐文章于 2023-05-22 18:37:10 发布

阅读量640

点赞数 1

分类专栏： Dubbo源码相关分析

本文链接：https://blog.csdn.net/szhlcy/article/details/102424925

版权

Dubbo源码相关分析专栏收录该内容

6 篇文章 1 订阅

订阅专栏

上面使用的dubbo版本是2.6.2版本的，然后我分析源码时候使用的是gitHub上最新下载的版本2.7.1的版本。在自习对比之后发现了部分差异，但是大致的逻辑并没有太大的影响。接下来就进入分析。

在前面搭建环境的时候我们只是在启动类上面贴了一个EnableDubbo的注解。从这里开始着手。

1.EnableDubbo标签

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@EnableDubboConfig
@DubboComponentScan
public @interface EnableDubbo {
    //用于指定扫描那些包包含@Service注解(声明后面提到Service注解都是Dubbo的Service注解)
    @AliasFor(annotation = DubboComponentScan.class, attribute = "basePackages")
    String[] scanBasePackages() default {};
    //用于指定扫描那些类包含@service注解
    @AliasFor(annotation = DubboComponentScan.class, attribute = "basePackageClasses")
    Class<?>[] scanBasePackageClasses() default {};
    //表示是否绑定到多个bean。
    //举例：作用是按照不同的配置文件格式进行选择。比如：dubbo.registry跟dubbo.registries之间的区别
    @AliasFor(annotation = EnableDubboConfig.class, attribute = "multiple")
    boolean multipleConfig() default false;

}

可以发现EnableDubbo注解其实是EnableDubboConfig跟DubboComponentScan标签的合并。先进入EnableDubboConfig注解

2.EnableDubboConfig分析

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
@Import(DubboConfigConfigurationRegistrar.class)
public @interface EnableDubboConfig {

    boolean multiple() default false;

}

可以看到这里使用Import标签指向了DubboConfigConfigurationRegistrar类(这里称呼为R类)。

2.1版本上的细微的区别

需要注意的是，我使用的2.6.2版本中，指向的是DubboConfigConfigurationSelector类(这里称呼为S类)。其中R类实现的是ImportBeanDefinitionRegistrar接口类，S类实现的是ImportSelector类。这两个类都是Spring中的类。虽然R类跟S类实现的类不同，但是这两个类的父接口的作用是相同的。

ImportSelector接口中只有一个方法selectImports作用是指定需要注册为bean的Class名称。当在@Configuration标注的Class上使用@Import引入了一个ImportSelector实现类后，会把实现类中返回的Class名称都定义为bean。
ImportBeanDefinitionRegistrar的用法和作用跟ImportSelector类似。唯一的不同点是ImportBeanDefinitionRegistrar的接口方法registerBeanDefinitions，返回类型是void，且多了一个BeanDefinitionRegistry类型的参数，它允许我们直接通过BeanDefinitionRegistry对象注册bean。在实现类中可以使用ClassPathBeanDefinitionScanner进行扫描并自动注册，它是ClassPathScanningCandidateComponentProvider的子类，所以还是可以添加相同的TypeFilter，然后通过scanner.scan(basePackages)扫描指定的basePackage下满足条件的Class并注册它们为bean。

2.2DubboConfigConfigurationRegistrar类

这里分析最新版本的，就是实现了ImportBeanDefinitionRegistrar接口的。

public class DubboConfigConfigurationRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
  //从importingClassMetadata对象（这个对象中包含启动类上的标签和其他信息）中获取EnableDubboConfig标签中的属性，并保存在map中然后封装到AnnotationAttributes中
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfig.class.getName()));
        //获取EnableDubboConfig标签中的multiple属性
        boolean multiple = attributes.getBoolean("multiple");
        //根据是否绑定到多个Bean分情况处理，并注册Bean。
        if (multiple) {
            registerBeans(registry, DubboConfigConfiguration.Multiple.class);
        } else {
            registerBeans(registry, DubboConfigConfiguration.Single.class);
        }
    }

}

默认情况下multiple的值为false，这里选择这种情况进行分析。

    public static void registerBeans(BeanDefinitionRegistry registry, Class<?>... annotatedClasses) {
        if (ObjectUtils.isEmpty(annotatedClasses)) {
            return;
        }
        boolean debugEnabled = logger.isDebugEnabled();
        //获取AnnotatedBeanDefinitionReader对象，这个对面里面包含了所有的注释后处理器,比如处理有Configuration标签的ConfigurationClassPostProcessor类
        AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(registry);
        if (debugEnabled) {
            logger.debug(registry.getClass().getSimpleName() + " will register annotated classes : " + Arrays.asList(annotatedClasses) + " .");
        }
        //将annotatedClasses注册为一个待处理的带注释的类
        reader.register(annotatedClasses);

    }

上面的registerBeanDefinitions方法中的registerBeans方法的作用就是注册对应的annotatedClasses为Bean，进入registerBeans方法

2.3AnnotatedBeanDefinitionRegistryUtils类

public abstract class AnnotatedBeanDefinitionRegistryUtils {

    public static void registerBeans(BeanDefinitionRegistry registry, Class<?>... annotatedClasses) {
        if (ObjectUtils.isEmpty(annotatedClasses)) {
            return;
        }
        boolean debugEnabled = logger.isDebugEnabled();
        //获取AnnotatedBeanDefinitionReader对象，这个对面里面包含了所有的注释后处理器,比如处理有Configuration标签的ConfigurationClassPostProcessor类
        AnnotatedBeanDefinitionReader reader = new AnnotatedBeanDefinitionReader(registry);
        if (debugEnabled) {
            logger.debug(registry.getClass().getSimpleName() + " will register annotated classes : " + Arrays.asList(annotatedClasses) + " .");
        }
        //将annotatedClasses注册为一个待处理的带注释的类
        reader.register(annotatedClasses);

    }
}`

现在进入DubboConfigConfiguration这个类中看看内部的静态类Single

    @EnableDubboConfigBindings({
            @EnableDubboConfigBinding(prefix = "dubbo.application", type = ApplicationConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.module", type = ModuleConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.registry", type = RegistryConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.protocol", type = ProtocolConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.monitor", type = MonitorConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.provider", type = ProviderConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.consumer", type = ConsumerConfig.class),
            @EnableDubboConfigBinding(prefix = "dubbo.config-center", type = ConfigCenterBean.class),
            @EnableDubboConfigBinding(prefix = "dubbo.metadata-report", type = MetadataReportConfig.class)
    })
    public static class Single {

    }

再看看其中EnableDubboConfigBindings跟EnableDubboConfigBinding两个标签

@Import(DubboConfigBindingsRegistrar.class)
public @interface EnableDubboConfigBindings {
    EnableDubboConfigBinding[] value();

}

@Target({ElementType.TYPE, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Repeatable(EnableDubboConfigBindings.class)
@Import(DubboConfigBindingRegistrar.class)
public @interface EnableDubboConfigBinding {

    String prefix();

    Class<? extends AbstractConfig> type();

    boolean multiple() default false;

}

可以看到在EnableDubboConfigBindings注解中就已经包含了EnableDubboConfigBinding数组，在标签上面使用Import导入了DubboConfigBindingsRegistrar类，进入到这个类中。

public class DubboConfigBindingsRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
    ···
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    //从importingClassMetadata对象中获取EnableDubboConfigBindings标签的内容
        AnnotationAttributes attributes = AnnotationAttributes.fromMap(
                importingClassMetadata.getAnnotationAttributes(EnableDubboConfigBindings.class.getName()));
        //从获取的map集合中找到value属性，此时value是一个EnableDubboConfigBinding标签的集合
        AnnotationAttributes[] annotationAttributes = attributes.getAnnotationArray("value");
        //创建DubboConfigBindingRegistrar类，这个类在后面会讲到，作用是注册EnableDubboConfigBinding标签中的Bean
        DubboConfigBindingRegistrar registrar = new DubboConfigBindingRegistrar();
        registrar.setEnvironment(environment);
        //遍历DubboConfigBindingRegistrar标签，并进行注册。
        for (AnnotationAttributes element : annotationAttributes) {
            registrar.registerBeanDefinitions(element, registry);

        }
    }

    ···
}

进入DubboConfigBindingRegistrar类中，对registerBeanDefinitions方法进行解析

public class DubboConfigBindingRegistrar implements ImportBeanDefinitionRegistrar, EnvironmentAware {
    ...
    protected void registerBeanDefinitions(AnnotationAttributes attributes, BeanDefinitionRegistry registry) {
        //解析传入的EnableDubboConfigBinding标签中的prefix属性的占位符，例如prefix=dubbo.application则这里最后prefix值为dubbo.application
        String prefix = environment.resolvePlaceholders(attributes.getString("prefix"));
        //获取EnableDubboConfigBinding标签中的type表示的对象的Class对象
        Class<? extends AbstractConfig> configClass = attributes.getClass("type");
        //获取EnableDubboConfigBinding标签中的multiple属性
        boolean multiple = attributes.getBoolean("multiple");
        //注册Dubbo的ConfigBean
        registerDubboConfigBeans(prefix, configClass, multiple, registry);

    }    
    
    private void registerDubboConfigBeans(String prefix,
                                          Class<? extends AbstractConfig> configClass,
                                          boolean multiple,
                                          BeanDefinitionRegistry registry) {
        //获取边境变量中的所有属性，并找到前缀为prefix的所有的属性集合；  例如 dubbo.application.name=dubbo-servic，则properties中的值为 name：dubbo-servic
        Map<String, Object> properties = getSubProperties(environment.getPropertySources(), prefix);
        if (CollectionUtils.isEmpty(properties)) {
            if (log.isDebugEnabled()) {
                log.debug("There is no property for binding to dubbo config class [" + configClass.getName()
                        + "] within prefix [" + prefix + "]");
            }
            return;
        }
        //如果是多个配置，则对配置的属性进行分离，如果不是则会根据configClass创建单个beanName，如果configClass是ApplicationConfig.Class则beanName为com.alibaba.dubbo.config.ApplicationConfig#0
        Set<String> beanNames = multiple ? resolveMultipleBeanNames(properties) :
                Collections.singleton(resolveSingleBeanName(properties, configClass, registry));
        //遍历beanNames
        for (String beanName : beanNames) {
            //使用beanName作为创建的configClass类型Bean的Name
            registerDubboConfigBean(beanName, configClass, registry);
            //注册DubboConfigBindingBeanPostProcessor，这里使用BeanDefinitionBuilder来创建Bean，并将prefix跟beanName加到Bean的构造器参数列表中，对于BeanDefinitionBuilder对象可以去网上查询相关的说明，这里会注册多个这个Bean只是构造参数不同
            registerDubboConfigBindingBeanPostProcessor(prefix, beanName, multiple, registry);
        }

    }    
    ...
}

上面的逻辑主要目的就是将Dubbo的主要的Bean注入到Spring中。通过标签跟对Spring的扩展来完成上述的操作。这些操作最后简化到通过贴一个EnableDubboConfig这个标签到启动类上完成了。现在对另外的一个标签DubboComponentScan进行解析。

3.DubboComponentScan标签解析

进入到DubboComponentScan这个标签中

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {

    String[] value() default {};
  
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};

}

在这里分析跟上面一样直接进入DubboComponentScanRegistrar类中查看。发现这个类也是实现spring的ImportBeanDefinitionRegistrar类，所以直接看实现的方法。

public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        //根据传入的importingClassMetadata找到贴有DubboComponentScan标签类的信息，从中获取需要扫描的包
        Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
        //注册ServiceAnnotationBeanPostProcessor，这里会把packagesToScan当作一个构造器的构造参数加入
        registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
        //注册ReferenceAnnotationBeanPostProcessor
        registerReferenceAnnotationBeanPostProcessor(registry);

    }
}

上面的主要的工作就是对需要扫描的包或者类的处理，统一处理为包路径。然后注册两个Bean。注册的两个Bean都是对Spring的扩展你的利用，在后面会进行调用。

总结一下Dubbo与Spring
boot的结合可以说是通过利用Spring的扩展机制，来进行结合的，最后通过标签来简化。上面一共注册了三个Bean。其中ReferenceAnnotationBeanPostProcessor是对Spring的BeanPostProcessor扩展，DubboConfigBindingBeanPostProcessor是对MergedBeanDefinitionPostProcessor跟InitializingBean的实现，ServiceAnnotationBeanPostProcessor是对BeanDefinitionRegistryPostProcessor的扩展。这里的对这几个类进行说明

BeanPostProcessor：允许我们在Spring容器中完成bean实例化、配置以及其他初始化方法前后要添加一些自己逻辑处理
InitializingBean：在Bean的属性被设置完毕之后处理一些逻辑
MergedBeanDefinitionPostProcessor：继承于BeanPostProcessor，增加了一个Bean合并之后的回调
BeanDefinitionRegistryPostProcessor：继承自BeanFactoryPostProcessor，是一种比较特殊的BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor中定义的postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)方法可以让我们实现自定义的注册bean定义的逻辑。

这里先讲解DubboConfigBindingBeanPostProcessor这个类，因为其余两个类逻辑比较复杂。因为上面已经说了这个类实现了MergedBeanDefinitionPostProcessor跟InitializingBean。所以主要对实现的方法进行分析就可以了，先调用postProcessBeforeInitialization在调用afterPropertiesSet

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //如果传入的beanName是构造创建时候传入的beanName(前面讲到过这个Bean注册时候会传入BeanName)，并且Bean是AbstractConfig类型
        if (beanName.equals(this.beanName) && bean instanceof AbstractConfig) {
            //转化为AbstractConfig
            AbstractConfig dubboConfig = (AbstractConfig) bean;
            //进行绑定
            dubboConfigBinder.bind(prefix, dubboConfig);
            if (log.isInfoEnabled()) {
                log.info("The properties of bean [name : " + beanName + "] have been binding by prefix of " +
                        "configuration properties : " + prefix);
            }
        }
        return bean;
    }

    public void afterPropertiesSet() throws Exception {

        if (dubboConfigBinder == null) {
            try {
            //创建DubboConfigBinder类型的bean，每次调用都会创建一个，这个保存在上面的DubboConfigBindingBeanPostProcessor这个Bean中
                dubboConfigBinder = applicationContext.getBean(DubboConfigBinder.class);
            } catch (BeansException ignored) {
                if (log.isDebugEnabled()) {
                    log.debug("DubboConfigBinder Bean can't be found in ApplicationContext.");
                }
                // Use Default implementation
                dubboConfigBinder = createDubboConfigBinder(applicationContext.getEnvironment());
            }
        }
        //再次设置忽略无效跟非法字段
        dubboConfigBinder.setIgnoreUnknownFields(ignoreUnknownFields);
        dubboConfigBinder.setIgnoreInvalidFields(ignoreInvalidFields);

    }

dubboConfigBinder是DubboConfigBinder对象其中是现实DefaultDubboConfigBinder类，上面调用的bind方法其实是对spring的DataBinder的使用

public class DefaultDubboConfigBinder extends AbstractDubboConfigBinder {

    @Override
    public <C extends AbstractConfig> void bind(String prefix, C dubboConfig) {
        //创建DataBinder对象，这个对象可以对指定字段进行校验
        DataBinder dataBinder = new DataBinder(dubboConfig);
        //设置是否忽略的无效和非法字段
        dataBinder.setIgnoreInvalidFields(isIgnoreInvalidFields());
        dataBinder.setIgnoreUnknownFields(isIgnoreUnknownFields());
        //从 PropertySources也就是配置中获取执行前缀的属性字段
        Map<String, Object> properties = getSubProperties(getPropertySources(), prefix);
        // 将Map转换为MutablePropertyValues
        MutablePropertyValues propertyValues = new MutablePropertyValues(properties);
        // 将配置参数进行绑定
        dataBinder.bind(propertyValues);
    }

}

可以看到DubboConfigBindingBeanPostProcessor作用主要是对配置属性的绑定到不同的DubboConfigBindingBeanPostProcessor类型的Bean中。

这里主要分析了Spring Boot跟Dubbo结合的时候，Spring是如何在启动的过程中创建Dubbo对应的Bean的。后面会对ReferenceAnnotationBeanPostProcessor跟ServiceAnnotationBeanPostProcessor这两个类的左右进行讲解，这两个类对我们在搭建基本的Spring boot跟Dubbo结合时使用到的@Service跟@Reference标签起到至关重要的作用

szhlcy

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
2.Dubbo源码分析----Dubbo在Spring Boot启动时如何运行的

上面使用的dubbo版本是2.6.2版本的，然后我分析源码时候使用的是gitHub上最新下载的版本2.7.1的版本。在自习对比之后发现了部分差异，但是大致的逻辑并没有太大的影响。接下来就进入分析。在前面搭建环境的时候我们只是在启动类上面贴了一个EnableDubbo的注解。从这里开始着手。1.EnableDubbo标签@Target({ElementType.TYPE})...
复制链接

扫一扫