一、RPC 是什么？为什么需要 RPC？

在分布式系统中，我们经常需要调用其他服务器上的方法，比如用户服务需要调用订单服务的 “创建订单” 接口。如果直接通过 HTTP 调用，会面临序列化、网络通信、服务发现、负载均衡等一系列问题。RPC（Remote Procedure Call，远程过程调用） 就是为解决这些问题而生的技术 —— 它能让我们像调用本地方法一样调用远程服务，屏蔽分布式通信的复杂细节。

举个通俗的例子：你在公司电脑上想查看家里电脑的文件，不需要自己手动建立网络连接、处理数据传输，只需要双击 “远程桌面” 图标，就能像操作本地电脑一样操作家里的电脑。RPC 就相当于分布式系统中的 “远程桌面”，让跨服务调用变得简单。

1.1 RPC 的核心价值

  • 透明化远程调用：调用远程方法和调用本地方法语法一致，开发者无需关注网络通信细节。
  • 高性能通信：相比 HTTP，RPC 通常采用更轻量的协议（如自定义 TCP 协议）和更高效的序列化方式（如 Protobuf、FastJSON2），性能更高。
  • 服务化支撑：RPC 框架通常集成服务注册发现、负载均衡、容错等能力，是微服务架构的基础。

1.2 RPC 调用的核心流程

为了让大家直观理解 RPC 的工作原理，我们用 Mermaid 流程图展示一次完整的 RPC 调用过程：

二、RPC 框架的核心架构设计

一个成熟的 RPC 框架需要包含 6 大核心组件，各组件职责清晰、协同工作。我们先通过架构图了解整体结构：

各组件的核心职责如下：

  1. 服务注册中心：存储服务名称与服务地址的映射关系（如 ZooKeeper、Nacos），支持服务注册和发现。
  2. 服务提供者：暴露本地服务，将服务信息注册到注册中心，接收并处理消费者的远程调用请求。
  3. 服务消费者：从注册中心获取服务地址，通过动态代理发起远程调用。
  4. 动态代理层：为消费者生成服务代理对象，将 “调用代理方法” 转为 “远程调用请求”。
  5. 网络传输层：负责跨节点的二进制数据传输（通常基于 Netty 的 NIO 模型实现）。
  6. 序列化层：将 Java 对象与二进制数据相互转换（解决 “对象不能跨网络传输” 的问题）。

三、环境搭建：确定技术栈与依赖

在开始编码前，我们先明确技术栈选型，所有组件均采用最新稳定版本，确保兼容性和性能：

组件技术选型版本用途说明
JDKOracle JDK17基础开发环境
项目管理Maven3.9.6依赖管理和项目构建
网络通信Netty4.1.100.Final高性能 NIO 通信框架，实现 TCP 传输
服务注册中心ZooKeeper3.9.2存储服务地址，支持服务发现
序列化FastJSON22.0.48高效 JSON 序列化 / 反序列化框架
动态代理JDK 动态代理内置生成服务代理对象
工具类Lombok、Spring UtilsLombok 1.18.30简化代码（@Slf4j）、判空工具等
接口文档Swagger32.2.0生成 API 文档，方便测试
持久层（可选）MyBatis-Plus3.5.5若服务需要操作数据库，用于数据访问

3.1 核心依赖配置（pom.xml）

创建 Maven 项目，在pom.xml中添加以下依赖，所有版本均为 2024 年最新稳定版：



    4.0.0
    com.ken.rpc
    ken-rpc-framework
    1.0.0
    
        17
        17
        UTF-8
        
        4.1.100.Final
        3.9.2
        2.0.48
        1.18.30
        6.1.5
        2.2.0
        3.5.5
        8.0.36
    
    
        
        
            org.projectlombok
            lombok
            ${lombok.version}
            provided
        
        
            org.springframework
            spring-context
            ${spring-context.version}
        
        
            com.google.guava
            guava
            33.1.0-jre
        
        
        
            io.netty
            netty-all
            ${netty.version}
        
        
        
            org.apache.zookeeper
            zookeeper
            ${zookeeper.version}
            
                
                    org.slf4j
                    slf4j-log4j12
                
                
                    log4j
                    log4j
                
            
        
        
        
            com.alibaba.fastjson2
            fastjson2
            ${fastjson2.version}
        
        
        
            org.springdoc
            springdoc-openapi-starter-webmvc-ui
            ${swagger.version}
        
        
        
            com.baomidou
            mybatis-plus-boot-starter
            ${mybatis-plus.version}
        
        
            mysql
            mysql-connector-java
            ${mysql.version}
            runtime

四、核心模块实现：从底层到上层

我们按照 “底层支撑→核心逻辑→上层应用” 的顺序实现 RPC 框架，每个模块都包含 “设计思路 + 可运行代码”，确保读者能直接复用。

4.1 序列化层：解决 “对象跨网络传输” 问题

设计思路：Java 对象不能直接通过网络传输，需要先转为二进制数据（序列化）；服务端接收后，再将二进制转成 Java 对象（反序列化）。我们选择 FastJSON2 作为序列化工具（相比 JSON、Protobuf，它兼顾性能和易用性），定义统一的序列化接口，方便后续替换其他序列化方式。

4.1.1 序列化接口定义
package com.ken.rpc.serialize;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import com.ken.rpc.exception.SerializeException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils;
/**
 * 序列化工具类（基于FastJSON2实现）
 * 负责Java对象与二进制数据的相互转换
 *
 * @author ken
 */
@Slf4j
public class FastJson2Serializer implements Serializer {
    /**
     * 序列化：将Java对象转为字节数组
     *
     * @param obj 待序列化的对象
     * @return 序列化后的字节数组
     * @throws SerializeException 序列化失败时抛出
     */
    @Override
    public byte[] serialize(Object obj) throws SerializeException {
        if (ObjectUtils.isEmpty(obj)) {
            log.error("序列化对象为空，无法执行序列化操作");
            throw new SerializeException("序列化对象不能为空");
        }
        try {
            // FastJSON2序列化：对象→JSON字符串→字节数组（指定UTF-8编码）
            return JSON.toJSONBytes(obj);
        } catch (Exception e) {
            log.error("对象序列化失败，对象类型：{}，异常信息：{}", obj.getClass().getName(), e.getMessage(), e);
            throw new SerializeException("序列化失败：" + e.getMessage());
        }
    }
    /**
     * 反序列化：将字节数组转为指定类型的Java对象
     *
     * @param bytes 待反序列化的字节数组
     * @param clazz 目标对象的Class类型
     * @param    目标对象的泛型
     * @return 反序列化后的Java对象
     * @throws SerializeException 反序列化失败时抛出
     */
    @Override
    public  T deserialize(byte[] bytes, Class clazz) throws SerializeException {
        if (ObjectUtils.isEmpty(bytes)) {
            log.error("反序列化字节数组为空，无法执行反序列化操作");
            throw new SerializeException("反序列化字节数组不能为空");
        }
        if (ObjectUtils.isEmpty(clazz)) {
            log.error("反序列化目标类型为空，无法执行反序列化操作");
            throw new SerializeException("反序列化目标类型不能为空");
        }
        try {
            // FastJSON2反序列化：字节数组→指定类型对象
            return JSON.parseObject(bytes, clazz);
        } catch (Exception e) {
            log.error("字节数组反序列化失败，目标类型：{}，异常信息：{}", clazz.getName(), e.getMessage(), e);
            throw new SerializeException("反序列化失败：" + e.getMessage());
        }
    }
    /**
     * 反序列化（支持泛型类型，如List、Map）
     *
     * @param bytes          待反序列化的字节数组
     * @param typeReference FastJSON2的TypeReference，用于指定泛型类型
     * @param            目标对象的泛型
     * @return 反序列化后的Java对象
     * @throws SerializeException 反序列化失败时抛出
     */
    @Override
    public  T deserialize(byte[] bytes, TypeReference typeReference) throws SerializeException {
        if (ObjectUtils.isEmpty(bytes)) {
            log.error("反序列化字节数组为空，无法执行反序列化操作");
            throw new SerializeException("反序列化字节数组不能为空");
        }
        if (ObjectUtils.isEmpty(typeReference)) {
            log.error("反序列化泛型类型为空，无法执行反序列化操作");
            throw new SerializeException("反序列化泛型类型不能为空");
        }
        try {
            // 支持泛型的反序列化（如List）
            return JSON.parseObject(bytes, typeReference);
        } catch (Exception e) {
            log.error("字节数组泛型反序列化失败，异常信息：{}", e.getMessage(), e);
            throw new SerializeException("泛型反序列化失败：" + e.getMessage());
        }
    }
}
4.1.2 序列化异常定义

为了统一异常处理，定义序列化相关的自定义异常：

package com.ken.rpc.exception;
/**
 * 序列化/反序列化异常
 * 当对象与字节数组转换过程中出现错误时抛出
 *
 * @author ken
 */
public class SerializeException extends RuntimeException {
    public SerializeException(String message) {
        super(message);
    }
    public SerializeException(String message, Throwable cause) {
        super(message, cause);
    }
}

4.2 网络传输层：基于 Netty 实现高性能通信

设计思路：网络传输是 RPC 的核心底层支撑，需要解决 “高并发”“低延迟” 问题。Netty 是基于 NIO 的高性能通信框架，我们用它实现 TCP 服务端（服务提供者）和客户端（服务消费者），并定义统一的 “请求 / 响应” 数据结构，确保数据传输的完整性。

4.2.1 定义 RPC 请求 / 响应实体

首先定义 RPC 调用的 “请求” 和 “响应” 格式，所有网络传输的数据都遵循这个结构：

package com.ken.rpc.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
 * RPC请求实体
 * 封装消费者向提供者发送的调用信息
 *
 * @author ken
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RpcRequest implements Serializable {
    /**
     * 请求ID：唯一标识一次RPC调用（用于解决请求与响应的对应问题）
     */
    private String requestId;
    /**
     * 服务接口名称（如com.ken.rpc.service.UserService）
     * 用于服务提供者找到对应的实现类
     */
    private String serviceName;
    /**
     * 方法名称（如getUserById）
     */
    private String methodName;
    /**
     * 方法参数类型列表（如[java.lang.Long]）
     * 用于服务提供者找到重载的方法
     */
    private Class[] parameterTypes;
    /**
     * 方法参数值列表（如[1001]）
     */
    private Object[] parameters;
    /**
     * 服务版本号（用于处理服务升级，如1.0.0、2.0.0）
     */
    private String serviceVersion;
}
package com.ken.rpc.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
 * RPC响应实体
 * 封装服务提供者向消费者返回的结果
 *
 * @author ken
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class RpcResponse implements Serializable {
    /**
     * 请求ID：与RpcRequest的requestId对应，确保响应匹配
     */
    private String requestId;
    /**
     * 调用成功：返回的方法执行结果
     */
    private Object result;
    /**
     * 调用失败：返回的异常信息
     */
    private Throwable exception;
    /**
     * 判断本次RPC调用是否成功
     *
     * @return true-成功，false-失败
     */
    public boolean isSuccess() {
        return exception == null;
    }
}
4.2.2 Netty 服务端实现（服务提供者）

