当前位置：首页 > news >正文

从零实现一个轻量级 RPC 框架：通信协议与动态代理的核心原理

news 2026/7/3 4:23:26

🔥个人主页：北极的代码（欢迎来访）
🎬作者简介：java后端学习者
❄️个人专栏：苍穹外卖日记，SSM框架深入，JavaWeb
✨命运的结局尽可永在，不屈的挑战却不可须臾或缺！

技术热点 · 源码实战 · 万字长文拆解 RPC 调用细节

摘要：

本文手把手教你实现一个极简RPC框架，深入剖析RPC底层原理。从自定义TCP协议解决粘包问题开始，到动态代理屏蔽网络调用细节，再到反射与服务注册机制，完整演示了RPC调用的核心流程。通过Java原生序列化示例，展示了客户端代理如何将方法调用转为网络请求，服务端如何通过反射执行并返回结果。
文章还探讨了序列化选型（JSON/Hessian/Protobuf）的优劣比较，并指出与生产级RPC框架（如Dubbo/gRPC）在注册中心、负载均衡等方面的差距。通过这个实践项目，开发者能透彻理解RPC框架的关键技术点：协议设计、代理机制和服务发现。

前言

微服务架构下，RPC（远程过程调用）几乎成了开发者的“日常工具”。但很多同学用得很熟练，问到“Feign 和 Dubbo 的本质区别”“为什么需要序列化协议”“动态代理到底做了什么”时，却往往答不上来。
这篇文章不是教你如何使用现成的 RPC 框架，而是手把手带你实现一个极简版 RPC 框架，涉及：
自定义 TCP 通信协议（解决粘包问题）
Java 动态代理（屏蔽网络调用细节）
反射与服务注册（服务端分发）
序列化选型（JSON vs Hessian vs Protobuf）
全程代码可运行，看完你将对 RPC 的底层原理有一个非常具体的认知。

一、RPC 调用流程回顾

一个完整的 RPC 调用包含 5 个关键角色：

text

[Client] ↓ 调用代理对象 [动态代理] → 将方法+参数转成请求对象 → 序列化 → ↓ [网络传输] (Socket) ↓ [Server 接收] → 反序列化 → 根据接口名+方法名找到实现类 → ↓ [反射执行] → 返回结果 → 再序列化 → 写回 Client

要自己实现一个 RPC，核心要解决三个问题：

协议设计：服务端怎么知道一个请求从哪里开始、到哪里结束
代理与调用：如何让调用远程方法像调用本地方法一样自然
服务发现（简化版）：服务端如何根据请求找到对应的实现类

我们逐一来实现。

二、自定义通信协议

TCP 是流式协议，没有天然的“消息边界”。如果连续发送两个 RPC 请求，服务端收到的可能是半包或粘包的数据。解决方案：在每个消息前面加上长度字段。

协议格式（简单版）

text

+------------+-------------+----------------+ | 魔数(2B) | 长度(4B) | body(bytes) | +------------+-------------+----------------+

魔数：用来快速判断是否是合法协议包（比如 0xCAFE）
长度：body 的字节长度
body：实际请求或响应数据（序列化后的字节）

编码器（客户端发送）

