RPC框架实战之手写RPC框架 第三章 个人总结复习

第三章

使用Netty传输数据，使用效率更高的Nio方式传输数据，因为原先使用的是传统BIO方式，现在为了支持Netty方式，需要抽象出接口，增加扩展性，这样也满足了设计模式六大原则中的依赖倒置原则。

抽象为接口

RpcServer和RpcClient抽象为接口

NettyServer实现RpcServer，NettyClient实现RpcClient

public interface RpcClient{
    Object sendRequest(RpcRequest rpcRequest);
}

public interface RpcServer{
    void start(int port);
}

导入Netty的依赖

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-all</artifactId>
    <version>4.1.70.Final</version>
</dependency>

NettyServer类

public class NettyServer implements RpcServer {

    private static final Logger logger = LoggerFactory.getLogger(NettyServer.class);

    /**
     * 启动并监听对应的端口，等待客户端的连接并处理数据
     *
     * @param port
     */
    @Override
    public void start(int port) {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .option(ChannelOption.SO_BACKLOG, 256)
                    .option(ChannelOption.SO_KEEPALIVE, true)
                    .childOption(ChannelOption.TCP_NODELAY, true)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new CommonEncoder(new JsonSerializer()));
                            pipeline.addLast(new CommonDecoder());
                            pipeline.addLast(new NettyServerHander());
                        }
                    });
            ChannelFuture future = serverBootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            logger.error("启动服务器时有错误发生: ", e);
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }

    }
}

ChannelOption.SO_BACKLOG

该设置为服务端接收连接的队列长度，如果队列已满，客户单连接将被拒绝。

服务端在处理客户端新连接请求时（三次握手）是顺序处理的，同一时间只能处理一个客户端连接，当有多个客户端连接到来的时候，服务端就会将不能处理的请求放在等待队列汇总等待，SO_BACKLOG设置的参数就是队列的大小。

服务端对完成第二次握手的连接放在一个队列（a队列）

如果完成了第三次握手，再把连接放在一个新队列中（b队列）

应用程序通过accept()方法取出握手成功的连接，然后系统会将该连接从队列中移除

a队列和b队列的长度总和为SO_BACKLOG设置的值，如果两个队列长度和大于SO_BACKLOG时，新连接将会被拒绝。

ChannelOption.SO_KEEPALIVE

该设置表示是否开启TCP心跳机制，true为连接保持心跳，默认为false，启用该功能后TCP会主动探测空闲连接的有效性，默认间隔为两小时。

ChannelOption.TCP_NODELAY

该设置如果为true表示立即发送数据，如果要求实时性，有数据发送时立马发送，就设置为true（关闭Nagle算法）；如果减少发送次数、减少网络交互，就设置为false（开启Nagle算法），当累积到一定大小的数据后在发送。

Nagle算法将小的碎片数据连接成更大的报文（或数据包）来最小化发送报文的数量，如果想要发送一些较小的报文，则需要禁用该算法。

ChildOption和ChildHandler

这两个是给workerGroup进行设置的，而Option和Handler是给bossGroup进行设置的。

当有一个新客户端连接到来的时候bossGroup就会为此连接初始化各种资源，然后从workerGroup中选出一个EventLoop绑定到此客户端连接中。服务端和客户端的交互过程就全在这个EventLoop中完成。

NettyClient类

public class NettyClient implements RpcClient {
    private static final Logger logger = LoggerFactory.getLogger(NettyClient.class);

    private String host;
    private int port;
    private static final Bootstrap bootstrap;

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

    /**
     * 静态代码块，首先设置好启动器的基本配置，并且只调用一次。
     */
    static {
        NioEventLoopGroup group = new NioEventLoopGroup();
        bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                        pipeline.addLast(new CommonDecoder());
                        pipeline.addLast(new CommonEncoder(new JsonSerializer()));
                        pipeline.addLast(new NettyClientHandler());
                    }
                })
                .option(ChannelOption.SO_KEEPALIVE, true);
    }

    /**
     * 将rpcRequest发送给服务端并接收到返回的相应结果
     *
     * @param rpcRequest
     * @return
     */
    @Override
    public Object sendRequest(RpcRequest rpcRequest) {
        try {
            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("发送消息时有错误发生：", future.cause());
                    }
                });
                channel.closeFuture().sync();
                // 这里通过获取到key 的方式获取到返回结果。
                AttributeKey<RpcResponse> key = AttributeKey.valueOf("rpcResponse");
                RpcResponse rpcResponse = channel.attr(key).get();
                return rpcResponse.getData();
            }
        } catch (InterruptedException e) {
            logger.error("发送消息时有错误发生：", e);
        }
        return null;
    }
}

