Netty的核心模块(二)

发布于 2021-06-13 631 次阅读

一，服务启动项Bootstrap和ServerBootstrap

Bootstrap是引导启动的意思，一个Netty应用程序通常由一个Bootstrap开始，主要主要作用是配置整个Netty程序，串联各个组件，Netty中Bootstrap类是客户端程序的启动引导配置类，ServerBootstrap是服务器的启动引导配置类

一，AbstractBootstrap抽象类

ServerBootstrap和Bootstrap继承了同一个父类AbstractBootstrap

AbstractBootstrap的API：

bind():绑定服务IP和端口号
group()：绑定EvnetLoopGroup，其实就是绑定BoosGroup和WorkGroup
register()：将通道，绑定到EventLoop中的Selector进行事件循环监听
handler()：为Boostrap的BossGroup绑定Handler，注：不是为WorkerGroup绑定
channel()：指定程序使用通道类对象，如NioSocketChannel.class
option()：用来给本地的ServerChannel通道添加配置
………………

所有方法实例方法抽象方法具体方法弃用方法
修饰符和类型	方法和描述
`<T> B`	`attr(AttributeKey<T> key, T value)` 允许指定新创建的`通道`的初始属性。
`ChannelFuture`	`bind()` 创建一个新`通道`并绑定它。
`ChannelFuture`	`bind(InetAddress inetHost, int inetPort)` 创建一个新`通道`并绑定它。
`ChannelFuture`	`bind(int inetPort)` 创建一个新`通道`并绑定它。
`ChannelFuture`	`bind(SocketAddress localAddress)` 创建一个新`通道`并绑定它。
`ChannelFuture`	`bind(String inetHost, int inetPort)` 创建一个新`通道`并绑定它。
`B`	`channel(Class<? extends C> channelClass)` 用于创建`通道`实例的`类`。
`B`	`channelFactory(ChannelFactory<? extends C> channelFactory)` 荒废的。改用`通道工厂（io.netty.频道.频道工厂）。`
`B`	`channelFactory(ChannelFactory<? extends C> channelFactory)` 用于在调用绑定时创建`通道`实例的`通道工厂。。`
`abstract B`	`clone()` 返回具有相同配置的此引导的深克隆。
`abstract AbstractBootstrapConfig<B,C>`	`config()` 返回可用于获取引导器当前配置的`抽象启动组合`对象。
`EventLoopGroup`	`group()` 荒废的。请改为使用`配置（）` 。
`B`	`group(EventLoopGroup group)` 用于处理要创建频道的所有事件的事件`循环组`
`B`	`handler(ChannelHandler handler)` 用于服务请求的`通道手`。
`B`	`localAddress(InetAddress inetHost, int inetPort)`
`B`	`localAddress(int inetPort)`
`B`	`localAddress(SocketAddress localAddress)` 用于将本地"结束"绑定到的`插座地址`。
`B`	`localAddress(String inetHost, int inetPort)`
`<T> B`	`option(ChannelOption<T> option, T value)` 允许指定`用于频道`实例的`通道`选项，一旦它们被创建。
`ChannelFuture`	`register()` 创建一个新`频道`，并将其注册为`事件循环`。
`String`	`toString()`
`B`	`validate()` 验证所有参数。

二，ServerBootStrap和BootStrap接口

ServerBootstrap API：

childHandler：前面的handler是为BoosGroup绑定Handler，这个是为WorkerGroup绑定Handler
config()：抽象启动主对象
chileOption()：用来给接收到的Channel添加配置

