Netty 编解码器

在 Netty 中，编解码器（Codec）组合了编码器和解码器的功能，用于将业务对象与字节数据之间进行双向转换。通过使用编解码器，开发者可以在同一个类中同时处理编码和解码逻辑，从而简化代码和管理。Netty 提供了一个方便的抽象类 MessageToMessageCodec，用于实现自定义的编解码器。

MessageToMessageCodec 简介

MessageToMessageCodec 是一个抽象类，用于将消息类型 I 编码为消息类型 O，以及将消息类型 O 解码为消息类型 I。它要求开发者实现两个抽象方法：

• encode(ChannelHandlerContext ctx, I msg, List<Object> out): 编码方法，将消息 I 编码为 O。
• decode(ChannelHandlerContext ctx, O msg, List<Object> out): 解码方法，将消息 O 解码为 I。

使用 MessageToMessageCodec

假设我们有一个简单的协议，协议格式为：消息头（4字节表示消息长度）+ 消息体（字符串）。我们可以创建一个自定义的编解码器来处理这种协议。

自定义编解码器示例

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageCodec;

import java.nio.charset.Charset;
import java.util.List;

public class CustomCodec extends MessageToMessageCodec<ByteBuf, String> {
    @Override
    protected void encode(ChannelHandlerContext ctx, String msg, List<Object> out) throws Exception {
        byte[] bytes = msg.getBytes(Charset.forName("UTF-8")); // 将字符串编码为字节数组
        int length = bytes.length; // 获取字节数组长度
        
        ByteBuf buffer = ctx.alloc().buffer(4 + length); // 分配一个新的 ByteBuf
        buffer.writeInt(length); // 写入消息长度
        buffer.writeBytes(bytes); // 写入消息体
        
        out.add(buffer); // 将编码后的 ByteBuf 添加到输出列表
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
        if (msg.readableBytes() < 4) {
            return; // 消息头长度不足，等待更多数据
        }

        msg.markReaderIndex(); // 标记当前读指针位置
        
        int length = msg.readInt(); // 读取消息长度
        
        if (msg.readableBytes() < length) {
            msg.resetReaderIndex(); // 消息体长度不足，恢复读指针位置，等待更多数据
            return;
        }

        ByteBuf buf = msg.readBytes(length); // 读取消息体
        String message = buf.toString(Charset.forName("UTF-8")); // 解码为字符串
        
        out.add(message); // 将解码后的字符串添加到输出列表
    }
}

使用示例

以下是一个使用自定义编解码器的 Netty 服务器示例：

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();

        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<Channel>() {
                        @Override
                        protected void initChannel(Channel ch) throws Exception {
                            ch.pipeline().addLast(new CustomCodec());
                            ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
                                    System.out.println("Received: " + msg);
                                    ctx.writeAndFlush("Hello, client!");
                                }
                            });
                        }
                    });

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

在这个示例中，CustomCodec 用于将字符串消息编码为字节数据，并将接收到的字节数据解码为字符串。服务器使用 ServerBootstrap 启动，并在管道中添加了 CustomCodec 编解码器和业务处理器。

总结

Netty 的编解码器提供了一种简洁而高效的方式来处理网络数据的编解码操作。通过使用 MessageToMessageCodec，开发者可以将编码和解码逻辑合并到一个类中，简化代码管理。Netty 提供了丰富的内置编码器和解码器，同时也允许自定义实现，以满足各种协议和应用场景的需求。