服务提供者需要启动 Netty 服务端，监听指定端口，接收消费者的请求并处理：

package com.ken.rpc.transport.netty;
import com.ken.rpc.entity.RpcRequest;
import com.ken.rpc.entity.RpcResponse;
import com.ken.rpc.handler.RpcRequestHandler;
import com.ken.rpc.serialize.FastJson2Serializer;
import com.ken.rpc.serialize.Serializer;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
 * Netty RPC服务端
 * 负责启动服务、监听端口、接收并处理消费者的RPC请求
 *
 * @author ken
 */
@Slf4j
public class NettyRpcServer {
    /**
     * 服务端口号
     */
    private final int port;
    /**
     * 服务注册中心地址（如zookeeper://127.0.0.1:2181）
     */
    private final String registryAddress;
    /**
     * 序列化工具（默认使用FastJSON2）
     */
    private final Serializer serializer;
    /**
     * RPC请求处理器（负责调用本地服务方法）
     */
    private final RpcRequestHandler rpcRequestHandler;
    public NettyRpcServer(int port, String registryAddress) {
        this(port, registryAddress, new FastJson2Serializer(), new RpcRequestHandler());
    }
    public NettyRpcServer(int port, String registryAddress, Serializer serializer, RpcRequestHandler rpcRequestHandler) {
        this.port = port;
        this.registryAddress = registryAddress;
        this.serializer = serializer;
        this.rpcRequestHandler = rpcRequestHandler;
    }
    /**
     * 启动Netty服务端
     */
    public void start() {
        // 1. 校验参数
        if (port <= 0 || port > 65535) {
            log.error("服务端口号非法，端口：{}（合法范围：1-65535）", port);
            throw new IllegalArgumentException("服务端口号非法：" + port);
        }
        if (!StringUtils.hasText(registryAddress)) {
            log.error("服务注册中心地址为空，无法启动服务");
            throw new IllegalArgumentException("服务注册中心地址不能为空");
        }
        // 2. 初始化Netty线程组
        // BossGroup：负责接收客户端连接
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // WorkerGroup：负责处理客户端的IO请求
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            // 3. 配置服务端启动参数
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    // 配置服务端通道类型（NIO）
                    .channel(NioServerSocketChannel.class)
                    // 日志打印（DEBUG级别，方便调试）
                    .handler(new LoggingHandler(LogLevel.DEBUG))
                    // 配置客户端连接的通道初始化器
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // ① 粘包/拆包处理器：基于消息长度字段解决TCP粘包问题
                            // 解码：读取消息时，先读取4字节的长度字段，再读取对应长度的消息体
                            pipeline.addLast(new LengthFieldBasedFrameDecoder(
                                    Integer.MAX_VALUE, 0, 4, 0, 4));
                            // 编码：发送消息时，在消息体前添加4字节的长度字段
                            pipeline.addLast(new LengthFieldPrepender(4));
                            // ② 序列化/反序列化处理器：将字节数组转为Java对象（请求），将Java对象转为字节数组（响应）
                            pipeline.addLast(new NettySerializerHandler(serializer, RpcRequest.class, RpcResponse.class));
                            // ③ RPC请求处理器：处理请求，调用本地服务方法，生成响应
                            pipeline.addLast(new NettyRpcServerHandler(rpcRequestHandler));
                        }
                    })
                    // 服务端接收连接的队列大小
                    .option(ChannelOption.SO_BACKLOG, 128)
                    // 保持TCP连接（防止连接超时）
                    .childOption(ChannelOption.SO_KEEPALIVE, true);
            // 4. 绑定端口，启动服务（同步阻塞，直到服务启动完成）
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            log.info("Netty RPC服务端启动成功，监听端口：{}，注册中心地址：{}", port, registryAddress);
            // 5. 注册服务到注册中心（后续章节实现）
            registerService();
            // 6. 阻塞等待通道关闭（服务停止时才会继续执行）
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("Netty RPC服务端启动过程被中断，异常信息：{}", e.getMessage(), e);
        } finally {
            // 7. 优雅关闭线程组
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
            log.info("Netty RPC服务端已关闭");
        }
    }
    /**
     * 注册服务到注册中心（后续章节实现服务注册逻辑）
     */
    private void registerService() {
        try {
            // 获取本地IP地址（服务提供者的IP）
            String localIp = InetAddress.getLocalHost().getHostAddress();
            log.info("准备注册服务到注册中心，服务地址：{}:{}", localIp, port);
            // TODO：后续章节实现ZooKeeper注册逻辑
        } catch (UnknownHostException e) {
            log.error("获取本地IP地址失败，无法注册服务，异常信息：{}", e.getMessage(), e);
            throw new RuntimeException("获取本地IP地址失败：" + e.getMessage());
        }
    }
}
4.2.3 Netty 客户端实现（服务消费者）

服务消费者需要通过 Netty 客户端发送 RPC 请求，并接收响应：

package com.ken.rpc.transport.netty;
import com.ken.rpc.entity.RpcRequest;
import com.ken.rpc.entity.RpcResponse;
import com.ken.rpc.serialize.FastJson2Serializer;
import com.ken.rpc.serialize.Serializer;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import java.net.InetSocketAddress;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
 * Netty RPC客户端
 * 负责与服务提供者建立连接，发送RPC请求，接收响应
 *
 * @author ken
 */
@Slf4j
public class NettyRpcClient {
    /**
     * 服务端地址（IP:端口）
     */
    private final InetSocketAddress serverAddress;
    /**
     * 序列化工具（默认使用FastJSON2）
     */
    private final Serializer serializer;
    /**
     * 存储未处理的RPC请求（key：requestId，value：CompletableFuture）
     * 用于将响应与请求匹配（Netty是异步通信，需要通过requestId关联）
     */
    private final ConcurrentMap> unprocessedRequests;
    /**
     * Netty客户端通道（与服务端的连接通道）
     */
    private Channel channel;
    /**
     * Netty事件循环组（负责处理IO事件）
     */
    private final EventLoopGroup eventLoopGroup;
    public NettyRpcClient(InetSocketAddress serverAddress) {
        this(serverAddress, new FastJson2Serializer());
    }
    public NettyRpcClient(InetSocketAddress serverAddress, Serializer serializer) {
        this.serverAddress = serverAddress;
        this.serializer = serializer;
        this.unprocessedRequests = new ConcurrentHashMap<>();
        this.eventLoopGroup = new NioEventLoopGroup();
        // 初始化客户端连接
        this.initialize();
    }
    /**
     * 初始化Netty客户端，与服务端建立连接
     */
    private void initialize() {
        // 1. 校验服务端地址
        if (ObjectUtils.isEmpty(serverAddress) || StringUtils.isEmpty(serverAddress.getHostName())) {
            log.error("服务端地址非法，无法建立连接");
            throw new IllegalArgumentException("服务端地址非法");
        }
        try {
            // 2. 配置客户端启动参数
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(eventLoopGroup)
                    // 客户端通道类型（NIO）
                    .channel(NioSocketChannel.class)
                    // 连接超时时间（3秒）
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
                    // 保持TCP连接
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    // 禁用Nagle算法（减少延迟，适合RPC小数据传输）
                    .option(ChannelOption.TCP_NODELAY, true)
                    // 配置通道初始化器
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            // ① 粘包/拆包处理器（与服务端对应）
                            pipeline.addLast(new LengthFieldBasedFrameDecoder(
                                    Integer.MAX_VALUE, 0, 4, 0, 4));
                            pipeline.addLast(new LengthFieldPrepender(4));
                            // ② 序列化/反序列化处理器（与服务端对应）
                            pipeline.addLast(new NettySerializerHandler(serializer, RpcRequest.class, RpcResponse.class));
                            // ③ 客户端响应处理器（接收服务端的响应，完成CompletableFuture）
                            pipeline.addLast(new NettyRpcClientHandler(unprocessedRequests));
                        }
                    });
            // 3. 与服务端建立连接（同步阻塞，直到连接建立完成）
            ChannelFuture channelFuture = bootstrap.connect(serverAddress).sync();
            log.info("Netty RPC客户端与服务端建立连接成功，服务端地址：{}:{}",
                    serverAddress.getHostName(), serverAddress.getPort());
            // 4. 保存通道引用，用于后续发送请求
            channel = channelFuture.channel();
            // 5. 监听通道关闭事件（连接断开时打印日志）
            channel.closeFuture().addListener(future -> {
                log.info("Netty RPC客户端与服务端连接断开，服务端地址：{}:{}",
                        serverAddress.getHostName(), serverAddress.getPort());
                eventLoopGroup.shutdownGracefully();
            });
        } catch (InterruptedException e) {
            log.error("Netty RPC客户端建立连接过程被中断，服务端地址：{}:{}，异常信息：{}",
                    serverAddress.getHostName(), serverAddress.getPort(), e.getMessage(), e);
            eventLoopGroup.shutdownGracefully();
        }
    }
    /**
     * 发送RPC请求，返回CompletableFuture（异步获取响应）
     *
     * @param rpcRequest RPC请求实体
     * @return 包含RPC响应的CompletableFuture
     */
    public CompletableFuture sendRequest(RpcRequest rpcRequest) {
        // 1. 校验请求和通道
        if (ObjectUtils.isEmpty(rpcRequest) || StringUtils.isEmpty(rpcRequest.getRequestId())) {
            log.error("RPC请求非法（请求ID为空），无法发送请求");
            throw new IllegalArgumentException("RPC请求ID不能为空");
        }
        if (ObjectUtils.isEmpty(channel) || !channel.isActive()) {
            log.error("客户端通道未建立或已关闭，无法发送请求，服务端地址：{}:{}",
                    serverAddress.getHostName(), serverAddress.getPort());
            throw new RuntimeException("客户端通道不可用，无法发送请求");
        }
        // 2. 创建CompletableFuture，用于接收响应
        CompletableFuture resultFuture = new CompletableFuture<>();
        // 3. 将请求ID与CompletableFuture关联，存入未处理请求Map
        unprocessedRequests.put(rpcRequest.getRequestId(), resultFuture);
        // 4. 发送请求（Netty的writeAndFlush是异步操作，不会阻塞）
        channel.writeAndFlush(rpcRequest).addListener((ChannelFutureListener) future -> {
            if (future.isSuccess()) {
                log.info("RPC请求发送成功，请求ID：{}，服务名称：{}，方法名称：{}",
                        rpcRequest.getRequestId(), rpcRequest.getServiceName(), rpcRequest.getMethodName());
            } else {
                // 发送失败：移除未处理请求，完成CompletableFuture（异常）
                unprocessedRequests.remove(rpcRequest.getRequestId());
                resultFuture.completeExceptionally(future.cause());
                log.error("RPC请求发送失败，请求ID：{}，异常信息：{}",
                        rpcRequest.getRequestId(), future.cause().getMessage(), future.cause());
            }
        });
        return resultFuture;
    }
    /**
     * 关闭客户端（优雅关闭线程组和通道）
     */
    public void close() {
        if (!ObjectUtils.isEmpty(channel) && channel.isActive()) {
            channel.close();
        }
        eventLoopGroup.shutdownGracefully();
        log.info("Netty RPC客户端已关闭，服务端地址：{}:{}",
                serverAddress.getHostName(), serverAddress.getPort());
    }
}
4.2.4 序列化 / 反序列化处理器

