public class HelloWorldServer {
    static final Logger log = LoggerFactory.getLogger(HelloWorldServer.class);
    void start() {
        NioEventLoopGroup boss = new NioEventLoopGroup(1);
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("connected {}", ctx.channel());
                            super.channelActive(ctx);
                        }

                        @Override
                        public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("disconnect {}", ctx.channel());
                            super.channelInactive(ctx);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080);
            log.debug("{} binding...", channelFuture.channel());
            channelFuture.sync();
            log.debug("{} bound...", channelFuture.channel());
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            log.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
            log.debug("stoped");
        }
    }

    public static void main(String[] args) {
        new HelloWorldServer().start();
    }
}

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);
    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            Random r = new Random();
                            char c = 'a';
                            for (int i = 0; i < 10; i++) {
                                ByteBuf buffer = ctx.alloc().buffer();
                                buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                                ctx.writeAndFlush(buffer);
                            }
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 8080).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

ByteBuf buffer = ctx.alloc().buffer();
for (int i = 0; i < 10; i++) {
    buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
}
ctx.writeAndFlush(buffer);

serverBootstrap.option(ChannelOption.SO_RCVBUF, 10);

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);

    public static void main(String[] args) {
        // 分 10 次发送
        for (int i = 0; i < 10; i++) {
            send();
        }
    }

    private static void send() {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    log.debug("conneted...");
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            ByteBuf buffer = ctx.alloc().buffer();
                            buffer.writeBytes(new byte[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15});
                            ctx.writeAndFlush(buffer);
                            // 发完即关
                            ctx.close();
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 8080).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

ch.pipeline().addLast(new FixedLengthFrameDecoder(8));

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);

    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            // 发送内容随机的数据包
                            Random r = new Random();
                            char c = 'a';
                            ByteBuf buffer = ctx.alloc().buffer();
                            for (int i = 0; i < 10; i++) {
                                byte[] bytes = new byte[8];
                                for (int j = 0; j < r.nextInt(8); j++) {
                                    bytes[j] = (byte) c;
                                }
                                c++;
                                buffer.writeBytes(bytes);
                            }
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("192.168.0.103", 9090).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

ch.pipeline().addLast(new LineBasedFrameDecoder(1024));

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);

    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            Random r = new Random();
                            char c = 'a';
                            ByteBuf buffer = ctx.alloc().buffer();
                            for (int i = 0; i < 10; i++) {
                                for (int j = 1; j <= r.nextInt(16)+1; j++) {
                                    buffer.writeByte((byte) c);
                                }
                                buffer.writeByte(10);
                                c++;
                            }
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("192.168.0.103", 9090).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

// 最大长度，长度偏移，长度占用字节，长度调整，剥离字节数
ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(1024, 0, 1, 0, 1));

public class HelloWorldClient {
    static final Logger log = LoggerFactory.getLogger(HelloWorldClient.class);

    public static void main(String[] args) {
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    log.debug("connetted...");
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) throws Exception {
                            log.debug("sending...");
                            Random r = new Random();
                            char c = 'a';
                            ByteBuf buffer = ctx.alloc().buffer();
                            for (int i = 0; i < 10; i++) {
                                byte length = (byte) (r.nextInt(16) + 1);
                                // 先写入长度
                                buffer.writeByte(length);
                                // 再
                                for (int j = 1; j <= length; j++) {
                                    buffer.writeByte((byte) c);
                                }
                                c++;
                            }
                            ctx.writeAndFlush(buffer);
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("192.168.0.103", 9090).sync();
            channelFuture.channel().closeFuture().sync();

        } catch (InterruptedException e) {
            log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

@Slf4j
public class TestRedis {
    /*
    set name Ray
    *3
    $3
    set
    $4
    name
    $3
    Ray
     */
    public static void main(String[] args) {
        final byte[] LINE = {13, 10}; // 13 回车 \r 10 换行 \n
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.group(worker);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) {
                    ch.pipeline().addLast(new LoggingHandler());
                    ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        // 连接建立，向 Redis 发送命令
                        @Override
                        public void channelActive(ChannelHandlerContext ctx) {
                            ByteBuf buf = ctx.alloc().buffer();
                            buf.writeBytes("*3".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("$3".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("set".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("$4".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("name".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("$3".getBytes());
                            buf.writeBytes(LINE);
                            buf.writeBytes("Ray".getBytes());
                            buf.writeBytes(LINE);
                            ctx.writeAndFlush(buf);
                        }

                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            ByteBuf buf = (ByteBuf) msg;
                            System.out.println(buf.toString(Charset.defaultCharset()));
                        }
                    });
                }
            });
            ChannelFuture channelFuture = bootstrap.connect("localhost", 6379).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            // log.error("client error", e);
        } finally {
            worker.shutdownGracefully();
        }
    }
}

