如何从头开始编写一个简单的 RPC 协议（手写 Dubbo 的自定义协议）

1. 设计协议格式

首先，需要定义协议的数据包格式，这通常包括头部（Header）和主体（Body）两部分。

• Header：存储协议的元数据，例如消息类型、序列化方式、请求 ID 等。

  • Magic Number (2 字节)：用于标识协议版本。
  • Flag (1 字节)：表示消息类型（请求或响应）和序列化方式。
  • Status (1 字节)：在响应消息中使用，表示成功或失败。
  • Request ID (8 字节)：唯一标识请求，用于匹配响应。
  • Body Length (4 字节)：表示消息体的字节长度。

• Body：包含实际的业务数据，通常是序列化后的对象。

示例协议格式

+-------------------+----------------+------------------+-----------------+------------------+
| Magic Number (2B) | Flag (1B)      | Status (1B)      | Request ID (8B) | Body Length (4B) |
+-------------------+----------------+------------------+-----------------+------------------+
| Body (Variable Length)                                                                 |
+----------------------------------------------------------------------------------------+

2. 实现序列化和反序列化

协议需要将对象转换为字节流（序列化）以便通过网络传输，并在接收到字节流后恢复为对象（反序列化）。

2.1 序列化

你可以使用现有的序列化框架（如 JSON、Hessian、Protobuf）或实现自定义的序列化。

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

示例：使用 Java 原生的序列化机制

public class JavaSerializer implements Serializer {
    @Override
    public byte[] serialize(Object obj) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream out = new ObjectOutputStream(bos);
        out.writeObject(obj);
        return bos.toByteArray();
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) throws IOException, ClassNotFoundException {
        ByteArrayInputStream bis = new ByteArrayInputStream(data);
        ObjectInputStream in = new ObjectInputStream(bis);
        return clazz.cast(in.readObject());
    }
}

2.2 编码和解码

编码是将请求对象封装为字节数组，解码则是从字节数组中解析出请求对象。

public class ProtocolEncoder {
    public byte[] encode(Request request) throws IOException {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        buffer.putShort(MAGIC_NUMBER);
        buffer.put(FLAG);
        buffer.put(STATUS);
        buffer.putLong(request.getRequestId());
        byte[] body = serializer.serialize(request.getBody());
        buffer.putInt(body.length);
        buffer.put(body);
        return buffer.array();
    }
}

public class ProtocolDecoder {
    public Request decode(byte[] data) throws IOException, ClassNotFoundException {
        ByteBuffer buffer = ByteBuffer.wrap(data);
        short magic = buffer.getShort();
        byte flag = buffer.get();
        byte status = buffer.get();
        long requestId = buffer.getLong();
        int bodyLength = buffer.getInt();
        byte[] body = new byte[bodyLength];
        buffer.get(body);
        Object requestBody = serializer.deserialize(body, RequestBody.class);
        return new Request(requestId, requestBody);
    }
}

3. 网络通信处理

实现网络通信层，使客户端和服务端能够通过协议进行数据交换。你可以使用 Netty 这种高性能网络库来处理长连接、数据读写等操作。

3.1 实现客户端

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

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

    public Response send(Request request) throws IOException {
        Socket socket = new Socket(host, port);
        OutputStream output = socket.getOutputStream();
        byte[] encodedRequest = ProtocolEncoder.encode(request);
        output.write(encodedRequest);
        output.flush();

        InputStream input = socket.getInputStream();
        byte[] data = input.readAllBytes();
        Response response = ProtocolDecoder.decode(data);

        socket.close();
        return response;
    }
}

3.2 实现服务端

public class RpcServer {
    private final int port;

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

    public void start() throws IOException {
        ServerSocket serverSocket = new ServerSocket(port);
        while (true) {
            Socket clientSocket = serverSocket.accept();
            new Thread(() -> handleRequest(clientSocket)).start();
        }
    }

    private void handleRequest(Socket clientSocket) {
        try {
            InputStream input = clientSocket.getInputStream();
            byte[] data = input.readAllBytes();
            Request request = ProtocolDecoder.decode(data);

            // Handle the request (e.g., invoke the corresponding service)
            Object result = invokeService(request);

            // Send the response back to the client
            Response response = new Response(request.getRequestId(), result);
            byte[] encodedResponse = ProtocolEncoder.encode(response);
            OutputStream output = clientSocket.getOutputStream();
            output.write(encodedResponse);
            output.flush();
            clientSocket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 集成与测试

在客户端和服务端之间集成并测试整个协议。客户端发送请求，服务端接收、处理并返回响应，确保数据的正确性和完整性。

5. 扩展性考虑

• 支持多种序列化方式：通过 SPI 机制支持可插拔的序列化方式。
• 优化网络传输：实现自定义线程池和连接池，减少资源消耗和延迟。
• 增强安全性：增加加密机制，确保数据传输的安全性。

6. 流程图

+-----------------------------------+
|  Step 1: Client Initiates Request |
+-----------------------------------+
              |
              v
+----------------------------------------+
|  Step 2: Client Encodes Request Object |
+----------------------------------------+
              |
              v
+----------------------------------+
|  Step 3: Send Request over Network |
+----------------------------------+
              |
              v
+------------------------------------------+
|  Step 4: Server Receives and Decodes Request |
+------------------------------------------+
              |
              v
+---------------------------------------+
|  Step 5: Server Processes Request and |
|  Prepares Response                    |
+---------------------------------------+
              |
              v
+----------------------------------------+
|  Step 6: Server Encodes and Sends Response |
+----------------------------------------+
              |
              v
+-------------------------------------------+
|  Step 7: Client Receives and Decodes Response |
+-------------------------------------------+

通过遵循以上步骤，你可以设计和实现一个类似于 Dubbo 的自定义 RPC 协议。这个协议可以在分布式系统中有效地管理和处理远程调用。