Netty RPC的实现

        什么是RPC? RPC（Remote Procedure Call）即远程过程调用，简单的理解是一个节点请求另一个节点提供的服务，本地过程调用通常是指直接的使用当前程序下的一个方法，而RPC指的是调用远程的不在本机的程序的方法，使用这些方法就好像是在使用本机方法一样，如通常在网络通信时我们有调用远程服务器的方法的需求。

比较正式的描述是：一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议

RPC的优点：

• 提升系统可扩展性，随着业务的增大，可以在新增的服务器上调用原来的接口
• 提升系统可维护性和持续交付能力
• 实现系统高可用

RPC的缺点：

• RPC框架调用成功率受限于网络状况
• 复杂，开发难度大

其中的代码是根据我们前面所设计的MyMessage着手，在这里只做简单的介绍。

MyMessage是所有消息类型的父类

 AbstractResponseMessage是所有响应消息的父类，同样继承了MyMessage

1.首先是Rpc调用的请求消息体，就是我的客户端需要远程调用服务器的方法，所以请求消息体里面需要有对应方法的类名、方法名、参数等……，且在服务器里面要根据这些请求消息里的信息用反射进行调用。（这两个消息体在客户端和服务器都需要有）

public class RpcRequestMessage extends MyMessage{
    
    private String interfaceName;
    
    private String methodName;
    
    private Class returnType;
    
    private Class[] parameterTypes;
    
    private Object[] parameterValues;

    public RpcRequestMessage(String interfaceName, String methodName, Class returnType, Class[] parameterTypes, Object[] parameterValues) {
        this.messageType=getMessageType();
        this.interfaceName = interfaceName;
        this.methodName = methodName;
        this.returnType = returnType;
        this.parameterTypes = parameterTypes;
        this.parameterValues = parameterValues;
    }

    @Override
    public int getMessageType() {
        return MessageType.RpcRequestMessage;
    }
}

Gson不支持Class类型的解析，所以使用Gson解析Class类型为字符串时要自定义编解码器！强烈建议使用Jackson，Gson坑太多

2.其次是Rpc响应信息体，服务器调用了对应的方法，需要给客户端返回返回值和异常信息。

public class RpcResponseMessage extends AbstractResponseMessage{
    
    private Object returnValue;
    
    private Exception exceptionValue;

    public RpcResponseMessage(Object returnValue, Exception exceptionValue) {
        this.messageType=getMessageType();
        this.returnValue = returnValue;
        this.exceptionValue = exceptionValue;
    }

    @Override
    public int getMessageType() {
        return MessageType.RpcResponseMessage;
    }
}

 3.在Netty服务器这边添加监听Rpc请求的Handler

 这个Handler的代码部分就是关键了，这里我先写死！

@ChannelHandler.Sharable
public class RpcRequestMessageHandler extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcRequestMessage msg) {
        RpcResponseMessage res = new RpcResponseMessage(null, null);
        try {
            //这里先写死
            if ("com.lxc.chatsystem.service.FriendsService".equals(msg.getInterfaceName())) {
                //获得该接口的实现类对象
                FriendsService service = FriendsServiceFactory.getFriendsService();

                //反射调用
                Method method = service.getClass().getMethod(msg.getMethodName(), msg.getParameterTypes());
                //得到返回结果
                Object result = method.invoke(service,msg.getParameterValues());
                System.out.println(result);
                res.setReturnValue(result);
            } else {
                System.out.println("错误");
            }
        } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
            //出异常的时候，要返回异常
            res.setExceptionValue(e);
        }
        //返回响应对象
        ctx.writeAndFlush(res);
    }
}

4.同样的在Netty客户端这边加入Rpc调用的响应消息处理器，接收返回值和异常信息

 打印出结果和异常即可

public class RpcResponseMessageHandler extends SimpleChannelInboundHandler {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcResponseMessage msg) throws Exception {
        Object returnValue = msg.getReturnValue();
        Exception exceptionValue = msg.getExceptionValue();
        System.out.println(returnValue);
        System.out.println(exceptionValue);
    }
}

5.测试

使用我的服务器中的一个方法进行测试，service接口代码如下(接口的实现类忽略)：

 现在客户端想要使用该方法，我们就需要给服务器发送Rpc请求了，请求信息包含了我要调用服务器方法的一切信息：

 结果正确，客户端正常执行到了服务端的方法，并得到了返回值。

刚刚我们只是验证了客户端和服务器的通信部分，且方法也是写死了的，以后我们要想调用各种各样的方法当然是不行的，所以现在才真正的开始写RPC了。

我们的服务器和客户端日后肯定不在一个地方，但是我们的客户端需要方便的使用到服务器的方法，所以我们最起码也要让服务器和客户端的接口相同(也可以使用命令的方式调用，不需要同步接口)，如下，我的客户端扣了服务器的接口。

客户端有了接口以后，就相当于有了一个模板，但是还是缺少实现类，为了能够像运行本机方法一样的运行服务器方法，我们现在还需要实现类，但是实现类当然不能扣服务器的，这样也就没有意义了，我们这时候就需要用到动态代理了，把这个复杂的方法调用过程给屏蔽起来。代码如下：        

public class RpcProxyService {
    
    public static  T getProxyService(Class serviceClass) {
        ClassLoader classLoader = serviceClass.getClassLoader();
        Class[] interfaces = {serviceClass};
        //创建代理对象
        Proxy proxy = (Proxy) Proxy.newProxyInstance(classLoader, interfaces, new InvocationHandler() {
            public Object invoke(Object o, Method method, Object[] args) throws Throwable {
                //1.将方法调用的逻辑转为 发送rpc消息，这也是代理的重点
                RpcRequestMessage rpcMessage = new RpcRequestMessage(serviceClass.getName(),
                        method.getName(),
                        method.getReturnType(),
                        method.getParameterTypes(),
                        args
                );
                //设置消息顺序号
                rpcMessage.setSequenceId(SequenceIdGenerator.nextId());
                //2.发送给服务器，我奥调用你的某个方法了
                AppInfo.clientChannel.writeAndFlush(rpcMessage);
                //3.准备一个promise用于接收结果,并放进存放结果的容器里等待                         指定promise对象异步接收结果的线程    
                DefaultPromise