1
Netty is an asynchronous event-driven network application framework
2
for rapid development of maintainable high performance protocol servers & clients.

1
public class HelloServer {
2
    public static void main(String[] args) {
3
        // 1、启动器，负责装配netty组件，启动服务器
4
        new ServerBootstrap()
5
                // 2、创建 NioEventLoopGroup，可以简单理解为 线程池 + Selector
6
                .group(new NioEventLoopGroup())
7
                // 3、选择服务器的 ServerSocketChannel 实现
8
                .channel(NioServerSocketChannel.class)
9
                // 4、child 负责处理读写，该方法决定了 child 执行哪些操作
10
              // ChannelInitializer 处理器（仅执行一次）
11
              // 它的作用是待客户端SocketChannel建立连接后，执行initChannel以便添加更多的处理器
12
                .childHandler(new ChannelInitializer<NioSocketChannel>() {
13
                    @Override
14
                    protected void initChannel(NioSocketChannel nioSocketChannel) throws Exception {
15
                        // 5、SocketChannel的处理器，使用StringDecoder解码，ByteBuf=>String
16
                        nioSocketChannel.pipeline().addLast(new StringDecoder());
17
                        // 6、SocketChannel的业务处理，使用上一个处理器的处理结果
18
                        nioSocketChannel.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
19
                            @Override
20
                            protected void channelRead0(ChannelHandlerContext channelHandlerContext, String s) throws Exception {
21
                                System.out.println(s);
22
                            }
23
                        });
24
                    }
25
                    // 7、ServerSocketChannel绑定8080端口
26
                }).bind(8080);
27
    }
28
}

1
public class HelloClient {
2
    public static void main(String[] args) throws InterruptedException {
3
        new Bootstrap()
4
                .group(new NioEventLoopGroup())
5
                // 选择客户 Socket 实现类，NioSocketChannel 表示基于 NIO 的客户端实现
6
                .channel(NioSocketChannel.class)
7
                // ChannelInitializer 处理器（仅执行一次）
8
                // 它的作用是待客户端SocketChannel建立连接后，执行initChannel以便添加更多的处理器
9
                .handler(new ChannelInitializer<Channel>() {
10
                    @Override
11
                    protected void initChannel(Channel channel) throws Exception {
12
                        // 消息会经过通道 handler 处理，这里是将 String => ByteBuf 编码发出
13
                        channel.pipeline().addLast(new StringEncoder());
14
                    }
15
                })
16
                // 指定要连接的服务器和端口
17
                .connect(new InetSocketAddress("localhost", 8080))
18
                // Netty 中很多方法都是异步的，如 connect
19
                // 这时需要使用 sync 方法等待 connect 建立连接完毕
20
                .sync()
21
                // 获取 channel 对象，它即为通道抽象，可以进行数据读写操作
22
                .channel()
23
                // 写入消息并清空缓冲区
24
                .writeAndFlush("hello world");
25
    }
26
}

1
public class TestEventLoop {
2
    public static void main(String[] args) {
3
        // 创建拥有两个EventLoop的NioEventLoopGroup，对应两个线程
4
        EventLoopGroup group = new NioEventLoopGroup(2);
5
        // 通过next方法可以获得下一个 EventLoop
6
        System.out.println(group.next());
7
        System.out.println(group.next());
8

9
        // 通过EventLoop执行普通任务
10
        group.next().execute(()->{
11
            System.out.println(Thread.currentThread().getName() + " hello");
12
        });
13

14
        // 通过EventLoop执行定时任务
15
        group.next().scheduleAtFixedRate(()->{
16
            System.out.println(Thread.currentThread().getName() + " hello2");
17
        }, 0, 1, TimeUnit.SECONDS);
18

19
        // 优雅地关闭
20
        group.shutdownGracefully();
21
    }
22
}

1
io.netty.channel.nio.NioEventLoop@7bb11784
2
io.netty.channel.nio.NioEventLoop@33a10788
3
nioEventLoopGroup-2-1 hello
4
nioEventLoopGroup-2-2 hello2
5
nioEventLoopGroup-2-2 hello2
6
nioEventLoopGroup-2-2 hello2

