上面使用的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标签起到至关重要的作用