所有方法实例方法具体方法弃用方法
修饰符和类型	方法和描述
`<T> ServerBootstrap`	`childAttr(AttributeKey<T> childKey, T value)` 在每个儿童`频道`上设置具有给定值的特定`属性键`。
`EventLoopGroup`	`childGroup()` 荒废的。请改为使用`配置（）` 。
`ServerBootstrap`	`childHandler(ChannelHandler childHandler)` 设置用于服务频道请求的`通道手`。
`<T> ServerBootstrap`	`childOption(ChannelOption<T> childOption, T value)` 允许指定`用于频道`实例的`通道`选项（在接受者接受`频道`之后）。
`ServerBootstrap`	`clone()` 返回具有相同配置的此引导的深克隆。
`ServerBootstrapConfig`	`config()` 返回可用于获取引导器当前配置的`抽象启动组合`对象。
`ServerBootstrap`	`group(EventLoopGroup group)` 指定用于父（接受者）和孩子（客户端）`的事件循环组`。
`ServerBootstrap`	`group(EventLoopGroup parentGroup, EventLoopGroup childGroup)` 为家长（接受者）和孩子（客户端）设置`事件循环组`。
`ServerBootstrap`	`validate()` 验证所有参数。

Bootstrap API：

connect()：连接远程服务器端，指定IP和端口
remoteAddress()：一旦连接返回一个套接项

所有方法实例方法具体方法
修饰符和类型	方法和描述
`Bootstrap`	`clone()` 返回具有相同配置的此引导的深克隆。
`Bootstrap`	`clone(EventLoopGroup group)` 返回此引导程序的深克隆，其配置相同，但使用给定`事件循环组`。
`BootstrapConfig`	`config()` 返回可用于获取引导器当前配置的`抽象启动组合`对象。
`ChannelFuture`	`connect()` 将`通道`连接到远程对等项。
`ChannelFuture`	`connect(InetAddress inetHost, int inetPort)` 将`通道`连接到远程对等项。
`ChannelFuture`	`connect(SocketAddress remoteAddress)` 将`通道`连接到远程对等项。
`ChannelFuture`	`connect(SocketAddress remoteAddress, SocketAddress localAddress)` 将`通道`连接到远程对等项。
`ChannelFuture`	`connect(String inetHost, int inetPort)` 将`通道`连接到远程对等项。
`Bootstrap`	`remoteAddress(InetAddress inetHost, int inetPort)`
`Bootstrap`	`remoteAddress(SocketAddress remoteAddress)` 一旦连接`（）`方法被调用，将连接到`套接地址`。
`Bootstrap`	`remoteAddress(String inetHost, int inetPort)`
`Bootstrap`	`resolver(AddressResolverGroup<?> resolver)` 设置`名称解体`，这将解决未解决的命名地址的地址。
`Bootstrap`	`validate()` 验证所有参数。

二，netty中的Channel

NIO中Channel的概念和Netty中的Channel大同小异，但Netty中Channel做了很多封装，对不同的应用场景，有不同的Channel对象进行处理

Channel的作用：

1）Netty的通信组件中，Channel能够用于执行网络IO操作

2）通过Channel可获得当前网络连接的通道状态

3）通过Channel可获得网络连接的配置参数，例如：缓冲区的大小，Pipline对象

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

5）调用立即返回一个ChannelFture实类对象，通过注册监听到ChannelFuture上，可以IO操作成功，失败或者取消回调通知调用方

6）支持关联IO操作与处理抽象

不同协议，不同堵塞类型的连接都有不同的Channel类型与之应

常见的Channel类型有：

NioSocketChannel：异步的客户端TCP Socket连接
NioServerSocketChannel：异步的服务端TCP Socket连接
NioDatagramChannel：异步的UDP连接
NioSctpChannel：异步的客户端Sctp连接
NioSctpServerChannel：异步的Sctp服务器端连接，这些通道涵盖了UDP和TCP网络IO以及文件IO

NioServerSocketChannel API:

