netty概述

第一章 Netty基础

1.Netty结构

Channel:

代表一个到实体设备的连接，执行一个或多个I/O操作

Callback:回调

Netty 内部使用回调处理事件时。一旦这样的回调被触发，事件可以由接口 ChannelHandler 的实现来处理。如下面的代码，一旦一个新的连接建立了,调用 channelActive(),并将打印一条消息。可简单继承ChannelInboundHandlerAdapter类来实现，其中有很多方法可覆盖。

public class ConnectHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {   //当建立一个新的连接时调用 ChannelActive()
        System.out.println(
                "Client " + ctx.channel().remoteAddress() + " connected");
    }
}

Future:

除回调外，另外一种通知应用操作已经完成的方式。这个对象作为一个异步操作结果的占位符,它将在将来的某个时候完成并提供结果。ChannelFuture,用于在执行异步操作时使用。
ChannelFuture 提供多个附件方法来允许一个或者多个 ChannelFutureListener 实例。这个回调方法 operationComplete() 会在操作完成时调用。简而言之, ChannelFutureListener 提供的通知机制不需要手动检查操作是否完成的。
每个 Netty 的 outbound I/O 操作都会返回一个 ChannelFuture;这样就不会阻塞。
例子：

Channel channel = ...;
//不会阻塞
ChannelFuture future = channel.connect(            //1 异步连接到远程对等节点。调用立即返回并提供 ChannelFuture。
        new InetSocketAddress("192.168.0.1", 25));
future.addListener(new ChannelFutureListener() {  //2 操作完成后通知注册一个 ChannelFutureListener 
@Override
public void operationComplete(ChannelFuture future) {
    if (future.isSuccess()) {                    //3 当 operationComplete() 调用时检查操作的状态。
        ByteBuf buffer = Unpooled.copiedBuffer(
                "Hello", Charset.defaultCharset()); //4 如果成功就创建一个 ByteBuf 来保存数据。
        ChannelFuture wf = future.channel().writeAndFlush(buffer);                //5 异步发送数据到远程。再次返回ChannelFuture。
        // ...业务代码 
    } else {
        Throwable cause = future.cause();        //6 如果有一个错误则抛出 Throwable,描述错误原因。
        cause.printStackTrace();
    }
}
});

Event 和 Handler

Netty 使用不同的事件来通知我们更改的状态或操作的状态。这使我们能够根据发生的事件触发适当的行为。
ChannelHandler是许多方面的核心

CHANNELPIPELINE

• 其实，ChannelPipeline 就是 ChannelHandler 链的容器，容器中由许多Handler构成1条链。
• ChannelPipeline 提供了一个容器给 ChannelHandler 链并提供了一个API 用于管理沿着链入站和出站事件的流动。每个 Channel 都有自己的ChannelPipeline，当 Channel 创建时自动创建的。 ChannelHandler 是如何安装在 ChannelPipeline？ 主要是实现了ChannelHandler 的抽象 ChannelInitializer。ChannelInitializer子类 通过 ServerBootstrap 进行注册。当它的方法 initChannel() 被调用时，这个对象将安装自定义的 ChannelHandler 集到 pipeline。当这个操作完成时，ChannelInitializer 子类则 从 ChannelPipeline 自动删除自身。
• 进站和出站的处理器都可以被安装在相同的 pipeline
  

包含入站和出站的ChannelInboundHandlers，ChannelInboundHandlers链

ChannelHandlerContext

• 当 ChannelHandler 被添加到的 ChannelPipeline 它得到一个 ChannelHandlerContext，它代表一个 ChannelHandler 和 ChannelPipeline 之间的“绑定”。
• 在 Netty 发送消息可以采用两种方式：直接写消息给 Channel 或者写入 ChannelHandlerContext 对象。
• 这两者主要的区别是， 前一种方法会导致消息从 ChannelPipeline的尾部开始，而后者导致消息从 ChannelPipeline 下一个处理器开始。

详解ChannelHandler

为了能够让开发处理逻辑变得简单，Netty提供了一些默认的处理程序来实现形式的“adapter（适配器）”类

会经常调用的适配器：ChannelHandlerAdapter、ChannelInboundHandlerAdapter、ChannelOutboundHandlerAdapter、ChannelDuplexHandlerAdapter

• 编码器、解码器