Netty 的ChannelHandler负责在通道中处理数据，我们需要自定义处理器，将 Netty 的ByteBuf与 RPC 的RpcRequest/RpcResponse相互转换：

package com.ken.rpc.transport.netty;
import com.ken.rpc.entity.RpcRequest;
import com.ken.rpc.entity.RpcResponse;
import com.ken.rpc.serialize.Serializer;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import io.netty.handler.codec.ReplayingDecoder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils;
import java.util.List;
/**
 * Netty序列化/反序列化处理器
 * 包含编码器（Request→ByteBuf）和解码器（ByteBuf→Response）
 *
 * @author ken
 */
@Slf4j
public class NettySerializerHandler {
    /**
     * RPC请求编码器：将RpcRequest对象转为ByteBuf（发送给服务端）
     */
    public static class RequestEncoder extends MessageToByteEncoder {
        private final Serializer serializer;
        public RequestEncoder(Serializer serializer) {
            this.serializer = serializer;
        }
        @Override
        protected void encode(ChannelHandlerContext ctx, RpcRequest msg, ByteBuf out) throws Exception {
            if (ObjectUtils.isEmpty(msg)) {
                log.error("RPC请求为空，无法编码");
                throw new IllegalArgumentException("RPC请求不能为空");
            }
            // 1. 序列化RpcRequest为字节数组
            byte[] bytes = serializer.serialize(msg);
            // 2. 将字节数组写入ByteBuf（Netty会自动处理后续传输）
            out.writeBytes(bytes);
            log.debug("RPC请求编码完成，请求ID：{}，字节长度：{}", msg.getRequestId(), bytes.length);
        }
    }
    /**
     * RPC响应解码器：将ByteBuf转为RpcResponse对象（接收服务端响应）
     * 使用ReplayingDecoder简化解码逻辑（无需手动处理半包问题）
     */
    public static class ResponseDecoder extends ReplayingDecoder {
        private final Serializer serializer;
        public ResponseDecoder(Serializer serializer) {
            this.serializer = serializer;
        }
        @Override
        protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception {
            if (ObjectUtils.isEmpty(in)) {
                log.error("RPC响应ByteBuf为空，无法解码");
                return;
            }
            // 1. 读取ByteBuf中的所有字节
            int length = in.readableBytes();
            byte[] bytes = new byte[length];
            in.readBytes(bytes);
            // 2. 反序列化为RpcResponse对象
            RpcResponse rpcResponse = serializer.deserialize(bytes, RpcResponse.class);
            // 3. 将解码后的对象加入输出列表（交给下一个Handler处理）
            out.add(rpcResponse);
            log.debug("RPC响应解码完成，请求ID：{}，响应是否成功：{}",
                    rpcResponse.getRequestId(), rpcResponse.isSuccess());
        }
    }
    /**
     * 通用构造方法：创建编码器和解码器
     *
     * @param serializer 序列化工具
     * @param requestCls 请求类（RpcRequest）
     * @param responseCls 响应类（RpcResponse）
     */
    public NettySerializerHandler(Serializer serializer, Class requestCls, Class responseCls) {
        // 此处仅为统一初始化，实际编码器和解码器已在Server和Client的ChannelPipeline中添加
        if (!RpcRequest.class.equals(requestCls) || !RpcResponse.class.equals(responseCls)) {
            log.warn("不支持的请求/响应类型，建议使用默认的RpcRequest和RpcResponse");
        }
    }
}

4.3 服务注册中心：基于 ZooKeeper 实现服务发现
设计思路：服务注册中心是 RPC 框架的 “导航地图”，服务提供者启动时将 “服务名称→服务地址” 注册到 ZooKeeper，服务消费者通过服务名称从 ZooKeeper 获取所有可用的服务地址。我们采用 ZooKeeper 的持久节点存储服务根路径，临时节点存储具体的服务地址（服务下线时临时节点自动删除，实现服务健康检测）。
4.3.1 ZooKeeper 节点设计
定义 ZooKeeper 的节点结构，确保服务注册和发现的逻辑清晰：
  • 根节点：/ken-rpc（持久节点，框架的根路径）
  • 服务节点：/ken-rpc/com.ken.rpc.service.UserService（持久节点，每个服务对应一个节点，名称为服务接口全限定名）
  • 服务地址节点：/ken-rpc/com.ken.rpc.service.UserService/192.168.1.100:8080（临时节点，存储服务提供者的 IP 和端口，服务下线时自动删除）
4.3.2 ZooKeeper 工具类实现
封装 ZooKeeper 的连接、节点创建、节点监听等操作，提供统一的服务注册和发现接口：


package com.ken.rpc.registry.zookeeper;
import com.ken.rpc.exception.RegistryException;
import com.ken.rpc.registry.ServiceRegistry;
import com.ken.rpc.util.NetUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
 * 基于ZooKeeper的服务注册与发现实现
 *
 * @author ken
 */
