Dubbo之@Reference 和 ReferenceBean

consumer调用dubbo服务

两种方法：

1、构建一个ReferenceBean，然后使用Spring的@Autowired引用服务

@Bean
public ReferenceBean<PLRepaymentPlanService> repaymentPlanServiceReferenceBean(){ReferenceBean<PLRepaymentPlanService> referenceBean = new ReferenceBean<>();referenceBean.setInterface(PLRepaymentPlanService.class);referenceBean.setCheck(false);referenceBean.setValidation("true");return referenceBean;
}

@Autowired
private PLRepaymentPlanService plRepaymentPlanService;

2、使用dubbo的@Reference注解

@Reference
ExampleService exampleService

@Reference其实就是将引用的服务构建成一个ReferenceBean然后在调用原理一样

以下资料参考：https://blog.csdn.net/u012394095/article/details/83142193

源码入口
com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScanRegistrar

Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 获取扫描包路径
Set<String> packagesToScan = getPackagesToScan(importingClassMetadata);
// 注册@service解析的类
registerServiceAnnotationBeanPostProcessor(packagesToScan, registry);
// 注册解析@Reference注解的bean
registerReferenceAnnotationBeanPostProcessor(registry);

}

registerReferenceAnnotationBeanPostProcessor

private void registerReferenceAnnotationBeanPostProcessor(BeanDefinitionRegistry registry) {

// Register @Reference Annotation Bean Processor
BeanRegistrar.registerInfrastructureBean(registry,
ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);

}

调用了BeanRegistrar工具类来注册Reference解析器的BeanDefinition， registerInfrastructureBean方法的主要作用就是将ReferenceAnnotationBeanPostProcessor这个类注册到BeanDefinition

public class BeanRegistrar {

/**
* Register Infrastructure Bean
*
* @param beanDefinitionRegistry {@link BeanDefinitionRegistry}
* @param beanType the type of bean
* @param beanName the name of bean
*/
public static void registerInfrastructureBean(BeanDefinitionRegistry beanDefinitionRegistry,
String beanName,
Class<?> beanType) {

if (!beanDefinitionRegistry.containsBeanDefinition(beanName)) {
RootBeanDefinition beanDefinition = new RootBeanDefinition(beanType);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 注册
beanDefinitionRegistry.registerBeanDefinition(beanName, beanDefinition);
}

}

ReferenceAnnotationBeanPostProcessor

本文的重点在于ReferenceAnnotationBeanPostProcessor类，该类继承了InstantiationAwareBeanPostProcessor ,用来解析@Reference注解并完成依赖注入。

public class ReferenceAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter
implements MergedBeanDefinitionPostProcessor, PriorityOrdered, ApplicationContextAware, BeanClassLoaderAware,
DisposableBean {
// 省略注解
}

**InstantiationAwareBeanPostProcessor **：实例化Bean后置处理器（继承BeanPostProcessor）

1.postProcessBeforeInstantiation ：在实例化目标对象之前执行，可以自定义实例化逻辑，如返回一个代理对象等。

2.postProcessAfterInitialization ： Bean实例化完毕后执行的后处理操作，所有初始化逻辑、装配逻辑之前执行，如果返回false将阻止其他的InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation的执行。

3.postProcessPropertyValues ：完成其他定制的一些依赖注入和依赖检查等，如AutowiredAnnotationBeanPostProcessor执行@Autowired注解注入，CommonAnnotationBeanPostProcessor执行@Resource等注解的注入，PersistenceAnnotationBeanPostProcessor执行@ PersistenceContext等JPA注解的注入，RequiredAnnotationBeanPostProcessor执行@ Required注解的检查等等。

dubbo也是采用了和@Autowired注入一样的原理，通过继承InstantiationAwareBeanPostProcessor 重写postProcessPropertyValues 方法来达到解析@Reference并实现依赖注入。

@Override
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
//这个是注入元数据，包含了目标Bean的Class对象，和注入元素（InjectionElement）集合
InjectionMetadata metadata = findReferenceMetadata(beanName, bean.getClass(), pvs);
try {
// 通过反射来给bean设置值了
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of @Reference dependencies failed", ex);
}
return pvs;
}

通过findReferenceMetadata找到@Reference，并解析得到元数据对象，最终实现依赖注入，@Autowired注解也是这个干的，二者的实现原理是一模一样。

private InjectionMetadata findReferenceMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
// 通过类名作为缓存的key
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// 从缓存中的injectionMetadataCache根据类名获取元数据
ReferenceInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
       // 判断metadata 是否为空， class对象不等于ReferenceInjectionMetadata ，则需要进行刷新
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
   // 双重检查机制
metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) {
metadata.clear(pvs);
}
try {
   // 构建InjectionMetadata元数据
metadata = buildReferenceMetadata(clazz);
this.injectionMetadataCache.put(cacheKey, metadata);
} catch (NoClassDefFoundError err) {
throw new IllegalStateException("Failed to introspect bean class [" + clazz.getName() +
"] for reference metadata: could not find class that it depends on", err);
}
}
}
}
return metadata;
}

buildReferenceMetadata