严格地说，其他处理器可以做编码器和解码器能做的事。但正如适配器类简化创建通道处理器，所有的编码器/解码器适配器类 都实现自 ChannelInboundHandler 或 ChannelOutboundHandler。
对于入站数据，channelRead 方法/事件被覆盖。这种方法在每个消息从入站 Channel 读入时调用。该方法将调用特定解码器的“解码”方法，并将解码后的消息转发到管道中下个的 ChannelInboundHandler。
出站消息是类似的。编码器将消息转为字节，转发到下个的 ChannelOutboundHandler。

• SimpleChannelHandler

也许最常见的处理器是接收到解码后的消息并应用一些业务逻辑到这些数据。要创建这样一个 ChannelHandler，你只需要扩展基类SimpleChannelInboundHandler 其中 T 是想要进行处理的类型。这样的处理器，你将覆盖基类的一个或多个方法，将获得被作为输入参数传递所有方法的 ChannelHandlerContext 的引用。

Bootstrapping

Bootstrapping 有以下两种类型：

• 一种是用于客户端的Bootstrap:连接到远程主机和端口,有1个EventLoopGroup
• 一种是用于服务端的ServerBootstrap:绑定本地端口,有2个EventLoopGroup

一个 ServerBootstrap 可以认为有2个 Channel 集合，第一个集合包含一个单例 ServerChannel，代表持有一个绑定了本地端口的 socket；第二集合包含所有创建的 Channel，处理服务器所接收到的客户端进来的连接。
与 ServerChannel 相关 EventLoopGroup 分配一个 EventLoop 是 负责创建 Channels 用于传入的连接请求。一旦连接接受，第二个EventLoopGroup 分配一个 EventLoop 给它的 Channel

2.整合

FUTURE, CALLBACK 和 HANDLER

Netty 的异步编程模型是建立在 future 和 callback 的概念上的。
拦截操作和转换入站或出站数据只需要您提供回调或利用 future 操作返回的。

SELECTOR, EVENT 和 EVENT LOOP

Netty 通过触发事件从应用程序中抽象出 Selector，从而避免手写调度代码。
EventLoop 本身是由只有一个线程驱动，它给一个 Channel 处理所有的 I/O 事件，并且在 EventLoop 的生命周期内不会改变。
这个简单而强大的线程模型消除你可能对你的 ChannelHandler 同步的任何关注

3.建立应用

先启动客户端
然后建立一个连接并发送一个或多个消息发送到服务器，其中每相呼应消息返回给客户端。

Netty 实现的 echo 服务器都需要下面这些：

一个服务器 handler：这个组件实现了服务器的业务逻辑，决定了连接创建后和接收到信息后该如何处理

Bootstrapping： 这个是配置服务器的启动代码。最少需要设置服务器绑定的端口，用来监听连接请求。

3.1通过 ChannelHandler 来实现服务器的逻辑

由于我们的应用很简单，只需要继承 ChannelInboundHandlerAdapter 就行了。这个类 提供了默认 ChannelInboundHandler 的实现，所以只需要覆盖下面的方法：

• channelRead() - 每个信息入站都会调用
• channelReadComplete() - 通知处理器最后的 channelread() 是当前批处理中的最后一条消息时调用
• exceptionCaught()- 读操作时捕获到异常时调用

@Sharable                                        //1 标识这类的实例之间可以在 channel 里面共享
public class EchoServerHandler extends
        ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx,
        Object msg) {
        ByteBuf in = (ByteBuf) msg;
        System.out.println("Server received: " + in.toString(CharsetUtil.UTF_8));        //2 日志消息输出到控制台
        ctx.write(in);                            //3 将所接收的消息返回给发送者。注意，这还没有冲刷数据
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.EMPTY_BUFFER)//4 冲刷所有待审消息到远程节点。关闭通道后，操作完成
        .addListener(ChannelFutureListener.CLOSE);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx,
        Throwable cause) {
        cause.printStackTrace();                //5 打印异常信息
        ctx.close();                            //6 关闭通道
    }
}

3.2引导服务器

• 监听和接收进来的连接请求
• 配置 Channel 来通知一个关于入站消息的 EchoServerHandler 实例

public class EchoServer {

    private final int port;