1
public class MyServer {
2
    public static void main(String[] args) {
3
        new ServerBootstrap()
4
                .group(new NioEventLoopGroup())
5
                .channel(NioServerSocketChannel.class)
6
                .childHandler(new ChannelInitializer<SocketChannel>() {
7
                    @Override
8
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
9
                        socketChannel.pipeline().addLast(new ChannelInboundHandlerAdapter() {
10
                            @Override
11
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
12
                                ByteBuf buf = (ByteBuf) msg;
13
                                System.out.println(Thread.currentThread().getName() + " " + buf.toString(StandardCharsets.UTF_8));
14

15
                            }
16
                        });
17
                    }
18
                })
19
                .bind(8080);
20
    }
21
}

1
public class MyClient {
2
    public static void main(String[] args) throws IOException, InterruptedException {
3
        Channel channel = new Bootstrap()
4
                .group(new NioEventLoopGroup())
5
                .channel(NioSocketChannel.class)
6
                .handler(new ChannelInitializer<SocketChannel>() {
7
                    @Override
8
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
9
                        socketChannel.pipeline().addLast(new StringEncoder());
10
                    }
11
                })
12
                .connect(new InetSocketAddress("localhost", 8080))
13
                .sync()
14
                .channel();
15
        System.out.println(channel);
16
        // 此处打断点调试，调用 channel.writeAndFlush(...);
17
        System.in.read();
18
    }
19
}

1
public class MyServer {
2
    public static void main(String[] args) {
3
        new ServerBootstrap()
4
              // 两个Group，分别为Boss 负责Accept事件，Worker 负责读写事件
5
                .group(new NioEventLoopGroup(1), new NioEventLoopGroup(2))
6

7
        ...
8
    }
9
}

1
nioEventLoopGroup-3-1 hello1
2
nioEventLoopGroup-3-2 hello2
3
nioEventLoopGroup-3-1 hello3
4
nioEventLoopGroup-3-2 hello4
5
nioEventLoopGroup-3-2 hello4

1
public class MyServer {
2
    public static void main(String[] args) {
3
        // 增加自定义的非NioEventLoopGroup
4
        EventLoopGroup group = new DefaultEventLoopGroup();
5

6
        new ServerBootstrap()
7
                .group(new NioEventLoopGroup(1), new NioEventLoopGroup(2))
8
                .channel(NioServerSocketChannel.class)
9
                .childHandler(new ChannelInitializer<SocketChannel>() {
10
                    @Override
11
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
12
                        // 增加两个handler，第一个使用NioEventLoopGroup处理，第二个使用自定义EventLoopGroup处理
13
                        socketChannel.pipeline().addLast("nioHandler",new ChannelInboundHandlerAdapter() {
14
                            @Override
15
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
16
                                ByteBuf buf = (ByteBuf) msg;
17
                                System.out.println(Thread.currentThread().getName() + " " + buf.toString(StandardCharsets.UTF_8));
18
                                // 调用下一个handler
19
                                ctx.fireChannelRead(msg);
20
                            }
21
                        })
22
                        // 该handler绑定自定义的Group
23
                        .addLast(group, "myHandler", new ChannelInboundHandlerAdapter() {
24
                            @Override
25
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
26
                                ByteBuf buf = (ByteBuf) msg;
27
                                System.out.println(Thread.currentThread().getName() + " " + buf.toString(StandardCharsets.UTF_8));
28
                            }
29
                        });
30
                    }
31
                })
32
                .bind(8080);
33
    }
34
}

1
nioEventLoopGroup-4-1 hello1
2
defaultEventLoopGroup-2-1 hello1
3
nioEventLoopGroup-4-2 hello2
4
defaultEventLoopGroup-2-2 hello2
5
nioEventLoopGroup-4-1 hello3
6
defaultEventLoopGroup-2-3 hello3
7
nioEventLoopGroup-4-2 hello4
8
defaultEventLoopGroup-2-4 hello4

1
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
2
    final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
3
    // 获得下一个EventLoop, excutor 即为 EventLoopGroup
