根据设计生成两个接口，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;
}
}
QRpcFactory
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 调用静态方法减少书写复杂
{
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，先不考虑通信处理实现，在实现写框架过程，依赖越少实现越简单。所以每个实例对象构造出来时必须能正常工作