    public EchoServer(int port) {
        this.port = port;
    }
    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.err.println(
                    "Usage: " + EchoServer.class.getSimpleName() +
                    " ");
            return;
        }
        int port = Integer.parseInt(args[0]);        //1 设置端口值（抛出一个 NumberFormatException 如果该端口参数的格式不正确）
        new EchoServer(port).start();                //2 呼叫服务器的 start() 方法
    }

    public void start() throws Exception {
        NioEventLoopGroup group = new NioEventLoopGroup(); //3 创建 EventLoopGroup
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(group)                                //4 创建 ServerBootstrap
             .channel(NioServerSocketChannel.class)        //5 指定使用 NIO 的传输 Channel
             .localAddress(new InetSocketAddress(port))    //6 设置 socket 地址使用所选的端口
             .childHandler(new ChannelInitializer() { //7 添加 EchoServerHandler 到 Channel 的 ChannelPipeline
                 @Override
                 public void initChannel(SocketChannel ch) 
                     throws Exception {
                     ch.pipeline().addLast(
                             new EchoServerHandler());
                 }
             });

            ChannelFuture f = b.bind().sync();            //8 绑定的服务器;sync 等待服务器关闭
            System.out.println(EchoServer.class.getName() + " started and listen on " + f.channel().localAddress());
            f.channel().closeFuture().sync();            //9 关闭 channel 和 块，直到它被关闭
        } finally {
            group.shutdownGracefully().sync();            //10 关机的 EventLoopGroup，释放所有资源。
        }
    }

}

第7步是关键：在这里我们使用一个特殊的类，ChannelInitializer 。当一个新的连接被接受，一个新的子 Channel 将被创建， ChannelInitializer 会添加我们EchoServerHandler 的实例到 Channel 的 ChannelPipeline。正如我们如前所述，如果有入站信息，这个处理器将被通知。

服务器的主代码组件是:

• EchoServerHandler 实现了的业务逻辑
• 在 main() 方法，引导了服务器

执行main()所需的步骤是：

• 创建 ServerBootstrap 实例来引导服务器并随后绑定
• 创建并分配一个 NioEventLoopGroup 实例来处理事件的处理，如接受新的连接和读/写数据。
• 指定本地 InetSocketAddress 给服务器绑定
• 通过 EchoServerHandler 实例给每一个新的 Channel 初始化
• 最后调用 ServerBootstrap.bind() 绑定服务器

写一个 echo 客户端

1.客户端的工作内容：

• 连接服务器
• 发送信息
• 发送的每个信息，等待和接收从服务器返回的同样的信息
• 关闭连接

2.用 ChannelHandler 实现客户端逻辑

2.1我们用 SimpleChannelInboundHandler 来处理所有的任务，需要覆盖三个方法(注意与服务端不同处)：

• channelActive() - 服务器的连接被建立后调用
• channelRead0() - 数据后从服务器接收到调用
• exceptionCaught() - 捕获一个异常时调用

@Sharable                                //1 标记这个类的实例可以在 channel 里共享
public class EchoClientHandler extends
        SimpleChannelInboundHandler {

    /**
    * 建立连接后该 channelActive() 方法被调用一次。
    */
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.writeAndFlush(Unpooled.copiedBuffer("Netty rocks!", //2 当被通知该 channel 是活动的时候就发送信息
        CharsetUtil.UTF_8));
    }

    /**
    * 这种方法会在接收到数据时被调用。注意，由服务器所发送的消息可以以块的形式被接收。
    * 即，当服务器发送 5 个字节是不是保证所有的 5 个字节会立刻收到 - 即使是只有 5 个字节，channelRead0() 方法可被调用两次，第一次用一个ByteBuf（Netty的字节容器）装载3个字节和第二次一个 ByteBuf 装载 2 个字节。唯一要保证的是，该字节将按照它们发送的顺序分别被接收。 （注意，这是真实的，只有面向流的协议如TCP）。
    */
    @Override
    public void channelRead0(ChannelHandlerContext ctx,
        ByteBuf in) {
        System.out.println("Client received: " + in.toString(CharsetUtil.UTF_8));    //3 记录接收到的消息
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx,
        Throwable cause) {                    //4 异常处理
        cause.printStackTrace();
        ctx.close();
    }
}

• SimpleChannelInboundHandler vs. ChannelInboundHandler

何时用这两个要看具体业务的需要。在客户端，当 channelRead0() 完成，我们已经拿到的入站的信息。当方法返回时，SimpleChannelInboundHandler 会小心的释放对 ByteBuf（保存信息） 的引用。
而在 EchoServerHandler,我们需要将入站的信息返回给发送者，由于 write() 是异步的，在 channelRead() 返回时，可能还没有完成。所以，我们使用 ChannelInboundHandlerAdapter,无需释放信息。最后在 channelReadComplete() 我们调用 ctxWriteAndFlush() 来释放信息。

2.2用 ChannelHandler 实现客户端逻辑

public class EchoClient {

    private final String host;
    private final int port;