4
    EventExecutor executor = next.executor();
5

6
    // 如果下一个EventLoop 在当前的 EventLoopGroup中
7
    if (executor.inEventLoop()) {
8
        // 使用当前 EventLoopGroup 中的 EventLoop 来处理任务
9
        next.invokeChannelRead(m);
10
    } else {
11
        // 否则让另一个 EventLoopGroup 中的 EventLoop 来创建任务并执行
12
        executor.execute(new Runnable() {
13
            public void run() {
14
                next.invokeChannelRead(m);
15
            }
16
        });
17
    }
18
}

1
public class MyClient {
2
    public static void main(String[] args) throws IOException, InterruptedException {
3
        ChannelFuture channelFuture = new Bootstrap()
4
                .group(new NioEventLoopGroup())
5
                .channel(NioSocketChannel.class)
6
                .handler(new ChannelInitializer<SocketChannel>() {
7
                    @Override
8
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
9
                        socketChannel.pipeline().addLast(new StringEncoder());
10
                    }
11
                })
12
                // 该方法为异步非阻塞方法，主线程调用后不会被阻塞，真正去执行连接操作的是NIO线程
13
              // NIO线程：NioEventLoop 中的线程
14
                .connect(new InetSocketAddress("localhost", 8080));
15

16
        // 该方法用于等待连接真正建立
17
        channelFuture.sync();
18

19
        // 获取客户端-服务器之间的Channel对象
20
        Channel channel = channelFuture.channel();
21
        channel.writeAndFlush("hello world");
22
        System.in.read();
23
    }
24
}

1
public class MyClient {
2
    public static void main(String[] args) throws IOException, InterruptedException {
3
        ChannelFuture channelFuture = new Bootstrap()
4
                .group(new NioEventLoopGroup())
5
                .channel(NioSocketChannel.class)
6
                .handler(new ChannelInitializer<SocketChannel>() {
7
                    @Override
8
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
9
                        socketChannel.pipeline().addLast(new StringEncoder());
10
                    }
11
                })
12
                // 该方法为异步非阻塞方法，主线程调用后不会被阻塞，真正去执行连接操作的是NIO线程
13
                // NIO线程：NioEventLoop 中的线程
14
                .connect(new InetSocketAddress("localhost", 8080));
15

16
    // 当connect方法执行完毕后，也就是连接真正建立后
17
        // 会在NIO线程中调用operationComplete方法
18
        channelFuture.addListener(new ChannelFutureListener() {
19
            @Override
20
            public void operationComplete(ChannelFuture channelFuture) throws Exception {
21
                Channel channel = channelFuture.channel();
22
                channel.writeAndFlush("hello world");
23
            }
24
        });
25
        System.in.read();
26
    }
27
}

1
public class ReadClient {
2
    public static void main(String[] args) throws InterruptedException {
3
        // 创建EventLoopGroup，使用完毕后关闭
4
        NioEventLoopGroup group = new NioEventLoopGroup();
5

6
        ChannelFuture channelFuture = new Bootstrap()
7
                .group(group)
8
                .channel(NioSocketChannel.class)
9
                .handler(new ChannelInitializer<SocketChannel>() {
10
                    @Override
11
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
12
                        socketChannel.pipeline().addLast(new StringEncoder());
13
                    }
14
                })
15
                .connect(new InetSocketAddress("localhost", 8080));
16
        channelFuture.sync();
17

18
        Channel channel = channelFuture.channel();
19
        Scanner scanner = new Scanner(System.in);
20

21
        // 创建一个线程用于输入并向服务器发送
22
        new Thread(()->{
23
            while (true) {
24
                String msg = scanner.next();
25
                if ("q".equals(msg)) {
26
                    // 关闭操作是异步的，在NIO线程中执行
27
                    channel.close();
28
                    break;
29
                }
30
                channel.writeAndFlush(msg);
31
            }
32
        }, "inputThread").start();
33

34
        // 获得closeFuture对象
35
        ChannelFuture closeFuture = channel.closeFuture();
36
        System.out.println("waiting close...");
37

38
        // 同步等待NIO线程执行完close操作
39
        closeFuture.sync();
40

41
        // 关闭之后执行一些操作，可以保证执行的操作一定是在channel关闭以后执行的
42
        System.out.println("关闭之后执行一些额外操作...");
43

44
        // 关闭EventLoopGroup
45
        group.shutdownGracefully();
46
    }
