Netty2

Netty2

Netty入站与出站机制

基本说明：
1）netty的组件设计：Netty的主要组件有Channel，EventLoop，ChannelFuture，ChannelHandler，ChannelPipe等。
2）ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现 ChannelInboundHandler 接口（或 ChannelInboundHandlerAdapter），你就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，也可以从 ChannelInboundHandler 冲刷数据。业务逻辑通常卸载一个或者多个 ChannelInboundHandler 中。ChannelOutboundHandler 原理一样，只不过它是用来处理出站数据的。
3）ChannelPipeline 提供了 ChannelHandler 链的容器。以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送服务端的数据会通过 pipeline 中的一系列 ChannelOutboundHandler，并被这些 Handler 处理，反之则称为入站的。

编码解码器
1）当 Netty 发送或者接收一个消息的时候，就将会发生一次数据转换。入站消息会被解码：从字节转换为另一种格式（比如 java 对象）；如果是出站消息，它会被编码成字节。
2）Netty 提供一系列实用的编解码器，他们都实现了 ChannelInboundHandler 或者 ChannelOutboundHandler 接口。在这些类中，channelRead 方法已经被重写了。已入站为例，对于每个从入站 Channel 读取的消息，这个方法会被调用。随后，它将调用由解码器所提供的 decode() 方法进行解码，并将已经解码的字节转发给 ChannelPipeline 中的下一个 ChannelInboundHandler。

解码器ByteToMessageDecoder
1）关系继承图，如下图：

2）由于不可能知道远程节点是否会一次性发送一个完整的信息，tcp有可能出现粘包拆包的问题，这个类会对入站数据进行缓冲，直到它准备好被处理。
3）关于ByteToMessageDecoder实例分析

public class ToIntegerDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if(in.readableBytes() >= 4){
            out.add(in.readInt());
        }
    }
}

注意ByteToMessageDecoder是一个解码器，除了这个解码器，还有一个编码器叫做MessageToByteEncoder。

实例说明：

• 这个例子，每次入站从 ByteBuf 读取4字节，将其解码为一个 int，然后将它添加到下一个 List 中。当没有更多元素可以被添加到该 List 中，它的内容将会发送给下一个 ChannelInboundHandler。int 在被添加到 List 中时，会被自动装箱为 Integer。在调用 readInt() 方法前必须验证所输入的 ByteBuf 是否具有足够的数据。
• decode执行分析图。

Netty的handler链的调用机制

要求：使用自定义的编码器和解码器来说明Netty的handler调用机制。
客户端发送long -> 服务器
服务端发送long->客户端

结果：数据在客户端和服务端之间传输的时候是通过二进制文件的形式传输的。客户端会先调用它的业务处理ClientHandler，然后会调用编码器Handler，接着把数据传输到Socket中，再由Socket把数据传输到服务器中；服务器接收到Socket中的数据之后，会先调用解码器Handler进行解码，然后调用它自己的ServerHandler进行业务处理，接着会把数据返回给客户端，会把这些数据编码，因此会执行编码器Handler，然后把数据传输到Scoket里面，再通过Scoket把数据传输给客户端，客户端拿到数据之后先解码，先调用解码处理器进行解码，然后再调用ClientHandler处理器进行客户端业务处理。整体流程图如下图：

编码器和解码器代码如下：

/**
 * @author xuan
 * @create 2023/9/19
 * 编码器
 */
public class MyLongToByteEncoder extends MessageToByteEncoder<Long> {
    @Override
    protected void encode(ChannelHandlerContext ctx, Long msg, ByteBuf out) throws Exception {
        System.out.println("MyLongToByteEncoder 的 encode()方法被调用");
        System.out.println("msg = " + msg);
        out.writeLong(msg);
    }
}


/**
 * @author xuan
 * @create 2023/9/19
 * 解码器
 */
public class MyByteToLongDecoder extends ByteToMessageDecoder {
    /**
     * decode 会根据接收的数据，被调用多次，知道确定没有新的元素被添加到list，或者是Bytebuf 没有更多的可读字节为止
     * 如果 list out 不为空，就会将list的内容传递给下一个 channelInboundHandler 处理，该处理器的方法也会被调用多次
     *
     * @param ctx 上下文
     * @param in 入站的 ByteBuf
     * @param out List 集合，将解码后的数据传给下一个 handler 处理
     * @throws Exception
     */
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        System.out.println("MyByteToLongDecoder 的 decode()方法被调用");
        // 因为 long 是 8 个字节，需要判断有 8 个字节，才能读取一个 long
        if(in.readableBytes() >= 8){
            out.add(in.readLong());
        }
    }
}

服务端代码如下：

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyServer {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
        NioEventLoopGroup workerGroup = new NioEventLoopGroup(8);

        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new MyServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();

        }finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

}

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyServerInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        // 入站的 handler 进行解码
        pipeline.addLast(new MyByteToLongDecoder());
        pipeline.addLast(new MyLongToByteEncoder());
        pipeline.addLast(new MyServerHandler());
    }
}

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyServerHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("从客户端" + ctx.channel().remoteAddress() + "读取到的数据到long " + msg);

        // 给客户端发送一个 long
        ctx.writeAndFlush(123L);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

客户端代码如下：

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyClient {
    public static void main(String[] args) throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new MyClientInitializer());

            ChannelFuture channelFuture = bootstrap.connect("localhost", 8080).sync();
            channelFuture.channel().closeFuture().sync();

        }finally {
            group.shutdownGracefully();
        }
    }
}

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyClientInitializer extends ChannelInitializer<SocketChannel> {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        //加入一个出站的handler，对数据进行一个编码
        pipeline.addLast(new MyLongToByteEncoder());
        pipeline.addLast(new MyByteToLongDecoder());
        //加入一个自定义的handler，处理业务逻辑
        pipeline.addLast(new MyClientHandler());
    }
}

/**
 * @author xuan
 * @create 2023/9/19
 */
public class MyClientHandler extends SimpleChannelInboundHandler<Long> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Long msg) throws Exception {
        System.out.println("服务器的ip=" + ctx.channel().remoteAddress());
        System.out.println("服务器回送的消息：" + msg );
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        System.out.println("MyClientHandler 发送数据");
        ctx.writeAndFlush(123456L);

        // 分析
        // 1. "abcdabcdabcdabcd" 是16个字节
        // 2. 该处理器的前一个 handler 是 MyLongToByteEncoder
        // 3. MyLongToByteEncoder 父类是 MessageToByteEncoder
        // 4. 父类 MessageToByteEncoder 中 acceptOutboundMessage(msg) 会判断当前 msg 是不是应该处理的类型，如果是就处理，不是就跳过
        // 5. 编写 Encoder 时要注意传入的数据类型和处理的数据类型需要一致
//        ctx.writeAndFlush(Unpooled.copiedBuffer("abcdabcdabcdabcd", CharsetUtil.UTF_8));
    }
}

几个要点说明，如下图：

编码的时候直接把Long类型数据写入即可，会自动的转换为byte二进制类型，如下图：