    public EchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();                //1 创建 Bootstrap
            b.group(group)                                //2 指定 EventLoopGroup 来处理客户端事件。由于我们使用 NIO 传输，所以用到了 NioEventLoopGroup 的实现
             .channel(NioSocketChannel.class)            //3 使用的 channel 类型是一个用于 NIO 传输
             .remoteAddress(new InetSocketAddress(host, port))    //4 设置服务器的 InetSocketAddress
             .handler(new ChannelInitializer() {    //5 当建立一个连接和一个新的通道时，创建添加到 EchoClientHandler 实例 到 channel pipeline
                 @Override
                 public void initChannel(SocketChannel ch) 
                     throws Exception {
                     ch.pipeline().addLast(
                             new EchoClientHandler());
                 }
             });

            ChannelFuture f = b.connect().sync();        //6 连接到远程;等待连接完成

            f.channel().closeFuture().sync();            //7 阻塞直到 Channel 关闭
        } finally {
            group.shutdownGracefully().sync();            //8 调用 shutdownGracefully() 来关闭线程池和释放所有资源
        }
    }

    public static void main(String[] args) throws Exception {
        if (args.length != 2) {
            System.err.println(
                    "Usage: " + EchoClient.class.getSimpleName() +
                    "  ");
            return;
        }

        final String host = args[0];
        final int port = Integer.parseInt(args[1]);

        new EchoClient(host, port).start();
    }
}

2.3要点回顾

• 创建一个 Bootstrap 来初始化客户端
• 一个 NioEventLoopGroup 实例被分配给处理该事件的处理，这包括创建新的连接和处理入站和出站数据
• 创建一个 InetSocketAddress 以连接到服务器
• 连接好服务器之时，将安装一个 EchoClientHandler 在 pipeline
• 之后 Bootstrap.connect（）被调用连接到远程的 - 本例就是 echo(回声)服务器。

Netty应用总结

本章中我们学会了构建并且运行第一个Netty的客户端及服务器。这个应用程序虽然没有多大的难度，但是也不要小瞧它，因为它可以扩展到几千个并发连接。

第二章 Netty核心之Transport（传输）

网络应用程序让人与系统之间可以进行通信，当然网络应用程序也可以将大量的数据从一个地方转移到另一个地方。如何做到这一点取决于具体的网络传输，但转移始终是相同的：字节通过线路。

1.NIO

在低连接数、需要低延迟时、阻塞时使用

2.OIO

NIO-在高连接数时使用

3.Local(本地)

在同一个JVM内通信时使用

4.Embedded(内嵌)

测试ChannelHandler时使用

第三章 Netty核心之Buffer（缓冲）

主要包括：

• ByteBuf
• ByteBufHolder

1.Netty字节数据的容器ByteBuf

ByteBuf 是一个已经经过优化的很好使用的数据容器，字节数据可以有效的被添加到 ByteBuf 中或者也可以从 ByteBuf 中直接获取数据。ByteBuf中有两个索引：一个用来读，一个用来写。
调用 ByteBuf 的以 “read” 或 “write” 开头的任何方法都将自动增加相应的索引。另一方面，“set” 、 "get"操作字节将不会移动索引位置，它们只会在指定的相对位置上操作字节。
ByteBuf 类似于一个字节数组

1.1ByteBuf 使用模式

• HEAP BUFFER(堆缓冲区)

ByteBuf heapBuf = ...;
if (heapBuf.hasArray()) {                //1 检查 ByteBuf 是否有支持数组。
    byte[] array = heapBuf.array();        //2 *如果有的话，得到引用数组，即是堆缓冲区
    int offset = heapBuf.arrayOffset() + heapBuf.readerIndex();                //3 计算第一字节的偏移量。
    int length = heapBuf.readableBytes();//4 获取可读的字节数。
    handleArray(array, offset, length); //5 使用数组，偏移量和长度作为调用方法的参数。
}

可以使用 ByteBuf.hasArray()来检查是否支持访问数组
这个用法与 JDK 的 ByteBuffer 类似

• DIRECT BUFFER(直接缓冲区)

“直接缓冲区”是另一个 ByteBuf 模式。对象的所有内存分配发生在 堆，对不对？好吧，并非总是如此。在 JDK1.4 中被引入 NIO 的ByteBuffer 类允许 JVM 通过本地方法调用分配内存，其目的是

通过免去中间交换的内存拷贝, 提升IO处理速度; 直接缓冲区的内容可以驻留在垃圾回收扫描的堆区以外。
DirectBuffer 在 -XX:MaxDirectMemorySize=xxM大小限制下, 使用 Heap 之外的内存, GC对此”无能为力”,也就意味着规避了在高负载下频繁的GC过程对应用线程的中断影响.