47
}

1
// 获得closeFuture对象
2
ChannelFuture closeFuture = channel.closeFuture();
3

4
// 同步等待NIO线程执行完close操作
5
closeFuture.sync();

1
closeFuture.addListener(new ChannelFutureListener() {
2
    @Override
3
    public void operationComplete(ChannelFuture channelFuture) throws Exception {
4
        // 等待channel关闭后才执行的操作
5
        System.out.println("关闭之后执行一些额外操作...");
6
        // 关闭EventLoopGroup
7
        group.shutdownGracefully();
8
    }
9
});

1
public class JdkFuture {
2
    public static void main(String[] args) throws ExecutionException, InterruptedException {
3
        ThreadFactory factory = new ThreadFactory() {
4
            @Override
5
            public Thread newThread(Runnable r) {
6
                return new Thread(r, "JdkFuture");
7
            }
8
        };
9
        // 创建线程池
10
        ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10,10, TimeUnit.SECONDS, new ArrayBlockingQueue<>(10), factory);
11

12
        // 获得Future对象
13
        Future<Integer> future = executor.submit(new Callable<Integer>() {
14

15
            @Override
16
            public Integer call() throws Exception {
17
                TimeUnit.SECONDS.sleep(1);
18
                return 50;
19
            }
20
        });
21

22
        // 通过阻塞的方式，获得运行结果
23
        System.out.println(future.get());
24
    }
25
}

1
public class NettyFuture {
2
    public static void main(String[] args) throws ExecutionException, InterruptedException {
3
        NioEventLoopGroup group = new NioEventLoopGroup();
4

5
        // 获得 EventLoop 对象
6
        EventLoop eventLoop = group.next();
7
        Future<Integer> future = eventLoop.submit(new Callable<Integer>() {
8
            @Override
9
            public Integer call() throws Exception {
10
                return 50;
11
            }
12
        });
13

14
        // 主线程中获取结果
15
        System.out.println(Thread.currentThread().getName() + " 获取结果");
16
        System.out.println("getNow " + future.getNow());
17
        System.out.println("get " + future.get());
18

19
        // NIO线程中异步获取结果
20
        future.addListener(new GenericFutureListener<Future<? super Integer>>() {
21
            @Override
22
            public void operationComplete(Future<? super Integer> future) throws Exception {
23
                System.out.println(Thread.currentThread().getName() + " 获取结果");
24
                System.out.println("getNow " + future.getNow());
25
            }
26
        });
27
    }
28
}

1
main 获取结果
2
getNow null
3
get 50
4
nioEventLoopGroup-2-1 获取结果
5
getNow 50

1
public class NettyPromise {
2
    public static void main(String[] args) throws ExecutionException, InterruptedException {
3
        // 创建EventLoop
4
        NioEventLoopGroup group = new NioEventLoopGroup();
5
        EventLoop eventLoop = group.next();
6

7
        // 创建Promise对象，用于存放结果
8
        DefaultPromise<Integer> promise = new DefaultPromise<>(eventLoop);
9

10
        new Thread(()->{
11
            try {
12
                TimeUnit.SECONDS.sleep(1);
13
            } catch (InterruptedException e) {
14
                e.printStackTrace();
15
            }
16
            // 自定义线程向Promise中存放结果
17
            promise.setSuccess(50);
18
        }).start();
19

20
        // 主线程从Promise中获取结果
21
        System.out.println(Thread.currentThread().getName() + " " + promise.get());
22
    }
23
}