@Slf4j
public class ZookeeperServiceRegistry implements ServiceRegistry, Watcher {
    /**
     * ZooKeeper会话超时时间（默认30秒）
     */
    private static final int SESSION_TIMEOUT = 30000;
    /**
     * RPC框架在ZooKeeper中的根节点路径
     */
    private static final String RPC_ROOT_PATH = "/ken-rpc";
    /**
     * ZooKeeper客户端实例
     */
    private final ZooKeeper zookeeper;
    /**
     * 用于等待ZooKeeper连接建立的计数器
     */
    private final CountDownLatch connectLatch;
    /**
     * 服务注册中心地址（如127.0.0.1:2181）
     */
    private final String registryAddress;
    /**
     * 初始化ZooKeeper客户端并建立连接
     *
     * @param registryAddress 服务注册中心地址（格式：IP:端口，多个地址用逗号分隔）
     * @throws RegistryException 注册中心连接失败时抛出
     */
    public ZookeeperServiceRegistry(String registryAddress) throws RegistryException {
        if (!StringUtils.hasText(registryAddress)) {
            log.error("ZooKeeper注册中心地址为空，无法初始化客户端");
            throw new RegistryException("ZooKeeper注册中心地址不能为空");
        }
        this.registryAddress = registryAddress;
        this.connectLatch = new CountDownLatch(1);
        try {
            // 初始化ZooKeeper客户端（this为Watcher，监听连接状态）
            this.zookeeper = new ZooKeeper(registryAddress, SESSION_TIMEOUT, this);
            // 等待连接建立完成（最多等待10秒）
            boolean connected = connectLatch.await(10, TimeUnit.SECONDS);
            if (!connected) {
                log.error("ZooKeeper连接超时，地址：{}，超时时间：10秒", registryAddress);
                throw new RegistryException("ZooKeeper连接超时：" + registryAddress);
            }
            log.info("ZooKeeper客户端初始化成功，注册中心地址：{}", registryAddress);
            // 检查并创建根节点（/ken-rpc）
            createRootNode();
        } catch (IOException e) {
            log.error("ZooKeeper客户端初始化失败（IO异常），地址：{}，异常信息：{}", registryAddress, e.getMessage(), e);
            throw new RegistryException("ZooKeeper客户端初始化失败：" + e.getMessage());
        } catch (InterruptedException e) {
            log.error("ZooKeeper连接等待被中断，地址：{}，异常信息：{}", registryAddress, e.getMessage(), e);
            Thread.currentThread().interrupt();
            throw new RegistryException("ZooKeeper连接等待被中断：" + e.getMessage());
        }
    }
    /**
     * 创建RPC根节点（/ken-rpc），持久节点
     */
    private void createRootNode() {
        try {
            Stat stat = zookeeper.exists(RPC_ROOT_PATH, false);
            if (stat == null) {
                // 创建根节点：持久节点，开放所有权限
                zookeeper.create(RPC_ROOT_PATH, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                log.info("ZooKeeper RPC根节点创建成功，路径：{}", RPC_ROOT_PATH);
            } else {
                log.info("ZooKeeper RPC根节点已存在，路径：{}", RPC_ROOT_PATH);
            }
        } catch (KeeperException | InterruptedException e) {
            log.error("ZooKeeper创建根节点失败，路径：{}，异常信息：{}", RPC_ROOT_PATH, e.getMessage(), e);
            throw new RegistryException("创建ZooKeeper根节点失败：" + e.getMessage());
        }
    }
    /**
     * 服务注册：将服务名称与服务地址注册到ZooKeeper
     *
     * @param serviceName 服务接口全限定名（如com.ken.rpc.service.UserService）
     * @param serviceAddress 服务地址（格式：IP:端口，如192.168.1.100:8080）
     * @throws RegistryException 服务注册失败时抛出
     */
    @Override
    public void register(String serviceName, String serviceAddress) throws RegistryException {
        // 1. 校验参数
        if (!StringUtils.hasText(serviceName)) {
            log.error("服务名称为空，无法注册服务");
            throw new RegistryException("服务名称不能为空");
        }
        if (!StringUtils.hasText(serviceAddress)) {
            log.error("服务地址为空，无法注册服务，服务名称：{}", serviceName);
            throw new RegistryException("服务地址不能为空");
        }
        if (!NetUtils.isValidAddress(serviceAddress)) {
            log.error("服务地址格式非法，无法注册服务，服务名称：{}，地址：{}", serviceName, serviceAddress);
            throw new RegistryException("服务地址格式非法：" + serviceAddress);
        }
        try {
            // 2. 创建服务节点（/ken-rpc/服务名称），持久节点
            String servicePath = RPC_ROOT_PATH + "/" + serviceName;
            Stat serviceStat = zookeeper.exists(servicePath, false);
            if (serviceStat == null) {
                zookeeper.create(servicePath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
                log.info("ZooKeeper服务节点创建成功，路径：{}", servicePath);
            } else {
                log.info("ZooKeeper服务节点已存在，路径：{}", servicePath);
            }
            // 3. 创建服务地址节点（/ken-rpc/服务名称/IP:端口），临时节点（服务下线时自动删除）
            String addressPath = servicePath + "/" + serviceAddress;
            Stat addressStat = zookeeper.exists(addressPath, false);
            if (addressStat == null) {
                zookeeper.create(addressPath, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                log.info("ZooKeeper服务地址节点创建成功，路径：{}，服务名称：{}", addressPath, serviceName);
            } else {
                log.info("ZooKeeper服务地址节点已存在，路径：{}，服务名称：{}", addressPath, serviceName);
            }
        } catch (KeeperException | InterruptedException e) {
            log.error("服务注册失败，服务名称：{}，地址：{}，异常信息：{}", serviceName, serviceAddress, e.getMessage(), e);
            throw new RegistryException("服务注册失败：" + e.getMessage());
        }
    }
    /**
     * 服务发现：根据服务名称从ZooKeeper获取所有可用的服务地址
     *
     * @param serviceName 服务接口全限定名
     * @return 服务地址列表（格式：IP:端口），无可用服务时返回空列表
     * @throws RegistryException 服务发现失败时抛出
     */
    @Override
    public List discover(String serviceName) throws RegistryException {
        // 1. 校验参数
        if (!StringUtils.hasText(serviceName)) {
            log.error("服务名称为空，无法发现服务");
            throw new RegistryException("服务名称不能为空");
        }
        try {
            // 2. 拼接服务节点路径
            String servicePath = RPC_ROOT_PATH + "/" + serviceName;
            Stat serviceStat = zookeeper.exists(servicePath, false);
            if (serviceStat == null) {
                log.warn("ZooKeeper中不存在该服务节点，服务名称：{}，路径：{}", serviceName, servicePath);
                return new ArrayList<>();
            }
            // 3. 获取服务节点下的所有地址节点（临时节点），并监听节点变化
            List addressList = zookeeper.getChildren(servicePath, this);
            if (CollectionUtils.isEmpty(addressList)) {
                log.warn("服务无可用地址，服务名称：{}，路径：{}", serviceName, servicePath);
                return new ArrayList<>();
            }
            // 4. 整理服务地址列表（地址节点名称即为服务地址）
            List serviceAddressList = new ArrayList<>(addressList.size());
            for (String addressNode : addressList) {
                serviceAddressList.add(addressNode);
            }
            log.info("服务发现成功，服务名称：{}，可用地址数量：{}，地址列表：{}",
                    serviceName, serviceAddressList.size(), serviceAddressList);
            return serviceAddressList;
        } catch (KeeperException | InterruptedException e) {
            log.error("服务发现失败，服务名称：{}，异常信息：{}", serviceName, e.getMessage(), e);
            throw new RegistryException("服务发现失败：" + e.getMessage());
        }
    }
    /**
     * ZooKeeper事件监听回调（处理连接状态和节点变化）
     *
     * @param event ZooKeeper事件
     */
    @Override
    public void process(WatchedEvent event) {
        Event.KeeperState state = event.getState();
        Event.EventType type = event.getType();
        String path = event.getPath();
        log.debug("ZooKeeper事件触发，状态：{}，类型：{}，路径：{}", state, type, path);
        // 处理连接状态事件
        if (state == Event.KeeperState.SyncConnected) {
            // 连接建立成功，倒计时器减1（释放等待线程）
            if (type == Event.EventType.None) {
                connectLatch.countDown();
                log.info("ZooKeeper连接建立成功，状态：{}", state);
            }
        } else if (state == Event.KeeperState.Disconnected) {
            log.warn("ZooKeeper连接已断开，状态：{}", state);
        } else if (state == Event.KeeperState.Expired) {
            log.error("ZooKeeper会话已过期，需要重新连接，状态：{}", state);
            // TODO：会话过期后重新初始化客户端（可选，增强可用性）
        }
        // 处理节点变化事件（服务地址新增/删除）
        if (type == Event.EventType.NodeChildrenChanged && path != null && path.startsWith(RPC_ROOT_PATH)) {
            log.info("服务地址节点发生变化，路径：{}，重新发现服务", path);
            // 提取服务名称（路径格式：/ken-rpc/服务名称）
            String serviceName = path.substring(RPC_ROOT_PATH.length() + 1);
            if (StringUtils.hasText(serviceName)) {
                // 重新发现服务（更新本地服务地址缓存）
                discover(serviceName);
            }
        }
    }
    /**
     * 关闭ZooKeeper客户端连接
     */
    public void close() {
        if (zookeeper != null) {
            try {
                zookeeper.close();
                log.info("ZooKeeper客户端已关闭，注册中心地址：{}", registryAddress);
            } catch (InterruptedException e) {
                log.error("ZooKeeper客户端关闭失败，注册中心地址：{}，异常信息：{}", registryAddress, e.getMessage(), e);
                Thread.currentThread().interrupt();
            }
        }
    }
}


4.3.3 服务注册异常定义


package com.ken.rpc.exception;
/**
 * 服务注册/发现异常
 * 当服务与注册中心交互（注册、发现、连接）过程中出现错误时抛出
 *
 * @author ken
 */
public class RegistryException extends RuntimeException {
    public RegistryException(String message) {
        super(message);
    }
    public RegistryException(String message, Throwable cause) {
        super(message, cause);
    }
}


4.4 动态代理层：让远程调用像本地调用一样简单
设计思路：服务消费者不能直接调用远程方法，需要通过 “代理对象” 间接调用。我们使用 JDK 动态代理（基于接口）生成代理对象，当消费者调用代理对象的方法时，代理对象会自动封装 RPC 请求、发送网络请求、接收响应并返回结果，从而实现 “本地调用” 的体验。
4.4.1 动态代理工厂实现


package com.ken.rpc.proxy;
import com.ken.rpc.entity.RpcRequest;
import com.ken.rpc.entity.RpcResponse;
import com.ken.rpc.exception.RpcException;
import com.ken.rpc.loadbalance.LoadBalancer;
import com.ken.rpc.loadbalance.impl.RoundRobinLoadBalancer;
import com.ken.rpc.registry.ServiceRegistry;
import com.ken.rpc.registry.zookeeper.ZookeeperServiceRegistry;
import com.ken.rpc.transport.ClientTransport;
import com.ken.rpc.transport.netty.NettyRpcClient;
import com.ken.rpc.util.IdUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.concurrent.CompletableFuture;
/**
 * RPC动态代理工厂
 * 为服务消费者生成代理对象，将本地方法调用转为远程RPC调用
 *
 * @author ken
 */
@Slf4j
public class RpcProxyFactory implements InvocationHandler {
    /**
     * 服务接口Class对象
     */
    private final Class serviceClass;
    /**
     * 服务版本号（默认1.0.0）
     */
    private final String serviceVersion;
    /**
     * 服务注册中心（用于发现服务地址）
     */
    private final ServiceRegistry serviceRegistry;
    /**
     * 负载均衡器（默认轮询算法）
     */
    private final LoadBalancer loadBalancer;
    /**
     * 客户端传输层（用于发送RPC请求）
     */
    private ClientTransport clientTransport;
    /**
     * 构造方法（默认使用ZooKeeper注册中心和轮询负载均衡）
     *
     * @param serviceClass 服务接口Class对象
     * @param serviceVersion 服务版本号
     * @param registryAddress 注册中心地址
     */
    public RpcProxyFactory(Class serviceClass, String serviceVersion, String registryAddress) {
        this(serviceClass, serviceVersion,
                new ZookeeperServiceRegistry(registryAddress),
                new RoundRobinLoadBalancer());
    }
    public RpcProxyFactory(Class serviceClass, String serviceVersion,
                           ServiceRegistry serviceRegistry, LoadBalancer loadBalancer) {
        // 1. 校验参数
        if (ObjectUtils.isEmpty(serviceClass) || !serviceClass.isInterface()) {
            log.error("服务类非法，必须是接口类型，类名：{}", serviceClass);
            throw new IllegalArgumentException("服务类必须是接口类型：" + serviceClass);
        }
        this.serviceClass = serviceClass;
        // 2. 服务版本号默认1.0.0
        this.serviceVersion = StringUtils.hasText(serviceVersion) ? serviceVersion : "1.0.0";
        // 3. 校验注册中心和负载均衡器
        this.serviceRegistry = ObjectUtils.isEmpty(serviceRegistry) ? new ZookeeperServiceRegistry("127.0.0.1:2181") : serviceRegistry;
        this.loadBalancer = ObjectUtils.isEmpty(loadBalancer) ? new RoundRobinLoadBalancer() : loadBalancer;
    }
    /**
     * 创建代理对象
     *
     * @return 服务接口的代理对象
     */
    @SuppressWarnings("unchecked")
    public  T getProxy() {
        // 使用JDK动态代理生成代理对象
        return (T) Proxy.newProxyInstance(
                serviceClass.getClassLoader(),
                new Class[]{serviceClass},
                this);
    }
    /**
     * 代理对象方法调用回调（核心逻辑）
     * 当消费者调用代理对象的方法时，会执行此方法
     *
     * @param proxy 代理对象
     * @param method 被调用的方法
     * @param args 方法参数
     * @return 远程方法执行结果
     * @throws Throwable 调用过程中出现的异常
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log.info("开始执行RPC代理调用，服务接口：{}，方法名称：{}，参数数量：{}",
                serviceClass.getName(), method.getName(), args == null ? 0 : args.length);
        try {
            // 1. 从注册中心发现服务地址
            String serviceName = serviceClass.getName();
            List serviceAddressList = serviceRegistry.discover(serviceName);
            if (ObjectUtils.isEmpty(serviceAddressList)) {
                log.error("服务无可用地址，无法执行RPC调用，服务名称：{}", serviceName);
                throw new RpcException("服务无可用地址：" + serviceName);
            }
            // 2. 负载均衡：选择一个服务地址
            String selectedAddress = loadBalancer.select(serviceAddressList, serviceName);
            log.info("负载均衡选择服务地址，服务名称：{}，选中地址：{}", serviceName, selectedAddress);
            // 3. 解析服务地址为IP和端口
            String[] addressParts = selectedAddress.split(":");
            if (addressParts.length != 2) {
                log.error("服务地址格式非法，无法解析，地址：{}", selectedAddress);
                throw new RpcException("服务地址格式非法：" + selectedAddress);
            }
            String serverIp = addressParts[0];
            int serverPort = Integer.parseInt(addressParts[1]);
            InetSocketAddress serverAddress = new InetSocketAddress(serverIp, serverPort);
            // 4. 创建客户端传输层（Netty客户端）
            if (ObjectUtils.isEmpty(clientTransport) || !clientTransport.isConnected()) {
                clientTransport = new NettyRpcClient(serverAddress);
                log.info("创建Netty客户端连接，服务地址：{}:{}", serverIp, serverPort);
            }
            // 5. 构建RPC请求对象
            RpcRequest rpcRequest = RpcRequest.builder()
                    .requestId(IdUtils.generateRequestId()) // 生成唯一请求ID
                    .serviceName(serviceName) // 服务接口名称
                    .methodName(method.getName()) // 方法名称
                    .parameterTypes(method.getParameterTypes()) // 方法参数类型
                    .parameters(args) // 方法参数值
                    .serviceVersion(serviceVersion) // 服务版本号
                    .build();
            // 6. 发送RPC请求，获取响应（异步转同步，等待响应结果）
            CompletableFuture responseFuture = clientTransport.sendRequest(rpcRequest);
            RpcResponse rpcResponse = responseFuture.get(); // 阻塞等待响应
            // 7. 处理响应结果
            if (ObjectUtils.isEmpty(rpcResponse)) {
                log.error("RPC响应为空，请求ID：{}", rpcRequest.getRequestId());
                throw new RpcException("RPC响应为空，请求ID：" + rpcRequest.getRequestId());
            }
            if (!rpcRequest.getRequestId().equals(rpcResponse.getRequestId())) {
                log.error("RPC请求与响应ID不匹配，请求ID：{}，响应ID：{}",
                        rpcRequest.getRequestId(), rpcResponse.getRequestId());
                throw new RpcException("请求与响应ID不匹配：" + rpcRequest.getRequestId() + " vs " + rpcResponse.getRequestId());
            }
            // 8. 判断调用是否成功，返回结果或抛出异常
            if (rpcResponse.isSuccess()) {
                log.info("RPC调用成功，请求ID：{}，服务接口：{}，方法名称：{}",
                        rpcRequest.getRequestId(), serviceName, method.getName());
                return rpcResponse.getResult();
            } else {
                log.error("RPC调用失败，请求ID：{}，异常信息：{}",
                        rpcRequest.getRequestId(), rpcResponse.getException().getMessage());
                throw new RpcException("RPC调用失败：" + rpcResponse.getException().getMessage(), rpcResponse.getException());
            }
        } catch (Exception e) {
            log.error("RPC代理调用异常，服务接口：{}，方法名称：{}，异常信息：{}",
                    serviceClass.getName(), method.getName(), e.getMessage(), e);
            throw new RpcException("RPC调用异常：" + e.getMessage(), e);
        }
    }
    /**
     * 关闭客户端传输层连接
     */
    public void close() {
        if (!ObjectUtils.isEmpty(clientTransport)) {
            clientTransport.close();
            log.info("RPC代理客户端连接已关闭，服务接口：{}", serviceClass.getName());
        }
    }
}


4.4.2 工具类：生成唯一请求 ID
为了确保 RPC 请求与响应的对应（Netty 异步通信），需要生成唯一的requestId，这里使用 UUID 简化实现：


package com.ken.rpc.util;
import java.util.UUID;
/**
 * ID生成工具类
 * 生成RPC请求ID、服务ID等唯一标识
 *
 * @author ken
 */
public class IdUtils {
    /**
     * 生成RPC请求ID（基于UUID，去除横杠）
     *
     * @return 唯一请求ID（32位字符串）
     */
    public static String generateRequestId() {
        // UUID格式：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx，去除横杠后为32位
        return UUID.randomUUID().toString().replace("-", "");
    }
}


4.5 负载均衡层：实现服务调用的负载分发
设计思路：当一个服务有多个提供者（如 UserService 部署在 3 台服务器上）时，消费者需要选择其中一台调用，这就是负载均衡的作用。我们定义负载均衡接口，实现常见的负载均衡算法（轮询、随机、加权随机），让框架支持灵活切换。
4.5.1 负载均衡接口定义


package com.ken.rpc.loadbalance;
import com.ken.rpc.exception.LoadBalanceException;
import org.springframework.util.CollectionUtils;
import java.util.List;
/**
 * 负载均衡接口
 * 定义从服务地址列表中选择一个地址的方法
 *
 * @author ken
 */
public interface LoadBalancer {
    /**
     * 从服务地址列表中选择一个地址
     *
     * @param serviceAddressList 服务地址列表（格式：IP:端口）
     * @param serviceName 服务名称（用于区分不同服务的负载均衡状态）
     * @return 选中的服务地址
     * @throws LoadBalanceException 负载均衡失败时抛出
     */
    String select(List serviceAddressList, String serviceName) throws LoadBalanceException;
    /**
     * 校验服务地址列表（通用方法，所有实现类可复用）
     *
     * @param serviceAddressList 服务地址列表
     * @param serviceName 服务名称
     * @throws LoadBalanceException 地址列表为空时抛出
     */
    default void validateAddressList(List serviceAddressList, String serviceName) throws LoadBalanceException {
        if (CollectionUtils.isEmpty(serviceAddressList)) {
            throw new LoadBalanceException("服务无可用地址，无法执行负载均衡，服务名称：" + serviceName);
        }
    }
}


4.5.2 轮询算法实现（最常用）
轮询算法：按顺序依次选择服务地址，如地址列表为 [A,B,C]，则调用顺序为 A→B→C→A→B→C...


package com.ken.rpc.loadbalance.impl;
import com.ken.rpc.exception.LoadBalanceException;
import com.ken.rpc.loadbalance.LoadBalancer;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * 轮询负载均衡算法
 * 按顺序依次选择服务地址，适用于服务节点性能相近的场景
 *
 * @author ken
 */
@Slf4j
public class RoundRobinLoadBalancer implements LoadBalancer {
    /**
     * 每个服务的轮询计数器（key：服务名称，value：当前计数）
     * 使用AtomicInteger保证线程安全
     */
    private final ConcurrentMap countMap = new ConcurrentHashMap<>();
    @Override
    public String select(List serviceAddressList, String serviceName) throws LoadBalanceException {
        // 1. 校验地址列表
        validateAddressList(serviceAddressList, serviceName);
        int addressCount = serviceAddressList.size();
        if (addressCount == 1) {
            // 只有一个地址，直接返回
            String address = serviceAddressList.get(0);
            log.debug("轮询负载均衡：服务只有一个地址，直接返回，服务名称：{}，地址：{}", serviceName, address);
            return address;
        }
        // 2. 获取当前服务的轮询计数器（不存在则初始化）
        AtomicInteger count = countMap.computeIfAbsent(serviceName, k -> new AtomicInteger(0));
        // 3. 原子递增计数，并取模（避免计数溢出）
        int currentCount = count.getAndIncrement();
        // 取模确保选择的索引在地址列表范围内
        int selectedIndex = currentCount % addressCount;
        // 4. 处理计数溢出（当计数超过Integer.MAX_VALUE时重置为0）
        if (currentCount > Integer.MAX_VALUE - 1000) {
            count.set(0);
            log.debug("轮询计数器即将溢出，重置为0，服务名称：{}，当前计数：{}", serviceName, currentCount);
        }
        // 5. 返回选中的地址
        String selectedAddress = serviceAddressList.get(selectedIndex);
        log.debug("轮询负载均衡选择完成，服务名称：{}，地址列表大小：{}，当前计数：{}，选中索引：{}，选中地址：{}",
                serviceName, addressCount, currentCount, selectedIndex, selectedAddress);
        return selectedAddress;
    }
}


4.5.3 负载均衡异常定义


package com.ken.rpc.exception;
/**
 * 负载均衡异常
 * 当从服务地址列表选择地址过程中出现错误时抛出
 *
 * @author ken
 */
public class LoadBalanceException extends RuntimeException {
    public LoadBalanceException(String message) {
        super(message);
    }
    public LoadBalanceException(String message, Throwable cause) {
        super(message, cause);
    }
}


4.6 服务提供者与消费者：注解驱动开发
设计思路：为了简化框架使用，我们采用注解驱动开发：服务提供者用@RpcService注解标记服务实现类，框架自动扫描并注册服务；服务消费者用@RpcReference注解标记服务接口，框架自动生成代理对象，消费者直接注入使用。
4.6.1 服务提供者注解：@RpcService


package com.ken.rpc.annotation;
import org.springframework.stereotype.Component;
import java.lang.annotation.*;
/**
 * RPC服务提供者注解
 * 标记服务实现类，框架自动扫描并注册到注册中心
 *
 * @author ken
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Component // 继承Spring的@Component，让Spring能扫描到该类
public @interface RpcService {
    /**
     * 服务接口Class对象（默认当前类实现的第一个接口）
     */
    Class interfaceClass() default void.class;
    /**
     * 服务接口名称（与interfaceClass二选一，优先使用interfaceClass）
     */
    String interfaceName() default "";
    /**
     * 服务版本号（默认1.0.0）
     */
    String serviceVersion() default "1.0.0";
}


4.6.2 服务消费者注解：@RpcReference


package com.ken.rpc.annotation;
import org.springframework.beans.factory.annotation.Autowired;
import java.lang.annotation.*;
/**
 * RPC服务消费者注解
 * 标记服务接口字段，框架自动生成代理对象并注入到Spring Bean中
 *
 * @author ken
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
@Autowired // 结合Spring自动注入机制，触发代理对象创建
public @interface RpcReference {
    /**
     * 服务接口Class对象（默认取字段的类型）
     */
    Class interfaceClass() default void.class;
    /**
     * 服务版本号（默认1.0.0，需与服务提供者版本一致）
     */
    String serviceVersion() default "1.0.0";
    /**
     * 注册中心地址（默认从全局配置读取，可单独指定）
     */
    String registryAddress() default "";
}


4.6.3 服务扫描与注册实现（核心）
需要实现两个核心逻辑：服务提供者扫描（识别@RpcService注解并注册服务）和服务消费者注入（识别@RpcReference注解并注入代理对象）。我们借助 Spring 的BeanPostProcessor机制，在 Bean 初始化阶段完成这些操作。
4.6.3.1 服务映射器：存储服务接口与实现的对应关系
服务端接收 RPC 请求后，需要根据 “服务名称 + 版本号” 找到对应的实现类，因此需要一个线程安全的服务映射器：


package com.ken.rpc.service;
import com.ken.rpc.exception.RpcException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
 * RPC服务映射器
 * 存储“服务接口+版本号”与服务实现类的对应关系，供服务端处理请求时查询
 *
 * @author ken
 */
@Slf4j
public class RpcServiceMapper {
    /**
     * 服务映射表：key=服务接口全限定名:版本号（如com.ken.rpc.service.UserService:1.0.0），value=服务实现类实例
     */
    private final Map serviceMap = new ConcurrentHashMap<>();
    /**
     * 注册服务到映射表
     *
     * @param serviceInterface 服务接口Class
     * @param serviceVersion 服务版本号
     * @param serviceImpl 服务实现类实例
     */
    public void registerService(Class serviceInterface, String serviceVersion, Object serviceImpl) {
        // 1. 校验参数
        if (ObjectUtils.isEmpty(serviceInterface) || !serviceInterface.isInterface()) {
            log.error("服务接口非法，必须是接口类型，接口类：{}", serviceInterface);
            throw new RpcException("服务接口必须是接口类型：" + serviceInterface);
        }
        if (ObjectUtils.isEmpty(serviceImpl)) {
            log.error("服务实现类实例为空，接口类：{}，版本号：{}", serviceInterface.getName(), serviceVersion);
            throw new RpcException("服务实现类实例不能为空");
        }
        if (!serviceInterface.isAssignableFrom(serviceImpl.getClass())) {
            log.error("服务实现类未实现指定接口，接口类：{}，实现类：{}", serviceInterface.getName(), serviceImpl.getClass().getName());
            throw new RpcException("服务实现类未实现接口：" + serviceInterface.getName());
        }
        // 2. 构建服务key（接口名:版本号）
        String serviceKey = buildServiceKey(serviceInterface.getName(), serviceVersion);
        // 3. 注册服务（若已存在则覆盖，支持服务热更新）
        if (serviceMap.containsKey(serviceKey)) {
            log.warn("服务已存在，将覆盖旧服务，服务key：{}，旧实现类：{}，新实现类：{}",
                    serviceKey, serviceMap.get(serviceKey).getClass().getName(), serviceImpl.getClass().getName());
        }
        serviceMap.put(serviceKey, serviceImpl);
        log.info("服务注册到映射表成功，服务key：{}，接口类：{}，实现类：{}，版本号：{}",
                serviceKey, serviceInterface.getName(), serviceImpl.getClass().getName(), serviceVersion);
    }
    /**
     * 根据服务接口名和版本号获取服务实现类
     *
     * @param serviceName 服务接口全限定名
     * @param serviceVersion 服务版本号
     * @return 服务实现类实例
     * @throws RpcException 服务不存在时抛出
     */
    public Object getService(String serviceName, String serviceVersion) {
        // 1. 校验参数
        if (ObjectUtils.isEmpty(serviceName)) {
            log.error("服务名称为空，无法获取服务实现");
            throw new RpcException("服务名称不能为空");
        }
        String serviceKey = buildServiceKey(serviceName, serviceVersion);
        // 2. 查询服务
        Object serviceImpl = serviceMap.get(serviceKey);
        if (ObjectUtils.isEmpty(serviceImpl)) {
            log.error("服务不存在，服务key：{}，可用服务列表：{}", serviceKey, serviceMap.keySet());
            throw new RpcException("服务不存在：" + serviceKey);
        }
        log.debug("获取服务实现成功，服务key：{}，实现类：{}", serviceKey, serviceImpl.getClass().getName());
        return serviceImpl;
    }
    /**
     * 构建服务key（接口名:版本号）
     * 版本号为空时，默认使用"1.0.0"
     *
     * @param serviceName 服务接口名
     * @param serviceVersion 服务版本号
     * @return 服务key
     */
    private String buildServiceKey(String serviceName, String serviceVersion) {
        String version = ObjectUtils.isEmpty(serviceVersion) ? "1.0.0" : serviceVersion;
        return serviceName + ":" + version;
    }
    /**
     * 获取所有已注册的服务key
     *
     * @return 服务key列表
     */
    public Map getServiceMap() {
        return serviceMap;
    }
}


4.6.3.2 服务提供者扫描处理器
实现BeanPostProcessor，在 Spring 初始化@RpcService标记的 Bean 后，将其注册到RpcServiceMapper和 ZooKeeper：


package com.ken.rpc.processor;
import com.ken.rpc.annotation.RpcService;
import com.ken.rpc.registry.ServiceRegistry;
import com.ken.rpc.service.RpcServiceMapper;
import com.ken.rpc.transport.netty.NettyRpcServer;
import com.ken.rpc.util.NetUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import java.lang.reflect.Method;
/**
 * RPC服务提供者扫描处理器
 * 扫描带有@RpcService注解的Bean，完成服务注册（映射表+注册中心）并启动Netty服务端
 *
 * @author ken
 */
@Slf4j
@Component
public class RpcServiceBeanPostProcessor implements BeanPostProcessor {
    /**
     * 服务映射器（注入Spring容器）
     */
    private final RpcServiceMapper rpcServiceMapper;
    /**
     * 服务注册中心（注入Spring容器，默认ZooKeeper实现）
     */
    private final ServiceRegistry serviceRegistry;
    /**
     * Netty服务端端口（从配置文件读取，默认8080）
     */
    @Value("${rpc.server.port:8080}")
    private int serverPort;
    /**
     * 注册中心地址（从配置文件读取，默认127.0.0.1:2181）
     */
    @Value("${rpc.registry.address:127.0.0.1:2181}")
    private String registryAddress;
    /**
     * Netty服务端实例（用于启动和关闭）
     */
    private NettyRpcServer nettyRpcServer;
    public RpcServiceBeanPostProcessor(RpcServiceMapper rpcServiceMapper, ServiceRegistry serviceRegistry) {
        this.rpcServiceMapper = rpcServiceMapper;
        this.serviceRegistry = serviceRegistry;
    }
    /**
     * Bean初始化后执行：处理@RpcService注解的Bean
     *
     * @param bean Bean实例
     * @param beanName Bean名称
     * @return 原Bean实例（不修改Bean）
     * @throws BeansException Bean处理异常
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 1. 判断Bean是否带有@RpcService注解
        RpcService rpcService = bean.getClass().getAnnotation(RpcService.class);
        if (ObjectUtils.isEmpty(rpcService)) {
            return bean; // 非RPC服务Bean，直接返回
        }
        // 2. 解析@RpcService注解的属性
        Class serviceInterface = rpcService.interfaceClass();
        String serviceInterfaceName = rpcService.interfaceName();
        String serviceVersion = rpcService.serviceVersion();
        // 3. 确定服务接口（优先使用interfaceClass，若未指定则取Bean实现的第一个接口）
        if (serviceInterface == void.class) {
            Class[] interfaces = bean.getClass().getInterfaces();
            if (ObjectUtils.isEmpty(interfaces)) {
                log.error("服务实现类未实现任何接口，无法注册服务，Bean名称：{}，实现类：{}",
                        beanName, bean.getClass().getName());
                throw new BeansException("服务实现类未实现接口：" + bean.getClass().getName()) {};
            }
            // 默认取第一个实现的接口
            serviceInterface = interfaces[0];
            log.warn("未指定服务接口（interfaceClass），默认使用实现类的第一个接口，Bean名称：{}，接口类：{}",
                    beanName, serviceInterface.getName());
        }
        // 4. 确定服务接口名（优先使用interfaceName，若未指定则取interfaceClass的全限定名）
        if (!StringUtils.hasText(serviceInterfaceName)) {
            serviceInterfaceName = serviceInterface.getName();
        }
        // 5. 注册服务到RpcServiceMapper（本地映射）
        rpcServiceMapper.registerService(serviceInterface, serviceVersion, bean);
        // 6. 注册服务到注册中心（ZooKeeper）
        String serviceAddress = NetUtils.getLocalIp() + ":" + serverPort;
        try {
            serviceRegistry.register(serviceInterfaceName, serviceAddress);
            log.info("服务注册到注册中心成功，服务接口：{}，版本号：{}，服务地址：{}，Bean名称：{}",
                    serviceInterfaceName, serviceVersion, serviceAddress, beanName);
        } catch (Exception e) {
            log.error("服务注册到注册中心失败，服务接口：{}，版本号：{}，服务地址：{}，异常信息：{}",
                    serviceInterfaceName, serviceVersion, serviceAddress, e.getMessage(), e);
            throw new BeansException("服务注册失败：" + serviceInterfaceName) {};
        }
        return bean;
    }
    /**
     * 初始化方法：启动Netty服务端（在所有Bean初始化前执行）
     */
    @PostConstruct
    public void startNettyServer() {
        if (!ObjectUtils.isEmpty(nettyRpcServer)) {
            log.warn("Netty服务端已启动，无需重复启动，端口：{}", serverPort);
            return;
        }
        // 启动Netty服务端（单独线程启动，避免阻塞Spring上下文初始化）
        new Thread(() -> {
            nettyRpcServer = new NettyRpcServer(serverPort, registryAddress);
            nettyRpcServer.start(); // 启动服务端（阻塞直到服务关闭）
        }, "netty-rpc-server-thread-" + serverPort).start();
        log.info("Netty服务端启动线程已创建，端口：{}，注册中心地址：{}", serverPort, registryAddress);
    }
    /**
     * 销毁方法：关闭Netty服务端和注册中心连接（Spring上下文关闭时执行）
     */
    @PreDestroy
    public void stopNettyServer() {
        // 1. 关闭Netty服务端
        if (!ObjectUtils.isEmpty(nettyRpcServer)) {
            nettyRpcServer.close(); // 自定义close方法，优雅关闭Netty线程组
            log.info("Netty服务端已关闭，端口：{}", serverPort);
        }
        // 2. 关闭注册中心连接（若ZooKeeper实现，需调用close方法）
        if (serviceRegistry instanceof AutoCloseable) {
            try {
                ((AutoCloseable) serviceRegistry).close();
                log.info("服务注册中心连接已关闭，地址：{}", registryAddress);
            } catch (Exception e) {
                log.error("服务注册中心连接关闭失败，地址：{}，异常信息：{}",
                        registryAddress, e.getMessage(), e);
            }
        }
    }
    /**
     * 关闭Netty服务端（供外部调用）
     */
    public void close() {
        stopNettyServer();
    }
}


4.6.3.3 服务消费者注入处理器
实现BeanPostProcessor，在 Spring 初始化带有@RpcReference字段的 Bean 时，生成代理对象并注入字段：


package com.ken.rpc.processor;
import com.ken.rpc.annotation.RpcReference;
import com.ken.rpc.proxy.RpcProxyFactory;
import com.ken.rpc.registry.ServiceRegistry;
import com.ken.rpc.registry.zookeeper.ZookeeperServiceRegistry;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.util.ReflectionUtils;
import org.springframework.util.StringUtils;
import java.lang.reflect.Field;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
 * RPC服务消费者注入处理器
 * 扫描Bean中带有@RpcReference注解的字段，生成代理对象并注入
 *
 * @author ken
 */
@Slf4j
@Component
public class RpcReferenceBeanPostProcessor implements BeanPostProcessor {
    /**
     * 代理对象缓存：key=服务接口名:版本号，value=代理对象（避免重复生成）
     */
    private final ConcurrentMap proxyCache = new ConcurrentHashMap<>();
    /**
     * 全局注册中心地址（从配置文件读取，默认127.0.0.1:2181）
     */
    @Value("${rpc.registry.address:127.0.0.1:2181}")
    private String globalRegistryAddress;
    /**
     * Bean初始化后执行：处理@RpcReference注解的字段
     *
     * @param bean Bean实例
     * @param beanName Bean名称
     * @return 原Bean实例（已注入代理对象）
     * @throws BeansException Bean处理异常
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 1. 获取Bean的所有字段
        Field[] fields = bean.getClass().getDeclaredFields();
        if (ObjectUtils.isEmpty(fields)) {
            return bean; // 无字段，直接返回
        }
        // 2. 遍历字段，处理带有@RpcReference注解的字段
        for (Field field : fields) {
            RpcReference rpcReference = field.getAnnotation(RpcReference.class);
            if (ObjectUtils.isEmpty(rpcReference)) {
                continue; // 非RPC引用字段，跳过
            }
            // 3. 解析@RpcReference注解的属性
            Class serviceInterface = rpcReference.interfaceClass();
            String serviceVersion = rpcReference.serviceVersion();
            String registryAddress = rpcReference.registryAddress();
            // 4. 确定服务接口（优先使用interfaceClass，若未指定则取字段类型）
            if (serviceInterface == void.class) {
                serviceInterface = field.getType();
                log.warn("未指定服务接口（interfaceClass），默认使用字段类型，Bean名称：{}，字段名：{}，接口类：{}",
                        beanName, field.getName(), serviceInterface.getName());
            }
            // 5. 确定注册中心地址（优先使用注解的registryAddress，若未指定则使用全局配置）
            if (!StringUtils.hasText(registryAddress)) {
                registryAddress = globalRegistryAddress;
            }
            // 6. 生成或获取代理对象（从缓存获取，避免重复生成）
            String proxyKey = buildProxyKey(serviceInterface.getName(), serviceVersion);
            Object proxy = proxyCache.computeIfAbsent(proxyKey, k -> {
                log.info("生成RPC代理对象，服务接口：{}，版本号：{}，注册中心地址：{}",
                        serviceInterface.getName(), serviceVersion, registryAddress);
                // 创建服务注册中心实例（ZooKeeper）
                ServiceRegistry serviceRegistry = new ZookeeperServiceRegistry(registryAddress);
                // 创建代理工厂并生成代理对象
                RpcProxyFactory proxyFactory = new RpcProxyFactory(serviceInterface, serviceVersion, serviceRegistry);
                return proxyFactory.getProxy();
            });
            // 7. 注入代理对象到字段（设置字段可访问，突破private修饰符）
            ReflectionUtils.makeAccessible(field);
            try {
                field.set(bean, proxy);
                log.info("RPC代理对象注入成功，Bean名称：{}，字段名：{}，服务接口：{}，版本号：{}",
                        beanName, field.getName(), serviceInterface.getName(), serviceVersion);
            } catch (IllegalAccessException e) {
                log.error("RPC代理对象注入失败，Bean名称：{}，字段名：{}，服务接口：{}，异常信息：{}",
                        beanName, field.getName(), serviceInterface.getName(), e.getMessage(), e);
                throw new BeansException("代理对象注入失败：" + field.getName()) {};
            }
        }
        return bean;
    }
    /**
     * 构建代理对象缓存key（服务接口名:版本号）
     *
     * @param serviceName 服务接口名
     * @param serviceVersion 服务版本号
     * @return 代理缓存key
     */
    private String buildProxyKey(String serviceName, String serviceVersion) {
        String version = ObjectUtils.isEmpty(serviceVersion) ? "1.0.0" : serviceVersion;
        return serviceName + ":" + version;
    }
}


4.6.4 框架自动配置类（简化用户配置）
为了让用户无需手动配置 Bean，我们使用 Spring Boot 的自动配置机制，通过@Configuration和@ConditionalOnMissingBean自动注册核心 Bean：


package com.ken.rpc.config;
import com.ken.rpc.processor.RpcReferenceBeanPostProcessor;
import com.ken.rpc.processor.RpcServiceBeanPostProcessor;
import com.ken.rpc.registry.ServiceRegistry;
import com.ken.rpc.registry.zookeeper.ZookeeperServiceRegistry;
import com.ken.rpc.service.RpcServiceMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * RPC框架自动配置类
 * 自动注册核心Bean，用户无需手动配置
 *
 * @author ken
 */
@Configuration
public class RpcAutoConfiguration {
    /**
     * 注册服务映射器（RpcServiceMapper）
     * 若用户未自定义，则使用默认实现
     */
    @Bean
    @ConditionalOnMissingBean
    public RpcServiceMapper rpcServiceMapper() {
        return new RpcServiceMapper();
    }
    /**
     * 注册服务注册中心（默认ZooKeeper实现）
     * 若用户未自定义，则使用ZookeeperServiceRegistry
     */
    @Bean
    @ConditionalOnMissingBean
    public ServiceRegistry serviceRegistry() {
        // 默认注册中心地址：127.0.0.1:2181（用户可通过配置文件覆盖）
        return new ZookeeperServiceRegistry("127.0.0.1:2181");
    }
    /**
     * 注册服务提供者扫描处理器
     */
    @Bean
    @ConditionalOnMissingBean
    public RpcServiceBeanPostProcessor rpcServiceBeanPostProcessor(RpcServiceMapper rpcServiceMapper, ServiceRegistry serviceRegistry) {
        return new RpcServiceBeanPostProcessor(rpcServiceMapper, serviceRegistry);
    }
    /**
     * 注册服务消费者注入处理器
     */
    @Bean
    @ConditionalOnMissingBean
    public RpcReferenceBeanPostProcessor rpcReferenceBeanPostProcessor() {
        return new RpcReferenceBeanPostProcessor();
    }
}


4.6.5 完整使用示例（可直接运行）
为了让用户直观理解框架使用流程，我们实现一个 “用户服务” 示例，包含服务接口、服务提供者、服务消费者三部分。
4.6.5.1 1. 定义服务接口（公共模块）
创建user-api模块，定义服务接口（服务提供者和消费者都需依赖此模块）：


package com.ken.rpc.service;
import com.ken.rpc.entity.User;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
/**
 * 用户服务RPC接口
 *
 * @author ken
 */
@Tag(name = "UserService", description = "用户服务RPC接口，提供用户查询、创建等功能")
public interface UserService {
    /**
     * 根据用户ID查询用户信息
     *
     * @param userId 用户ID（非负整数）
     * @return 用户信息（userId不存在时返回null）
     */
    @Operation(summary = "查询用户", description = "根据用户ID查询用户详情，支持ID范围：1-10000")
    User getUserById(@Parameter(description = "用户ID", required = true, example = "1001") Long userId);
    /**
     * 创建新用户
     *
     * @param user 用户信息（username和age为必填字段）
     * @return 创建成功的用户ID（自增主键）
     */
    @Operation(summary = "创建用户", description = "创建新用户，返回自增用户ID")
    Long createUser(@Parameter(description = "用户信息", required = true) User user);
}


用户实体类（需实现Serializable，支持序列化）：


package com.ken.rpc.entity;
import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
/**
 * 用户实体类
 *
 * @author ken
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Schema(description = "用户实体类，存储用户基本信息")
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    /**
     * 用户ID（自增主键）
     */
    @Schema(description = "用户ID（自增主键）", example = "1001")
    private Long userId;
    /**
     * 用户名（非空，长度1-20）
     */
    @Schema(description = "用户名", required = true, example = "zhangsan")
    private String username;
    /**
     * 用户年龄（1-120）
     */
    @Schema(description = "用户年龄", required = true, example = "25")
    private Integer age;
    /**
     * 用户邮箱（可选，格式需符合邮箱规范）
     */
    @Schema(description = "用户邮箱", example = "zhangsan@example.com")
    private String email;
}


