Netty 小结

1. NioEventLoop 和 NioEventLoopGroup

1. NioEventLoop 表示一个不断循环的执行处理任务的线程。每个NioEventLoop都包含一个Selector，用于监听绑定在它上面的socket通讯。 每个Loop 都有一个线程池，进来的时候会用线程池处理请求。

2. NioEventLoopGroup 相当于一个事件循环组，它下面维护很多个NioEventLoop(事件循环)。NioEventLoopGroup 构造指定的线程数就是创建几个NioEventLoop， 不传的话默认是CPU核数乘以2。EventLoopGroup 提供 next 接口，可以从组里面按照一定规则获取其中一个 EventLoop来处理任务。

2. Bootstrap

　　引导，AbstractBootstrap 抽象类。一个 Netty 应用通常由一个 Bootstrap 开始，主要作用是配置整个 Netty 程序，串联各个组件，Netty 中 Bootstrap 类是客户端程序的启动引导类，ServerBootstrap 是服务端启动引导类， 两个都继承抽象类。

常见的方法有：

(1) io.netty.bootstrap.AbstractBootstrap#group(io.netty.channel.EventLoopGroup) // 该方法用于客户端，用来设置一个 EventLoop

(2) io.netty.bootstrap.ServerBootstrap#group(io.netty.channel.EventLoopGroup, io.netty.channel.EventLoopGroup) // 这个用于服务器端，用来设置两个 EventLoop。 第一个是作为Acceptor线程组接收请求， 第二个是工作线程，对应于childGroup。实际上第一个也是调用父类的方法设为一个group 属性， 第二个参数作为serverBootstrap 特有的 childGroup， 下面childHandler 方法给这个group 设置handler。

(3) io.netty.bootstrap.AbstractBootstrap#channel // 该方法用来设置一个通道实现

(4) io.netty.bootstrap.AbstractBootstrap#handler(io.netty.channel.ChannelHandler) // 该方法用来设置业务处理类（自定义的 handler）. 对应的是参数的第一个EventLoop， 也就是BossGroup。 

(5) io.netty.bootstrap.ServerBootstrap#childHandler(io.netty.channel.ChannelHandler) // 这个方法给workerGroup 设置Handler。

(6) io.netty.bootstrap.AbstractBootstrap#option // 用来给 ServerChannel 添加配置

(7) io.netty.bootstrap.ServerBootstrap#childOption // 用来给接收到的通道添加配置

(8) io.netty.bootstrap.AbstractBootstrap#bind(int) // 该方法用于服务器端，用来设置占用的端口号

(9) io.netty.bootstrap.Bootstrap#connect(java.lang.String, int) // 该方法用于客户端，用来连接服务器端

3. Future、ChannelFuture

　　Netty中的I/O是异步的，包括Bind、Write、Connect等操作会简单的返回一个ChannelFuture。Netty的异步模型是建立在future和fallback基础上的。callback是回调；future的核心思想是：假设一个方法fun，计算过程可能非常耗时，等待fun返回显然不合适。那么可以在调用fun的时候，立马返回一个future，后续通过future去监控方法的处理过程(即： future-listener机制)

例如：

        // 启动服务器并绑定端口。绑定一个端口并且同步，生成一个ChannelFuture对象
        ChannelFuture channelFuture = bootstrap.bind(6666).sync();
        // 绑定端口是异步操作，添加监听器进行处理
        channelFuture.addListener(future -> {
            // isDone 方法来判断当前操作是否完成
            System.out.println(future.isDone());
            // isSuccess 方法来判断已完成的当前操作是否成功；
            System.out.println(future.isSuccess());
            // isCancelled 方法来判断已完成的当前操作是否被取消；
            System.out.println(future.isCancelled());
            if (future.isSuccess()) {
                System.out.println("绑定成功");
            } else {
                System.err.println("6666 端口绑定失败");
            }
        });

4. Channel

Netty 网络通信的组件，能够用于执行网络I/O 操作。

通过Channel 可获得当前网络连接的通道的状态，channel.config() 获取相关信息。

通过Channel 可获得 网络连接的配置参数(例如接收缓冲区大小)。

Channel 提供异步的网络 I/O 操作(如建立连接，读写，绑定端口)，异步调用意味着任何 I/O 调用都将立即返回，并且不保证在调用结束时所请求的 I/O 操作已完成。

