【Dubbo学习系列】Dubbo消费端的代理生成详解(@DubboReference和@Reference)

Spring中Dubbo实现RPC

在使用dubbo的过程中，我们的用法是在Service中引入 远程接口，然后标记上注解写入名称与版本号等一系列配置信息，然后在需要进行RPC通信的地方调用接口方法，然后就能获取到信息了。
那么按照这种思路，就应该有下列几个步骤需要完成

1. 发现使用dubbo注解的成员与方法并托管于spring容器
2. 在对象实例中找到有指定注解的成员变量或方法
3. 通过动态代理的方式，编织通信代码到访问逻辑中

当然，上述是主要脉络，细分的话还有 序列化问题，地址的负载均衡问题，访问策略问题等等，本文主要讲述的就是上面的主要脉络。

这里主要是对@Reference和@DubboReference不同点做分析

更好的表述其实应该是新老版本的区别，这里@Reference就代指于旧版本2.7.7以下，@DubboReference就代指新版本2.7.7以上。后文也以@Reference和@DubboReference区分新旧

如何加载@Reference和@DubboReference注解

注意，@Reference已被废弃，2.7.7后使用@DubboReference

在springboot中我们会在启动类上添加 @EnableDubbo这个注解，而这个注解中有两个功能性注解 @EnableDubboConfig
@DubboComponentScan
前者负责dubbo配置的初始化，后者负责扫描dubbo配置中指定的包范围，也就是DubboComponentScanRegistrar.class类的职责

@EnableDubboConfig
@DubboComponentScan
public @interface EnableDubbo {
}
@Import(DubboComponentScanRegistrar.class)
public @interface DubboComponentScan {
}
1
2
3
4
5
6
7

DubboComponentScanRegistrar

在源码中，作者标注出了这个类需要关注的几个关键类和注解

/**
 * Dubbo {@link DubboComponentScan} Bean Registrar
 *
 * @see Service  注解，老版本dubbo标注的服务方Service注解
 * @see DubboComponentScan  注解，用于指定dubbo的管理范围,也就是扫描范围
 * @see ImportBeanDefinitionRegistrar  自身实现的接口，在spring的bean定义注册时期进行处理逻辑
 * @see ServiceAnnotationPostProcessor 对扫描路径的处理
 * @see ReferenceAnnotationBeanPostProcessor 处理dubbo注解，并生成代理类，【主要关注点】
 * @since 2.5.7
 */
 public class DubboComponentScanRegistrar implements ImportBeanDefinitionRegistrar {
 }
1
2
3
4
5
6
7
8
9
10
11
12

主要关注registerBeanDefinitions方法

    @Override
   public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

       // initialize dubbo beans
       //初始化信息
       DubboSpringInitializer.initialize(registry);
       //获取需要扫描的包路径，这个方法主要关注点就是，包路径的优先级关系与默认值问题
       Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
       //为后续扫描上面获取的包路径做准备
       registerServiceAnnotationPostProcessor(packagesToScan, registry);
   }
1
2
3
4
5
6
7
8
9
10
11

先来看看第二步包路径优先级问题 ,这个问题很简单

• 先看@DubboComponentScan
• 在看@EnableDubbo
• 最后如果都没有，则选用启动类的包路径

所以一般我们不设置包路径就是因为默认会扫描 启动类的包路径，也就会查询我们项目下面所有的类

   private Set<String> getPackagesToScan(AnnotationMetadata metadata) {
       // get from @DubboComponentScan
       Set<String> packagesToScan = getPackagesToScan0(metadata, DubboComponentScan.class, "basePackages", "basePackageClasses");

       // get from @EnableDubbo, compatible with spring 3.x
       if (packagesToScan.isEmpty()) {
           packagesToScan = getPackagesToScan0(metadata, EnableDubbo.class, "scanBasePackages", "scanBasePackageClasses");
       }

       if (packagesToScan.isEmpty()) {
           return Collections.singleton(ClassUtils.getPackageName(metadata.getClassName()));
       }
       return packagesToScan;
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

第三步，就是创建ServiceAnnotationPostProcessor类的bean定义，然后将其注册到spring中

    private void registerServiceAnnotationPostProcessor(Set<String> packagesToScan, BeanDefinitionRegistry registry) {

        //针对ServiceAnnotationPostProcessor类，创建bean定义
        BeanDefinitionBuilder builder = rootBeanDefinition(ServiceAnnotationPostProcessor.class);
        //添加构造参数为包路径
        builder.addConstructorArgValue(packagesToScan);
        builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        AbstractBeanDefinition beanDefinition = builder.getBeanDefinition();
        BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinition, registry);
    }