4.6.5.2 2. 服务提供者实现（user-provider 模块）
创建user-provider模块，依赖user-api，实现UserService并通过@RpcService暴露服务。
（1）服务实现类（集成 MyBatis-Plus 操作数据库）


package com.ken.rpc.provider.service.impl;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ken.rpc.annotation.RpcService;
import com.ken.rpc.entity.User;
import com.ken.rpc.mapper.UserMapper;
import com.ken.rpc.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import org.springframework.util.StringUtils;
import javax.annotation.Resource;
/**
 * 用户服务实现类（RPC服务提供者）
 *
 * @author ken
 */
@Slf4j
@Service
@RpcService(interfaceClass = UserService.class, serviceVersion = "1.0.0")
public class UserServiceImpl implements UserService {
    @Resource
    private UserMapper userMapper;
    @Override
    public User getUserById(Long userId) {
        // 1. 校验参数
        if (ObjectUtils.isEmpty(userId) || userId <= 0) {
            log.error("查询用户失败：用户ID非法，userId：{}", userId);
            throw new IllegalArgumentException("用户ID必须为正整数：" + userId);
        }
        // 2. MyBatis-Plus查询用户
        LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(User.class)
                .eq(User::getUserId, userId);
        User user = userMapper.selectOne(queryWrapper);
        // 3. 日志记录
        if (ObjectUtils.isEmpty(user)) {
            log.warn("查询用户不存在，userId：{}", userId);
        } else {
            log.info("查询用户成功，userId：{}，username：{}", userId, user.getUsername());
        }
        return user;
    }
    @Override
    public Long createUser(User user) {
        // 1. 校验参数
        if (ObjectUtils.isEmpty(user)) {
            log.error("创建用户失败：用户信息为空");
            throw new IllegalArgumentException("用户信息不能为空");
        }
        if (!StringUtils.hasText(user.getUsername()) || user.getUsername().length() > 20) {
            log.error("创建用户失败：用户名非法，username：{}", user.getUsername());
            throw new IllegalArgumentException("用户名必须为1-20位非空字符串：" + user.getUsername());
        }
        if (ObjectUtils.isEmpty(user.getAge()) || user.getAge() < 1 || user.getAge() > 120) {
            log.error("创建用户失败：年龄非法，age：{}", user.getAge());
            throw new IllegalArgumentException("年龄必须为1-120的整数：" + user.getAge());
        }
        // 2. MyBatis-Plus插入用户（自增主键会自动回写）
        int insertCount = userMapper.insert(user);
        if (insertCount != 1) {
            log.error("创建用户失败：插入数据库失败，影响行数：{}，用户信息：{}", insertCount, user);
            throw new RuntimeException("创建用户失败：数据库插入异常");
        }
        // 3. 日志记录
        log.info("创建用户成功，userId：{}，username：{}", user.getUserId(), user.getUsername());
        return user.getUserId();
    }
}


