从零开始手写RPC框架（4）

这一节主要讲述���络传输模块的代码，并且几乎每一行代码都加上了我个人理解的注释，同时也讲述了其中一些以前没见过的函数，和大致的底层运行逻辑。

目录

• 网络传输实体类
• 网络传输实现
• • 基于Socket实现网络传输
  • 基于Netty实现网络传输
  • • 客户端
    • 服务端

      再重新梳理一下RPC的逻辑，当你需要调用远程方法时，你必须通过网络请求将目标类、方法信息以及方法参数等数据发送到服务器端。这就涉及到了网络传输的问题。

      对于网络传输的具体实现，你可以选择使用 Socket —— 这是 Java 中最基础且最原始的网络通信方式。然而，Socket 是阻塞IO，其性能较低且功能单一。你也可以选择使用同步非阻塞的 I/O 模型 NIO，但是使用 NIO 进行网络编程可能会比较复杂。因此，你可以考虑使用基于 NIO 的网络编程框架 Netty，它是最佳选择。

      网络传输模块整体结构如下：

      一共被分为了 4 个包：

      1. constants : 存放一些网络传输模块共用的常量2. dto : 用于网络传输的类。3. handler : 里面只有一个用于处理 rpc 请求的类RpcRequestHandler（根据 rpc 请求调用目标类的目标方法）。4. transport : 用户网络传输相关类（真正传输网络请求的地方。提供了 Socket 和 Netty 两种网络传输方式）。

      下面分别进行介绍。

      网络传输实体类

      网络传输实体类在 dto 包下，主要有两个类。RpcRequest.java和RpcResponse.java

      首先是RpcRequest.java——rpc 请求实体类。当你要调用远程方法的时候，你需要先传输一个 RpcRequest 给对方， RpcRequest里面包含了要调用的目标方法和类的名称、参数等数据。

      @AllArgsConstructor@NoArgsConstructor@Getter@Builder@ToStringpublic class RpcRequest implements Serializable {    private static final long serialVersionUID = 1905122041950251207L;// 序列化版本号    private String requestId;// 请求ID    private String interfaceName;// 接口名称    private String methodName;// 方法名称    private Object[] parameters;// 参数列表    private Class[] paramTypes;// 参数类型列表    private String version;// 版本号 主要是为后续不兼容升级提供可能    private String group;// 分组 主要用于处理一个接口有多个类实现的情况    /**     * 获取RPC服务名称     *     * @return 返回接口名称、分组和版本号的组合     */    public String getRpcServiceName() {        return this.getInterfaceName() + this.getGroup() + this.getVersion();    }}

      然后是RpcResponse.java——rpc 响应实体类，当服务端通过 RpcRequest 中的相关数据调用到目标服务的目标方法之后，调用结果就通过RpcResponse 返回给客户端。

      @AllArgsConstructor@NoArgsConstructor@Getter@Setter@Builder@ToStringpublic class RpcResponse implements Serializable {    private static final long serialVersionUID = 715745410605631233L;// 序列化版本号    private String requestId;// 请求ID    private Integer code;// 响应码    private String message;// 响应消息    private T data;// 响应体    /**     * 成功响应     * @param data 响应数据     * @param requestId 请求ID     * @return 返回一个包含成功响应码、消息和请求ID的响应对象     */    public static  RpcResponse success(T data, String requestId) {        RpcResponse response = new RpcResponse();        response.setCode(RpcResponseCodeEnum.SUCCESS.getCode());        response.setMessage(RpcResponseCodeEnum.SUCCESS.getMessage());        response.setRequestId(requestId);        if (null != data) {            response.setData(data);        }        return response;    }    /**     * 失败响应     * @param rpcResponseCodeEnum 响应码枚举     * @return 返回一个包含失败响应码和消息的响应对象     */    public static  RpcResponse fail(RpcResponseCodeEnum rpcResponseCodeEnum) {        RpcResponse response = new RpcResponse();        response.setCode(rpcResponseCodeEnum.getCode());        response.setMessage(rpcResponseCodeEnum.getMessage());        return response;    }}

      网络传输实现

      这部分基于 Socket，和基于 Netty 的网络传输方式实现。因此，先定义一个发送 RPC 请求的顶层接口，然后分别使用 Socket 和 Netty 两种方式对这个

      接口进行实现即可，RpcRequestTransport.java 传输请求的接口：

      @SPIpublic interface RpcRequestTransport {    /**     * send rpc request to server and get result     *     * @param rpcRequest message body     * @return data from server     */    Object sendRpcRequest(RpcRequest rpcRequest);}

      其中@SPI 是一个自定义注解

      @Documented@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface SPI {}

      在 Java 中，SPI 是一种服务发现机制。它允许第三方为应用程序提供插件或模块。在运行时，应用程序可以查询哪些插件或模块可用，并选择其中之一进行调用。

      具体到我们的代码中，@SPI 被用于标记 RpcRequestTransport 接口。这意味着 RpcRequestTransport 的实现可以由第三方提供，并在运行时动态加载。这样，RPC 框架就可以支持多种传输协议，比如 HTTP、TCP、UDP 等，只要有相应的 RpcRequestTransport 实现即可。

      下面，我们先来看一下比较简单点的使用 Socket 进行网络传输的方式。

      基于Socket实现网络传输

      客户端

      客户端主要用于发送网络请求到服务端（目标方法所在的服务器）。当我们知道了服务端的地址之后，我们就可以通过 SocketRpcClient 发送 rpc 请求(RpcRequest) 到服务端了(如果我们要找到服务端的地址，涉及到了注册中心相关的知识,下一节会介绍）

      @AllArgsConstructor@Slf4jpublic class SocketRpcClient implements RpcRequestTransport {    private final ServiceDiscovery serviceDiscovery;// 服务发现组件    /**     * 构造函数     * 默认使用 ZooKeeper 作为服务发现组件     */    public SocketRpcClient() {        //ExtensionLoader 是一个用于加载扩展实现的工具类，它实现了一种称为 SPI（Service Provider Interface）的设计模式。        //getExtensionLoader(ServiceDiscovery.class)：获取 ServiceDiscovery 接口的 ExtensionLoader。如果缓存中没有，就创建一个新的 ExtensionLoader 并放入缓存。        //getExtension(ServiceDiscoveryEnum.ZK.getName())：从 ExtensionLoader 中获取名为 ServiceDiscoveryEnum.ZK.getName() 的扩展实现。如果缓存中没有，就创建一个新的实例并放入缓存。        this.serviceDiscovery = ExtensionLoader.getExtensionLoader(ServiceDiscovery.class).getExtension(ServiceDiscoveryEnum.ZK.getName());    }    /**     * 发送 RPC 请求     *     * @param rpcRequest RPC 请求     * @return 服务端返回的数据     */    @Override    public Object sendRpcRequest(RpcRequest rpcRequest) {        InetSocketAddress inetSocketAddress = serviceDiscovery.lookupService(rpcRequest);// 通过服务发现组件获取服务端地址        try (Socket socket = new Socket()) {            socket.connect(inetSocketAddress);// 连接到服务端            ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());            // 通过输出流向服务端发送数据            objectOutputStream.writeObject(rpcRequest);            ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());            // 通过输入流读取服务端返回的数据            return objectInputStream.readObject();        } catch (IOException | ClassNotFoundException e) {            throw new RpcException("调用服务失败:", e);        }    }}

      “拓展类"通常指的是一种设计模式，叫做"服务提供者接口”（SPI，Service Provider Interface）。在这种模式中，有一个接口（或抽象类），以及这个接口的多个实现类，这些实现类就是所谓的"拓展类"。这种模式允许第三方为一个模块、库、框架或者应用提供插件或者拓展。

      ExtensionLoader类的主要作用是加载扩展类。它首先从META-INF/extensions/目录下的文件中读取扩展类的信息，然后通过类加载器加载这些扩展类，并将它们存储在一个映射中。当需要获取一个扩展类的实例时，它会首先从缓存中获取，如果缓存中没有，就创建一个新的实例。

      使用ExtensionLoader来加载拓展类，而不是直接通过包引用，有以下几个优点：

      灵活性：使用ExtensionLoader可以在运行时动态地加载和卸载拓展类，而不需要在编译时确定。这使得你可以很容易地添加、替换或删除一个拓展。

      解耦：ExtensionLoader使得你的代码和拓展类之间的耦合度降低。你的代码不需要直接引用拓展类，只需要通过ExtensionLoader来使用拓展。这使得你的代码更容易维护和测试。

      隔离：ExtensionLoader可以为每个拓展类提供一个独立的类加载器，这样就可以防止拓展类之间的冲突和干扰。

      服务端

      Socket 服务端。用于等待客户端连接。当客户端成功连接之后，就可以发送 rpc 请求( RpcRequest ) 到服务端了。然后，服务端拿到 RpcRequest 就会去执行对应的方法。执行完对应的方法之后，就把执行得到的结果放在RpcResponse 中返回给客户端。

      /** * Socket 服务端 * 用于等待客户端连接并处理请求 */@Slf4jpublic class SocketRpcServer {    private final ExecutorService threadPool;// 线程池，用于处理客户端请求    private final ServiceProvider serviceProvider;// 服务提供者，用于注册和查找服务    public SocketRpcServer() {        threadPool = ThreadPoolFactoryUtil.createCustomThreadPoolIfAbsent("socket-server-rpc-pool");        serviceProvider = SingletonFactory.getInstance(ZkServiceProviderImpl.class);    }    /**     * 注册服务     * @param rpcServiceConfig 服务配置     */    public void registerService(RpcServiceConfig rpcServiceConfig) {        serviceProvider.publishService(rpcServiceConfig);    }    /**     * 启动服务     * 开始监听客户端连接并处理请求     */    public void start() {        try (ServerSocket server = new ServerSocket()) { // 创建一个新的 ServerSocket            String host = InetAddress.getLocalHost().getHostAddress();// 获取本地主机的 IP 地址            server.bind(new InetSocketAddress(host, PORT));// 将 ServerSocket 绑定到指定的 IP 地址和端口号            CustomShutdownHook.getCustomShutdownHook().clearAll();// 添加一个自定义的关闭钩子，当 JVM 关闭时，这个关闭钩子会执行 clearAll 方法            //clearAll()方法为了告诉其他 RPC 服务或客户端，当前服务器已经不再提供服务，会清除注册中心中的当前服务器信息，并且关闭所有线程池，释放资源。            Socket socket;            while ((socket = server.accept()) != null) {// 循环接受客户端的连接                log.info("client connected [{}]", socket.getInetAddress());// 记录客户端的 IP 地址                threadPool.execute(new SocketRpcRequestHandlerRunnable(socket));// 将新的客户端连接提交给线程池处理            }            threadPool.shutdown();// 关闭线程池        } catch (IOException e) {            log.error("occur IOException:", e);        }    }}

      其中SocketRpcRequestHandlerRunnable.java的代码如下

      /** * Socket 请求处理器 * 用于处理来自客户端的请求 */@Slf4jpublic class SocketRpcRequestHandlerRunnable implements Runnable {    private final Socket socket;// 客户端 Socket 连接    private final RpcRequestHandler rpcRequestHandler;// RPC 请求处理器    public SocketRpcRequestHandlerRunnable(Socket socket) {        this.socket = socket;        this.rpcRequestHandler = SingletonFactory.getInstance(RpcRequestHandler.class);    }    /**     * 处理客户端请求     */    @Override    public void run() {        log.info("server handle message from client by thread: [{}]", Thread.currentThread().getName());// 记录当前线程的名称        try (ObjectInputStream objectInputStream = new ObjectInputStream(socket.getInputStream());             ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream())) {            RpcRequest rpcRequest = (RpcRequest) objectInputStream.readObject();// 从输入流读取 RpcRequest 对象            Object result = rpcRequestHandler.handle(rpcRequest);// 处理 RpcRequest，得到处理结果            objectOutputStream.writeObject(RpcResponse.success(result, rpcRequest.getRequestId()));// 将处理结果包装成 RpcResponse，写入到输出流            objectOutputStream.flush();// 刷新输出流，确保 RpcResponse 对象被发送到客户端        } catch (IOException | ClassNotFoundException e) {            log.error("occur exception:", e);        }    }}

      基于Netty实现网络传输

      Netty 这部分的原理也差不多，不过实现代码差别很大。

      客户端

      Netty 客户端NettyClient.java主要提供了:

      • doConnect() :用于连接服务端（目标方法所在的服务器）并返回对应的 Channel 。当我们知道了服务端的地址之后，我们就可以通过 NettyClient 成功连接服务端了。（有了Channel 之后就能发送数据到服务端了）
      • sendRpcRequest() : 用于传输 rpc 请求( RpcRequest ) 到服务端。

        @Slf4jpublic final class NettyRpcClient implements RpcRequestTransport {    private final ServiceDiscovery serviceDiscovery;// 服务发现组件    private final UnprocessedRequests unprocessedRequests;// 未处理的请求    private final ChannelProvider channelProvider;// 通道提供者    private final Bootstrap bootstrap;// Netty 启动类    private final EventLoopGroup eventLoopGroup;// Netty 事件循环组    public NettyRpcClient() {//构造函数初始化资源，如 EventLoopGroup、Bootstrap 等        eventLoopGroup = new NioEventLoopGroup();        bootstrap = new Bootstrap();        bootstrap.group(eventLoopGroup)// 设置事件循环组                .channel(NioSocketChannel.class)// 设置通道类型为 NioSocketChannel                .handler(new LoggingHandler(LogLevel.INFO))// 添加日志处理器                // 设置连接超时时间，如果超过这个时间还未连接成功，则连接失败                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 5000)                .handler(new ChannelInitializer() {                    @Override                    protected void initChannel(SocketChannel ch) {// 添加通道初始化器                        ChannelPipeline p = ch.pipeline();                        // 如果在 15 秒内没有向服务器发送数据，就发送一个心跳请求                        p.addLast(new IdleStateHandler(0, 5, 0, TimeUnit.SECONDS));                        p.addLast(new RpcMessageEncoder());// 添加 RPC 消息编码器                        p.addLast(new RpcMessageDecoder());// 添加 RPC 消息解码器                        p.addLast(new NettyRpcClientHandler());// 添加 Netty RPC 客户端处理器                    }                });        // 获取服务发现组件的实例        this.serviceDiscovery = ExtensionLoader.getExtensionLoader(ServiceDiscovery.class).getExtension(ServiceDiscoveryEnum.ZK.getName());        // 获取未处理的请求的实例        this.unprocessedRequests = SingletonFactory.getInstance(UnprocessedRequests.class);        // 获取通道提供者的实例        this.channelProvider = SingletonFactory.getInstance(ChannelProvider.class);    }    /**     * 连接服务端并返回对应的 Channel     * @param inetSocketAddress 服务端地址     * @return 服务端的 Channel     */    @SneakyThrows    public Channel doConnect(InetSocketAddress inetSocketAddress) {        // 创建一个 CompletableFuture 对象，用于存储 Channel        CompletableFuture completableFuture = new CompletableFuture();        // 使用 Bootstrap 的 connect 方法连接到服务端        bootstrap.connect(inetSocketAddress).addListener((ChannelFutureListener) future -> {            if (future.isSuccess()) {// 如果连接成功记录连接成功的日志                log.info("The client has connected [{}] successful!", inetSocketAddress.toString());                completableFuture.complete(future.channel());// 将 Channel 存入 CompletableFuture            } else {                throw new IllegalStateException();            }        });        return completableFuture.get();// 返回 CompletableFuture 中的 Channel    }    /**     * 发送 RPC 请求     * @param rpcRequest RPC 请求     * @return 服务端返回的数据     */    @Override    public Object sendRpcRequest(RpcRequest rpcRequest) {        // 创建 CompletableFuture 对象，用于存储 RPC 响应的结果        CompletableFuture resultFuture = new CompletableFuture();        // 通过服务发现组件获取服务端的地址        InetSocketAddress inetSocketAddress = serviceDiscovery.lookupService(rpcRequest);        // 获取与服务端地址相关的通道        Channel channel = getChannel(inetSocketAddress);        if (channel.isActive()) {// 检查通道是否活跃            // 将未处理的请求放入 unprocessedRequests            unprocessedRequests.put(rpcRequest.getRequestId(), resultFuture);            // 创建 RPC 消息对象            RpcMessage rpcMessage = RpcMessage.builder().data(rpcRequest)                    .codec(SerializationTypeEnum.HESSIAN.getCode())                    .compress(CompressTypeEnum.GZIP.getCode())                    .messageType(RpcConstants.REQUEST_TYPE).build();            // 将 RPC 消息对象写入通道并刷新，同时添加一个监听器处理发送失败的情况            channel.writeAndFlush(rpcMessage).addListener((ChannelFutureListener) future -> {                if (future.isSuccess()) {                    log.info("client send message: [{}]", rpcMessage);                } else {// 如果消息发送失败，关闭通道，并将异常存入 resultFuture                    future.channel().close();                    resultFuture.completeExceptionally(future.cause());                    log.error("Send failed:", future.cause());                }            });        } else {            throw new IllegalStateException();        }        return resultFuture; // 返回 CompletableFuture 对象    }    /**     * 获取通道     * @param inetSocketAddress 服务端地址     * @return 与服务端地址相关的通道     */    public Channel getChannel(InetSocketAddress inetSocketAddress) {        Channel channel = channelProvider.get(inetSocketAddress);        if (channel == null) {            channel = doConnect(inetSocketAddress);            channelProvider.set(inetSocketAddress, channel);        }        return channel;    }    // 优雅地关闭事件循环组，即在关闭事件循环组之前，会等待所有任务都完成，包括正在执行的任务和提交的但还未执行的任务    public void close() {        eventLoopGroup.shutdownGracefully();    }}

        CompletableFuture 是 Java 8 引入的一个类，它实现了 Future 和 CompletionStage 接口，提供了一种异步编程的方式。Future 是 Java 5 引入的一个接口，用于表示异步计算的结果。但是，Future 的功能比较有限，例如，它无法表示计算完成后的回调，也无法组合多个 Future 的结果。CompletableFuture 弥补了这些不足，提供了丰富的方法来处理异步计算的结果。

        在我们的代码中，CompletableFuture 被用于存储 RPC 响应的结果。当 RPC 响应返回时，CompletableFuture 的 complete 方法被调用，将结果存入 CompletableFuture。然后，可以通过 CompletableFuture 的 get 方法来获取结果。如果结果还未返回，get 方法会阻塞，直到结果返回为止。

        其中UnprocessedRequests.java用于存放未被服务端处理的请求（建议限制 map 容器大小，避免未处理请求过多 OOM)。

        public class UnprocessedRequests {    // 存储未处理的请求    private static final Map UNPROCESSED_RESPONSE_FUTURES = new ConcurrentHashMap();    /**     * 将未处理的请求放入 UNPROCESSED_RESPONSE_FUTURES     * @param requestId 请求 ID     * @param future 未来的 RPC 响应     */    public void put(String requestId, CompletableFuture future) {        UNPROCESSED_RESPONSE_FUTURES.put(requestId, future);    }    /**     * 完成 RPC 响应     * @param rpcResponse RPC 响应     */    public void complete(RpcResponse rpcResponse) {        // 从 UNPROCESSED_RESPONSE_FUTURES 中移除请求并获取对应的 CompletableFuture        CompletableFuture future = UNPROCESSED_RESPONSE_FUTURES.remove(rpcResponse.getRequestId());        // 如果 CompletableFuture 存在，则完成它        if (null != future) {            future.complete(rpcResponse);        } else {            throw new IllegalStateException();        }    }}

        自定义客户端 ChannelHandler 用于处理服务器返回的数据。下面是NettyRpcClientHandler.java

        @Slf4jpublic class NettyRpcClientHandler extends ChannelInboundHandlerAdapter {    private final UnprocessedRequests unprocessedRequests;// 未处理的请求    private final NettyRpcClient nettyRpcClient;// Netty RPC 客户端    public NettyRpcClientHandler() {        this.unprocessedRequests = SingletonFactory.getInstance(UnprocessedRequests.class);        this.nettyRpcClient = SingletonFactory.getInstance(NettyRpcClient.class);    }    /**     * 读取服务器传输的消息     */    @Override    public void channelRead(ChannelHandlerContext ctx, Object msg) {// 当从服务器接收到一条消息时被调用        try {            log.info("client receive msg: [{}]", msg);            if (msg instanceof RpcMessage) {// 如果消息是RpcMessage类型                RpcMessage tmp = (RpcMessage) msg;                byte messageType = tmp.getMessageType();                if (messageType == RpcConstants.HEARTBEAT_RESPONSE_TYPE) {// 如果是心跳响应类型                    log.info("heart [{}]", tmp.getData());                } else if (messageType == RpcConstants.RESPONSE_TYPE) {// 如果是响应类型                    RpcResponse rpcResponse = (RpcResponse) tmp.getData();// 获取响应数据                    unprocessedRequests.complete(rpcResponse);// 完成未处理的请求                }            }        } finally {            ReferenceCountUtil.release(msg);// 释放消息资源        }    }    //userEventTriggered也是netty的一个回调方法 当发生空闲状态事件时被调用    @Override    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {        if (evt instanceof IdleStateEvent) {// 如果事件是空闲状态事件            IdleState state = ((IdleStateEvent) evt).state();// 获取空闲状态            if (state == IdleState.WRITER_IDLE) {// 如果是写空闲状态                log.info("write idle happen [{}]", ctx.channel().remoteAddress());// 记录写空闲事件                Channel channel = nettyRpcClient.getChannel((InetSocketAddress) ctx.channel().remoteAddress());// 获取与远程地址相关的通道                RpcMessage rpcMessage = new RpcMessage();// 创建一个新的RpcMessage                rpcMessage.setCodec(SerializationTypeEnum.PROTOSTUFF.getCode());// 设置编解码类型                rpcMessage.setCompress(CompressTypeEnum.GZIP.getCode());// 设置压缩类型                rpcMessage.setMessageType(RpcConstants.HEARTBEAT_REQUEST_TYPE);// 设置消息类型为心跳请求类型                rpcMessage.setData(RpcConstants.PING);// 设置数据为PING                channel.writeAndFlush(rpcMessage).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);// 将消息写入并刷新到通道，如果失败则关闭通道            }        } else {            super.userEventTriggered(ctx, evt);        }    }    /**     * 当处理客户端消息时发生异常时调用     */    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {        log.error("client catch exception：", cause);        cause.printStackTrace();// 打印异常堆栈跟踪        ctx.close();    }}

        在Netty中，空闲状态事件是指在一段时间内没有进行读操作、写操作或者两者都没有进行的情况。这是通过IdleStateHandler来检测的，它会在指定的空闲时间后触发一个IdleStateEvent事件。

        空闲状态有三种类型：

        读空闲（READER_IDLE）：在一段时间内没有读取到对方的数据，也就是说，如果在指定的时间内没有接收到对方的数据，那么就会触发这个事件。

        写空闲（WRITER_IDLE）：在一段时间内没有向对方写数据，也就是说，如果在指定的时间内没有向对方发送数据，那么就会触发这个事件。

        读写空闲（ALL_IDLE）：在一段时间内既没有读取到对方的数据，也没有向对方写数据，也就是说，如果在指定的时间内既没有接收到对方的数据，也没有向对方发送数据，那么就会触发这个事件。

        在我们的代码中，当发生写空闲事件时，客户端会向服务器发送一个心跳请求。这是因为，如果客户端在一段时间内没有向服务器发送数据，可能会导致服务器认为客户端已经断开连接，从而关闭连接。为了保持连接的活跃，当发生写空闲事件时，客户端会向服务器发送一个心跳请求，告诉服务器它还在。这样，即使在没有数据交换的情况下，客户端和服务器之间的连接也能保持活跃。这就是心跳机制的作用。

        从代码中，可以看出当 rpc 请求被成功处理（客户端收到服务端的执行结果）之后，我们调用了unprocessedRequests.complete(rpcResponse) 方法，这样的话，你只需要通过下面的方式就能成

        功接收到服务端返回的结果。

        CompletableFuture completableFuture =(CompletableFuture) clientTransport.sendRpcRequest(rpcRequest);rpcResponse = completableFuture.get();

        然后是ChannelProvider.java用于存放Channel （ Channel 用于在服务端和客户端之间传输数据）。

        @Slf4jpublic class ChannelProvider {    private final Map channelMap;// 存储通道的映射    public ChannelProvider() {        channelMap = new ConcurrentHashMap();    }    /**     * 获取通道     * @param inetSocketAddress 服务端地址     * @return 与服务端地址相关的通道     */    public Channel get(InetSocketAddress inetSocketAddress) {        String key = inetSocketAddress.toString();// 将服务端地址转换为字符串作为键        // 判断是否存在对应地址的连接        if (channelMap.containsKey(key)) {            Channel channel = channelMap.get(key);            // 如果存在，则判断连接是否可用，如果可用，则直接获取            if (channel != null && channel.isActive()) {                return channel;            } else {                channelMap.remove(key);            }        }        return null;    }    /**     * 设置通道     * @param inetSocketAddress 服务端地址     * @param channel 通道     */    public void set(InetSocketAddress inetSocketAddress, Channel channel) {        String key = inetSocketAddress.toString();        channelMap.put(key, channel);    }    /**     * 移除通道     * @param inetSocketAddress 服务端地址     */    public void remove(InetSocketAddress inetSocketAddress) {        String key = inetSocketAddress.toString();        channelMap.remove(key);        log.info("Channel map size :[{}]", channelMap.size());    }}

        服务端

        NettyRpcServer.java，Netty 服务端，监听客户端的连接。另外，还提供了两个用户手动注册服务的方法（还可以通过注解RpcService 注册服务，这个后面也会介绍到）。

        @Slf4j@Componentpublic class NettyRpcServer {    public static final int PORT = 9998;// 服务端口    // 服务提供者，用于注册和查找服务    private final ServiceProvider serviceProvider = SingletonFactory.getInstance(ZkServiceProviderImpl.class);    /**     * 注册服务     * @param rpcServiceConfig 服务配置     */    public void registerService(RpcServiceConfig rpcServiceConfig) {        serviceProvider.publishService(rpcServiceConfig);    }    /**     * 启动服务     */    @SneakyThrows// Lombok提供的注解，用于处理所有受检异常在方法体中自动捕获并处理异常，将异常转换为非受检异常（Unchecked Exception）并抛出。    public void start() {        // 添加一个自定义的关闭钩子，当 JVM 关闭时，这个关闭钩子会执行 clearAll 方法        //clearAll()方法为了告诉其他 RPC 服务或客户端，当前服务器已经不再提供服务，会清除注册中心中的当前服务器信息，并且关闭所有线程池，释放资源。        CustomShutdownHook.getCustomShutdownHook().clearAll();// 获取自定义关闭钩子实例并调用其clearAll方法        String host = InetAddress.getLocalHost().getHostAddress();// 获取本地主机地址        EventLoopGroup bossGroup = new NioEventLoopGroup(1);//创建一个bossGroup，它负责接收客户端的连接，指定线程数为1        EventLoopGroup workerGroup = new NioEventLoopGroup();// 创建一个workerGroup，它负责处理已接受的连接        DefaultEventExecutorGroup serviceHandlerGroup = new DefaultEventExecutorGroup(                RuntimeUtil.cpus() * 2,// 创建一个线程数为CPU核数的两倍的DefaultEventExecutorGroup                // 使用ThreadPoolFactoryUtil创建一个线程工厂                ThreadPoolFactoryUtil.createThreadFactory("service-handler-group", false)        );        try {            ServerBootstrap b = new ServerBootstrap();// 创建一个ServerBootstrap实例            b.group(bossGroup, workerGroup)// 设置bossGroup和workerGroup                    .channel(NioServerSocketChannel.class)// 设置通道为NioServerSocketChannel                    // TCP默认开启了 Nagle 算法，该算法的作用是尽可能的发送大数据快，减少网络传输。TCP_NODELAY 参数的作用就是控制是否启用 Nagle 算法。                    .childOption(ChannelOption.TCP_NODELAY, true)// 设置TCP_NODELAY为true，禁用Nagle算法                    // 是否开启 TCP 底层心跳机制                    .childOption(ChannelOption.SO_KEEPALIVE, true)// 设置SO_KEEPALIVE为true，开启TCP底层心跳机制                    //表示系统用于临时存放已完成三次握手的请求的队列的最大长度,如果连接建立频繁，服务器处理创建新连接较慢，可以适当调大这个参数                    .option(ChannelOption.SO_BACKLOG, 128)                    .handler(new LoggingHandler(LogLevel.INFO))// 添加一个日志处理器                    // 当客户端第一次进行请求的时候才会进行初始化                    .childHandler(new ChannelInitializer() {                        @Override                        protected void initChannel(SocketChannel ch) {                            ChannelPipeline p = ch.pipeline();// 获取通道的管道                            // 添加一个空闲状态处理器，如果30秒内没有收到客户端的请求，就关闭连接                            p.addLast(new IdleStateHandler(30, 0, 0, TimeUnit.SECONDS));                            p.addLast(new RpcMessageEncoder());// 添加一个RpcMessage编码器                            p.addLast(new RpcMessageDecoder());// 添加一个RpcMessage解码器                            p.addLast(serviceHandlerGroup, new NettyRpcServerHandler());// 添加一个NettyRpcServerHandler处理器                        }                    });            ChannelFuture f = b.bind(host, PORT).sync(); // 绑定主机和端口，并同步等待绑定成功            // 等待服务端监听端口关闭            f.channel().closeFuture().sync();        } catch (InterruptedException e) {// 记录启动服务器时发生的异常            log.error("occur exception when start server:", e);        } finally {            log.error("shutdown bossGroup and workerGroup");            // 优雅地关闭事件循环组，即在关闭事件循环组之前，会等待所有任务都完成，包括正在执行的任务和提交的但还未执行的任务            bossGroup.shutdownGracefully();            workerGroup.shutdownGracefully();            serviceHandlerGroup.shutdownGracefully();        }    }}

        然后是NettyServerHandler.java，自定义服务端ChannelHandler 用于处理客户端发送的数据。当客户端发的 rpc 请求( RpcRequest ) 来了之后，服务端就会处理 rpc 请求( RpcRequest ) ，处理完之后就把得到 rpc 相应( RpcResponse )传输给客户端。

        @Slf4jpublic class NettyRpcServerHandler extends ChannelInboundHandlerAdapter {    private final RpcRequestHandler rpcRequestHandler;//RpcRequestHandler实例，用于处理Rpc请求    public NettyRpcServerHandler() {        this.rpcRequestHandler = SingletonFactory.getInstance(RpcRequestHandler.class);    }    @Override    public void channelRead(ChannelHandlerContext ctx, Object msg) {// 当从客户端接收到一条消息时被调用        try {            if (msg instanceof RpcMessage) {// 如果消息是RpcMessage类型                log.info("server receive msg: [{}] ", msg);                byte messageType = ((RpcMessage) msg).getMessageType();// 获取消息类型                RpcMessage rpcMessage = new RpcMessage();// 创建一个新的RpcMessage用作响应                rpcMessage.setCodec(SerializationTypeEnum.HESSIAN.getCode());// 设置编解码类型                rpcMessage.setCompress(CompressTypeEnum.GZIP.getCode());// 设置压缩类型                if (messageType == RpcConstants.HEARTBEAT_REQUEST_TYPE) {// 如果是心跳请求类型                    rpcMessage.setMessageType(RpcConstants.HEARTBEAT_RESPONSE_TYPE);// 设置响应消息类型为心跳响应类型                    rpcMessage.setData(RpcConstants.PONG);//设置数据为PONG                } else {//不是心跳请求类型 说明是rpc请求                    RpcRequest rpcRequest = (RpcRequest) ((RpcMessage) msg).getData();// 获取请求数据                    Object result = rpcRequestHandler.handle(rpcRequest);// 执行目标方法（客户端需要执行的方法）并返回方法结果                    log.info(String.format("server get result: %s", result.toString()));// 记录获取到的结果                    rpcMessage.setMessageType(RpcConstants.RESPONSE_TYPE);// 设置消息类型为响应类型                    if (ctx.channel().isActive() && ctx.channel().isWritable()) {// 如果通道是活跃的并且是可写的                        RpcResponse rpcResponse = RpcResponse.success(result, rpcRequest.getRequestId());                        rpcMessage.setData(rpcResponse);// 创建一个成功的Rpc响应并设置响应数据                    } else {// 如果通道是不活跃的或者不可写的                        RpcResponse rpcResponse = RpcResponse.fail(RpcResponseCodeEnum.FAIL);                        rpcMessage.setData(rpcResponse);// 创建一个失败的Rpc响应并// 设置响应数据                        log.error("not writable now, message dropped");                    }                }                // 将消息写入并刷新到通道，如果失败则关闭通道                ctx.writeAndFlush(rpcMessage).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);            }        } finally {            //释放消息资源仿真内存泄露            ReferenceCountUtil.release(msg);        }    }    // 当发生用户事件时被调用即一段时间内没有读取到客户端的数据，那么就关闭连接。    @Override    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {        if (evt instanceof IdleStateEvent) {// 如果事件是空闲状态事件            IdleState state = ((IdleStateEvent) evt).state();// 获取空闲状态            if (state == IdleState.READER_IDLE) {// 如果是读空闲状态                log.info("idle check happen, so close the connection");                ctx.close();// 关闭通道处理上下文            }        } else {            super.userEventTriggered(ctx, evt);// 如果不是空闲状态事件，调用父类的userEventTriggered方法            //父类的这个方法默认实现是不做任何事情但，如果有其他的ChannelInboundHandler在管道中，            // 并且这个ChannelInboundHandler重写了userEventTriggered方法，那么这个方法就会被调用。        }    }    @Override    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {// 当处理客户端消息时发生异常时调用        log.error("server catch exception");// 记录异常信息        cause.printStackTrace();// 打印异常堆栈跟踪        ctx.close();// 关闭通道处理上下文    }}