所有方法实例方法具体方法
修饰符和类型	方法和说明
`SocketChannelConfig`	`config()` 返回此通道的配置。
`protected void`	`doBind(SocketAddress localAddress)` 绑定`Channel`到`SocketAddress`
`protected void`	`doClose()` 关上 `Channel`
`protected boolean`	`doConnect(SocketAddress remoteAddress, SocketAddress localAddress)` 连接到远程对等方
`protected void`	`doDisconnect()` 断开`Channel`它与其远程对等方的连接
`protected void`	`doFinishConnect()` 完成连接
`protected int`	`doReadBytes(ByteBuf byteBuf)` 将字节读入给定值`ByteBuf`并返回数量。
`protected void`	`doShutdownOutput()` 当条件证明关闭通道的输出部分时调用。
`protected void`	`doWrite(ChannelOutboundBuffer in)` 将给定缓冲区的内容刷新到远程对等方。
`protected int`	`doWriteBytes(ByteBuf buf)` 写入字节形成给`ByteBuf`底层的`Channel`.
`protected long`	`doWriteFileRegion(FileRegion region)` 写一个 `FileRegion`
`boolean`	`isActive()` `true`如果处于`Channel`活动状态并且已连接，则返回。
`boolean`	`isInputShutdown()` 返回`true`当且仅当，使得没有更多的数据是从该信道接收的远端对等体的关闭它的输出。
`protected boolean`	`isInputShutdown0()`
`boolean`	`isOutputShutdown()`
`boolean`	`isShutdown()` 确定该通道的输入和输出是否都已关闭。
`protected SocketChannel`	`javaChannel()`
`InetSocketAddress`	`localAddress()` 返回此通道绑定到的本地地址。
`protected SocketAddress`	`localAddress0()` 返回`SocketAddress`本地绑定的。
`protected AbstractNioChannel.AbstractNioUnsafe`	`newUnsafe()` 创建一个新`AbstractChannel.AbstractUnsafe`实例，该实例将在整个生命周期内使用`Channel`
`ServerSocketChannel`	`parent()` 返回此频道的父级。
`InetSocketAddress`	`remoteAddress()` 返回此通道连接到的远程地址。
`protected SocketAddress`	`remoteAddress0()` 返回`SocketAddress`其`Channel`被连接到。
`ChannelFuture`	`shutdown()` 将关闭该通道的输入和输出侧。
`ChannelFuture`	`shutdown(ChannelPromise promise)` 将关闭该通道的输入和输出侧。
`ChannelFuture`	`shutdownInput()` 关闭通道的输入端。
`ChannelFuture`	`shutdownInput(ChannelPromise promise)` 将关闭输入并通知`ChannelPromise`。
`ChannelFuture`	`shutdownOutput()`
`ChannelFuture`	`shutdownOutput(ChannelPromise promise)` 将关闭输出并通知`ChannelPromise`。

三，netty中的Selector

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

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

四，netty中的ChannelHandler处理器

netty中的Handler都是ChannnelHandler的子接口或者子类

1）channelHandler是一个接口，处理I/O事件或者拦截I/O操作，并将其转发到其ChannelPipeline(业务处理链)中

2）ChannelHandler本身并没有提供很多方法，因为这个接口有许多的子接口和子类实现，它的子接口和子类很多

① ChannelHandler有着庞大的实现类，但直接子接口和直接子类只有几个

② ChannelHandler直接子接口关系图

ChannelInboundHandler：用于处理入站I/O事件

ChannelOutboundHandler：用于处理出站的I/O事件

适配器：

ChannelInboundHandlerAdapter：用于处理入站I/O事件
ChannelOutboundHandlerAdapter：用于处理出站的I/O操作
ChannelDuplexHandler：用于处理入站和出站的事件

③ ChannelHandler的API(以ChannelInboundHandlerAdapter为例)

channelActive()：通道就绪事件
channelRead()：通道读取数据事件
channelReadComplete()：通道读取完毕事件
exceptionCaught()：通道发生异常事件
handlerAdded()：连接建立执行的事件

