[编织消息框架][JAVA核心技术]动态代理应用7-IRpcSend实现

根据设计生成两个接口，IRpcSend send方法返回数据要求包装成QResult对象

public interface IRpcSend {
    public <T> QResult<T> send(byte command, Object... args);
}

public interface IRpcReceive {
    public <T> T receive(byte command, Objec[] args);
}

public interface IRpcContext {
    RpcContext getContext();
    void setContext(RpcContext ctx);
}

public interface QResult<T> extends Future<T> {

    /**
     * 是否出错
     * */
    public boolean isError();
    /**
     * 获取返回结果
     * */   
    public T getResult();
    /**
     * 设置结果
     * */  
    public void setResult(T result);
}

@SuppressWarnings("unchecked")
public abstract class QRpcFactory {
    private static Method SEND_METHOD = ReflectUtil.getMethod(IRpcSend.class, "send");
    private static Method RECEIVE_METHOD = ReflectUtil.getMethod(IRpcReceive.class, "receive");

    private static Map<Short, Class<?>> SEND_CLASS = new HashMap<>();
    private static Map<Short, IRpcReceive> RECEIVE = new HashMap<>();

    public static <T> T loadSendProxy(Class<T> target, QNode... nodes) {
        T ret = loadSendPorxy0(target);
        IRpcContext ctx = (IRpcContext) ret;
        ctx.setContext(RpcContext.of(nodes));
        return ret;
    }

    public static <T> T loadSendProxy(Class<T> target, Long... ids) {
        T ret = loadSendPorxy0(target);
        IRpcContext ctx = (IRpcContext) ret;
        ctx.setContext(RpcContext.of(ids));
        return ret;
    }

    public static <T> T loadSendProxy(Class<T> target, String... addresses) {
        T ret = loadSendPorxy0(target);
        IRpcContext ctx = (IRpcContext) ret;
        ctx.setContext(RpcContext.of(addresses));
        return ret;
        }

        private static <T> T loadSendPorxy0(Class<T> target) {
        QModel modelAnno = ReflectUtil.getAnno(target, QModel.class);
        Class<?> proxyClass = SEND_CLASS.get(modelAnno.value());
        T ret = null;
        try {
            ret = (T) proxyClass.newInstance();
        } catch (InstantiationException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
        return ret;
    }

    public static <T> T loadLocalProxy(Class<T> target) {
        QModel modelAnno = ReflectUtil.getAnno(target, QModel.class);
        Object ret = RECEIVE.get(modelAnno.value());
        return (T) ret;
    }

    public static IRpcReceive loadReceiveProxy(short model) {
        IRpcReceive ret = RECEIVE.get(model);
        return ret;
    }
}

public static void registerSendProxy(Class<?> target) {
    if (!target.isInterface()) {
        throw new RuntimeException("class is not  Interface : " + target);
    }
    QModel modelAnno = ReflectUtil.getAnno(target, QModel.class);
    String proxyClassName = target.getCanonicalName() + "$$send$$";
    ClassPool classPool = JavassistHepler.classPool;
    CtClass ctClass = classPool.makeClass(proxyClassName);

    try {
        // 设置接口
        CtClass[] interfaces = new CtClass[3];
        interfaces[0] = classPool.get(target.getName());
        interfaces[1] = classPool.get(IRpcSend.class.getName());
        interfaces[2] = classPool.get(IRpcContext.class.getName());
        ctClass.setInterfaces(interfaces);

        {
            // 添加ctx字段
            final String ctxName = RpcContext.class.getName();
            CtField ctField = new CtField(classPool.get(ctxName), "ctx", ctClass);
            ctField.setModifiers(Modifier.PRIVATE);
            ctClass.addField(ctField);
            // 添加ctx get set 方法
            CtMethod ctMethod = CtMethod.make("public " + ctxName + " getContext(){return ctx;}", ctClass);
            ctMethod.setModifiers(Modifier.PUBLIC);
            ctClass.addMethod(ctMethod);

            ctMethod = CtMethod.make("public void setContext(" + ctxName + " value){ ctx =value;}", ctClass);
            ctMethod.setModifiers(Modifier.PUBLIC);
            ctClass.addMethod(ctMethod);
        }

        // 生成send method 调用静态方法减少书写复杂
        {
          37            38             final String body = " return ($r){ " + resultType + QRpcFactory.class.getName() + ".proxySend(this,$2, (short)" + modelAnno.value() + "  ,(byte) $1);}";
            JavassistHepler.addMethod(ctClass, SEND_METHOD, body);
        }

        // 生成代理方法
        for (Method method : target.getDeclaredMethods()) {
            QCommond commond = method.getAnnotation(QCommond.class);
            if (commond == null) {
                continue;
            }

            String resultType = "";
            if (void.class != method.getReturnType()) {
                resultType = " return ($r) ";
            }
            final String body = "{ " + resultType + " this.send((byte)" + commond.value() + ",$args); }";
            JavassistHepler.addMethod(ctClass, method, body);
        }

        // 保存记录
        Class<?> newClass = ctClass.toClass();
        ctClass.detach();
        SEND_CLASS.put(modelAnno.value(), newClass);

    } catch (Exception e) {
        e.printStackTrace();
    }
}
public static QResult proxySend(IRpcContext target, Object[] args, short model, byte commondIndex) {
    System.out.println("model : " + model + " commondIndex : " + commondIndex);
    return null;
}

测试理论：

    @QModel(1)
    public interface TestObject {
        @QCommond(1)
        public void a(int a, String b);

        @QCommond(2)
        public void setAge(int value);

        @QCommond(3)
        public QResult<Integer> getAge();

        @QCommond(4)
        public void setObj(TestObject1 obj);
        
        @QCommond(5)
        public void test(int a,Integer b,Double c ,List<Integer> d,Integer[] e );
    }

    public class TestObject1 {
        public int a = 67;
    }

    public static class TestObjectImpl implements TestObject {
        private int age;

        @Override
        public void a(int a, String b) {
            System.out.println("a : " + a + " " + b);
        }

        @Override
        public void setAge(int value) {
            age = value;
        }

        @Override
        public QResult<Integer> getAge() {
            return QResultWrapper.of(age);
        }

        @Override
        public void setObj(TestObject1 obj) {
            System.out.println(obj.a);
        }

        @Override
        public void test(int a, Integer b, Double c ,List<Integer> d,Integer[] e ) {
            
        }
    }

 public class TestRpcProxy {
     @Test
     public void testSend() {
         QRpcFactory3.registerSendProxy(TestObject.class);
         TestObject proxy = QRpcFactory3.loadSendProxy(TestObject.class, 1L);
 
         proxy.a(1, "b");
         QResult<Integer> ret = proxy.getAge();
     }
 }

由于发送处理涉及netty，先不考虑通信处理实现，在实现写框架过程，依赖越少实现越简单。所以每个实例对象构造出来时必须能正常工作