java public class RpcEncoder { public static byte[] encode(byte[] body) { ByteBuffer buffer = ByteBuffer.allocate(2 + 4 + body.length); buffer.putShort((short) 0xCAFE); // 魔数 buffer.putInt(body.length); // 长度 buffer.put(body); // 数据 return buffer.array(); } }

解码器（服务端接收）

服务端需要循环读 Socket 输入流，每次先读 6 个字节（2+4），解析出长度，再读取对应长度的 body 数据。

java public static byte[] decode(InputStream in) throws IOException { DataInputStream dis = new DataInputStream(in); short magic = dis.readShort(); if (magic != 0xCAFE) { throw new RuntimeException("非法协议包"); } int len = dis.readInt(); byte[] body = new byte[len]; dis.readFully(body); // 确保读满 len 字节 return body; }

这是 Netty 中 LengthFieldBasedFrameDecoder 的极简原型。

三、动态代理：让远程调用像本地一样

客户端不应该了解 Socket 细节。我们通过java.lang.reflect.Proxy生成一个代理对象：

java public class RpcClientProxy implements InvocationHandler { private String host; private int port; public RpcClientProxy(String host, int port) { this.host = host; this.port = port; } public <T> T getProxy(Class<T> clazz) { return (T) Proxy.newProxyInstance( clazz.getClassLoader(), new Class[]{clazz}, this ); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 1. 构建请求对象 RpcRequest request = new RpcRequest(); request.setInterfaceName(method.getDeclaringClass().getName()); request.setMethodName(method.getName()); request.setParameterTypes(method.getParameterTypes()); request.setParameters(args); // 2. 通过 Socket 发送请求，并等待响应 try (Socket socket = new Socket(host, port); ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream()); ObjectInputStream ois = new ObjectInputStream(socket.getInputStream())) { oos.writeObject(request); RpcResponse response = (RpcResponse) ois.readObject(); if (response.getError() != null) { throw response.getError(); } return response.getResult(); } } }

这里为了方便演示直接用了 Java 原生序列化，生产环境会换成更高效的序列化协议。

四、服务端：注册表 + 反射执行

服务端需要维护一个 Map：接口名 → 实现类对象。

java public class RpcServer { private Map<String, Object> serviceMap = new ConcurrentHashMap<>(); private ExecutorService threadPool = Executors.newCachedThreadPool(); public void registerService(Object service) { Class<?>[] interfaces = service.getClass().getInterfaces(); for (Class<?> anInterface : interfaces) { serviceMap.put(anInterface.getName(), service); System.out.println("注册服务: " + anInterface.getName()); } } public void start(int port) throws IOException { try (ServerSocket serverSocket = new ServerSocket(port)) { while (true) { Socket socket = serverSocket.accept(); threadPool.submit(() -> handleRequest(socket)); } } } private void handleRequest(Socket socket) { try (ObjectInputStream ois = new ObjectInputStream(socket.getInputStream()); ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream())) { RpcRequest request = (RpcRequest) ois.readObject(); // 找到服务实现 Object service = serviceMap.get(request.getInterfaceName()); if (service == null) { throw new RuntimeException("未找到服务: " + request.getInterfaceName()); } // 反射调用 Method method = service.getClass().getMethod( request.getMethodName(), request.getParameterTypes() ); Object result = method.invoke(service, request.getParameters()); // 返回响应 RpcResponse response = RpcResponse.success(result); oos.writeObject(response); } catch (Exception e) { e.printStackTrace(); } } }

五、Demo 演示：调用远程计算服务

定义接口

java

public interface Calculator { int add(int a, int b); }

服务端实现

java

public class CalculatorImpl implements Calculator { @Override public int add(int a, int b) { return a + b; } } // 启动服务端 RpcServer server = new RpcServer(); server.registerService(new CalculatorImpl()); server.start(8888);

客户端调用

java

RpcClientProxy proxy = new RpcClientProxy("127.0.0.1", 8888); Calculator calculator = proxy.getProxy(Calculator.class); int result = calculator.add(10, 20); System.out.println(result); // 输出 30，完全像本地方法

看到没有？客户端没有任何网络代码，也没有序列化/反序列化逻辑 —— 全部被动态代理屏蔽了。

六、进阶话题：序列化选型

上面用了 Java 原生ObjectOutputStream，存在几个问题：

跨语言不友好（Python/Go 无法调用）
性能较差，序列化体积大
安全性问题

常见替代方案：

序列化方案	体积	速度	跨语言	可读性
Java 原生	大	慢	❌	二进制
JSON	中	中	✅	高
Hessian2	小	快	✅	二进制
Protobuf	很小	很快	✅	二进制

在我们的自定义协议中，只需要替换编码/解码时使用的序列化工具即可，与协议长度字段完全解耦。

示例用 Protobuf 改造：

java // 编码 byte[] body = calcRequest.toByteArray(); // protobuf 生成的对象 ByteBuffer buffer = ByteBuffer.allocate(2 + 4 + body.length); // 解码 CalcRequest req = CalcRequest.parseFrom(body);