Netty 从入门到入土（史诗级教程）

ChannelHandler 是 Netty 中用于处理 Channel 上事件的处理器。它可以对数据进行编解码、业务逻辑处理等操作。Netty 提供了多种类型的 ChannelHandler，如 ChannelInboundHandler 用于处理入站事件，ChannelOutboundHandler 用于处理出站事件。

2.5 ChannelPipeline

ChannelPipeline 是一个 ChannelHandler 的链表，它负责管理和执行 Channel 上的所有处理器。当一个事件发生时，会按照 ChannelPipeline 中处理器的顺序依次调用，从而完成数据的处理和转换。

三、Netty 的线程模型

3.1 单线程模型

单线程模型中，所有的 I/O 操作和业务逻辑处理都由一个线程完成。这种模型适用于处理少量连接的场景，因为单线程无法充分利用多核 CPU 的资源。

3.2 多线程模型

多线程模型中，有一个专门的线程负责接受客户端的连接，而连接建立后的 I/O 操作和业务逻辑处理则由多个线程完成。这种模型可以充分利用多核 CPU 的资源，但线程之间的切换会带来一定的性能开销。

3.3 主从多线程模型

主从多线程模型是 Netty 默认的线程模型，它由一个主 EventLoopGroup 负责接受客户端的连接，然后将连接分配给从 EventLoopGroup 进行处理。主 EventLoopGroup 和从 EventLoopGroup 都可以包含多个 EventLoop，从而实现了高并发处理。

四、Netty 的编解码器

4.1 为什么需要编解码器

在网络通信中，数据需要在不同的节点之间传输，而不同的节点可能使用不同的数据格式。因此，需要对数据进行编码和解码，将数据转换为适合网络传输的格式，以及将接收到的数据转换为应用程序可以处理的格式。例如，应用程序中使用的是 Java 对象，而网络传输只能处理字节流，这时就需要将 Java 对象编码为字节流进行传输，在接收端再将字节流解码为 Java 对象。

4.2 Netty 提供的编解码器

4.2.1 ByteToMessageDecoder

ByteToMessageDecoder 是一个抽象类，用于将字节流解码为消息对象。它会不断地从输入的 ByteBuf 中读取数据，直到可以解码出一个完整的消息对象。开发者需要继承这个类，并重写 decode 方法来实现具体的解码逻辑。

以下是一个简单的示例，将字节流解码为字符串：

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import java.nio.charset.StandardCharsets;
import java.util.List;

public class StringDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in.readableBytes() >= 4) {
            int length = in.readInt();
            if (in.readableBytes() >= length) {
                byte[] bytes = new byte[length];
                in.readBytes(bytes);
                String message = new String(bytes, StandardCharsets.UTF_8);
                out.add(message);
            }
        }
    }
}

4.2.2 MessageToByteEncoder

MessageToByteEncoder 是一个抽象类，用于将消息对象编码为字节流。开发者需要继承这个类，并重写 encode 方法来实现具体的编码逻辑。

以下是一个将字符串编码为字节流的示例：

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
import java.nio.charset.StandardCharsets;

public class StringEncoder extends MessageToByteEncoder<String> {
    @Override
    protected void encode(ChannelHandlerContext ctx, String msg, ByteBuf out) throws Exception {
        byte[] bytes = msg.getBytes(StandardCharsets.UTF_8);
        out.writeInt(bytes.length);
        out.writeBytes(bytes);
    }
}

4.2.3 LengthFieldBasedFrameDecoder

在网络通信中，由于 TCP 协议的特性，会出现粘包和拆包问题。LengthFieldBasedFrameDecoder 是 Netty 提供的一个基于长度字段的解码器，用于解决粘包和拆包问题。它通过在消息中添加一个长度字段，来确定一个完整消息的边界。

以下是一个使用 LengthFieldBasedFrameDecoder 的示例：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
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;

public class NettyServerWithLengthFieldDecoder {

    private final int port;