private ReferenceInjectionMetadata buildReferenceMetadata(final Class<?> beanClass) {
// 获取属性上的@Reference注解
Collection<ReferenceFieldElement> fieldElements = findFieldReferenceMetadata(beanClass);
// 获取方法上的@Reference注解
Collection<ReferenceMethodElement> methodElements = findMethodReferenceMetadata(beanClass);
return new ReferenceInjectionMetadata(beanClass, fieldElements, methodElements);

}

获取属性上的@Reference注解findFieldReferenceMetadata

private List<ReferenceFieldElement> findFieldReferenceMetadata(final Class<?> beanClass) {

final List<ReferenceFieldElement> elements = new LinkedList<ReferenceFieldElement>();
       // 通过反射的工具类，获取当前beanClass的所有Filed
ReflectionUtils.doWithFields(beanClass, new ReflectionUtils.FieldCallback() {
@Override
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException {
               // 获取Reference注解
Reference reference = getAnnotation(field, Reference.class);
               // 注解不为空
if (reference != null) {

if (Modifier.isStatic(field.getModifiers())) {
if (logger.isWarnEnabled()) {
logger.warn("@Reference annotation is not supported on static fields: " + field);
}
return;
}
// 构建ReferenceFieldElement
elements.add(new ReferenceFieldElement(field, reference));
}

}
});

return elements;

}

上面的代码就很简单了，通过ReflectionUtils工具类，反射获取当前beanClass 的所有Filed , 之后获取每个filed上的@Reference注解，如果获取不为空，则继续下一步。最终构建ReferenceFieldElement对象，将对应的filed和Reference注解放进去。

元数据收集好了，接下来就是调用metadata.inject(bean, beanName, pvs);这个方法了。

public void inject(Object target, String beanName, PropertyValues pvs) throws Throwable {
// 获取InjectedElement
Collection<InjectionMetadata.InjectedElement> elementsToIterate = this.checkedElements != null ? this.checkedElements : this.injectedElements;
if (!((Collection)elementsToIterate).isEmpty()) {
boolean debug = logger.isDebugEnabled();
// 进行循环，也就是循环设值，因为有多个字段嘛。
InjectionMetadata.InjectedElement element;
for(Iterator var6 = ((Collection)elementsToIterate).iterator(); var6.hasNext(); element.inject(target, beanName, pvs)) {
element = (InjectionMetadata.InjectedElement)var6.next();
if (debug) {
logger.debug("Processing injected element of bean '" + beanName + "': " + element);
}
}
}

}

上面的代码，其实只有一行，那就是element.inject(target, beanName, pvs) 这一行，因为一个InjectedElement对象就表示一个字段对象，这个对象中将字段信息和注解信息绑定在了一起，调用inject方法就是为了给这个filed进行赋值。

###ReferenceFieldElement

private class ReferenceFieldElement extends InjectionMetadata.InjectedElement {
       // 字段对象
private final Field field;
       // Reference注解对象
private final Reference reference;
       // 服务引用对象
private volatile ReferenceBean<?> referenceBean;

protected ReferenceFieldElement(Field field, Reference reference) {
super(field, null);
this.field = field;
this.reference = reference;
}

@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
           // 获取字段的类型
Class<?> referenceClass = field.getType();
           // 构建ReferenceBean
referenceBean = buildReferenceBean(reference, referenceClass);
           // 字段为私有，需要设置这个属性field.setAccessible(true) 才能进行设值
ReflectionUtils.makeAccessible(field);
           // 给这个对象bean的这个filed设置值，值为：referenceBean.getObject()
field.set(bean, referenceBean.getObject());

}

通过buildReferenceBean方法创建服务引用对象

private ReferenceBean<?> buildReferenceBean(Reference reference, Class<?> referenceClass) throws Exception {
// 获取服务引用对象的缓存key
String referenceBeanCacheKey = generateReferenceBeanCacheKey(reference, referenceClass);
// 从缓存map中获取服务引用对象
ReferenceBean<?> referenceBean = referenceBeansCache.get(referenceBeanCacheKey);

if (referenceBean == null) {
// 如果引用对象为空，则需要当场创建一个
ReferenceBeanBuilder beanBuilder = ReferenceBeanBuilder
.create(reference, classLoader, applicationContext)
.interfaceClass(referenceClass);

referenceBean = beanBuilder.build();
//并且放入到缓存map中。
referenceBeansCache.putIfAbsent(referenceBeanCacheKey, referenceBean);

}

return referenceBean;

}
private String generateReferenceBeanCacheKey(Reference reference, Class<?> beanClass) {
// 获取接口名称
String interfaceName = resolveInterfaceName(reference, beanClass);
// 通过引用的URl+接口名+接口版本号+接口分组，用来做缓存key
String key = reference.url() + "/" + interfaceName +
"/" + reference.version() +
"/" + reference.group();

Environment environment = applicationContext.getEnvironment();

key = environment.resolvePlaceholders(key);

return key;

}

消费者每引用的一种服务，都会创建一个ReferenceBean，如果多个地方使用@Reference引用同一个服务，需要看他们的的缓存key是否一样，如果都是一样的，那么就只会创建一个ReferenceBean，如果有些配置不一样，比如版本号不一致，则会创建创建不同的ReferenceBean对象，这也是他版本号能够起到的作用把。至此，@Reference注解已经解析完毕，并且服务引用的对象也已经创建了。