Dubbo之消费端服务RPC调用

在消费端服务是基于接口调用Provider端提供的服务，所以在消费端并没有服务公共接口的实现类。

@RestController
@RequestMapping("/consumer")
public class CountryController {
 
    @DubboReference(version = "2.0",lazy = true)
    CountryService countryService;
 
    @GetMapping("/getCountry")
    public JSONObject getCountry() {
        JSONObject rtn = new JSONObject();
        rtn.put("msg",countryService.getCountry());
        return rtn;
    }
}

1. 利用注解@DubboReference将目标接口CountryService作为CountryController类的字段属性，在解析类CountryController时获取全部字段属性并单独关注解析存在注解@DubboReference的字段属性。
2. 通过步骤1得到服务公共接口类型，在生成RootBeanDefinition时设置其Class属性为ReferenceBean，最终将服务公共接口CountryService注册至IOC容器中。
3. 通过JdkDynamicAopProxy对服务公共接口生成代理。

1.ReferenceAnnotationBeanPostProcessor

ReferenceAnnotationBeanPostProcessor重置服务目标接口CountryService在IOC注册表class的属性为ReferenceBean。

public class ReferenceBean implements FactoryBean{
    @Override
    public T getObject() {
        if (lazyProxy == null) {
            // 对目标类代理处理
            createLazyProxy();
        }
        return (T) lazyProxy;
    }
 
    private void createLazyProxy() {
 
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setTargetSource(new DubboReferenceLazyInitTargetSource());
        proxyFactory.addInterface(interfaceClass);
        Class[] internalInterfaces = AbstractProxyFactory.getInternalInterfaces();
        for (Class anInterface : internalInterfaces) {
            proxyFactory.addInterface(anInterface);
        }
        if (!StringUtils.isEquals(interfaceClass.getName(), interfaceName)) {
            Class serviceInterface = ClassUtils.forName(interfaceName, beanClassLoader);
            proxyFactory.addInterface(serviceInterface);
        }
        //jdk基于接口代理
        this.lazyProxy = proxyFactory.getProxy(this.beanClassLoader);
    }
 
    private Object getCallProxy() throws Exception {
        //get reference proxy
        return referenceConfig.get();
    }
 
    private class DubboReferenceLazyInitTargetSource extends AbstractLazyCreationTargetSource {
 
        @Override
        protected Object createObject() throws Exception {
            return getCallProxy();
        }
 
        @Override
        public synchronized Class getTargetClass() {
            return getInterfaceClass();
        }
    }
}

jdk动态代理技术生成目标接口代理类过程中需要注意 DubboReferenceLazyInitTargetSource之lazyTarget属性【属性赋值时机、属性使用时机】。

TargetSource之DubboReferenceLazyInitTargetSource是初始化lazyTarget属性值的时机其实是通过抽象类AbstractLazyCreationTargetSource完成的。

public abstract class AbstractLazyCreationTargetSource implements TargetSource {
	/**
	 * Returns the lazy-initialized target object,
	 * creating it on-the-fly if it doesn't exist already.
	 * @see #createObject()
	 */
	@Override
	public synchronized Object getTarget() throws Exception {
		if (this.lazyTarget == null) {
			// 触发CountryService的代理
			this.lazyTarget = createObject();
		}
		return this.lazyTarget;
	}
}

根据注解得知lazyTarget属性赋值是懒加载方式得到的，即首次获取lazyTarget对象时才真正触发其完成赋值。但是实际情况是在创建目标接口的代理类时就实现赋值操作【不知道为啥？】。

class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
	
	// 代理目标类中的目标方法
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		Object oldProxy = null;
		boolean setProxyContext = false;
		// 通过 ProxyFactory 获取TargetSource之DubboReferenceLazyInitTargetSource
		TargetSource targetSource = this.advised.targetSource;
		Object target = null;
 
		...
 
		Object retVal;
		// 此处就是获取目标接口CountryService的代理，其实就是lazyTarget属性值
		target = targetSource.getTarget();
		Class targetClass = (target != null ? target.getClass() : null);
 
		// Get the interception chain for this method.
		List