但是直接缓冲区的缺点是在内存空间的分配和释放上比堆缓冲区更复杂，另外一个缺点是如果要将数据传递给遗留代码处理，因为数据不是在堆上，你可能不得不作出一个副本

ByteBuf directBuf = ...
if (!directBuf.hasArray()) {            //1 *检查 ByteBuf 是不是由数组支持。如果不是，这是一个直接缓冲区。
    int length = directBuf.readableBytes();//2 获取可读的字节数
    byte[] array = new byte[length];    //3 分配一个新的数组来保存字节
    directBuf.getBytes(directBuf.readerIndex(), array);        //4    字节复制到数组 
    handleArray(array, 0, length);  //5 将数组，偏移量和长度作为参数调用某些处理方法
}

• COMPOSITE BUFFER(复合缓冲区)

Netty 提供了 ByteBuf 的子类 CompositeByteBuf 类来处理复合缓冲区，CompositeByteBuf 只是一个视图。

• 警告

CompositeByteBuf.hasArray() 总是返回 false，因为它可能既包含堆缓冲区，也包含直接缓冲区
例如，一条消息由 header 和 body 两部分组成，将 header 和 body 组装成一条消息发送出去，可能 body 相同，只是 header 不同

// 使用数组保存消息的各个部分
ByteBuffer[] message = { header, body };

// 使用副本来合并这两个部分
ByteBuffer message2 = ByteBuffer.allocate(
        header.remaining() + body.remaining());
message2.put(header);
message2.put(body);
message2.flip();

CompositeByteBuf 的改进版本

CompositeByteBuf messageBuf = ...;	// 追加 ByteBuf 实例的 CompositeByteBuf
ByteBuf headerBuf = ...; // 可以支持或直接
ByteBuf bodyBuf = ...; // 可以支持或直接
messageBuf.addComponents(headerBuf, bodyBuf);
// ....
messageBuf.removeComponent(0); // 移除头    //2 删除 索引1的 ByteBuf

for (int i = 0; i < messageBuf.numComponents(); i++) {                  //3 遍历所有 ByteBuf 实例。
    System.out.println(messageBuf.component(i).toString());
}

当作普通数组使用

CompositeByteBuf compBuf = ...;
int length = compBuf.readableBytes();    //1 取得数组长度
byte[] array = new byte[length];        //2	分配数组保存字节
compBuf.getBytes(compBuf.readerIndex(), array);    //3 将字节复制到数组
handleArray(array, 0, length);    //4	将数组，偏移量和长度作为参数调用某些处理方法

2.Netty字节级别的操作

2.1随机访问索引

• 第一个字节的索引是 0，最后一个字节的索引是 ByteBuf 的 capacity - 1

ByteBuf buffer = ...;
for (int i = 0; i < buffer.capacity(); i++) {
    byte b = buffer.getByte(i);
    System.out.println((char) b);
}

注意通过索引访问时不会推进 readerIndex （读索引）和 writerIndex（写索引），我们可以通过 ByteBuf 的 readerIndex(index) 或 writerIndex(index) 来分别推进读索引或写索引
flip() 方法来切换读和写模式
ByteBuf 一定符合：0 <= readerIndex <= writerIndex <= capacity。

2.2可丢弃字节的字节

• 标有“可丢弃字节”的段包含已经被读取的字节。他们可以被丢弃，通过调用discardReadBytes() 来回收空间。这个段的初始大小存储在readerIndex，为 0，当“read”操作被执行时递增（“get”操作不会移动 readerIndex）。

2.3可读字节

ByteBuf 的“可读字节”分段存储的是实际数据。
如果所谓的读操作是一个指定 ByteBuf 参数作为写入的对象，并且没有一个目标索引参数，目标缓冲区的 writerIndex 也会增加了。

readBytes(ByteBuf dest);

2.4索引管理

可以设置和重新定位ByteBuf readerIndex 和 writerIndex 通过调用 markReaderIndex(), markWriterIndex(), resetReaderIndex() 和 resetWriterIndex()。这些类似于InputStream 的调用，所不同的是，没有 readlimit 参数来指定当标志变为无效。

也可以通过调用 readerIndex(int) 或 writerIndex(int) 将指标移动到指定的位置。在尝试任何无效位置上设置一个索引将导致 IndexOutOfBoundsException 异常。
调用 clear() 可以同时设置 readerIndex 和 writerIndex 为 0。注意，这不会清除内存中的内容。让我们看看它是如何工作的。

