Dubbo系列之 （四）服务订阅（1）
辅助链接
Dubbo系列之 （一）SPI扩展
Dubbo系列之 （二）Registry注册中心-注册（1）
Dubbo系列之 （三）Registry注册中心-注册（2）
Dubbo系列之 （四）服务订阅（1）
介绍
dubbo的服务订阅可以通过2种方式: 1）通过xml文件的标签<dubbo:reference /> ;2)通过注解@DubboReference。
这2种服务订阅在使用上基本没区别，因为标签<dubbo:reference />上的属性字段都可以在注解@DubboReference上对应的找到。一般使用XML的配置文件方式来订阅服务。
但是这2种的源码实现上有一定的区别和公用。
首先，这2种的实现最终都是调用ReferenceBean#get()方法来产生代理对象和订阅服务。所以ReferenceBean#get()方法是我们分析的重点。
其次，标签<dubbo:reference />的实现方式是通过Spring自定义的标签来实现的，当一个<dubbo:reference />标签被DubboBeanDefinitionParser处理转化后，会变成一个RootBeanDefinition，接着注册到Spring容器中。而这个RootBeanDefinition对应的类就是ReferenceBean，这个ReferenceBean 实现了工厂Bean接口FactoryBean，所以在具体创建这个Bean得对象时候，会调用FactoryBean#getObject()来返回具体类对象。刚好这个ReferenceBean的getObject()方法就是调用ReferenceBean#get()来返回具体引用服务类型对象和订阅服务。
再次，注解@DubboReference的实现方式则有所不同，它是通过BeanPostProcessor来实现的。一般我们把注解@DubboReference打在某个被Spring托管的类的成员变量上，例如：
@Component("demoServiceComponent")
public class DemoServiceComponent implements DemoService {
@DubboReference(check = false, mock = "true" ,version = "2.0.0")
private DemoService demoService;
......
}
所以可以知道@DubboReference注解和@Resource，@Autowired等注入注解类似，都是注入一个DemoService这种类型的对象。
而Dubbo框架正是通过自己编写类似于AutowiredAnnotationBeanPostProcessor的处理器ReferenceAnnotationBeanPostProcessor,通过这个处理器来处理@DubboReference注解。读者可以2者结合起来看。
ReferenceAnnotationBeanPostProcessor 分析
通过xml配置的方式的解析没有太多的价值，所以我们直接分析注解的方式。接下来我们分析Spring扩展点和dubbo框架的相结合内容。
1、Spring相关：一个Bean属性依赖注入的扩展点在哪
在远程服务引用的解析前，我们需要先了解下Spring的一个特殊的BeanPostProcessor,即
InstantiationAwareBeanPostProcessor，该后置处理器主要有三个作用：
1）、Bean实例化前的一个回调:postProcessBeforeInstantiation。
2）、Bean实例化后属性显式填充和自动注入前的回调:postProcessAfterInstantiation
3）、给Bean对象属性自动注入的机会:postProcessPropertyValues
显而易见，被打上@DubboReference 注解的属性值注入，就是利用了这个后置处理器的第三个作用（给Bean对象属性自动注入的机会postProcessPropertyValues）。就是在这个方法内处理Bean对象属性成员的注入。
有了以上Spring扩展点的基础，我们来看下AbstractAnnotationBeanPostProcessor的postProcessPropertyValues。
因为ReferenceAnnotationBeanPostProcessor继承了AbstractAnnotationBeanPostProcessor.
public PropertyValues postProcessPropertyValues(
PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeanCreationException {
/**
* 查找bean 下需要注入的相关成员（包括成员变量和方法，即被@DubboReference标注的成员，并把这些这些属性集合封装为一个对象InjectionMetadata，）
* InjectionMetadata 对象内部for 循环，一次注入相关的属性值。
*/
InjectionMetadata metadata = findInjectionMetadata(beanName, bean.getClass(), pvs);
try {
metadata.inject(bean, beanName, pvs);
} catch (BeanCreationException ex) {
throw ex;
} catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of @" + getAnnotationType().getSimpleName()
+ " dependencies is failed", ex);
}
return pvs;
}
这个方法的实现和上面的基础铺垫内容一致。首先第一步就是通过findInjectionMetadata()得到查找需要注入的相关成员。接着通过Spring内置的对象InjectionMetadata来注入bean的相关属性。这里需要注意点，metdata对象封装了该bean 需要注入的所有属性成员，在inject内部for循环一致注入。查看代码类似如下：
public void inject(Object target, String beanName, PropertyValues pvs){
Collection<InjectedElement> elementsToIterate =
(this.checkedElements != null ? this.checkedElements : this.injectedElements);
if (!elementsToIterate.isEmpty()) {
for (InjectedElement element : elementsToIterate) {
element.inject(target, beanName, pvs);
}
}
}
2、Spring相关：一个引用了远程服务的Bean,是如何找到打上@DubboReference注解的成员
通过第一个问题，我们知道当一个Spring Service的对象引用了远程对象（通过注解@DubboReference）,是通过postProcessPropertyValues注入的。接着我们需要找到它是如何需要注入的属性成员。
/**
* 找到相关的需要注入的成员元信息，并封装为InjectionMetadata
*
* @param beanName 当前需要被注入的 beanName
* @param clazz 当前需要被注入的 类的Class
* @param pvs 当前 需要被注入bean 的参数
* @return
*/
private InjectionMetadata findInjectionMetadata(String beanName, Class<?> clazz, PropertyValues pvs) {
// Fall back to class name as cache key, for backwards compatibility with custom callers.
//获取缓存key,默认为beanName，否则为className
String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
// Quick check on the concurrent map first, with minimal locking.
//从缓存中拿，如果未null 或者注入属性元数据所在的目标类和当前需要注入属性的bean的类型不一致时，需要重写获取
AnnotatedInjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
synchronized (this.injectionMetadataCache) {
metadata = this.injectionMetadataCache.get(cacheKey); //双层判断锁定
if (InjectionMetadata.needsRefresh(metadata, clazz)) {
if (metadata != null) { //原来的目标类不一致，先clear下参数属性，但排除需要的参数pvs
metadata.clear(pvs);
}
try {
metadata = buildAnnotatedMetadata(clazz); //通过需要注入的类的字节码clazz，得到需要被注入的属性的元信息。
this.injectionMetadataCache.put(cacheKey, metadata); //放入缓存。
} catch (NoClassDefFoundError err) {
throw new IllegalStateException("Failed to introspect object class [" + clazz.getName() +
"] for annotation metadata: could not find class that it depends on", err);
}
}
}
}
return metadata;
}
该注释已经非常清楚了，其实就是通过buildAnnotatedMetadata()方法构建注入的元数据信息，然后放入缓存injectionMetadataCache中。而buildAnnotatedMetadata()方法的如下：
private AnnotatedInjectionMetadata buildAnnotatedMetadata(final Class<?> beanClass) {
/**
*
* 1、查找 需要注入的成员的元信息
*/
Collection<AnnotatedFieldElement> fieldElements = findFieldAnnotationMetadata(beanClass);
/**
*
* 2、查找 需要注入的方法的元信息
*/
Collection<AnnotatedMethodElement> methodElements = findAnnotatedMethodMetadata(beanClass);
/**
*
* 组合返回元信息
*/
return new AnnotatedInjectionMetadata(beanClass, fieldElements, methodElements);
}
其中findFieldAnnotationMetadata()和findAnnotatedMethodMetadata()方法其实就是分别在clazz上的成员和方法上找是否有被@DubboReference打标的属性。
3、真正的属性注入是怎么实现的
Dubbo框架为了实现属性的注入，分别定义了2个注入类，一个AnnotatedFieldElement和一个AnnotatedMethodElement。很显然，一个是整对成员，一个整对方法。这个2个类都继承了
Spring的InjectionMetadata.InjectedElement，然后实现inject方法。接着我们来看下
这2个类的inject 是如何实现：
public class AnnotatedFieldElement extends InjectionMetadata.InjectedElement {
private final Field field;
private final AnnotationAttributes attributes;
private volatile Object bean;
protected AnnotatedFieldElement(Field field, AnnotationAttributes attributes) {
super(field, null);
this.field = field;
this.attributes = attributes;
}
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Class<?> injectedType = field.getType();
Object injectedObject = getInjectedObject(attributes, bean, beanName, injectedType, this);
ReflectionUtils.makeAccessible(field);
field.set(bean, injectedObject);
}
}
private class AnnotatedMethodElement extends InjectionMetadata.InjectedElement {
private final Method method;
private final AnnotationAttributes attributes;
private volatile Object object;
protected AnnotatedMethodElement(Method method, PropertyDescriptor pd, AnnotationAttributes attributes) {
super(method, pd);
this.method = method;
this.attributes = attributes;
}
@Override
protected void inject(Object bean, String beanName, PropertyValues pvs) throws Throwable {
Class<?> injectedType = pd.getPropertyType();
Object injectedObject = getInjectedObject(attributes, bean, beanName, injectedType, this);
ReflectionUtils.makeAccessible(method);
method.invoke(bean, injectedObject);
}
}
其实就是通过反射，把需要的属性对象注入进来。成员属性就通过field.set()。而方法就通过method.invoke().那么注入的injectedObject对象是如何获取的呢。从上面的inject()方法知道，通过调用getInjectedObject()方法来实现，而该方法其实只是从缓存injectedObjectsCache中获取注入的对象，如果不存在，就调用doGetInjectedBean().接着放入缓存中。
doGetInjectedBean()方法的作用见注释：
/**
*
*
* 该方法是个模板方法，用来得到一个需要注入类型的的对象。
*
* @param attributes ReferenceBean注解属性
* @param bean 需要被注入的对象,一般是Spring Bean
* @param beanName 需要被注入的对象名
* @param injectedType 注入对象的类型
* @param injectedElement 注入对象描述元信息
* @return
* @throws Exception
*/
@Override
protected Object doGetInjectedBean(AnnotationAttributes attributes, Object bean, String beanName, Class<?> injectedType,
InjectionMetadata.InjectedElement injectedElement) throws Exception {
/**
* The name of bean that annotated Dubbo's {@link Service @Service} in local Spring {@link ApplicationContext}
*/
/**
*
* 得到需要被注入的对象的BeanName,生成规则默认是,查看ServiceBeanNameBuilder.build()
* ServiceBean:${interfaceName}:${version}:${group}
*/
String referencedBeanName = buildReferencedBeanName(attributes, injectedType);
/**
* The name of bean that is declared by {@link Reference @Reference} annotation injection
*/
/**
* 得到引用对象@ReferenceBean的BeanName ,
* 如果有Id 就是Id,没有通过generateReferenceBeanName()产生，产生的类名如下：
* @Reference(${attributes})${interface}
*/
String referenceBeanName = getReferenceBeanName(attributes, injectedType);
/**
* 构建一个ReferenceBean 对象，如果不存在的话。
*
*/
ReferenceBean referenceBean = buildReferenceBeanIfAbsent(referenceBeanName, attributes, injectedType);
/**
* 判断是否为本地ServiceBean,一般都是远程引用dubbo服务。
*/
boolean localServiceBean = isLocalServiceBean(referencedBeanName, referenceBean, attributes);
/**
* 然后注册referenceBean
*/
registerReferenceBean(referencedBeanName, referenceBean, attributes, localServiceBean, injectedType);
/**
* 把referenceBean 放入缓存中。
*/
cacheInjectedReferenceBean(referenceBean, injectedElement);
/**
*
* 通过referenceBean 创建动态代理创建一个injectedType类型的对象。核心，创建一个代理对象，用来代表需要引用远程的Service服务
*/
return getOrCreateProxy(referencedBeanName, referenceBean, localServiceBean, injectedType);
}
上面内部方法调用都比较简单，逻辑也非常清楚，最终是通过getOrCreateProxy()方法来创建一个远程的代理对象，然后通过InjectedElement.inject注入该代理对象。
接着我们最好看下getOrCreateProxy()方法。
private Object getOrCreateProxy(String referencedBeanName, ReferenceBean referenceBean, boolean localServiceBean,
Class<?> serviceInterfaceType) {
/**
*
* 如果是本地就有服务Bean的话。
*/
if (localServiceBean) { // If the local @Service Bean exists, build a proxy of Service
//通过Proxy.newProxyInstance创建一个新的代理对象，在内部通过applicationContext获取本地Service即可。
return newProxyInstance(getClassLoader(), new Class[]{serviceInterfaceType},
newReferencedBeanInvocationHandler(referencedBeanName));
} else {
//如果是远程Service,判断被引用的服务referencedBeanName是否已经存在在applicationContext上，是的话，直接暴露服务，
// 基本上不太可能，因为在前面已经判断了被引用的服务Bean在远程，所以这里仅仅是为了防止localServiceBean判断错误。
exportServiceBeanIfNecessary(referencedBeanName); // If the referenced ServiceBean exits, export it immediately
//接着直接通过get()方法来创建一个代理，这get操作就会引入dubbo服务的订阅等相关内容。
return referenceBean.get();
}
}
可以看到最终调用了referenceBean.get()方法来创建一个远程本地代理对象。referenceBean.get()在下一个章节分析。
到这里，我们已经分析了@DubboReference注解的处理过程，然后知道了referenceBean.get()在Spring的postProcessPropertyValues扩展点上被调用。