自定义协议

在服务端和客户端的队列中都添加了一个自定义的编码器、解码器和处理器。

因为自定义了传输协议，因此需要自定义编码解码器

/* CommonEncoder就是将request或者response包装成协议包
* 协议分为五个部分：
* magicNumber表示这是一个协议包
* packageType表示这是一个请求还是响应
* SerializerType表示序列化的协议类型
* DataLength表示实际数据的长度，防止粘包
* 最后为数据部分
* +---------------+---------------+-----------------+-------------+
* |  Magic Number |  Package Type | Serializer Type | Data Length |
* |    4 bytes    |    4 bytes    |     4 bytes     |   4 bytes   |
* +---------------+---------------+-----------------+-------------+
* |                          Data Bytes                           |
* |                   Length: ${Data Length}                      |
* +---------------------------------------------------------------+
 /

CommonDecoder需要实现ByteToMessageDecoder，同时实现decode方法

CommonIncoder需要实现MessageToByteEncoder，同时实现encode方法

CommonDecoder

public class CommonDecoder extends ReplayingDecoder {

    private static final Logger logger = LoggerFactory.getLogger(CommonDecoder.class);

    private static final int MAGIC_NUMBER = 0xCAFEBABE;

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        // 首先读取第一部分判断是否是协议包
        int magic = in.readInt();
        if (magic != MAGIC_NUMBER) {
            logger.error("不识别的协议包：{}", magic);
            throw new RpcException(RpcError.UNKNOW_PROROCOL);
        }
        // 接着读取数据类型部分
        int packageCode = in.readInt();
        Class<?> packageClass;
        if (packageCode == PackageType.REQUEST_PACK.getCode()) {
            packageClass = RpcRequest.class;
        } else if (packageCode == PackageType.RESPONSE_PACK.getCode()) {
            packageClass = RpcResponse.class;
        } else {
            logger.error("不识别的数据包：{}", packageCode);
            throw new RpcException(RpcError.UNKNOWN_PACKAGE_TYPE);
        }
        // 读取序列化协议部分
        int serializerCode = in.readInt();
        CommonSerializer serializer = CommonSerializer.getByte(serializerCode);
        if (serializer == null) {
            logger.error("不识别的反序列化器：{}", serializerCode);
            throw new RpcException(RpcError.UNKNOWN_SERIALIZER);
        }
        // 读取数据长度
        int length = in.readInt();
        byte[] bytes = new byte[length];
        // 读取数据
        in.readBytes(bytes);
        // 反序列化数据
        Object obj = serializer.deserialize(bytes, packageClass);
        out.add(obj);

    }
}

CommonEncoder

public class CommonEncoder extends MessageToByteEncoder {

    private static final int MAGIC_NUMBER = 0xCAFEBABE;

    private final CommonSerializer serializer;

    public CommonEncoder(CommonSerializer serializer) {
        this.serializer = serializer;
    }

    @Override
    protected void encode(ChannelHandlerContext channelHandlerContext, Object o, ByteBuf byteBuf) throws Exception {
        // 第一部分
        byteBuf.writeInt(MAGIC_NUMBER);
        // 写入第二部分
        if (o instanceof RpcRequest) {
            byteBuf.writeInt(PackageType.REQUEST_PACK.getCode());
        } else {
            byteBuf.writeInt(PackageType.RESPONSE_PACK.getCode());
        }
        // 写入第三部分
        byteBuf.writeInt(serializer.getCode());
        byte[] bytes = this.serializer.serializer(o);
        // 写入数据的长度
        byteBuf.writeInt(bytes.length);
        // 写入数据
        byteBuf.writeBytes(bytes);
    }
}

处理器

服务端处理器

public class NettyServerHander extends SimpleChannelInboundHandler<RpcRequest> {

    private static final Logger logger = LoggerFactory.getLogger(NettyServerHander.class);

    private static RequestHandler requestHandler;

    private static RpcRegistry rpcRegistry;

    static {
        requestHandler = new RequestHandler();
        rpcRegistry = new DefaultRpcRegistry();
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcRequest msg) throws Exception {
        try {
            logger.info("服务器接收到请求：{}", msg);
            String interfaceName = msg.getInterfaceName();
            Object service = rpcRegistry.getService(interfaceName);
            Object result = requestHandler.handle(msg, service);
            ChannelFuture future = ctx.writeAndFlush(result);
            future.addListener(ChannelFutureListener.CLOSE);
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        logger.error("处理过程调用时有错误发生：");
        cause.printStackTrace();
        ctx.close();
    }
}

客户端处理器

public class NettyClientHandler extends SimpleChannelInboundHandler<RpcResponse> {
    private static final Logger logger = LoggerFactory.getLogger(NettyClientHandler.class);

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, RpcResponse msg) throws Exception {
        try {
            logger.info("客户端接收到消息：{}", msg);
            AttributeKey<RpcResponse> key = AttributeKey.valueOf("rpcResponse");
            ctx.channel().attr(key).set(msg);
            ctx.channel().close();
        } finally {
            ReferenceCountUtil.release(msg);
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        logger.error("过程调用时有错误发生：");
        cause.printStackTrace();
        ctx.close();
    }
}

序列化接口

CommonSerializer

public interface CommonSerializer {

    byte[] serializer(Object object);

    Object deserialize(byte[] bytes, Class<?> clazz) throws Exception;

    int getCode();

    static CommonSerializer getByte(int code) {
        switch (code) {
            case 1:
                return new JsonSerializer();
            default:
                return null;
        }
    }

}

实现了JSON的序列化器，序列化器使用的是jackson

public class JsonSerializer implements CommonSerializer {

    private static final Logger logger = LoggerFactory.getLogger(JsonSerializer.class);

    private ObjectMapper objectMapper = new ObjectMapper();

    /**
     * 序列化
     *
     * @param object
     * @return
     */
    @Override
    public byte[] serializer(Object object) {
        try {
            // 将Object值序列化为字节数组
            return objectMapper.writeValueAsBytes(object);
        } catch (JsonProcessingException e) {
            logger.error("序列化时有错误发生：{}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 反序列化
     *
     * @param bytes
     * @param clazz
     * @return
     */
    @Override
    public Object deserialize(byte[] bytes, Class<?> clazz) {
        try {
            // 根据clazz将bytes反序列换为对应的实例，还需要判断反序列化后实例类型是否正确
            // 因为RepRequest中有一个Object的数据，进行反序列时可能会失败，
            Object obj = objectMapper.readValue(bytes, clazz);
            if (obj instanceof RpcRequest) {
                obj = handleRequest(obj);
            }
            return obj;
        } catch (IOException e) {
            logger.error("反序列化时有错误发生：{}", e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 由于使用JSON序列化和反序列化Object数组，无法保证反序列化后仍然为原实例类型
     * 需要重新判断
     *
     * @param obj
     * @return
     * @throws Exception
     */
    private Object handleRequest(Object obj) throws IOException {
        RpcRequest rpcRequest = (RpcRequest) obj;
        for (int i = 0; i < rpcRequest.getParamTypes().length; i++) {
            Class<?> clazz = rpcRequest.getParamTypes()[i];
            // 确定此Class对象表示的类或接口是否与指定的Class参数表示的类或接口相同，
            // 或者是其超类或超接口。 如果是，则返回true ； 否则返回false 。
            if (!clazz.isAssignableFrom(rpcRequest.getParameters()[i].getClass())) {
                // 如果不对应，则将这个参数重新反序列化为对应的参数类型。
                byte[] bytes = objectMapper.writeValueAsBytes(rpcRequest.getParameters()[i]);
                rpcRequest.getParameters()[i] = objectMapper.readValue(bytes, clazz);
            }
        }
        return rpcRequest;
    }

    @Override
    public int getCode() {
        return SerializerCode.valueOf("JSON").getCode();
    }
}

使用JSON序列化器无法保证反序列化后仍然为原实例类型，因此后面会增加性能更好的序列化器。

在RPCRequest中有一个字段是Object数组，是一个模糊的类型，在反序列化时会出现失败的现象，所以就需要另一个字段ParamTypes来获取Object数组中的每个实例的实际类，辅助反序列化，也就是handleRequet（）方法的作用。