2.5查询操作

最简单的是使用 indexOf() 方法
更复杂的搜索执行以 ByteBufProcessor 为参数的方法
寻找一个回车符，\ r的一个例子

ByteBuf buffer = ...;
int index = buffer.forEachByte(ByteBufProcessor.FIND_CR);

2.6衍生的缓冲区

衍生的缓冲区”是代表一个专门的展示 ByteBuf 内容的“视图”
例

Charset utf8 = Charset.forName("UTF-8");
ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8); //1创建一个 ByteBuf 保存特定字节串。

ByteBuf sliced = buf.slice(0, 14);          //2 创建从索引 0 开始，并在 14 结束的 ByteBuf 的新 slice。
System.out.println(sliced.toString(utf8));  //3 .打印 Netty in Action

buf.setByte(0, (byte) 'J');                 //4
assert buf.getByte(0) == sliced.getByte(0);

另一个例子

Charset utf8 = Charset.forName("UTF-8");
ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);     //1

ByteBuf copy = buf.copy(0, 14);               //2
System.out.println(copy.toString(utf8));      //3

buf.setByte(0, (byte) 'J');                   //4
assert buf.getByte(0) != copy.getByte(0);

2.6读/写操作:2类

• gget()/set() 操作从给定的索引开始，保持不变
• read()/write() 操作从给定的索引开始，与字节访问的数量来适用，递增当前的写索引或读索引

常见的 get() 操作：

方法名称	描述
getBoolean(int)	返回当前索引的 Boolean 值
getByte(int) getUnsignedByte(int)	返回当前索引的(无符号)字节
getMedium(int) getUnsignedMedium(int)	返回当前索引的 (无符号) 24-bit 中间值
getInt(int) getUnsignedInt(int)	返回当前索引的(无符号) 整型
getLong(int) getUnsignedLong(int)	返回当前索引的 (无符号) Long 型
getShort(int) getUnsignedShort(int)	返回当前索引的 (无符号) Short 型
getBytes(int, …)	字节

常见的set()操作：

方法名称	描述
setBoolean(int, boolean)	在指定的索引位置设置 Boolean 值
setByte(int, int)	在指定的索引位置设置 byte 值
setMedium(int, int)	在指定的索引位置设置 24-bit 中间 值
setInt(int, int)	在指定的索引位置设置 int 值
setLong(int, long)	在指定的索引位置设置 long 值
setShort(int, int)	在指定的索引位置设置 short 值

用法:

Charset utf8 = Charset.forName("UTF-8");
ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);    //1 创建一个新的 ByteBuf 给指定 String 保存字节
System.out.println((char)buf.getByte(0));                    //2 打印的第一个字符，

int readerIndex = buf.readerIndex();                        //3 存储当前 readerIndex 和 writerIndex
int writerIndex = buf.writerIndex();

buf.setByte(0, (byte)'B');                            //4 更新索引 0 的字符

System.out.println((char)buf.getByte(0));                    //5 打印出的第一个字符，现在是B
assert readerIndex == buf.readerIndex();                    //6 这些断言成功，因为这些操作永远不会改变索引
assert writerIndex ==  buf.writerIndex();

read() 方法

方法名称	描述
readBoolean()	读取当前readerIndex处的布尔值，并将readerIndex增加1。
readByte() readUnsignedByte()	读取当前readerIndex处的（无符号）字节值，并将readerIndex增加1。
readMedium() readUnsignedMedium()	在当前readerIndex处读取（无符号）24位中值，并将readerIndex增加3。
readInt()　readUnsignedInt()	读取当前readerIndex处的（无符号）int值，并将readerIndex增加4。
readLong()　readUnsignedLong()	在当前readerIndex处读取（无符号）long值，并将readerIndex增加8。
readShort()　readUnsignedShort()	在当前readerIndex处读取（无符号）short值，并将readerIndex增加2。
readBytes(int,int, …)	将给定对象中给定长度的当前readerIndex上的值读取到给定对象中。也增加了readerIndex的长度。

• 每个read() 方法都对应一个write()