1
public class PipeLineServer {
2
    public static void main(String[] args) {
3
        new ServerBootstrap()
4
                .group(new NioEventLoopGroup())
5
                .channel(NioServerSocketChannel.class)
6
                .childHandler(new ChannelInitializer<SocketChannel>() {
7
                    @Override
8
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
9
                        // 在socketChannel的pipeline中添加handler
10
                        // pipeline中handler是带有head与tail节点的双向链表，的实际结构为
11
               // head <-> handler1 <-> ... <-> handler4 <->tail
12
                        // Inbound主要处理入站操作，一般为读操作，发生入站操作时会触发Inbound方法
13
                        // 入站时，handler是从head向后调用的
14
                        socketChannel.pipeline().addLast("handler1" ,new ChannelInboundHandlerAdapter() {
15
                            @Override
16
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
17
                                System.out.println(Thread.currentThread().getName() + " Inbound handler 1");
18
                                // 父类该方法内部会调用fireChannelRead
19
                                // 将数据传递给下一个handler
20
                                super.channelRead(ctx, msg);
21
                            }
22
                        });
23
                        socketChannel.pipeline().addLast("handler2", new ChannelInboundHandlerAdapter() {
24
                            @Override
25
                            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
26
                                System.out.println(Thread.currentThread().getName() + " Inbound handler 2");
27
                                // 执行write操作，使得Outbound的方法能够得到调用
28
          socketChannel.writeAndFlush(ctx.alloc().buffer().writeBytes("Server...".getBytes(StandardCharsets.UTF_8)));
29
                                super.channelRead(ctx, msg);
30
                            }
31
                        });
32
                        // Outbound主要处理出站操作，一般为写操作，发生出站操作时会触发Outbound方法
33
                        // 出站时，handler的调用是从tail向前调用的
34
                        socketChannel.pipeline().addLast("handler3" ,new ChannelOutboundHandlerAdapter(){
35
                            @Override
36
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
37
                                System.out.println(Thread.currentThread().getName() + " Outbound handler 1");
38
                                super.write(ctx, msg, promise);
39
                            }
40
                        });
41
                        socketChannel.pipeline().addLast("handler4" ,new ChannelOutboundHandlerAdapter(){
42
                            @Override
43
                            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
44
                                System.out.println(Thread.currentThread().getName() + " Outbound handler 2");
45
                                super.write(ctx, msg, promise);
46
                            }
47
                        });
48
                    }
49
                })
50
                .bind(8080);
51
    }
52
}

1
nioEventLoopGroup-2-2 Inbound handler 1
2
nioEventLoopGroup-2-2 Inbound handler 2
3
nioEventLoopGroup-2-2 Outbound handler 2
4
nioEventLoopGroup-2-2 Outbound handler 1

1
public class TestEmbeddedChannel {
2
    public static void main(String[] args) {
3
        ChannelInboundHandlerAdapter h1 = new ChannelInboundHandlerAdapter() {
4
            @Override
5
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
6
                System.out.println("1");
7
                super.channelRead(ctx, msg);
8
            }
9
        };
10

11
        ChannelInboundHandlerAdapter h2 = new ChannelInboundHandlerAdapter() {
12
            @Override
13
            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
14
                System.out.println("2");
15
                super.channelRead(ctx, msg);
16
            }
17
        };
18

19
        ChannelOutboundHandlerAdapter h3 = new ChannelOutboundHandlerAdapter() {
20
            @Override
21
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
22
                System.out.println("3");
23
                super.write(ctx, msg, promise);
24
            }
25
        };
26

27
        ChannelOutboundHandlerAdapter h4 = new ChannelOutboundHandlerAdapter() {
28
            @Override
29
            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
30
                System.out.println("4");
31
                super.write(ctx, msg, promise);
32
            }
33
        };
34

35
        // 用于测试Handler的Channel
36
        EmbeddedChannel channel = new EmbeddedChannel(h1, h2, h3, h4);
37

38
        // 执行Inbound操作
39
        channel.writeInbound(ByteBufAllocator.DEFAULT.buffer().writeBytes("hello".getBytes(StandardCharsets.UTF_8)));
40
        // 执行Outbound操作
41
        channel.writeOutbound(ByteBufAllocator.DEFAULT.buffer().writeBytes("hello".getBytes(StandardCharsets.UTF_8)));
42
    }
43
}