（2）MyBatis-Plus Mapper 接口


package com.ken.rpc.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.ken.rpc.entity.User;
import org.apache.ibatis.annotations.Mapper;
/**
 * 用户Mapper接口（MyBatis-Plus）
 *
 * @author ken
 */
@Mapper
public interface UserMapper extends BaseMapper {
}


（3）数据库表结构（MySQL 8.0）


-- 创建用户表
CREATE TABLE `user` (
  `user_id` bigint NOT NULL AUTO_INCREMENT COMMENT '用户ID（自增主键）',
  `username` varchar(20) NOT NULL COMMENT '用户名',
  `age` int NOT NULL COMMENT '用户年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '用户邮箱',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  PRIMARY KEY (`user_id`),
  UNIQUE KEY `uk_username` (`username`) COMMENT '用户名唯一索引'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';
-- 插入测试数据
INSERT INTO `user` (`username`, `age`, `email`) VALUES
('zhangsan', 25, 'zhangsan@example.com'),
('lisi', 30, 'lisi@example.com');


（4）服务提供者配置文件（application.yml）


# Spring配置
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/rpc_db?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
    username: root
    password: 123456
# MyBatis-Plus配置
mybatis-plus:
  mapper-locations: classpath:mapper/**/*.xml
  type-aliases-package: com.ken.rpc.entity
  configuration:
    map-underscore-to-camel-case: true # 下划线转驼峰
    log-impl: org.apache.ibatis.logging.slf4j.Slf4jImpl # 日志实现
# RPC框架配置
rpc:
  server:
    port: 8080 # Netty服务端端口
  registry:
    address: 127.0.0.1:2181 # ZooKeeper注册中心地址
# Swagger3配置
springdoc:
  api-docs:
    path: /v3/api-docs
  swagger-ui:
    path: /swagger-ui.html
    operationsSorter: method
  packages-to-scan: com.ken.rpc.provider.controller


（5）服务提供者启动类


package com.ken.rpc.provider;
import io.swagger.v3.oas.annotations.OpenAPIDefinition;
import io.swagger.v3.oas.annotations.info.Info;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
/**
 * RPC服务提供者启动类（用户服务）
 *
 * @author ken
 */
@SpringBootApplication(scanBasePackages = "com.ken.rpc")
@MapperScan("com.ken.rpc.mapper") // 扫描MyBatis Mapper
@EntityScan("com.ken.rpc.entity") // 扫描实体类
@OpenAPIDefinition(info = @Info(title = "User Provider API", version = "1.0", description = "用户服务提供者接口文档"))
public class UserProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserProviderApplication.class, args);
    }
}