1
2
3
4
5
6
7
8
9
10

包路径的扫描，过滤等处理就交由ServiceAnnotationPostProcessor来向下进行，后续就不在展开讲解该类了，有兴趣的可以自行查看。

概括

DubboComponentScanRegistrar类主要目的就是，将托管范围内的类，并入spring中。

发现@Refrence和@DubboReference注解，并编织RPC通信逻辑

上述流程完成了第一步，将dubbo的相关注解纳入spring的管理，下一步就是借助spring来发现相关注解并进行一些逻辑的编织生成代理对象。

ReferenceAnnotationBeanPostProcessor（核心）

该类是重点类，是dubbo逻辑编织处理类，这里要说明下，@Reference和@DubboReference的处理是有很大区别的（新老版本），背后的思想方式很有借鉴性。

/**
* 该类继承AbstractAnnotationBeanPostProcessor，核心逻辑分为两步
* 第一，发现被dubbo注解标识的成员变量，方法，或者类
* 第二，生成动态代理类，注入成员变量或方法，或者生成类（Bean）放入spring容器
**/
public class ReferenceAnnotationBeanPostProcessor extends AbstractAnnotationBeanPostProcessor{
}
1
2
3
4
5
6
7

@Reference

这里 @Reference 发现主要借助于，postProcessMergedBeanDefinition方法在Bean创建之前合并定义的时候进行判断该类中是否有指定注解，如果有则持有其反射对象，待后面通过 postProcessPropertyValues 统一处理 （这种方式，在spring中与使用@Value注解流程一致）。