所有方法实例方法具体方法
修饰符和类型	方法和描述
`void`	`channelActive(ChannelHandlerContext ctx)` 调用`通道手语文本.fire渠道活动（）`转发到下一个`通道入境手`在`通道线`。
`void`	`channelInactive(ChannelHandlerContext ctx)` 调用`频道手语文本.fire渠道不活跃（）`转发到下一个`通道入境手`在`通道线`。
`void`	`channelRead(ChannelHandlerContext ctx, Object msg)` 调用`频道手语文本.fire频道阅读（对象）`转发到下一个`频道入境手`在`频道管`。
`void`	`channelReadComplete(ChannelHandlerContext ctx)` 调用`频道手语文本.fire频道阅读完成（）`转发到下一个`频道入境手`在`频道线`。
`void`	`channelRegistered(ChannelHandlerContext ctx)` 呼叫`频道手语文本.fire通道注册（）`转发到通道线的下一个`通道进站手`。
`void`	`channelUnregistered(ChannelHandlerContext ctx)` 呼叫`频道手语文本.fire 通道未注册（）`转发到`通道线`的下一个通道`入境手`。
`void`	`channelWritabilityChanged(ChannelHandlerContext ctx)` 调用`频道手语文本.fire频道可行性更改（）`转发到`通道线`的下一个通道`进站手`。
`void`	`exceptionCaught(ChannelHandlerContext ctx, Throwable cause)` 调用`频道手语文本.fire除名（可投掷）`转发到`通道线`的下一个通道`手`。
`void`	`userEventTriggered(ChannelHandlerContext ctx, Object evt)` 调用`通道手架文本.fire使用者触发（对象）`转发到下一个`通道入境手`在`通道线`。

五，Pipeline和ChannelPipeline管道

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

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

3）在Netty中每一个Channel都有且仅有一个ChannelPipeline与之对应，它组成的关系如下：

一个Channel包含了一个ChannelPipeline(其实也是互相包含的关系)，而ChannelPipeline中又维护了一个由ChannelHandler和ChannelHandlerContext组成的双向链表，每一个ChannelHandler和ChannelHandlerContext都是相互关联的关系
入站事件和出站事件在一个双向链表中，入站事件会从链表head往后传递到最后一个入站的handler，出站事件会从链表tail往前传递到最前一个出站的handler，两种类型的Handler互不干扰

ChannelPipeline的API：

addAfter()：在当前的Channelhandler之前再插入Handler
addBefore()：在当前的Channelhandler之后再插入Handler
addFirst()：在第一个位置插入Channelhannel
addLast()：在最后一个位置插入Channelhannel
remove()：移除Channelhandler处理器
removeFirst()：移除第一个Channelhandler处理器
removeLast()：移除最后一个Channelhandler处理器
replace()：替换Channelhandler处理器
channel()：在Pipeline中获取channel，channel和Pipeline是相互获取，相互包含的
context()：返回上下文对象
name()：返回Channelhandler处理器的名字