4.6.5.3 3. 服务消费者实现（user-consumer 模块）
创建user-consumer模块，依赖user-api，通过@RpcReference注入UserService代理对象，提供 HTTP 接口供测试。
（1）消费者控制器（集成 Swagger3）


package com.ken.rpc.consumer.controller;
import com.ken.rpc.annotation.RpcReference;
import com.ken.rpc.entity.User;
import com.ken.rpc.service.UserService;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.tags.Tag;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.*;
import org.springframework.util.ObjectUtils;
/**
 * 用户服务消费者控制器（HTTP接口）
 *
 * @author ken
 */
@Slf4j
@RestController
@RequestMapping("/user")
@Tag(name = "UserConsumerController", description = "用户服务消费者接口，通过RPC调用用户服务")
public class UserConsumerController {
    /**
     * 注入UserService RPC代理对象（通过@RpcReference自动生成）
     */
    @RpcReference(interfaceClass = UserService.class, serviceVersion = "1.0.0", registryAddress = "127.0.0.1:2181")
    private UserService userService;
    /**
     * HTTP接口：根据用户ID查询用户（调用RPC服务）
     *
     * @param userId 用户ID
     * @return 用户信息
     */
    @GetMapping("/{userId}")
    @Operation(summary = "查询用户", description = "通过HTTP接口调用RPC服务查询用户")
    public String getUserById(
            @Parameter(description = "用户ID", required = true, example = "1001")
            @PathVariable Long userId) {
        try {
            log.info("消费者接收查询用户请求，userId：{}", userId);
            User user = userService.getUserById(userId);
            if (ObjectUtils.isEmpty(user)) {
                return "查询结果：用户不存在，userId：" + userId;
            }
            return "查询结果：" + user.toString();
        } catch (Exception e) {
            log.error("查询用户失败，userId：{}，异常信息：{}", userId, e.getMessage(), e);
            return "查询失败：" + e.getMessage();
        }
    }
    /**
     * HTTP接口：创建用户（调用RPC服务）
     *
     * @param user 用户信息
     * @return 创建结果
     */
    @PostMapping("/create")
    @Operation(summary = "创建用户", description = "通过HTTP接口调用RPC服务创建用户")
    public String createUser(
            @Parameter(description = "用户信息", required = true)
            @RequestBody User user) {
        try {
            log.info("消费者接收创建用户请求，用户信息：{}", user);
            Long userId = userService.createUser(user);
            return "创建成功：新用户ID=" + userId;
        } catch (Exception e) {
            log.error("创建用户失败，用户信息：{}，异常信息：{}", user, e.getMessage(), e);
            return "创建失败：" + e.getMessage();
        }
    }
}


