RPC(2)------ Netty(NIO) + 多种序列化协议 + JDK动态代理实现

news2024/11/27 10:33:47

依赖包解释

Guava
包含了若干被Google的 Java项目广泛依赖的核心库，例如：集合 [collections] 、缓存 [caching] 、原生类型支持 [primitives support] 、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。所有这些工具每天都在被Google的工程师应用在产品服务中。

Jackson
用来序列化和反序列化 json 的 Java 的开源框架.

jackson-core，核心包，提供基于"流模式"解析的相关 API，它包括 JsonPaser 和 JsonGenerator。 Jackson 内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json
jackson-annotations，注解包，提供标准注解功能；
jackson-databind ，数据绑定包，提供基于"对象绑定" 解析的相关 API （ ObjectMapper ）和"树模型" 解析的相关 API （JsonNode）；基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。

netty一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。

版本回顾

在前面实现的RPC(1)------Java BIO + JDK原生序列化 + JDK动态代理实现中，是基于java多线程的阻塞调用，每次客户端调用，服务端都会开启一个线程来处理客户端请求，这也是上个版本的缺点。这次基于netty的版本就是针对上个版本的缺陷来做出的优化，代码见V2.0

基于NIO的RPC实现

本次更新主要是在rpc-core模块，将前一个基于socket实现的功能放在socket包下，codec包下是序列化和反序列化代码，netty包下是基于netty实现的rpc客户端和服务端；serializer包下是实现的几种不同的序列化算法。

在这里插入图片描述

关于netty的基本组件介绍可以参考netty快速入门

netty client

首先创建NioEventLoopGroup线程组，然后创建bootstrap对象，配置参数

public class NettyClient implements RpcClient {

    private static final Logger logger = LoggerFactory.getLogger(NettyClient.class);
    private static final Bootstrap bootstrap;

    private CommonSerializer serializer;

    static {
        EventLoopGroup group = new NioEventLoopGroup();
        bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.SO_KEEPALIVE, true);
    }

    private String host;
    private int port;

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

然后是实现sendrequest方法，这个和socket实现的一样，发送客户端请求，然后等待请求结果返回，功能一样，我们主要看netty的实现方式。

首先初始化channel以及绑定handler

bootstrap.handler(new ChannelInitializer<SocketChannel>() {
            @Override
            protected void initChannel(SocketChannel ch) {
                ChannelPipeline pipeline = ch.pipeline();
                pipeline.addLast(new CommonDecoder())//in
                        .addLast(new CommonEncoder(serializer))//out
                        .addLast(new NettyClientHandler());//in
            }
        });

然后绑定端口，连接服务器发送请求

//sync方法是等待异步操作执行完毕
ChannelFuture future = bootstrap.connect(host, port).sync();
            logger.info("客户端连接到服务器 {}:{}", host, port);
            Channel channel = future.channel();
            if (channel != null) {
                channel.writeAndFlush(rpcRequest).addListener(future1 -> {
                    if (future1.isSuccess()) {
                        logger.info(String.format("客户端发送消息: %s", rpcRequest.toString()));
                    } else {
                        logger.error("发送消息时有错误发生: ", future1.cause());
                    }
                });

然后在channel上获取返回信息，这个信息是在NettyClientHandler处理器上添加的

//主线程会在执行完bind().sync()方法后，不执行后面的代码
                channel.closeFuture().sync();
                AttributeKey<RpcResponse> key = AttributeKey.valueOf("rpcResponse" + rpcRequest.getRequestId());
                RpcResponse rpcResponse = channel.attr(key).get();
                RpcMessageChecker.check(rpcRequest, rpcResponse);
                return rpcResponse.getData();

服务端也类似，这里不再详细贴出

核心理解，pipeline执行流程

pipeline是存储通道处理器（Handler）的链表，在netty中，通道处理器分为两种：

入站处理器：一般都是ChannelInboundHandlerAdapter以及它的子类实现。
出站处理器：一般都是ChannelOutboundHandlerAdapter以及它的子类实现。
一个是in，一个是out，入站处理器只处理入站请求，出站处理器只处理出站请求。
了解到次，我们看一下服务端的pipeline和客户端的pipeline

服务端接收到请求时

服务端接收到请求时，即相对于服务端来说，数据是入站请求，执行入站处理器，handler从左到右执行，执行CommonDecoder(反序列化)和NettyServerHandler，CommonEncoder是出站处理器，不执行.
在这里插入图片描述

服务端返回到请求结果时

服务端处理完请求之后返回结果时，对于服务端来说，数据是出站请求，执行出站处理器，handler从右到左执行，只执行出站处理器CommonEncoder(序列化).
在这里插入图片描述

客户端也是这样分析

在这里插入图片描述

序列化方法不在详细说明

V2.0和V1.0对比

定义协议包

Magic Number 魔数，表识一个 MRF 协议包，0xCAFEBABE
Package Type 包类型，标明这是一个调用请求还是调用响应
Serializer Type 序列化器类型，标明这个包的数据的序列化方式
Data Length 数据字节的长度，反序列化时读取数据
Data Bytes 传输的对象，通常是一个RpcRequest或RpcClient对象，取决于Package Type字段，对象的序列化方式取决于Serializer Type字段。