下面是第一步 postProcessMergedBeanDefinition的处理流程：

    @Override
    public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
        if (beanType != null) {
            if (isReferenceBean(beanDefinition)) {
            ...
            } else if (isAnnotatedReferenceBean(beanDefinition)) {
            ...
            } else {
                //上面几个判断主要是对于@DubboReference的处理
                //第一步，找到当前类中使用@Reference的成员变量和方法
                AnnotatedInjectionMetadata metadata = findInjectionMetadata(beanName, beanType, null);
                metadata.checkConfigMembers(beanDefinition);
                try {
                    //第二步,放入容器中
                    prepareInjection(metadata);
                } catch (Exception e) {
                    throw new IllegalStateException("Prepare dubbo reference injection element failed", e);
                }
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

而容器就是该类上面的两个成员变量

	//管理成员变量
    private final ConcurrentMap<InjectionMetadata.InjectedElement, String> injectedFieldReferenceBeanCache =
            new ConcurrentHashMap<>(CACHE_SIZE);
	//管理方法
    private final ConcurrentMap<InjectionMetadata.InjectedElement, String> injectedMethodReferenceBeanCache =
            new ConcurrentHashMap<>(CACHE_SIZE);
1
2
3
4
5
6

这里有个注意点，对于静态成员变量dubbo是不会进行处理的

    private List<AbstractAnnotationBeanPostProcessor.AnnotatedFieldElement> findFieldAnnotationMetadata(final Class<?> beanClass) {
		...
		 if (Modifier.isStatic(field.getModifiers())) {
			 if (logger.isWarnEnabled()) {
				logger.warn("@" + annotationType.getName() + " is not supported on static fields: " + field);
			}
		 	return;
		 }
		...
    }
1
2
3
4
5
6
7
8
9
10

如果需要设置为静态成员变量，只能通过访问方法，然后在其中设置，注意：这种使用方式，将会使你RPC通信内部的信息共享，导致不可预见的问题，请避免使用。

到这里，需要进行反射持有的对象已经放入容器中了，下一步就行进行代理生成并注入 。

下面是 postProcessPropertyValues的处理流程 , 也是两步
第一步，从容器中获取反射对象，如果没有，则重复发现步骤
第二步，就是进行动态代理，并注入

    @Override
    public PropertyValues postProcessPropertyValues(
            PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {

        try {
            //第一步，从容器中获取反射对象，如果没有，则重复发现步骤
            AnnotatedInjectionMetadata metadata = findInjectionMetadata(beanName, bean.getClass(), pvs);
            prepareInjection(metadata);
            //第二步进行注入
            metadata.inject(bean, beanName, pvs);
        } catch (BeansException ex) {
            throw ex;
        } catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Injection of @" + getAnnotationType().getSimpleName()
                    + " dependencies is failed", ex);
        }
        return pvs;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

而第二步方法主要是调用实现父类的doGetInjectedBean方法，注意：下面是旧版本中的代码

    @Override
    protected Object doGetInjectedBean(Reference reference, Object bean, String beanName, Class<?> injectedType,
                                       InjectionMetadata.InjectedElement injectedElement) throws Exception {

        String referencedBeanName = buildReferencedBeanName(reference, injectedType);
		//生成ReferenceBean，这个bean是一个FactoryBean,这里并没有将其托管与Spring容器
        ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referencedBeanName, reference, injectedType, getClassLoader());

        cacheInjectedReferenceBean(referenceBean, injectedElement);
		//生成代理类
        Object proxy = buildProxy(referencedBeanName, referenceBean, injectedType);
		//返回该对象
        return proxy;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14

到此，注解对象就注入完毕了。

@DubboReference

而 @DubboReference 的发现则需要借助于spring容器，通过手动创建ReferenceBean托管于Spring容器，后续通过spring的 @Autowired 注解获取实例 详细请看@DubboReference的注释

在DubboReference中呢，也兼容了老版本的注解 ，doGetInjectedBean 变更为了直接从BeanFactory中获取

    @Override
    protected Object doGetInjectedBean(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
                                       AnnotatedInjectElement injectedElement) throws Exception {

        if (injectedElement.injectedObject == null) {
            throw new IllegalStateException("The AnnotatedInjectElement of @DubboReference should be inited before injection");
        }

        return getBeanFactory().getBean((String) injectedElement.injectedObject);
    }
1
2
3
4
5
6
7
8
9
10

在老注解@Reference不变的情况下，只需要自己的Configuration类中注入对应的ReferenceBean就OK了。

@Reference和@DubboReference的区别

这里其实已经可以看出明显思路的变化了，@Reference设计上是游离在Spring容器之外的，直接通过反射的方式进行增强，不依托于spring的容器，而 @DubboReference 则通过将FactoryBean融入到Spring环境中，真正的像使用本地方法一样，进行远程访问。

@DubboReference的使用方式

参考@DubboReference注解上面的注释就好了。

* Step 1: Register ReferenceBean in Java-config class:
 * <pre class="code">
 * @Configuration
 * public class ReferenceConfiguration {
 *     @Bean
 *     @DubboReference(group = "demo")
 *     public ReferenceBean<HelloService> helloService() {
 *         return new ReferenceBean();
 *     }
 *
 *     @Bean
 *     @DubboReference(group = "demo", interfaceClass = HelloService.class)
 *     public ReferenceBean<GenericService> genericHelloService() {
 *         return new ReferenceBean();
 *     }
 * }
 * </pre>
 *
 * Step 2: Inject ReferenceBean by @Autowired
 * <pre class="code">
 * public class FooController {
 *     @Autowired
 *     private HelloService helloService;
 *
 *     @Autowired
 *     private GenericService genericHelloService;
 * }
 * </pre>
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

总结

依托于Spring容器的好处在于职责的划分更加清晰，dubbo本身只负责于rpc的通信，而bean的管理交还给spring，而且使ReferenceAnnotationBeanPostProcessor类更加轻，dubbo的关注点更加集中。