所有方法实例方法抽象方法
修饰符和类型	方法和描述
`ChannelPipeline`	`addAfter(EventExecutorGroup group, String baseName, String name, ChannelHandler handler)` 在该管道的现有处理程序后插入`通道手`。
`ChannelPipeline`	`addAfter(String baseName, String name, ChannelHandler handler)` 在该管道的现有处理程序后插入`通道手`。
`ChannelPipeline`	`addBefore(EventExecutorGroup group, String baseName, String name, ChannelHandler handler)` 在该管道的现有处理器之前插入`通道手`。
`ChannelPipeline`	`addBefore(String baseName, String name, ChannelHandler handler)` 在该管道的现有处理器之前插入`通道手`。
`ChannelPipeline`	`addFirst(ChannelHandler... handlers)` 将`通道手`插入此管道的第一位置。
`ChannelPipeline`	`addFirst(EventExecutorGroup group, ChannelHandler... handlers)` 将`通道手`插入此管道的第一位置。
`ChannelPipeline`	`addFirst(EventExecutorGroup group, String name, ChannelHandler handler)` 在管道的第一位置插入`通道手`。
`ChannelPipeline`	`addFirst(String name, ChannelHandler handler)` 在管道的第一位置插入`通道手`。
`ChannelPipeline`	`addLast(ChannelHandler... handlers)` 将`通道手`插入此管道的最后位置。
`ChannelPipeline`	`addLast(EventExecutorGroup group, ChannelHandler... handlers)` 将`通道手`插入此管道的最后位置。
`ChannelPipeline`	`addLast(EventExecutorGroup group, String name, ChannelHandler handler)` 在此管道的最后位置附加一个`通道手`。
`ChannelPipeline`	`addLast(String name, ChannelHandler handler)` 在此管道的最后位置附加一个`通道手`。
`Channel`	`channel()` 返回此管道连接到的`通道`。
`ChannelHandlerContext`	`context(ChannelHandler handler)` 在此管道中返回指定`通道手的`上下文对象。
`ChannelHandlerContext`	`context(Class<? extends ChannelHandler> handlerType)` 返回此管道中指定类型`通道手`的上下文对象。
`ChannelHandlerContext`	`context(String name)` 返回`通道手`的上下文对象，并在该管道中使用指定名称。
`ChannelPipeline`	`fireChannelActive()` `通道`现在处于活动状态，这意味着它已连接。
`ChannelPipeline`	`fireChannelInactive()` `通道`现在处于非活动状态，这意味着它已关闭。
`ChannelPipeline`	`fireChannelRead(Object msg)` `频道`收到消息。
`ChannelPipeline`	`fireChannelReadComplete()` 触发一个`频道入境手.频道阅读完成（频道手语文本）`事件到下一个`频道入境手`在`频道线`。
`ChannelPipeline`	`fireChannelRegistered()` 一个`频道`注册到其`活动循环`。
`ChannelPipeline`	`fireChannelUnregistered()` 一个`频道`没有从其`活动循环中`注册。
`ChannelPipeline`	`fireChannelWritabilityChanged()` 触发`频道进站手.通道可更改（通道手语文本）`事件到`通道线`中的下一个通道`入境手`。
`ChannelPipeline`	`fireExceptionCaught(Throwable cause)` `一个通道`在其一个进站操作中收到了`可扔`的。
`ChannelPipeline`	`fireUserEventTriggered(Object event)` `频道`收到用户定义的事件。
`ChannelHandler`	`first()` 返回此管道中的第一个`通道手`。
`ChannelHandlerContext`	`firstContext()` 返回此管道中的第一个`通道手`的上下文。
`ChannelPipeline`	`flush()` 请求通过此通道外调用者冲洗所有待处理的消息。
`<T extends ChannelHandler> T`	`get(Class<T> handlerType)` 返回此管道中指定类型的`通道手`。
`ChannelHandler`	`get(String name)` 返回`通道手，`在此管道中注明名称。
`ChannelHandler`	`last()` 返回此管道中的最后一`个通道手`。
`ChannelHandlerContext`	`lastContext()` 返回此管道中最后一个`通道手的`上下文。
`List<String>`	`names()` Returns the `List` of the handler names.
`ChannelPipeline`	`remove(ChannelHandler handler)` Removes the specified `ChannelHandler` from this pipeline.
`<T extends ChannelHandler> T`	`remove(Class<T> handlerType)` Removes the `ChannelHandler` of the specified type from this pipeline.
`ChannelHandler`	`remove(String name)` Removes the `ChannelHandler` with the specified name from this pipeline.
`ChannelHandler`	`removeFirst()` Removes the first `ChannelHandler` in this pipeline.
`ChannelHandler`	`removeLast()` Removes the last `ChannelHandler` in this pipeline.
`ChannelPipeline`	`replace(ChannelHandler oldHandler, String newName, ChannelHandler newHandler)` Replaces the specified `ChannelHandler` with a new handler in this pipeline.
`<T extends ChannelHandler> T`	`replace(Class<T> oldHandlerType, String newName, ChannelHandler newHandler)` Replaces the `ChannelHandler` of the specified type with a new handler in this pipeline.
`ChannelHandler`	`replace(String oldName, String newName, ChannelHandler newHandler)` Replaces the `ChannelHandler` of the specified name with a new handler in this pipeline.
`Map<String,ChannelHandler>`	`toMap()` Converts this pipeline into an ordered `Map` whose keys are handler names and whose values are handlers.

六，ChannelHandlerContext上下文对象