1
private static void log(ByteBuf buffer) {
2
    int length = buffer.readableBytes();
3
    int rows = length / 16 + (length % 15 == 0 ? 0 : 1) + 4;
4
    StringBuilder buf = new StringBuilder(rows * 80 * 2)
5
        .append("read index:").append(buffer.readerIndex())
6
        .append(" write index:").append(buffer.writerIndex())
7
        .append(" capacity:").append(buffer.capacity())
8
        .append(NEWLINE);
9
    appendPrettyHexDump(buf, buffer);
10
    System.out.println(buf.toString());
11
}

1
public class ByteBufStudy {
2
    public static void main(String[] args) {
3
        // 创建ByteBuf
4
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);
5
        ByteBufUtil.log(buffer);
6

7
        // 向buffer中写入数据
8
        StringBuilder sb = new StringBuilder();
9
        for(int i = 0; i < 20; i++) {
10
            sb.append("a");
11
        }
12
        buffer.writeBytes(sb.toString().getBytes(StandardCharsets.UTF_8));
13

14
        // 查看写入结果
15
        ByteBufUtil.log(buffer);
16
    }
17
}

1
read index:0 write index:0 capacity:16
2

3
read index:0 write index:20 capacity:64
4
         +-------------------------------------------------+
5
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
6
+--------+-------------------------------------------------+----------------+
7
|00000000| 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 |aaaaaaaaaaaaaaaa|
8
|00000010| 61 61 61 61                                     |aaaa            |
9
+--------+-------------------------------------------------+----------------+

1
ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);

1
ByteBuf buffer = ByteBufAllocator.DEFAULT.heapBuffer(16);

1
ByteBuf buffer = ByteBufAllocator.DEFAULT.directBuffer(16);

1
public class ByteBufStudy {
2
    public static void main(String[] args) {
3
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);
4
        System.out.println(buffer.getClass());
5

6
        buffer = ByteBufAllocator.DEFAULT.heapBuffer(16);
7
        System.out.println(buffer.getClass());
8

9
        buffer = ByteBufAllocator.DEFAULT.directBuffer(16);
10
        System.out.println(buffer.getClass());
11
    }
12
}
13
// 使用池化的直接内存
14
class io.netty.buffer.PooledUnsafeDirectByteBuf
15

16
// 使用池化的堆内存
17
class io.netty.buffer.PooledUnsafeHeapByteBuf
18

19
// 使用池化的直接内存
20
class io.netty.buffer.PooledUnsafeDirectByteBuf

1
-Dio.netty.allocator.type={unpooled|pooled}

1
public class ByteBufStudy {
2
    public static void main(String[] args) {
3
        // 创建ByteBuf
4
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);
5
        ByteBufUtil.log(buffer);
6

7
        // 向buffer中写入数据
8
        buffer.writeBytes(new byte[]{1, 2, 3, 4});
9
        ByteBufUtil.log(buffer);
10

11
        buffer.writeInt(5);
12
        ByteBufUtil.log(buffer);
13

14
        buffer.writeIntLE(6);
15
        ByteBufUtil.log(buffer);
16

17
        buffer.writeLong(7);
18
        ByteBufUtil.log(buffer);
19
    }
20
}

1
read index:0 write index:0 capacity:16
2

3
read index:0 write index:4 capacity:16
4
         +-------------------------------------------------+
5
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
6
+--------+-------------------------------------------------+----------------+
7
|00000000| 01 02 03 04                                     |....            |
8
+--------+-------------------------------------------------+----------------+
9

10
read index:0 write index:8 capacity:16
11
         +-------------------------------------------------+
12
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
13
+--------+-------------------------------------------------+----------------+
14
|00000000| 01 02 03 04 00 00 00 05                         |........        |
15
+--------+-------------------------------------------------+----------------+
16

17
read index:0 write index:12 capacity:16
18
         +-------------------------------------------------+
19
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
20
+--------+-------------------------------------------------+----------------+
21
|00000000| 01 02 03 04 00 00 00 05 06 00 00 00             |............    |
22
+--------+-------------------------------------------------+----------------+
23