方法名称	描述
writeBoolean(boolean)	在当前writerIndex上写入布尔值，并将writerIndex增加1。
writeByte(int)	将字节值写入当前writerIndex并将writerIndex增加1。
writeMedium(int)	将中间值写到当前writerIndex上，并使writerIndex增加3。
writeInt(int)	将int值写入当前的writerIndex并将writerIndex增加4。
writeLong(long)	将long值写入当前的writerIndex并将writerIndex增加8。
writeShort(int)	在当前writerIndex上写入short值，并将writerIndex增加2。
writeBytes(int，…）	从给定资源中传输当前writerIndex上的字节。

用法：

Charset utf8 = Charset.forName("UTF-8");
ByteBuf buf = Unpooled.copiedBuffer("Netty in Action rocks!", utf8);    //1 创建一个新的 ByteBuf 保存给定 String 的字节。
System.out.println((char)buf.readByte());                    //2 打印的第一个字符

int readerIndex = buf.readerIndex();                        //3 存储当前的 readerIndex
int writerIndex = buf.writerIndex();                        //4 保存当前的 writerIndex

buf.writeByte((byte)'?');                            //5 更新索引0的字符 B

assert readerIndex == buf.readerIndex();
assert writerIndex != buf.writerIndex();  // 此断言成功，因为 writeByte() 在 5 移动了 writerIndex

2.7更多操作

方法名称	描述
isReadable（）	如果可以读取至少一个字节，则返回true。
isWritable（）	如果可以写入至少一个字节，则返回true。
readableBytes()	返回可以读取的字节数。
writablesBytes（）	返回可以写入的字节数。
capacity()	返回ByteBuf可以容纳的字节数。之后，它将尝试再次扩展，直到达到maxCapacity（）。
maxCapacity（）	返回ByteBuf可以容纳的最大字节数。
hasArray（）	如果ByteBuf由字节数组支持，则返回true。
array（）	如果ByteBuf由字节数组支持，则返回字节数组，否则抛出UnsupportedOperationException.

3.ByteBufHolder的使用

我们时不时的会遇到这样的情况：即需要另外存储除有效的实际数据各种属性值。HTTP响应就是一个很好的例子；与内容一起的字节的还有状态码，cookies等
ByteBufHolder 还提供了对于 Netty 的高级功能，如缓冲池

方法名称	描述
data()	返回 ByteBuf 保存的数据
copy()	制作一个 ByteBufHolder 的拷贝，但不共享其数据(所以数据也是拷贝).

4.ByteBuf 分配

4.1ByteBufAllocator

为了减少分配和释放内存的开销，Netty 通过支持池类 ByteBufAllocator

方法名称	描述
buffer() buffer(int) buffer(int, int)	返回具有基于堆或直接数据存储的ByteBuf。
heapBuffer() heapBuffer(int) heapBuffer(int, int)	返回具有基于堆的存储的ByteBuf。
directBuffer() directBuffer(int) directBuffer(int, int)	返回具有直接存储的ByteBuf。
compositeBuffer() compositeBuffer(int) heapCompositeBuffer() heapCompositeBuffer(int) directCompositeBuffer()directCompositeBuffer(int)	返回一个CompositeByteBuf，可以通过添加基于堆的缓冲区或直接缓冲区来对其进行扩展。
ioBuffer()	返回一个ByteBuf，它将用于套接字上的I / O操作。

一些方法接受整型参数允许用户指定 ByteBuf 的初始和最大容量值
你可以得到从 Channel （在理论上，每 Channel 可具有不同的 ByteBufAllocator ），或通过绑定到的 ChannelHandler 的 ChannelHandlerContext 得到它，用它实现了你数据处理逻辑。

Channel channel = ...;
ByteBufAllocator allocator = channel.alloc(); //1 从 channel 获得 ByteBufAllocator
....
ChannelHandlerContext ctx = ...;
ByteBufAllocator allocator2 = ctx.alloc(); //2 从 ChannelHandlerContext 获得 ByteBufAllocator
...

2种实现

• PooledByteBufAllocator Netty 默认使用 PooledByteBufAllocator
• 其他的实现

4.2ByteBufUtil

当未引用 ByteBufAllocator 时，上面的方法无法访问到 ByteBuf。对于这个用例 Netty 提供一个实用工具类称为 Unpooled,，它提供了静态辅助方法来创建非池化的 ByteBuf 实例

方法名称	描述
buffer() buffer(int) buffer(int, int)	返回具有基于堆的存储的未池化ByteBuf
directBuffer() directBuffer(int) directBuffer(int, int)	返回具有直接存储的未池化ByteBuf
wrappedBuffer()	返回一个ByteBuf，它包装给定的数据。
copiedBuffer()	返回一个ByteBuf，它将复制给定的数据

在 非联网项目，该 Unpooled 类也使得它更容易使用的 ByteBuf API，获得一个高性能的可扩展缓冲 API，而不需要 Netty 的其他部分的。

5.引用计数器

在Netty 4中为 ByteBuf 和 ByteBufHolder（两者都实现了 ReferenceCounted 接口）引入了引用计数器。
它能够在特定的对象上跟踪引用的数目，实现了ReferenceCounted 的类的实例会通常开始于一个活动的引用计数器为 1。而如果对象活动的引用计数器大于0，就会被保证不被释放。当数量引用减少到0，将释放该实例。

Channel channel = ...;
ByteBufAllocator allocator = channel.alloc(); //1 从 channel 获取 ByteBufAllocator
....
ByteBuf buffer = allocator.directBuffer(); //2 从 ByteBufAllocator 分配一个 ByteBuf
assert buffer.refCnt() == 1; //3 检查引用计数器是否是 1
boolean released = buffer.release(); //4 release（）将会递减对象引用的数目。当这个引用计数达到0时，对象已被释放，并且该方法返回 true。
...

第四章 ChannelHandler 和 ChannelPipeline

1.ChannelHandler 家族

1.1 生命周期（顺序如下）

• Channel

状态	描述
1 channelUnregistered	channel已创建但未注册到一个 EventLoop.
2 channelRegistered	channel 注册到一个 EventLoop.
3 channelActive	channel 变为活跃状态(连接到了远程主机)，现在可以接收和发送数据了
4 channelInactive	channel 处于非活跃状态，没有连接到远程主机

• ChannelHandler

当 ChannelHandler 添加到 ChannelPipeline，或者从 ChannelPipeline 移除后，对应的方法将会被调用。每个方法都传入了一个 ChannelHandlerContext 参数

状态	描述
handlerAdded	当 ChannelHandler 添加到 ChannelPipeline 调用
handlerRemoved	当 ChannelHandler 从 ChannelPipeline 移除时调用
exceptionCaught	当 ChannelPipeline 执行抛出异常时调用

1.2 ChannelHandler 子接口

• ChannelInboundHandler - 处理进站数据和所有状态更改事件
• ChannelOutboundHandler - 处理出站数据，允许拦截各种操作

ChannelHandler 适配器
Netty 提供了一个简单的 ChannelHandler 框架实现，给所有声明方法签名。这个类 ChannelHandlerAdapter 的方法,主要推送事件 到 pipeline 下个 ChannelHandler 直到 pipeline 的结束。这个类 也作为 ChannelInboundHandlerAdapter 和ChannelOutboundHandlerAdapter 的基础。所有三个适配器类的目的是作为自己的实现的起点;您可以扩展它们,覆盖你需要自定义的方法。

1.3 ChannelInboundHandler

状态	描述
channelRegistered	当通道注册到其EventLoop并且能够处理I / O时调用。
channelUnregistered	当通道从其EventLoop注销时调用，并且无法处理任何I / O。
channelActive	当通道处于活动状态时调用；通道已连接/绑定并准备就绪。
channelInactive	当Channel保持活动状态并且不再连接到其远程对等方时调用。
channelReadComplete	在通道上的读取操作完成时调用。
channelRead	如果从通道读取数据，则调用。
channelWritabilityChanged	当Channel的可写状态更改时调用。用户可以确保写操作不会太快（有OutOfMemoryError的风险），或者可以在Channel再次变为可写状态时恢复写操作。Channel.isWritable（）可用于检测通道的实际可写性。可写性阈值可以通过Channel.config（）。setWriteHighWaterMark（）和Channel.config（）。setWriteLowWaterMark（）设置。
userEventTriggered(…)	当用户调用Channel.fireUserEventTriggered（…）以将pojo通过ChannelPipeline传递时调用。这可用于通过ChannelPipeline传递用户特定的事件，从而允许处理这些事件。

ChannelInboundHandler 实现覆盖了 channelRead() 方法处理进来的数据用来响应释放资源。Netty 在 ByteBuf 上使用了资源池，所以当执行释放资源时可以减少内存的消耗。

@ChannelHandler.Sharable
public class DiscardHandler extends ChannelInboundHandlerAdapter {        //1 扩展(继承) ChannelInboundHandlerAdapter

    @Override
    public void channelRead(ChannelHandlerContext ctx,
                                     Object msg) {
        ReferenceCountUtil.release(msg); //2 ReferenceCountUtil.release() 来丢弃收到的信息
    }

}

Netty 用一个 WARN-level 日志条目记录未释放的资源,使其能相当简单地找到代码中的违规实例。然而,由于手工管理资源会很繁琐,您可以通过使用 SimpleChannelInboundHandler 简化问题。如下：

@ChannelHandler.Sharable
public class SimpleDiscardHandler extends SimpleChannelInboundHandler