RPC（简单实现）
笔者之前仅看过RPC这个单词，完全没有了解过，不想终于还是碰上了。起因：这边想提高并发量而去看kafka（最后折中使用了redis），其中kafka需要安装ZooKeeper，而ZooKeeper又与分布式相关，再继续就发现分布式的基础是RPC，于是写下了这篇博文
1. RPC
RPC（Remote Procedure Call）远程过程调用，即通过网络通信来调用远程计算机程序上的服务，而这个调用过程就像调用本地方法一样简单透明，并且不需要了解底层的网络技术协议。RPC采用C/S架构，发出请求的程序是Client，提供服务的则是Server，类似于Http请求与响应。简单总结就是：调用的方法实际在远程，而要像调用本地方法一样简单。
1）对于客户端的我：调用本地的一个方法（存根）就能获得服务。 这个存根是远程服务的一个代理，其底层如何实现，对于我来说是透明的。
2）对于远程服务器：监听是否有连接过来，来了就调用对应的方法并返回（服务器端较易理解）
其结构图如下：
- 用户调用一个 “本地” 函数，该函数调用客户句柄（远程服务在本地的存根）
- 客户句柄调用网络通信来访问远程程序
- 远程程序收到网络通信及相关信息就调用服务句柄
- 服务句柄就调用服务函数，函数结束逆序返回结果完成一次远程调用
2. 为什么需要RPC
当我们的业务量越来越庞大，垂直增加服务器的数量对提高性能的作用愈加微乎，此时难免会采用分布式的架构以便更好地提高性能。分布式架构的每个服务都是独立的部分，当需要完成某项业务且依赖不同的服务式时，这些服务就需要互相调用，此时服务之间的调用就需要一种高效的应用程序之间的通讯手段了，这就是PRC出现的原因
3. RPC实现要求
3.1 服务提供方
提供服务：实现所提供的服务
服务暴漏：仅仅实现了服务是不够的，还需要将提供的服务暴漏给外界，让外界知道有何，如何使用服务
3.2 服务调用方
远程代理对象：在调用本地方法时实际调用的是远程的方法，那么势必本地需要一个远程代理对象
总结：为了实现RPC需要有：通信模型（BIO、NIO），服务定位（IP、PORT），远程代理对象（远程服务的本地代理），序列化（网络传输转换成二进制）
4. 简单实现
其主要的对象有：服务端接口、服务端接口实现、服务暴漏、客户端接口（与服务端共享同个接口）、服务的引用
4.1 服务端接口
public interface Service {
// 提供两个服务，说hello和整数相加
public String hello();
public int sum(int a, int b);
}
4.2 服务端接口实现
public class ServiceImpl implements Service {
@Override
public String hello() {
return "Hello World";
}
@Override
public int sum(int a, int b) {
return a + b;
}
}
4.3 服务暴漏
public static void export(Object service, int port) {
if (service == null || port <= 0 || port > 65535) {
throw new RuntimeException("Arguments error");
}
System.out.println(service.getClass().getName() + ": " + port + "服务暴露");
new Thread( () -> {
try (ServerSocket server = new ServerSocket(port);) {
while(true){
try (
Socket socket = server.accept();
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
) {
// 读取方法名
String methodName = in.readUTF();
// 读取参数类型
Class<?>[] parameterTypes = (Class<?>[])in.readObject();
// 读取参数值
Object[] arguments = (Object[])in.readObject();
// 获取方法
Method method = service.getClass().getMethod(methodName, parameterTypes);
// 处理结果
Object result = method.invoke(service, arguments);
// 写入结果
out.writeObject(result);
} catch (Exception e) {
e.printStackTrace();
}
}
} catch (IOException e1) {
e1.printStackTrace();
}
}).start();
}
这个暴露的逻辑是服务端监听特定端口，等客户端发起请求后连接，然后通过Java的IO流获取方法名，参数等相关信息，最后通过反射实现方法的调用并将结果响应给客户端
4.4 客户端接口
public interface ClientService {
// 提供两个服务，说hello和整数相加
public String hello();
public int sum(int a, int b);
}
4.5 服务引用
public static <T>T refer(Class<T> interfaceClass, String host, int port){
if(interfaceClass == null || !interfaceClass.isInterface() || host == null || port <= 0 || port > 65535){
throw new RuntimeException("Arguments error");
}
System.out.println("正在调用远程服务");
@SuppressWarnings("unchecked")
T proxy = (T)Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class<?>[] {interfaceClass}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
try (
Socket socket = new Socket(host, port);
ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
ObjectInputStream in = new ObjectInputStream(socket.getInputStream());
) {
out.writeUTF(method.getName());
out.writeObject(method.getParameterTypes());
out.writeObject(args);
result = in.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
});
return proxy;
}
而引用服务的逻辑是：创建Socket套接字连接，序列化相关请求信息发送给服务端，然后等待响应结果。其中透明调用是使用了动态代理
4.6 测试
public class Test {
public static void main(String[] args) {
// 暴露服务
ServiceImpl service = new ServiceImpl();
RPCFramework.export(service, 8080);
// 调用服务
Client client = RPCFramework.refer(Client.class, "127.0.0.1", 8080);
int sum = client.sum(1, 2);
String rs = client.hello();
System.out.println("远程响应：" + sum);
System.out.println("远程响应：" + rs);
}
}
RPC.ServiceImpl:8080----- 服务暴露
正在调用远程服务
远程响应：3
远程响应：Hello World
5. 思考
5.1 为什么不用Http
RPC与具体协议无关，可基于Http、TCP，但因为TCP性能相对较好。Http属于应用层协议，TCP属于传输层协议，相对在底层少了一层封装，而且为了可靠传输而选择TCP不选择UDP
5.2 常用的RPC框架
Dubbo（阿里巴巴）、SpringCloud、RMI（JDK内置）
5.3 为什么要使用动态代理
因为要像本地调用一样，对于使用者来说是透明的。
Object result = XXX(String method, String host, int port)
上面这样其实也行，但并不能感觉到是调用本地方法一样，而且如果一个接口有多个方法的话，每调用一次方法就需要发送一次host / port
// 动态代理可以这样使用
ProxyObject.方法1
ProxyObject.方法2
// 没有使用动态代理则不人性化
XXX(String method1, String host, int port)
XXX(String method2, String host, int port)
5.4 为什么参数与参数类型需要分开传
为了方便分辨方法的重载，下面获取方法需要方法名和参数类型
service.getClass().getMethod(methodName, parameterTypes)
6. 优化
6.1 网络通信
上面事例中采用BIO形式，阻塞访问而导致并发量不高，可以用NIO代替
6.2 序列化
这里用了JDK原生方法只能序列化实现了Serializable接口的类，可以使用第三方的类库来提高性能
6.3 服务负载
服务的自动发现，客户端能动态感知服务端的变化，从实现热部署，可用定时轮询的方法，eg:ZooKeeper
6.4 Cluster
集群化，这样便可以提供负载均衡
6.5 请求与响应
请求与响应可以进行编码封装，而不是这样单独一个一个发送