ChannelHandlerContext保存了Channel相关的所以上下文信息，关联一个ChannelHandler对象，同时它也绑定了对应的pipeline和channel的信息，方便ChannelHandler进行调用

常用API：

close()：关闭通道
flush()：刷新
writerAndFlush()：将数据写到ChannelPipline中当前ChannelHandler的下一个ChannelHandler开始处理(出站)

所有方法实例方法抽象方法弃用方法
修饰符和类型	方法和描述
`ByteBufAllocator`	`alloc()` 返回分配的`拜特布夫分配器`，用于分配`拜特布夫`。
`<T> Attribute<T>`	`attr(AttributeKey<T> key)` 荒废的。使用`属性Map.attr（属性键）`
`Channel`	`channel()` 返回绑定到`通道手语的通道`。
`EventExecutor`	`executor()` 返回用于执行任意任务`的事件执行器`。
`ChannelHandlerContext`	`fireChannelActive()` `通道`现在处于活动状态，这意味着它已连接。
`ChannelHandlerContext`	`fireChannelInactive()` `通道`现在处于非活动状态，这意味着它已关闭。
`ChannelHandlerContext`	`fireChannelRead(Object msg)` `频道`收到消息。
`ChannelHandlerContext`	`fireChannelReadComplete()` 触发一个`频道入境手.频道阅读完成（频道手语文本）`事件到下一个`频道入境手`在`频道线`。
`ChannelHandlerContext`	`fireChannelRegistered()` 一个`频道`注册到其`活动循环`。
`ChannelHandlerContext`	`fireChannelUnregistered()` 一个`频道`没有从其`活动循环中`注册。
`ChannelHandlerContext`	`fireChannelWritabilityChanged()` 触发`频道进站手.通道可更改（通道手语文本）`事件到`通道线`中的下一个通道`入境手`。
`ChannelHandlerContext`	`fireExceptionCaught(Throwable cause)` `一个通道`在其一个进站操作中收到了`可扔`的。
`ChannelHandlerContext`	`fireUserEventTriggered(Object evt)` `频道`收到用户定义的事件。
`ChannelHandlerContext`	`flush()` 请求通过此通道外调用者冲洗所有待处理的消息。
`ChannelHandler`	`handler()` `绑`定这个`频道手的通道手语。`
`<T> boolean`	`hasAttr(AttributeKey<T> key)` 荒废的。使用`属性Map.哈塞特（属性键）`
`boolean`	`isRemoved()` 返回，如果属于此上下文的`通道手`从`频道线`中删除。`true`
`String`	`name()` `海峡汉德勒语文`的独特名称。这个名字是使用时，`然后频道手`被添加到`频道管`线。
`ChannelPipeline`	`pipeline()` 返回指定的`通道线`
`ChannelHandlerContext`	`read()` 请求将`来自 Channel`的数据读取到第一个入站缓冲区，如果读取数据，则触发`Channel 入站手控器.channelRead（通道手语、对象）`事件，并触发`通道阅读完成`事件，以便处理程序可以决定继续阅读。

七，EventLoopGroup和其实现类NioEventLoopGroup

基本概念：

1，EventLoopGroup是一组EventLoop的抽象，Netty为了更好的利用多核CPU资源，一般有多个EventLoop同时工作，每一个EventLoop都维护了一个Selector对象实例

2，EventLoopGroup包含了一组EventLoop，它提供了Next接口，可以按照一定规则从组中获取一个EventLoop来处理任务，在Netty服务器架构中一般提供两给EventLoopGroup，例如：BossEventLoopGroup和WorkerEventLoopGroup

3，通常一个服务端口即一个ServerSocketChannel对应一个Selector和一个EventLoop线程，BossEventLoopGroup负责接收客户端的连接并将SocketChannel交给WorkerEventLoopGroup进行IO处理

处理流程：

BoosEventLoopGroup通常是一个单线程的EventLoop，EventLoop维护着一个注册了ServerSocketChannel的selector实例，BoosEventLoopGroup不断轮询selector将连接事件分离出来进行单独处理
通常OP_ACCEPT事件，然后将接收到的SocketChannel交给WorkerEventLoopGroup
WorkerEventLoopGroup会由next选择其中一个EventLoop来将这个SocketChannel注册到其维护的Select并对其后续的IO进行处理