调用立即返回一个 ChannelFuture 实例，通过注册监听器到 ChannelFuture 上，可以 I/O 操作成功、失败或取消时回调通知调用方。

支持关联 I/O 操作与对应的处理程序。

不同协议、不同的阻塞类型的连接都有不同的 Channel 类型与之对应。

常用的 Channel 类型：

NioSocketChannel，异步的客户端 TCP Socket 连接。

NioServerSocketChannel，异步的服务器端 TCP Socket 连接。

NioDatagramChannel，异步的 UDP 连接。

NioSctpChannel，异步的客户端 Sctp 连接。

NioSctpServerChannel，异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。

5. Selector

Netty 基于 Selector 对象实现 I/O 多路复用，通过 Selector 一个线程可以监听多个连接的 Channel 事件

当向一个 Selector 中注册 Channel 后，Selector 内部的机制就可以自动不断地查询(Select) 这些注册的 Channel 是否有已就绪的 I/O 事件（例如可读，可写，网络连接完成等），这样程序就可以很简单地使用一个线程高效地管理多个 Channel

6. ChannelHandler

ChannelHandler 是一个接口，处理 I/O 事件或拦截 I/O 操作，并将其转发到其 ChannelPipeline(业务处理链)中的下一个处理程序。

ChannelHandler 本身并没有提供很多方法，可以继承它的子类。主要的子类如下：

1》ChannelInboundHandler 用于处理入站 I/O 事件。

2》ChannelOutboundHandler 用于处理出站 I/O 操作。

//适配器

3》ChannelInboundHandlerAdapter 用于处理入站 I/O 事件。

4》ChannelOutboundHandlerAdapter 用于处理出站 I/O 操作。

5》ChannelDuplexHandler 用于处理入站和出站事件。

 

　　入站和出站是相对ChannelHandler而言的，进入ChannelHandler为入站，从ChannelHandler发出消息是出站。 发数据是出站，接数据是入站，客户端和服务器端都可以收发消息。

7. ChannelPipeline

　　ChannelPipeline 是一个 Handler 的集合，它负责处理和拦截 inbound 或者 outbound 的事件和操作，相当于一个贯穿 Netty 的链。(也可以这样理解：ChannelPipeline 是 保存 ChannelHandler 的 List，用于处理或拦截 Channel 的入站事件和出站操作)

ChannelPipeline 实现了一种高级形式的拦截过滤器模式，使用户可以完全控制事件的处理方式，以及 Channel 中各个的 ChannelHandler 如何相互交互

在 Netty 中每个 Channel 都有且仅有一个 ChannelPipeline 与之对应(io.netty.channel.AbstractChannel#pipeline)。

 

一个 Channel 包含了一个 ChannelPipeline，而 ChannelPipeline 中又维护了一个由ChannelHandlerContext 组成的双向链表，并且每个 ChannelHandlerContext 中又关联着一个ChannelHandler。

入站事件和出站事件在一个双向链表中，入站事件会从链表 head 往后传递到最后一个入站的 handler，出站事件会从链表 tail往前传递到最前一个出站的 handler，两种类型的 handler 互不干扰。

 

比如查看一个ChannelPipeline 结构如下：

 

 　　可以看到是一个双向链表的结构。链表的节点是io.netty.channel.AbstractChannelHandlerContext(这个里面有next和prev 属性)， 其实际类型是io.netty.channel.DefaultChannelHandlerContext， 这个对象内部有个io.netty.channel.ChannelHandler 属性(也就是我们的handler)。

常用方法:

ChannelPipeline addFirst(ChannelHandler… handlers)，把一个业务处理类（handler）添加到链中的第一个位置

ChannelPipeline addLast(ChannelHandler… handlers)，把一个业务处理类（handler）添加到链中的最后一个位置

8. ChannelHandlerContext

保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。保存 Channel 相关的所有上下文信息，同时关联一个 ChannelHandler 对象。

常用方法：

ChannelFuture close()，关闭通道

ChannelOutboundInvoker flush()，刷新

ChannelFuture writeAndFlush(Object msg) ， 将 数 据 写 到 ChannelPipeline 中 当 前ChannelHandler， 下一个 ChannelHandler 开始处理（出站）