面试题：让你设计一个 RPC 框架，怎么设计？

设计一个 RPC（Remote Procedure Call）框架是一个经典的面试题，涉及网络通信、序列化、服务发现、负载均衡等多个方面。以下是设计一个简化版 RPC 框架的详细思路和实现方案。

1. 需求分析

核心功能

远程调用：客户端调用远程服务的方法。
序列化与反序列化：将方法参数和返回值序列化为字节流。
网络通信：通过网络传输序列化后的数据。
服务发现：客户端发现可用的服务端。
负载均衡：在多个服务端之间分配请求。

非功能需求

高性能：低延迟、高吞吐量。
高可用：支持服务端故障转移。
可扩展性：支持动态添加服务端。
易用性：提供简单的 API，方便用户使用。

2. 系统设计

核心组件

客户端（Client）：发起远程调用。
服务端（Server）：接收请求并执行方法。
注册中心（Registry）：管理服务端地址。
序列化模块：将数据序列化为字节流。
网络通信模块：负责数据传输。
负载均衡模块：在多个服务端之间分配请求。

3. 详细设计

序列化模块

支持多种序列化协议（如 JSON、Protobuf、Hessian）。
提供统一的序列化接口。

网络通信模块

使用 TCP 或 HTTP 协议传输数据。
支持同步和异步通信。

服务发现

服务端启动时向注册中心注册。
客户端从注册中心获取服务端地址。

负载均衡

支持多种负载均衡策略（如轮询、随机、加权轮询）。
在客户端实现负载均衡逻辑。

远程调用流程

客户端通过代理调用远程方法。
代理将方法名和参数序列化为字节流。
代理通过网络通信模块发送请求到服务端。
服务端接收请求，反序列化数据并执行方法。
服务端将结果序列化并返回给客户端。
客户端接收结果并反序列化。

4. 关键问题与解决方案

1. 序列化性能

解决方案：选择高效的序列化协议（如 Protobuf）。

2. 网络通信可靠性

解决方案：使用 TCP 协议，实现重试机制。

3. 服务端高可用

解决方案：使用注册中心实现服务端故障转移。

4. 负载均衡

解决方案：在客户端实现负载均衡逻辑，支持多种策略。

5. 示例实现

序列化接口

public interface Serializer {
    <T> byte[] serialize(T obj);
    <T> T deserialize(byte[] data, Class<T> clazz);
}

JSON 序列化实现

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonSerializer implements Serializer {
    private final ObjectMapper objectMapper = new ObjectMapper();

    @Override
    public <T> byte[] serialize(T obj) {
        try {
            return objectMapper.writeValueAsBytes(obj);
        } catch (Exception e) {
            throw new RuntimeException("Serialization failed", e);
        }
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        try {
            return objectMapper.readValue(data, clazz);
        } catch (Exception e) {
            throw new RuntimeException("Deserialization failed", e);
        }
    }
}

网络通信模块

import java.io.*;
import java.net.Socket;

public class TransportClient {
    private final String host;
    private final int port;

    public TransportClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public byte[] send(byte[] data) {
        try (Socket socket = new Socket(host, port);
             OutputStream out = socket.getOutputStream();
             InputStream in = socket.getInputStream()) {
            out.write(data); // 发送数据
            out.flush();

            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            byte[] temp = new byte[1024];
            int len;
            while ((len = in.read(temp)) != -1) {
                buffer.write(temp, 0, len); // 接收数据
            }
            return buffer.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException("Network communication failed", e);
        }
    }
}

服务端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class RpcServer {
    private final int port;
    private final Serializer serializer;

    public RpcServer(int port, Serializer serializer) {
        this.port = port;
        this.serializer = serializer;
    }

    public void start() {
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            while (true) {
                Socket socket = serverSocket.accept();
                new Thread(() -> handleRequest(socket)).start(); // 处理请求
            }
        } catch (IOException e) {
            throw new RuntimeException("Server start failed", e);
        }
    }

    private void handleRequest(Socket socket) {
        try (InputStream in = socket.getInputStream();
             OutputStream out = socket.getOutputStream()) {
            ByteArrayOutputStream buffer = new ByteArrayOutputStream();
            byte[] temp = new byte[1024];
            int len;
            while ((len = in.read(temp)) != -1) {
                buffer.write(temp, 0, len); // 接收数据
            }
            byte[] requestData = buffer.toByteArray();

            // 处理请求（示例）
            String response = "Hello, World!";
            byte[] responseData = serializer.serialize(response);

            out.write(responseData); // 发送响应
            out.flush();
        } catch (IOException e) {
            throw new RuntimeException("Request handling failed", e);
        }
    }
}

客户端代理

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class RpcClient {
    private final TransportClient transportClient;
    private final Serializer serializer;

    public RpcClient(String host, int port, Serializer serializer) {
        this.transportClient = new TransportClient(host, port);
        this.serializer = serializer;
    }

    public <T> T createProxy(Class<T> clazz) {
        return (T) Proxy.newProxyInstance(
            clazz.getClassLoader(),
            new Class<?>[]{clazz},
            new RpcInvocationHandler()
        );
    }

    private class RpcInvocationHandler implements InvocationHandler {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            // 构造请求
            RpcRequest request = new RpcRequest(method.getDeclaringClass().getName(), method.getName(), args);
            byte[] requestData = serializer.serialize(request);

            // 发送请求
            byte[] responseData = transportClient.send(requestData);

            // 解析响应
            return serializer.deserialize(responseData, method.getReturnType());
        }
    }
}

RPC 请求类

public class RpcRequest {
    private String className;
    private String methodName;
    private Object[] args;

    public RpcRequest(String className, String methodName, Object[] args) {
        this.className = className;
        this.methodName = methodName;
        this.args = args;
    }

    // Getters and Setters
}