https://www.jianshu.com/p/096dbda7d528

代理方式

  2. public class RpcFactory implements InvocationHandler {
  4.     @Autowired
  5.     private NettyClient client;
  7.     Logger logger = LoggerFactory.getLogger(this.getClass());
  9.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  10.         Request request = new Request();
  11.         request.setClassName(method.getDeclaringClass().getName());
  12.         request.setMethodName(method.getName());
  13.         request.setParameters(args);
  14.         request.setParameterTypes(method.getParameterTypes());
  15.         request.setId(IdUtil.getId());
  17.         Object result = client.send(request);
  18.         Class<?> returnType = method.getReturnType();
  20.         Response response = JSON.parseObject(result.toString(), Response.class);
  21.         if (response.getCode()==1){
  22.             throw new Exception(response.getError_msg());
  23.         }
  24.         if (returnType.isPrimitive() || String.class.isAssignableFrom(returnType)){
  25.             return response.getData();
  26.         }else if (Collection.class.isAssignableFrom(returnType)){
  27.             return JSONArray.parseArray(response.getData().toString(),Object.class);
  28.         }else if(Map.class.isAssignableFrom(returnType)){
  29.             return JSON.parseObject(response.getData().toString(),Map.class);
  30.         }else{
  31.             Object data = response.getData();
  32.             return JSONObject.parseObject(data.toString(), returnType);
  33.         }
  34.     }
  35. }
  1. package com.viewscenes.netsupervisor.configurer.rpc;
  3. import org.springframework.beans.factory.FactoryBean;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.beans.factory.support.AbstractBeanFactory;
  6. import org.springframework.context.support.AbstractApplicationContext;
  8. import java.lang.reflect.Proxy;
  10. /**
  11.  * Created by MACHENIKE on 2018-12-03.
  12.  */
  13. public class RpcFactoryBean<T> implements FactoryBean<T> {
  15.     private Class<T> rpcInterface;
  17.     @Autowired
  18.     private RpcFactory<T> factory;
  20.     /**
  21.      * {@link AbstractApplicationContext#registerBeanPostProcessors(org.springframework.beans.factory.config.ConfigurableListableBeanFactory)}
  22.      * 会通过 rpcInterface 实例化 RpcFactoryBean
  23.      * @param rpcInterface
  24.      */
  25.     public RpcFactoryBean(Class<T> rpcInterface) {
  26.         this.rpcInterface = rpcInterface;
  27.     }
  29.     /**
  30.      * 把 Bean 的定义 GenericBeanDefinition 放到了容器之后，就需要初始化这些 Bean,
  31.      * 而 Bean 的初始化时机有2个：
  32.      *      1、在程序第一个主动调用 getBean 的时候
  33.      *      2、在完成容器初始化的时候会初始化 lazy-init 配置为 false 的Bean（默认为false）
  34.      * 在这里，由于 RpcFactoryBean 未设置懒加载，故初始化的时机是第二种。上面两种初始化的过程都是一样的，
  35.      * 都会调用 {@link AbstractBeanFactory#doGetBean(java.lang.String, java.lang.Class, java.lang.Object[], boolean) 方法，
  36.      * 里面有个方法 getObjectForBeanInstance，会判断当前的 Bean 是否实现了 {@link FactoryBean}。
  37.      * 如果该 Bean 未实现 FactoryBean 接口，则直接返回该Bean实例；
  38.      * 如果该 Bean 实现了 FactoryBean 接口，则会返回的实例是 getObject() 返回值。
  39.      * @return
  40.      * @throws Exception
  41.      */
  42.     public T getObject() throws Exception {
  43.         return getRpc();
  44.     }
  46.     public Class<?> getObjectType() {
  47.         return this.rpcInterface;
  48.     }
  50.     public boolean isSingleton() {
  51.         return true;
  52.     }
  54.     /**
  55.      * JDK 动态代理，当调用 rpcInterface 接口的方法时，会走 factory 的 invoke 方法
  56.      * @param <T>
  57.      * @return
  58.      */
  59.     public <T> T getRpc() {
  60.         return (T) Proxy.newProxyInstance(rpcInterface.getClassLoader(), new Class[] { rpcInterface },factory);
  61.     }
  62. }
  1. // 0.容器启动
  2. 1.编码是要实现FactoryBean类，getObjectType方法通过外部传入用于初始化，getObject方法返回代理对象。
  3. 1.编码时需要标记哪些服务是rpc bean（dubbo:reference, sofa:reference ...）。
  4. 2.spring容器启动时基于bean加载注册时某些扩展点的进行判断为rpc bean。
  5.   针对rpc bean进行改造，将其BeanDefiniation的Class改为自定义的FactoryBean，
  6.   并改为按type注册，也就是FactoryBean.getObjectType方法。
  7. 3.BeanDefiniation实例化时（注册或者首次使用）会判断是否是FactoryBean实现类，
  8.   如果是会通过FactoryBean.getObject方法来返回实例对象（代理对象）。
  9. 4.代理对象在执行时实际执行时通过socket通信获取结果。并不会实际调用method.invoke,或者说
  10.   这一步被推到服务端进行执行了。
  12. // 1.Client
  13. class XXClientImpl{
  15.     @AutoWired
  16.     private UserService userService;
  18.     public void doSomething(){
  19.         userService.getUser();
  20.     }
  21. }
  23. // 2. 客户端通过动态代理 + socket(netty) + 服务端通过反射
  24. // FactoryBean是springIoC提供的一项比较方便来实现动态代理类注册的功能，因为它把实现对象和注册类
  25. // 在分化开来，并在框架内给予了特殊处理。
  26. // 想想一下，如果没有FactoryBean，如何处理？也就是要把代理类作为普通bean来注册，这就需要一个地方来
  27. // 维护jar类和代理类之间的关系，或者基于约定大于配置的思想，通过名称来关联。