24
read index:0 write index:20 capacity:20
25
         +-------------------------------------------------+
26
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
27
+--------+-------------------------------------------------+----------------+
28
|00000000| 01 02 03 04 00 00 00 05 06 00 00 00 00 00 00 00 |................|
29
|00000010| 00 00 00 07                                     |....            |
30
+--------+-------------------------------------------------+----------------+

1
buffer.writeLong(7);
2
ByteBufUtil.log(buffer);
3
// 扩容前
4
read index:0 write index:12 capacity:16
5
...
6

7
// 扩容后
8
read index:0 write index:20 capacity:20
9
         +-------------------------------------------------+
10
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
11
+--------+-------------------------------------------------+----------------+
12
|00000000| 01 02 03 04 00 00 00 05 06 00 00 00 00 00 00 00 |................|
13
|00000010| 00 00 00 07                                     |....            |
14
+--------+-------------------------------------------------+----------------+

1
Exception in thread "main" java.lang.IndexOutOfBoundsException: writerIndex(20) + minWritableBytes(8) exceeds maxCapacity(20): PooledUnsafeDirectByteBuf(ridx: 0, widx: 20, cap: 20/20)
2
...

1
public class ByteBufStudy {
2
    public static void main(String[] args) {
3
        // 创建ByteBuf
4
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);
5

6
        // 向buffer中写入数据
7
        buffer.writeBytes(new byte[]{1, 2, 3, 4});
8
        buffer.writeInt(5);
9

10
        // 读取4个字节
11
        System.out.println(buffer.readByte());
12
        System.out.println(buffer.readByte());
13
        System.out.println(buffer.readByte());
14
        System.out.println(buffer.readByte());
15
        ByteBufUtil.log(buffer);
16

17
        // 通过mark与reset实现重复读取
18
        buffer.markReaderIndex();
19
        System.out.println(buffer.readInt());
20
        ByteBufUtil.log(buffer);
21

22
        // 恢复到mark标记处
23
        buffer.resetReaderIndex();
24
        ByteBufUtil.log(buffer);
25
    }
26
}
27
1
28
2
29
3
30
4
31
read index:4 write index:8 capacity:16
32
         +-------------------------------------------------+
33
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
34
+--------+-------------------------------------------------+----------------+
35
|00000000| 00 00 00 05                                     |....            |
36
+--------+-------------------------------------------------+----------------+
37
5
38
read index:8 write index:8 capacity:16
39

40
read index:4 write index:8 capacity:16
41
         +-------------------------------------------------+
42
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
43
+--------+-------------------------------------------------+----------------+
44
|00000000| 00 00 00 05                                     |....            |
45
+--------+-------------------------------------------------+----------------+

1
while (!buffer.release()) {}

1
protected void onUnhandledInboundMessage(Object msg) {
2
    try {
3
        logger.debug("Discarded inbound message {} that reached at the tail of the pipeline. Please check your pipeline configuration.", msg);
4
    } finally {
5
        // 具体的释放方法
6
        ReferenceCountUtil.release(msg);
7
    }
8
}

1
public static boolean release(Object msg) {
2
  return msg instanceof ReferenceCounted ? ((ReferenceCounted)msg).release() : false;
3
}

1
public class TestSlice {
2
    public static void main(String[] args) {
3
        // 创建ByteBuf
4
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);
5

6
        // 向buffer中写入数据
7
        buffer.writeBytes(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});
8

9
        // 将buffer分成两部分
10
        ByteBuf slice1 = buffer.slice(0, 5);
11
        ByteBuf slice2 = buffer.slice(5, 5);
12

13
        // 需要让分片的buffer引用计数加一
14
        // 避免原Buffer释放导致分片buffer无法使用
15
        slice1.retain();
16
        slice2.retain();
17

18
        ByteBufUtil.log(slice1);
19
        ByteBufUtil.log(slice2);
20

21
        // 更改原始buffer中的值
22
        System.out.println("===========修改原buffer中的值===========");
23
        buffer.setByte(0,5);
24

25
        System.out.println("===========打印slice1===========");
26
        ByteBufUtil.log(slice1);
27
    }
28
}