手写RPC笔记（1）

RPC框架原理

RPC，是Remote Procedure Call 即远程过程调用，对标的是本地调用，本地调用相当于之前自己写的demo里面每个模块之间的调用，例如controller调用service，service调用dao层，这些都是发生在本地并且是同一个服务器下的，如果项目上线的话，其实也还是相当于在一台服务器里面完成的接口调用，只不过用的是Http 方式以RestFUL风格的调用。而RPC就是在不同的服务器之下，远程调用其他服务器中的一个方法，这也可以理解成分布式雏形，为了实现高性能，需要把不同的方法放在不同的服务器之中，在这个服务器集群之中互相远程调用之间的方法。

项目主体

本项目使用的是Github上的一个开源项目。项目地址 项目基础是一个Maven项目，用了lombok，本来在项目基础上集成一下mybatis实现真正的数据库业务，但是普通的maven项目做mybatis麻烦（配置一大堆），懒得搞。
贴代码：
实现一个实体类用来做业务：

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class User implements Serializable {
    private int id;
    private String name;
    private boolean sex;
}

RPC 客户端 Client

public class RPCClient {
    public static void main(String[] args) {
        ClientProxy clientProxy = new ClientProxy("127.0.0.1", 8899);
        UserService proxy = clientProxy.getProxy(UserService.class);
        User user = proxy.getUserNameById(new Random().nextInt(500));
        System.out.println("从服务端获取的用户为: " + user);
        int row = proxy.insertUserById(User.builder().name("XXX").sex(true).id(10).build());
        System.out.println("向服务器插入数据: " + row + "条");
    }
}

Server 端

public class RPCServer {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        try {
            ServerSocket serverSocket = new ServerSocket(8899);
            System.out.println("服务端启动了");
            //Blocking I/O 方式
            while (true){
                Socket socket = serverSocket.accept();
                //开启线程处理
                new Thread(() -> {
                    try {
                        ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
                        ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
                        //读取client传来的id
                        RPCRequest request = (RPCRequest) ois.readObject();
                        //反射
                        Method method = userService.getClass().getMethod(request.getMethodName(),request.getParamsTypes());
                        Object invoke = method.invoke(userService, request.getParams());
                        //写回user给Client
                        oos.writeObject(RPCResponse.success(invoke));
                        oos.flush();
                    } catch (IOException | ClassNotFoundException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
                        e.printStackTrace();
                        System.out.println("从IO中读取数据错误");
                    }
                }).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

为了实现项目的消息格式一致，创建了Request，Response，类似于Http的。
RPCRequest

/**
 * client 传入service接口名，方法名，参数，参数类型
 * server通过反射获取调用方法
 */
@Data
@Builder
public class RPCRequest implements Serializable{
    // 服务类名,接口名,服务端接口名指向实现类
    private String interfaceName;
    // 方法名
    private String methodName;
    // 参数列表
    private Object[] params;
    // 参数类型
    private Class<?>[] paramsTypes;
}

RPCResponse

/**
 * 将传输的对象抽象成Object,这样就可以支持多类型
 */
@Data
@Builder
public class RPCResponse implements Serializable {
    // 状态信息
    private int code;
    private String message;
    // 具体数据
    private Object data;

    public static RPCResponse success(Object data){
        return RPCResponse.builder().code(200).data(data).build();
    }
    public static RPCResponse fail(){
        return RPCResponse.builder().code(500).message("服务器发生错误").build();
    }
}

客户端根据不同的Service动态代理，代理对象增强公共行为。
底层通信：

public class IOClient {
    public static RPCResponse sendRequest(String host, int port, RPCRequest request){
        try {
            Socket socket = new Socket(host, port);
            ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
            ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
            System.out.println(request);
            oos.writeObject(request);
            oos.flush();
            RPCResponse response = (RPCResponse) ois.readObject();
            return response;
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

使用动态代理对不同的方法的Request封装

@AllArgsConstructor
public class ClientProxy implements InvocationHandler {
    private String host;
    private int port;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        RPCRequest request = RPCRequest.builder().interfaceName(method.getDeclaringClass().getName())
                .methodName(method.getName())
                .params(args).paramsTypes(method.getParameterTypes()).build();
        RPCResponse response = IOClient.sendRequest(host, port, request);
        return response.getData();
    }
    public <T>T getProxy(Class<T> clazz){
        Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this);
        return (T)o;
    }
}

业务类随便写写吧

public interface UserService {
    User getUserNameById(int id);
    int insertUserById(User user);
}

public class UserServiceImpl implements UserService {
    @Override
    public User getUserNameById(int id) {
        System.out.println("客户端查询了id为" + id + "的用户");
        Random random = new Random();
        User user = User.builder().id(id).name(UUID.randomUUID().toString()).sex(random.nextBoolean()).build();
        return user;
    }

    @Override
    public int insertUserById(User user) {
        System.out.println("插入数据成功:" + user);
        return 1;
    }
}

基本上就这些内容，用一个图总结一下执行流程：