二，EventLoopGroup的继承关系和API

EventLoopGroup的常用API：

shoudownGracefully()：断开连接
next()：获取下一个事件EventLoop
register()：在Selector中注册Channel事件

Modifier and Type	Method and Description
`boolean`	`isShuttingDown()` Returns if and only if all `EventExecutor`s managed by this `EventExecutorGroup` are being shut down gracefully or was shut down.`true`
`Iterator<EventExecutor>`	`iterator()`
`EventExecutor`	`next()` 返回由此`事件执行者组管理的事件执行人`之一。
`<V> ScheduledFuture<V>`	`schedule(Callable<V> callable, long delay, TimeUnit unit)`
`ScheduledFuture<?>`	`schedule(Runnable command, long delay, TimeUnit unit)`
`ScheduledFuture<?>`	`scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit)`
`ScheduledFuture<?>`	`scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit)`
`void`	`shutdown()` 荒废的。 `关闭（长，长，时间统一）`或`关闭（）`代替。
`Future<?>`	`shutdownGracefully()` 具有合理默认值的关闭快捷方法`（长、长、时间单位）。`
`Future<?>`	`shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit)` 向此执行人发出信号，呼叫者希望关闭执行人。
`List<Runnable>`	`shutdownNow()` 荒废的。 `关闭（长，长，时间统一）`或`关闭（）`代替。
`<T> Future<T>`	`submit(Callable<T> task)`
`Future<?>`	`submit(Runnable task)`
`<T> Future<T>`	`submit(Runnable task, T result)`
`Future<?>`	`terminationFuture()` 返回由此事件执行者`组`管理的所有`事件执行人`已终止后通知`的未来`。

修饰符和类型	方法和描述
`EventLoop`	`next()` 返回下一`个事件循环`使用
`ChannelFuture`	`register(Channel channel)` 注册一个`频道`与此`事件循环`。
`ChannelFuture`	`register(Channel channel, ChannelPromise promise)` 荒废的。改为使用`注册（渠道承诺）。`
`ChannelFuture`	`register(ChannelPromise promise)` 使用`通道`未来注册此`事件循环的频道`。

八，Unpooled类

Netty提供了一个专门用于操作缓冲区(即Netty的数据容器)的工具类它就是Unpooled

Unpooled类是java.netty.buffer包下的一个类，我们操作Buf大多用这个类，当然根据应用场景也会选择用其他类

注：在Netty中Buffer不需要fila进行反转，假如是NIO操作Buffer读写切换时都需要进行反转，当netty不需要，它底层维护了Readerindex和Writerindex，Readerindex针对读，Writerindex针对写

Unpooled的API：

buffer()：创建一个缓冲区
copiedBuffer()：可以输入指定内容，并将内容加入到缓冲区并返回