    public NettyServerWithLengthFieldDecoder(int port) {
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
              .channel(NioServerSocketChannel.class)
              .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 4, 0, 4));
                        ch.pipeline().addLast(new StringDecoder());
                        ch.pipeline().addLast(new NettyServerHandler());
                    }
                })
              .option(ChannelOption.SO_BACKLOG, 128)
              .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new NettyServerWithLengthFieldDecoder(port).run();
    }
}

4.2.4 ProtobufEncoder 和 ProtobufDecoder

Google Protocol Buffers 是一种高效的序列化协议，Netty 提供了 ProtobufEncoder 和 ProtobufDecoder 来处理 Protobuf 格式的数据。使用这两个编解码器可以方便地将 Protobuf 消息对象进行编码和解码。

以下是一个使用 Protobuf 编解码器的示例：

import com.google.protobuf.MessageLite;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.protobuf.ProtobufDecoder;
import io.netty.handler.codec.protobuf.ProtobufEncoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import io.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;

public class NettyServerWithProtobuf {

    private final int port;

    public NettyServerWithProtobuf(int port) {
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
              .channel(NioServerSocketChannel.class)
              .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new ProtobufVarint32FrameDecoder());
                        ch.pipeline().addLast(new ProtobufDecoder(YourProtobufMessage.getDefaultInstance()));
                        ch.pipeline().addLast(new ProtobufVarint32LengthFieldPrepender());
                        ch.pipeline().addLast(new ProtobufEncoder());
                        ch.pipeline().addLast(new NettyServerProtobufHandler());
                    }
                })
              .option(ChannelOption.SO_BACKLOG, 128)
              .childOption(ChannelOption.SO_KEEPALIVE, true);

            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new NettyServerWithProtobuf(port).run();
    }
}

4.3 自定义编解码器

在某些情况下，Netty 提供的编解码器可能无法满足需求，这时可以自定义编解码器。自定义编解码器需要继承 ByteToMessageDecoder 或 MessageToByteEncoder 等相关类，并实现相应的方法。

五、Netty 的应用示例

5.1 简单的 TCP 服务器示例

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {

    private final int port;

    public NettyServer(int port) {
        this.port = port;
    }

    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(); // 主 EventLoopGroup
        EventLoopGroup workerGroup = new NioEventLoopGroup(); // 从 EventLoopGroup
        try {
            ServerBootstrap b = new ServerBootstrap(); // 服务器启动辅助类
            b.group(bossGroup, workerGroup)
              .channel(NioServerSocketChannel.class) // 指定使用 NIO 传输通道
              .childHandler(new ChannelInitializer<SocketChannel>() { // 为每个新连接创建一个 ChannelPipeline
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new NettyServerHandler());
                    }
                })
              .option(ChannelOption.SO_BACKLOG, 128)          // 设置服务器的连接队列大小
              .childOption(ChannelOption.SO_KEEPALIVE, true); // 设置连接的保持活动状态

            // 绑定端口，开始接收连接
            ChannelFuture f = b.bind(port).sync();

            // 等待服务器关闭
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        new NettyServer(port).run();
    }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import java.nio.charset.StandardCharsets;

public class NettyServerHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf in = (ByteBuf) msg;
        String request = in.toString(StandardCharsets.UTF_8);
        System.out.println("Received from client: " + request);

        // 发送响应
        String response = "Hello, client! I received your message: " + request;
        ByteBuf resp = Unpooled.copiedBuffer(response, StandardCharsets.UTF_8);
        ctx.writeAndFlush(resp);
    }

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

5.2 示例代码解释

NettyServer 类：负责启动服务器，配置 EventLoopGroup、ServerBootstrap 等组件，并绑定端口开始接收连接。
NettyServerHandler 类：继承自 ChannelInboundHandlerAdapter，用于处理客户端发送的消息。在 channelRead 方法中，读取客户端发送的消息，并发送响应给客户端。在 exceptionCaught 方法中，处理异常并关闭连接。