手把手教你实现一个简单的RPC框架：深入理解远程过程调用的原理与细节

手把手教你实现一个简单的RPC框架：深入理解远程过程调用的原理与细节

大家好！今天我想和你聊聊如何从零开始实现一个简单的RPC框架。还记得我第一次听说RPC时，满脑子都是问号。啥是远程过程调用？为啥需要它？咋实现的？别担心，我会用最容易理解的方式，带你揭开RPC的神秘面纱。

RPC是啥

RPC (Remote Procedure Call)远程过程调用，说白了就是让你能够调用另一台机器上的函数，就像调用本地函数一样简单。想象一下，你的程序需要用到另一台服务器上的功能，但你不想关心网络通信细节，RPC就能帮你搞定这事。

1// 本地调用

2int result = calculator.add(1， 2)；

3

4// RPC调用（看起来一样简单）

5int result = remoteCalculator.add(1， 2)； // 实际上是调用远程服务器上的方法

温馨提示：RPC让分布式系统的通信变得超级简单，你只管调方法，底层的网络通信、序列化啥的，RPC框架都给你处理好了。

RPC框架的核心组件

一个基本的RPC框架包含这几个关键部分：

服务接口

：定义了可以被远程调用的方法

服务提供者

：实现服务接口的服务端

服务消费者

：调用远程服务的客户端

代理对象

：客户端用来"假装"调用本地方法的对象

序列化/反序列化

：把对象转成字节流，便于网络传输

网络传输

：负责客户端和服务端之间的通信

动手实现一个迷你RPC框架

好啦，开始写代码啦！我们先定义一个超简单的接口：

1// 定义服务接口

2public interface CalculatorService {

3    int add(int a， int b)；

4    int subtract(int a， int b)；

5}

6

接着实现这个接口：

1// 服务实现类

2public class CalculatorServiceImpl implements CalculatorService {

3    @Override

4    public int add(int a， int b) {

5        return a + b；

6    }

7

8    @Override

9    public int subtract(int a， int b) {

10        return a - b；

11    }

12}

现在搞定序列化部分，我用Java自带的序列化机制：

1// 请求对象

2public class RpcRequest implements Serializable {

3    private String className；

4    private String methodName；

5    private Class<？>[] parameterTypes；

6    private Object[] parameters；

7

8    // 省略getter和setter

9}

10

11// 响应对象

12public class RpcResponse implements Serializable {

13    private Object result；

14    private Exception exception；

15

16    // 省略getter和setter

17}

温馨提示：真实项目中别用Java自带序列化！它又慢效率又低，还不安全。可以考虑用JSON、Protocol Buffers或Hessian等更高效的序列化方式。

服务端实现，监听请求并处理：

1public class RpcServer {

2    public void start(int port) {

3        try (ServerSocket serverSocket = new ServerSocket(port)) {

4            System.out.println("服务器启动，端口：" + port)；

5

6            while (true) {

7                Socket socket = serverSocket.accept()；

8                new Thread(() -> handleRequest(socket)).start()；

9            }

10        } catch (IOException e) {

11            e.printStackTrace()；

12        }

13    }

14

15    private void handleRequest(Socket socket) {

16        try (ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream())；

17             ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream())) {

18

19            // 读取请求

20            RpcRequest request = (RpcRequest) inputStream.readObject()；

21

22            // 处理请求

23            RpcResponse response = new RpcResponse()；

24            try {

25                Class<？> clazz = Class.forName(request.getClassName())；

26                Object serviceImpl = clazz.newInstance()；

27                Method method = clazz.getMethod(request.getMethodName()， request.getParameterTypes())；

28                Object result = method.invoke(serviceImpl， request.getParameters())；

29                response.setResult(result)；

30            } catch (Exception e) {

31                response.setException(e)；

32            }

33

34            // 发送响应

35            outputStream.writeObject(response)；

36

37        } catch (Exception e) {

38            e.printStackTrace()；

39        }

40    }

41}

客户端代理实现：

1public class RpcClientProxy implements InvocationHandler {

2    private String host；

3    private int port；

4

5    public RpcClientProxy(String host， int port) {

6        this.host = host；

7        this.port = port；

8    }

9

10    @SuppressWarnings("unchecked")

11    public <T> T getProxy(Class<T> interfaceClass) {

12        return (T) Proxy.newProxyInstance(

13            interfaceClass.getClassLoader()，

14            new Class<？>[]{interfaceClass}，

15            this

16        )；

17    }

18

19    @Override

20    public Object invoke(Object proxy， Method method， Object[] args) throws Throwable {

21        // 创建请求对象

22        RpcRequest request = new RpcRequest()；

23        request.setClassName(method.getDeclaringClass().getName())；

24        request.setMethodName(method.getName())；

25        request.setParameterTypes(method.getParameterTypes())；

26        request.setParameters(args)；

27

28        // 发送请求并获取响应

29        try (Socket socket = new Socket(host， port)；

30             ObjectOutputStream outputStream = new ObjectOutputStream(socket.getOutputStream())；

31             ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream())) {

32

33            outputStream.writeObject(request)；

34            RpcResponse response = (RpcResponse) inputStream.readObject()；

35

36            if (response.getException() ！= null) {

37                throw response.getException()；

38            }

39

40            return response.getResult()；

41        }

42    }

43}

最后，写个简单的测试代码：

1// 服务端

2public class ServerDemo {

3    public static void main(String[] args) {

4        RpcServer server = new RpcServer()；

5        server.start(8888)；

6    }

7}

8

9// 客户端

10public class ClientDemo {

11    public static void main(String[] args) {

12        RpcClientProxy proxy = new RpcClientProxy("localhost"， 8888)；

13        CalculatorService calculatorService = proxy.getProxy(CalculatorService.class)；

14

15        int addResult = calculatorService.add(10， 20)；

16        System.out.println("10 + 20 = " + addResult)；

17

18        int subtractResult = calculatorService.subtract(100， 50)；

19        System.out.println("100 - 50 = " + subtractResult)；

20    }

21}

进阶优化点

刚才实现的RPC框架太简单了，实际上还有很多可以优化的地方：

服务注册与发现

：使用Zookeeper或Nacos等注册中心管理服务

负载均衡

：当有多个服务提供者时，选择合适的服务器处理请求

连接池

：重用连接而不是每次都创建新连接

异步调用

：支持非阻塞的调用方式

超时处理

：设置合理的超时时间，避免无限等待

熔断降级

：当服务出问题时进行降级处理

温馨提示：这个简易RPC框架只适合学习原理，生产环境建议用成熟的框架如Dubbo、gRPC或Spring Cloud。它们不仅功能丰富，还经过了大量实战检验。

实现一个RPC框架看起来挺复杂，但拆解开来，就是序列化、网络传输和动态代理这几个基本概念的组合。只要掌握了核心原理，你也能写出自己的RPC框架！

学会了RPC，你就掌握了分布式系统通信的一种重要方式。下次遇到系统间调用的场景，可以考虑用RPC来简化你的开发工作。