修饰符和类型	方法和描述
`static ByteBuf`	`buffer()` 创建一个新的大端爪哇堆缓冲器，初始容量相当小，可无限地按需扩展其容量。
`static ByteBuf`	`buffer(int initialCapacity)` 创建一个新的大端爪哇堆缓冲器与指定的，它无限地扩大其容量的需求。`capacity`
`static ByteBuf`	`buffer(int initialCapacity, int maxCapacity)` 创建一个新的大端爪哇堆缓冲区与指定的，可能成长为新的缓冲区和是。`initialCapacitymaxCapacityreaderIndexwriterIndex0`
`static CompositeByteBuf`	`compositeBuffer()` 返回一个新的大端复合缓冲区，没有组件。
`static CompositeByteBuf`	`compositeBuffer(int maxNumComponents)` 返回一个新的大端复合缓冲区，没有组件。
`static ByteBuf`	`copiedBuffer(byte[]... arrays)` 创建一个新的大端缓冲区，其内容是指定的合并副本。`arrays`
`static ByteBuf`	`copiedBuffer(byte[] array)` 创建一个新的大端缓冲区，其内容是指定的副本。`array`
`static ByteBuf`	`copiedBuffer(byte[] array, int offset, int length)` 创建一个新的大端缓冲区，其内容是指定子区域的副本。`array`
`static ByteBuf`	`copiedBuffer(ByteBuf... buffers)` 创建一个新的缓冲区，其内容是指定的"可读字节"的合并副本。`buffers`
`static ByteBuf`	`copiedBuffer(ByteBuf buffer)` 创建一个新的缓冲区，其内容是指定的可读字节的副本。`buffer`
`static ByteBuf`	`copiedBuffer(ByteBuffer... buffers)` 创建一个新的缓冲区，其内容是指定"切片"的合并副本。`buffers`
`static ByteBuf`	`copiedBuffer(ByteBuffer buffer)` 创建一个新的缓冲区，其内容是指定当前切片的副本。`buffer`
`static ByteBuf`	`copiedBuffer(char[] array, Charset charset)` 创建一个新的大端缓冲区，其内容在指定的编码中指定。`arraycharset`
`static ByteBuf`	`copiedBuffer(char[] array, int offset, int length, Charset charset)` 创建一个新的大端缓冲区，其内容是指定编码的子区域。`arraycharset`
`static ByteBuf`	`copiedBuffer(CharSequence string, Charset charset)` 创建一个新的大端缓冲区，其内容在指定的编码中指定。`stringcharset`
`static ByteBuf`	`copiedBuffer(CharSequence string, int offset, int length, Charset charset)` 创建一个新的大端缓冲区，其内容是指定编码的子区域。`stringcharset`
`static ByteBuf`	`copyBoolean(boolean... values)` 创建一个新的大端缓冲区，该缓冲区可容纳指定的布尔值序列。
`static ByteBuf`	`copyBoolean(boolean value)` 创建一个新的单节大端缓冲区，该缓冲区具有指定的布尔值。
`static ByteBuf`	`copyDouble(double... values)` 创建一个新的大端缓冲区，该缓冲区可容纳指定的 64 位浮动点数序列。
`static ByteBuf`	`copyDouble(double value)` 创建一个新的 8 节大端缓冲区，该缓冲区保留指定的 64 位浮动点编号。
`static ByteBuf`	`copyFloat(float... values)` 创建一个新的大端缓冲区，该缓冲区保留指定的 32 位浮动点数的序列。

九，netty的编码和解码

在编写网络应用时，因为数据在网络中传输的都是二进制字节码数据，在发送数据时需要编码，接收数据时就需要解码

Codec(编解码器)的组成部分有两个：decoder(解码器)和encode(编码器)，encoder负责把业务数据转化成字节码数据，decoder负责把子码数据转化成业务数据

Netty本身的编解码的机制和问题：

1）Netty自身根据不同协议提供了一些codec(编解码器)

io.netty.handler.codec.http：针对于http协议客户端和服务器数据传输的编解码
io.netty.handler.codec.protobuf：一种全新的编解码机制，它适应于tcp+protobuf数据传输，只会会单独说
io.netty.handler.codec.json：针对于json数据的编解码
io.netty.handler.codec.dns：针对dns协议的数据传输的编解码

2）Netty提供的编码器：

StringEncoder：对字符串进行编码
ObjectEncode：对java对象进行编码
………………

3）Netty提供的解码器：

StringEncoder：对字符串进行解码
ObjectEncode：对java对象进行解码
………………

4）Netty本身自带的ObjectDecoder和ObjectEncode可以用来实现POJO对象或者各种业务对象的编码和解码，底层使用的依旧是java原生序列化技术，而java序列化技术本身效率并不高，存在如下问题：

无法跨语言：什么语言进行编码，就要什么语言进行解码
序列化体积大：是二机制编码的五倍
序列化性能太低

针对这个问题netty引进了一个新的方案：Google的Protobuf编解码器

Author

WQL

路漫漫其修远兮,吾将上下而求索

WQL