package com.netty.demo04.c2;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import lombok.extern.java.Log;
import lombok.extern.slf4j.Slf4j;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH;

/**
 * @author Ray
 * @date 2023/7/13 16:54
 * @description
 */
public class TestHttp {

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

    public static void main(String[] args) {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss, worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel ch) throws Exception {
                    ch.pipeline().addLast(new LoggingHandler(LogLevel.DEBUG));
                    ch.pipeline().addLast(new HttpServerCodec());
                    // SimpleChannelInboundHandler<HttpRequest>()
                    // 只专注与对 HttpRequest 数据的处理
                    // 其它类型数据直接跳过该处理器
                    ch.pipeline().addLast(new SimpleChannelInboundHandler<HttpRequest>() {
                        @Override
                        protected void channelRead0(ChannelHandlerContext ctx, HttpRequest msg) throws Exception {
                            // 获取请求
                            logger.debug(msg.uri());

                            // 返回响应
                            DefaultFullHttpResponse response =
                                    new DefaultFullHttpResponse(msg.protocolVersion(), HttpResponseStatus.OK);

                            byte[] bytes = "<h1>Hello, world!</h1>".getBytes();

                            // 添加响应头，告诉浏览器已经响应完成。
                            response.headers().setInt(CONTENT_LENGTH, bytes.length);
                            response.content().writeBytes(bytes);

                            // 写回响应
                            ctx.writeAndFlush(response);
                        }
                    });
                    /*ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                        @Override
                        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                            log.debug("{}", msg.getClass());

                            if (msg instanceof HttpRequest) { // 请求行，请求头

                            } else if (msg instanceof HttpContent) { //请求体

                            }
                        }
                    });*/
                }
            });
            ChannelFuture channelFuture = serverBootstrap.bind(8080).sync();
            channelFuture.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            logger.error("server error", e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }
}
17:00:07.031 [nioEventLoopGroup-3-1] DEBUG io.netty.handler.logging.LoggingHandler - [id: 0xb21cda91, L:/[0:0:0:0:0:0:0:1]:8080 - R:/[0:0:0:0:0:0:0:1]:62041] READ: 747B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 47 45 54 20 2f 20 48 54 54 50 2f 31 2e 31 0d 0a |GET / HTTP/1.1..|
|00000010| 48 6f 73 74 3a 20 6c 6f 63 61 6c 68 6f 73 74 3a |Host: localhost:|
|00000020| 38 30 38 30 0d 0a 43 6f 6e 6e 65 63 74 69 6f 6e |8080..Connection|
|00000030| 3a 20 6b 65 65 70 2d 61 6c 69 76 65 0d 0a 43 61 |: keep-alive..Ca|
|00000040| 63 68 65 2d 43 6f 6e 74 72 6f 6c 3a 20 6d 61 78 |che-Control: max|
|00000050| 2d 61 67 65 3d 30 0d 0a 73 65 63 2d 63 68 2d 75 |-age=0..sec-ch-u|
|00000060| 61 3a 20 22 4e 6f 74 2e 41 2f 42 72 61 6e 64 22 |a: "Not.A/Brand"|
|00000070| 3b 76 3d 22 38 22 2c 20 22 43 68 72 6f 6d 69 75 |;v="8", "Chromiu|
|00000080| 6d 22 3b 76 3d 22 31 31 34 22 2c 20 22 47 6f 6f |m";v="114", "Goo|
|00000090| 67 6c 65 20 43 68 72 6f 6d 65 22 3b 76 3d 22 31 |gle Chrome";v="1|
|000000a0| 31 34 22 0d 0a 73 65 63 2d 63 68 2d 75 61 2d 6d |14"..sec-ch-ua-m|
|000000b0| 6f 62 69 6c 65 3a 20 3f 30 0d 0a 73 65 63 2d 63 |obile: ?0..sec-c|
|000000c0| 68 2d 75 61 2d 70 6c 61 74 66 6f 72 6d 3a 20 22 |h-ua-platform: "|
|000000d0| 6d 61 63 4f 53 22 0d 0a 55 70 67 72 61 64 65 2d |macOS"..Upgrade-|
|000000e0| 49 6e 73 65 63 75 72 65 2d 52 65 71 75 65 73 74 |Insecure-Request|
|000000f0| 73 3a 20 31 0d 0a 55 73 65 72 2d 41 67 65 6e 74 |s: 1..User-Agent|
|00000100| 3a 20 4d 6f 7a 69 6c 6c 61 2f 35 2e 30 20 28 4d |: Mozilla/5.0 (M|
|00000110| 61 63 69 6e 74 6f 73 68 3b 20 49 6e 74 65 6c 20 |acintosh; Intel |
|00000120| 4d 61 63 20 4f 53 20 58 20 31 30 5f 31 35 5f 37 |Mac OS X 10_15_7|
|00000130| 29 20 41 70 70 6c 65 57 65 62 4b 69 74 2f 35 33 |) AppleWebKit/53|
|00000140| 37 2e 33 36 20 28 4b 48 54 4d 4c 2c 20 6c 69 6b |7.36 (KHTML, lik|
|00000150| 65 20 47 65 63 6b 6f 29 20 43 68 72 6f 6d 65 2f |e Gecko) Chrome/|
|00000160| 31 31 34 2e 30 2e 30 2e 30 20 53 61 66 61 72 69 |114.0.0.0 Safari|
|00000170| 2f 35 33 37 2e 33 36 0d 0a 41 63 63 65 70 74 3a |/537.36..Accept:|
|00000180| 20 74 65 78 74 2f 68 74 6d 6c 2c 61 70 70 6c 69 | text/html,appli|
|00000190| 63 61 74 69 6f 6e 2f 78 68 74 6d 6c 2b 78 6d 6c |cation/xhtml+xml|
|000001a0| 2c 61 70 70 6c 69 63 61 74 69 6f 6e 2f 78 6d 6c |,application/xml|
|000001b0| 3b 71 3d 30 2e 39 2c 69 6d 61 67 65 2f 61 76 69 |;q=0.9,image/avi|
|000001c0| 66 2c 69 6d 61 67 65 2f 77 65 62 70 2c 69 6d 61 |f,image/webp,ima|
|000001d0| 67 65 2f 61 70 6e 67 2c 2a 2f 2a 3b 71 3d 30 2e |ge/apng,*/*;q=0.|
|000001e0| 38 2c 61 70 70 6c 69 63 61 74 69 6f 6e 2f 73 69 |8,application/si|
|000001f0| 67 6e 65 64 2d 65 78 63 68 61 6e 67 65 3b 76 3d |gned-exchange;v=|
|00000200| 62 33 3b 71 3d 30 2e 37 0d 0a 53 65 63 2d 46 65 |b3;q=0.7..Sec-Fe|
|00000210| 74 63 68 2d 53 69 74 65 3a 20 6e 6f 6e 65 0d 0a |tch-Site: none..|
|00000220| 53 65 63 2d 46 65 74 63 68 2d 4d 6f 64 65 3a 20 |Sec-Fetch-Mode: |
|00000230| 6e 61 76 69 67 61 74 65 0d 0a 53 65 63 2d 46 65 |navigate..Sec-Fe|
|00000240| 74 63 68 2d 55 73 65 72 3a 20 3f 31 0d 0a 53 65 |tch-User: ?1..Se|
|00000250| 63 2d 46 65 74 63 68 2d 44 65 73 74 3a 20 64 6f |c-Fetch-Dest: do|
|00000260| 63 75 6d 65 6e 74 0d 0a 41 63 63 65 70 74 2d 45 |cument..Accept-E|
|00000270| 6e 63 6f 64 69 6e 67 3a 20 67 7a 69 70 2c 20 64 |ncoding: gzip, d|
|00000280| 65 66 6c 61 74 65 2c 20 62 72 0d 0a 41 63 63 65 |eflate, br..Acce|
|00000290| 70 74 2d 4c 61 6e 67 75 61 67 65 3a 20 7a 68 2d |pt-Language: zh-|
|000002a0| 43 4e 2c 7a 68 3b 71 3d 30 2e 39 0d 0a 43 6f 6f |CN,zh;q=0.9..Coo|
|000002b0| 6b 69 65 3a 20 49 64 65 61 2d 63 33 63 34 64 63 |kie: Idea-c3c4dc|
|000002c0| 36 38 3d 30 38 30 31 31 36 36 36 2d 31 62 33 66 |68=08011666-1b3f|
|000002d0| 2d 34 64 38 37 2d 39 39 31 64 2d 36 66 33 65 38 |-4d87-991d-6f3e8|
|000002e0| 65 37 65 35 36 64 37 0d 0a 0d 0a                |e7e56d7....     |
+--------+-------------------------------------------------+----------------+
17:00:07.045 [nioEventLoopGroup-3-1] DEBUG com.netty.demo04.c2.TestHttp - /
17:00:07.047 [nioEventLoopGroup-3-1] DEBUG io.netty.handler.logging.LoggingHandler - [id: 0xb21cda91, L:/[0:0:0:0:0:0:0:1]:8080 - R:/[0:0:0:0:0:0:0:1]:62041] WRITE: 61B
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 54 54 50 2f 31 2e 31 20 32 30 30 20 4f 4b 0d |HTTP/1.1 200 OK.|
|00000010| 0a 63 6f 6e 74 65 6e 74 2d 6c 65 6e 67 74 68 3a |.content-length:|
|00000020| 20 32 32 0d 0a 0d 0a 3c 68 31 3e 48 65 6c 6c 6f | 22....<h1>Hello|
|00000030| 2c 20 77 6f 72 6c 64 21 3c 2f 68 31 3e          |, world!</h1>   |
+--------+-------------------------------------------------+----------------+
17:00:07.047 [nioEventLoopGroup-3-1] DEBUG io.netty.handler.logging.LoggingHandler - [id: 0xb21cda91, L:/[0:0:0:0:0:0:0:1]:8080 - R:/[0:0:0:0:0:0:0:1]:62041] FLUSH

public class MessageCodec extends ByteToMessageCodec<Message> {

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

    @Override
    public void encode(ChannelHandlerContext channelHandlerContext, Message message, ByteBuf byteBuf) throws Exception {
        // 1. 3 字节 魔数
        byteBuf.writeBytes("Ray".getBytes());
        // 2. 1 字节 版本号
        byteBuf.writeByte(1);
        // 3. 1 字节 序列化算法 jdk 0 , json 1
        byteBuf.writeByte(0);
        // 4. 1 字节 指令类型
        byteBuf.writeByte(message.getMessageType());
        // 5. 4 字节 序列号
        byteBuf.writeInt(message.getSequenceId());
        // 无意义，对齐填充
        byteBuf.writeByte(0xff);
        byteBuf.writeByte(0xff);
        // 6. 获取内容的字节数组
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(message);
        byte[] bytes = bos.toByteArray();
        // 7. 长度
        byteBuf.writeInt(bytes.length);
        // 8. 内容
        byteBuf.writeBytes(bytes);
    }

    @Override
    protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) throws Exception {
        String magicNum = byteBuf.readBytes(3).toString(StandardCharsets.UTF_8);
        byte version = byteBuf.readByte();
        byte serializerType = byteBuf.readByte();
        byte messageType = byteBuf.readByte();
        int sequenceId = byteBuf.readInt();
        byteBuf.readBytes(2);
        int length = byteBuf.readInt();
        byte[] bytes = new byte[length];
        byteBuf.readBytes(bytes,0,length);
        if (serializerType==0) {
            ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes));
            Message message = (Message) ois.readObject();
            logger.info("magicNum: {}, version: {}, serializerType: {}, messageType: {}, sequenceId: {}, contentLength: {}", magicNum, version, serializerType, messageType, sequenceId, length);
            logger.info("content: {}", message);
            list.add(message);
        }

    }
}

public class TestMessageCodec {

    public static void main(String[] args) throws Exception {
        EmbeddedChannel channel = new EmbeddedChannel(
                new LoggingHandler(LogLevel.DEBUG),
                // 确定长度字段偏移量以及帧的最大长度，避免半包问题，只有当数据长度=长度字段值才向下传递
                new LengthFieldBasedFrameDecoder(
                        1024,12,4,0,0
                ),
                new MessageCodec()
        );
        // encode
        LoginRequestMessage message = new LoginRequestMessage("Ray","123456","瑞");
        // channel.writeOutbound(message);
        // decode
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer();
        new MessageCodec().encode(null,message,buffer);

        // 入站
        // channel.writeInbound(buffer);

        ByteBuf s1 = buffer.slice(0, 100);
        ByteBuf s2 = buffer.slice(100, buffer.readableBytes() - 100);
        buffer.retain(); // 引用计数+1    2
        // 这里writeInbound 会 调用 s1.release 引用计数-1
        // 由于 slice 基于零拷贝,共用同一块内存，所以也会导致 buffer 引用计数-1
        // 也就无法使用另一块 slice s2
        // 需要在之前 buffer.retain() 将 buffer 引用计数+1
        channel.writeInbound(s1);
        channel.writeInbound(s2);
    }
}

public class ChatServer {

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

    public static void main(String[] args) {
        NioEventLoopGroup boss = new NioEventLoopGroup();
        NioEventLoopGroup worker = new NioEventLoopGroup();
        // 日志处理器
        LoggingHandler LOGGING_HANDLER = new LoggingHandler(LogLevel.DEBUG);
        // 编解码器
        MessageCodecSharable MESSAGE_CODEC = new MessageCodecSharable();
        // 登录处理器
        LoginRequestMessageHandler LOGIN_HANDLER = new LoginRequestMessageHandler();
        // 私聊处理器
        ChatRequestMessageHandler CHAT_HADNLER = new ChatRequestMessageHandler();
        // 群聊创建
        GroupCreateRequestMessageHandler GROUP_CREATE_HANDLER = new GroupCreateRequestMessageHandler();
        // 群发处理器
        GroupChatRequestMessageHandler GROUP_CHAR_HANDLER = new GroupChatRequestMessageHandler();
        // 查询群成员
        GroupMembersRequestMessageHandler GROUP_MEMBERS_HANDLER = new GroupMembersRequestMessageHandler();
        // 加入群组
        GroupJoinRequestMessageHandler GROUP_JOIN_HANDLER = new GroupJoinRequestMessageHandler();
        // 退出群组
        GroupQuitRequestMessageHandler GROUP_QUIT_HANDLER = new GroupQuitRequestMessageHandler();
        // 退出
        QuitHandler QUIT_HANDLER = new QuitHandler();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.channel(NioServerSocketChannel.class);
            serverBootstrap.group(boss,worker);
            serverBootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline()
                            .addLast(new ProtocolFrameDecoder())
                            .addLast(LOGGING_HANDLER)
                            .addLast(MESSAGE_CODEC)
                            // 用来判断 读间隔时间过长 写间隔时间过长 读写间隔时间过长
                            // 5s 内如果没有收到 channel 的数据，会触发一个 IdleState#READER_IDLE 事件
                            .addLast(new IdleStateHandler(5,0,0))
                            // ChannelDuplexHandler 可以同时作为入站和出站处理器
                            .addLast(new ChannelDuplexHandler(){
                                // 用于处理特殊事件
                                @Override
                                public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                                    if (evt instanceof IdleStateEvent event) {
                                        // 读间隔事件
                                        if (event.state()== IdleState.READER_IDLE) {
                                            System.out.println("已经5s没有读到数据。");
                                            ctx.channel().close();
                                        }
                                    }
                                }
                            })
                            .addLast(LOGIN_HANDLER)
                            .addLast(CHAT_HADNLER)
                            .addLast(GROUP_CREATE_HANDLER)
                            .addLast(GROUP_CHAR_HANDLER)
                            .addLast(GROUP_MEMBERS_HANDLER)
                            .addLast(GROUP_JOIN_HANDLER)
                            .addLast(GROUP_QUIT_HANDLER)
                            .addLast(QUIT_HANDLER);
                }
            });
            Channel channel = serverBootstrap.bind(8080).sync().channel();
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            logger.error("server error",e);
        } finally {
            boss.shutdownGracefully();
            worker.shutdownGracefully();
        }
    }

}

public class ChatClient {

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

    public static void main(String[] args) {
        NioEventLoopGroup group = new NioEventLoopGroup();
        LoggingHandler LOGGING_HANDLER = new LoggingHandler(LogLevel.DEBUG);
        MessageCodecSharable MESSAGE_CODEC = new MessageCodecSharable();
        // 计数器,不为0时 await 阻塞,调用 countDown 计数器-1，为0时放行
        CountDownLatch WAIT_FOR_LOGIN = new CountDownLatch(1);
        // 是否登录
        AtomicBoolean LOGIN = new AtomicBoolean(false);
        // 是否退出
        AtomicBoolean EXIT = new AtomicBoolean(false);
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group);
            bootstrap.channel(NioSocketChannel.class);
            bootstrap.handler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline()
                            .addLast(new ProtocolFrameDecoder())
                            .addLast(LOGGING_HANDLER)
                            .addLast(MESSAGE_CODEC)
                            // 用来判断 读间隔时间过长 写间隔时间过长 读写间隔时间过长
                            // 3s 内如果没有向服务端写入数据，会触发一个 IdleState#WRITER_IDLE 事件
                            // 不能比服务端读间隔时间长,否则服务端一段时间没有读到数据就会关闭连接
                            .addLast(new IdleStateHandler(0,3,0))
                            // ChannelDuplexHandler 可以同时作为入站和出站处理器
                            .addLast(new ChannelDuplexHandler(){
                                @Override
                                public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
                                    if (evt instanceof IdleStateEvent event) {
                                        // 写间隔时间过长，发送心跳包
                                        if (event.state() == IdleState.WRITER_IDLE) {
                                            System.out.println("3s 没有写数据了，发送一个心跳包");
                                            ctx.writeAndFlush(new PingMessage());
                                        }
                                    }
                                }
                            })
                            .addLast("client handler",new ChannelInboundHandlerAdapter(){
                                // 连接建立后触发 Active 事件
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    // 使用Nio线程，可能导致阻塞
                                    // 这里创建一个新的线程,用于用户输入,向服务端发送消息
                                    // 也是为了让 NIO 线程专心负责通信
                                    new Thread(()->{
                                        Scanner sc = new Scanner(System.in);
                                        System.out.println("请输入用户名:");
                                        String username = sc.nextLine();
                                        if(EXIT.get()){
                                            return;
                                        }
                                        System.out.println("请输入密码:");
                                        String password = sc.nextLine();
                                        if(EXIT.get()){
                                            return;
                                        }
                                        // 组装消息
                                        LoginRequestMessage message = new LoginRequestMessage(username, password);
                                        // 发送消息
                                        ctx.writeAndFlush(message);
                                        System.out.println("等待后续操作....");
                                        try {
                                            // 阻塞IO线程,直到返回登录响应
                                            WAIT_FOR_LOGIN.await();
                                        } catch (InterruptedException e) {
                                            e.printStackTrace();
                                        }
                                        // 登录失败
                                        if(!LOGIN.get()) {
                                            ctx.channel().close(); // 关闭,走closeFuture
                                            return;
                                        }
                                        while(true) {
                                            // 菜单
                                            System.out.println("==================================");
                                            System.out.println("1. send [username] [content]");
                                            System.out.println("2. send_group [group name] [content]");
                                            System.out.println("3. create_group [group name] [m1,m2,m3...]");
                                            System.out.println("4. members_group [group name]");
                                            System.out.println("5. join_group [group name]");
                                            System.out.println("6. quit_group [group name]");
                                            System.out.println("7. quit");
                                            System.out.println("==================================");
                                            String command = sc.nextLine();
                                            if(EXIT.get()){
                                                return;
                                            }
                                            // 解析命令
                                            String[] key = command.split(" ");
                                            switch (key[0]) {
                                                case "send":    // 私聊
                                                    ctx.writeAndFlush(new ChatRequestMessage(username,key[1],key[2]));
                                                    break;
                                                case "send_group":  // 群发
                                                    ctx.writeAndFlush(new GroupChatRequestMessage(username,key[1],key[2]));
                                                    break;
                                                case "create_group": // 创建群组
                                                    Set<String> members = new HashSet<>(Arrays.asList(key[2].split(",")));
                                                    members.add(username); // 成员中加入当前用户
                                                    ctx.writeAndFlush(new GroupCreateRequestMessage(key[1],members));
                                                    break;
                                                case "members_group": // 查询群组成员
                                                    ctx.writeAndFlush(new GroupMembersRequestMessage(key[1]));
                                                    break;
                                                case "join_group":  // 加入群组
                                                    ctx.writeAndFlush(new GroupJoinRequestMessage(username,key[1]));
                                                    break;
                                                case "quit_group":  // 退出群组
                                                    ctx.writeAndFlush(new GroupQuitRequestMessage(username,key[1]));
                                                    break;
                                                case "quit":    // 退出
                                                    ctx.channel().close();
                                                    return;
                                            }
                                        }
                                    },"Input").start();
                                }

                                @Override
                                public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                                    System.out.println("连接已经断开，按任意键退出..");
                                    EXIT.set(true);
                                }

                                @Override
                                public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                                    System.out.println("连接已经断开，按任意键退出..");
                                    System.out.println("exception: " + cause.getMessage());
                                    EXIT.set(true);
                                }

                                // 接收响应消息
                                @Override
                                public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
                                    // 登录响应
                                    if (msg instanceof LoginResponseMessage response) {
                                        if(response.isSuccess()) {
                                            LOGIN.set(true);
                                        }
                                        System.out.println(response.getReason());
                                        // 计数器-1 = 0,唤醒IO线程
                                        WAIT_FOR_LOGIN.countDown();
                                    }
                                    // 私聊响应
                                    if (msg instanceof ChatResponseMessage response) {
                                        if (response.isSuccess()) {
                                            System.out.println("[" + response.getFrom() + "]: " + response.getContent());
                                        } else {
                                            System.out.println(response.getReason());
                                        }
                                    }
                                    // 创建群组响应
                                    if (msg instanceof GroupCreateResponseMessage response) {
                                        System.out.println(response.getReason());
                                    }
                                    // 群聊响应
                                    if (msg instanceof GroupChatResponseMessage response) {
                                        if (response.isSuccess()) {
                                            System.out.println("【" + response.getGroupName() + "】");
                                            System.out.println("[" + response.getFrom() + "]: " + response.getContent());
                                        } else {
                                            System.out.println(response.getReason());
                                        }
                                    }
                                    // 查询群组成员响应
                                    if (msg instanceof GroupMembersResponseMessage response) {
                                        Set<String> members = response.getMembers();
                                        System.out.println("【" + response.getGroupName() + "】:");
                                        for (String member : members) {
                                            System.out.println("[" + member + "]");
                                        }
                                    }
                                    // 加入群组响应
                                    if (msg instanceof GroupJoinResponseMessage response) {
                                        if (response.isSuccess()) {
                                            Group group = response.getGroup();
                                            System.out.println("您已加入群组【" + group.getName() + "】");
                                            System.out.println("当前群组成员:");
                                            for (String member : group.getMembers()) {
                                                System.out.println("[" + member + "]");
                                            }
                                        }
                                    }
                                    // 退出群组响应
                                    if (msg instanceof GroupQuitResponseMessage response) {
                                        if (response.isSuccess()) {
                                            Group group = response.getGroup();
                                            System.out.println("您已退出群组【" + group.getName() + "】");
                                            System.out.println("当前群组成员:");
                                            for (String member : group.getMembers()) {
                                                System.out.println("[" + member + "]");
                                            }
                                        }
                                    }
                                }
                            });
                }
            });
            Channel channel = bootstrap.connect("localhost", 8080).sync().channel();
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            logger.error("client error",e);
        } finally {
            group.shutdownGracefully();
        }
    }
}

// 用来判断 读间隔时间过长 写间隔时间过长 读写间隔时间过长
// 5s 内如果没有收到 channel 的数据，会触发一个 IdleState#READER_IDLE 事件
ch.pipeline().addLast(new IdleStateHandler(5, 0, 0));
// ChannelDuplexHandler 可以同时作为入站和出站处理器
ch.pipeline().addLast(new ChannelDuplexHandler() {
    // 用于触发特殊事件
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception{
        IdleStateEvent event = (IdleStateEvent) evt;
        // 读间隔事件
        if (evt instanceof IdleStateEvent event) {
            // 读间隔事件
            if (event.state()== IdleState.READER_IDLE) {
                System.out.println("已经5s没有读到数据。");
                ctx.channel().close();
            }
        }
    }
});

// 用来判断 读间隔时间过长 写间隔时间过长 读写间隔时间过长
// 3s 内如果没有向服务端写入数据，会触发一个 IdleState#WRITER_IDLE 事件
// 不能比服务端读间隔时间长,否则服务端一段时间没有读到数据就会关闭连接
ch.pipeline().addLast(new IdleStateHandler(0, 3, 0));
// ChannelDuplexHandler 可以同时作为入站和出站处理器
ch.pipeline().addLast(new ChannelDuplexHandler() {
    // 用于触发特殊事件
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception{
        IdleStateEvent event = (IdleStateEvent) evt;
        // 写间隔时间过长，发送心跳包
        if (event.state() == IdleState.WRITER_IDLE) {
            //                                log.debug("3s 没有写数据了，发送一个心跳包");
            ctx.writeAndFlush(new PingMessage());
        }
    }
});