（2）服务消费者配置文件（application.yml）


# Spring配置
spring:
  application:
    name: user-consumer
# RPC框架配置
rpc:
  registry:
    address: 127.0.0.1:2181 # ZooKeeper注册中心地址（全局配置）
# 服务器端口（避免与服务提供者冲突）
server:
  port: 8081
# Swagger3配置
springdoc:
  api-docs:
    path: /v3/api-docs
  swagger-ui:
    path: /swagger-ui.html
    operationsSorter: method
  packages-to-scan: com.ken.rpc.consumer.controller


（3）服务消费者启动类


package com.ken.rpc.consumer;
import io.swagger.v3.oas.annotations.OpenAPIDefinition;
import io.swagger.v3.oas.annotations.info.Info;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
/**
 * RPC服务消费者启动类（用户服务）
 *
 * @author ken
 */
@SpringBootApplication(scanBasePackages = "com.ken.rpc")
@EntityScan("com.ken.rpc.entity") // 扫描实体类
@OpenAPIDefinition(info = @Info(title = "User Consumer API", version = "1.0", description = "用户服务消费者接口文档"))
public class UserConsumerApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserConsumerApplication.class, args);
    }
}


5. 框架测试与验证
5.1 环境准备
  1. 启动 ZooKeeper：下载 ZooKeeper 3.9.2，解压后修改conf/zoo.cfg，设置dataDir，执行bin/zkServer.sh start（Linux）或bin/zkServer.cmd start（Windows）。
  2. 创建数据库：在 MySQL 8.0 中创建rpc_db数据库，执行 4.6.5.2 中的 SQL 脚本创建user表并插入测试数据。
  3. 构建项目：在父项目根目录执行mvn clean install，确保所有模块编译通过。
5.2 启动与测试步骤
步骤 1：启动服务提供者
  1. 运行UserProviderApplication的main方法。
  2. 查看日志，确认以下信息：
 
    • Netty 服务端启动成功（监听端口 8080）。
    • 服务注册到 ZooKeeper 成功（服务 key：com.ken.rpc.service.UserService:1.0.0）。
步骤 2：启动服务消费者
  1. 运行UserConsumerApplication的main方法。
  2. 查看日志，确认以下信息：
 
    • RPC 代理对象生成成功（UserService代理）。
    • 代理对象注入到UserConsumerController成功。
步骤 3：通过 Swagger3 测试接口
  1. 访问消费者 Swagger 地址：http://localhost:8081/swagger-ui.html。
  2. 测试 “查询用户” 接口：
 
    • 展开/user/{userId}接口，输入userId=1001，点击 “Try it out”。
    • 预期结果：返回zhangsan的用户信息。
  3. 测试 “创建用户” 接口：
 
    • 展开/user/create接口，输入请求体：
 
      json
      

      {
  "username": "wangwu",
  "age": 28,
  "email": "wangwu@example.com"
}
      

    • 点击 “Try it out”，预期结果：返回新用户 ID（如 1003）。
  4. 验证数据库：查询user表，确认wangwu的记录已插入。
5.3 测试结果分析
  • 正确性：RPC 调用成功，服务消费者能通过代理对象调用远程服务，数据交互正确。
  • 透明性：消费者无需关注网络通信、序列化、服务发现等细节，像调用本地方法一样调用远程服务。
  • 可用性：服务提供者下线后，ZooKeeper 会自动删除临时节点，消费者后续调用会选择其他可用节点（需部署多个提供者测试）。
6. 框架优化与扩展方向
当前实现的 RPC 框架已具备核心功能，但在生产环境中还需优化和扩展，以下是常用方向：
6.1 容错机制
  • 重试机制：调用失败时自动重试（如网络抖动），可通过Guava-Retryer实现，支持重试次数、重试间隔配置。
  • 服务降级：当服务不可用时，返回默认值或友好提示（如Resilience4j的降级功能）。
  • 熔断机制：服务连续失败次数达到阈值时，暂时停止调用，避免雪崩效应（如Resilience4j的熔断功能）。
6.2 性能优化
  • 序列化优化：替换 FastJSON2 为 Protobuf，Protobuf 是二进制序列化协议，体积更小、速度更快，适合高性能场景。
  • 连接池优化：Netty 客户端使用连接池，避免频繁创建和关闭连接，减少开销。
  • 异步调用：支持 CompletableFuture 异步调用，避免同步调用阻塞线程，提高并发量。
6.3 功能扩展
  • 多注册中心支持：实现 Nacos、Etcd 等注册中心的ServiceRegistry接口，用户可通过配置切换。
  • 服务监控：集成 SkyWalking 或 Prometheus，监控 RPC 调用耗时、成功率、并发量等指标。
  • 权限控制：在 RPC 请求中添加 token，服务端验证 token 合法性，防止非法调用。
  • 服务文档自动生成：基于服务接口注解，自动生成 RPC 服务文档（类似 Swagger）。
6.4 代码示例：添加重试机制
以RpcProxyFactory为例，集成Guava-Retryer实现重试：


// 添加Guava Retryer依赖

    com.github.rholder
    guava-retrying
    2.0.0

// 在RpcProxyFactory的invoke方法中添加重试逻辑
Retryer retryer = RetryerBuilder.newBuilder()
        .retryIfExceptionOfType(NetworkException.class) // 网络异常重试
        .retryIfResult(response -> !response.isSuccess()) // 调用失败重试
        .withStopStrategy(StopStrategies.stopAfterAttempt(3)) // 最多重试3次
        .withWaitStrategy(WaitStrategies.fixedWait(100, TimeUnit.MILLISECONDS)) // 重试间隔100ms
        .build();
try {
    // 带重试的调用
    RpcResponse rpcResponse = retryer.call(() -> clientTransport.sendRequest(rpcRequest).get());
} catch (ExecutionException e) {
    // 重试失败处理
    throw new RpcException("RPC调用重试失败：" + e.getCause().getMessage(), e.getCause());
}


7. 总结
本文从 0 到 1 实现了一个可运行的 RPC 框架，核心包含序列化层、网络传输层、服务注册中心、动态代理层、负载均衡层、注解驱动层六大模块，通过示例验证了框架的正确性和可用性。
  • 核心逻辑：通过动态代理屏蔽远程调用细节，Netty 实现高性能通信，ZooKeeper 实现服务发现，负载均衡实现服务分发，注解驱动简化用户使用。
  • 关键收获：理解 RPC 的底层原理（如 TCP 粘包拆包、序列化、服务发现），掌握框架设计的 “接口化” 思想（如Serializer、ServiceRegistry），便于后续扩展。
  • 生产落地：若需在生产环境使用，需补充容错、监控、权限等功能，并进行性能测试和压测，确保满足业务需求。