ChannelPipeline (Netty API Reference (4.1.22.Final))

All Superinterfaces:

ChannelInboundInvoker ， ChannelOutboundInvoker ，java.lang.Iterable <java.util.Map.Entry <java.lang.String中， ChannelHandler >>

所有已知实现类：

DefaultChannelPipeline
```
public interface ChannelPipeline
extends ChannelInboundInvoker, ChannelOutboundInvoker, java.lang.Iterable<java.util.Map.Entry<java.lang.String,ChannelHandler>>
```
处理或截取Channel的入站事件和出站操作的ChannelHandler列表。 ChannelPipeline实现了Intercepting Filter模式的高级形式，以便用户完全控制事件处理方式以及管道中的ChannelHandler如何相互交互。
创建管道
每个通道都有自己的管道，并且在创建新通道时自动创建。
事件如何在管道中流动
下面的图表描述了如何I / O事件由处理ChannelHandler个 S IN一个ChannelPipeline典型。 I / O事件由ChannelInboundHandler或ChannelOutboundHandler处理，并通过调用ChannelHandlerContext中定义的事件传播方法（如ChannelHandlerContext.fireChannelRead(Object)和ChannelOutboundInvoker.write(Object)）转发给其最近的处理程序。
```
  I/O Request
                                            via Channel or
                                        ChannelHandlerContext
                                                      |
  +---------------------------------------------------+---------------+
  |                           ChannelPipeline         |               |
  |                                                  \|/              |
  |    +---------------------+            +-----------+----------+    |
  |    | Inbound Handler  N  |            | Outbound Handler  1  |    |
  |    +----------+----------+            +-----------+----------+    |
  |              /|\                                  |               |
  |               |                                  \|/              |
  |    +----------+----------+            +-----------+----------+    |
  |    | Inbound Handler N-1 |            | Outbound Handler  2  |    |
  |    +----------+----------+            +-----------+----------+    |
  |              /|\                                  .               |
  |               .                                   .               |
  | ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()|
  |        [ method call]                       [method call]         |
  |               .                                   .               |
  |               .                                  \|/              |
  |    +----------+----------+            +-----------+----------+    |
  |    | Inbound Handler  2  |            | Outbound Handler M-1 |    |
  |    +----------+----------+            +-----------+----------+    |
  |              /|\                                  |               |
  |               |                                  \|/              |
  |    +----------+----------+            +-----------+----------+    |
  |    | Inbound Handler  1  |            | Outbound Handler  M  |    |
  |    +----------+----------+            +-----------+----------+    |
  |              /|\                                  |               |
  +---------------+-----------------------------------+---------------+
                  |                                  \|/
  +---------------+-----------------------------------+---------------+
  |               |                                   |               |
  |       [ Socket.read() ]                    [ Socket.write() ]     |
  |                                                                   |
  |  Netty Internal I/O Threads (Transport Implementation)            |
  +-------------------------------------------------------------------+ 
```
入站事件由入站处理程序以自下而上的方向处理，如图左侧所示。入站处理程序通常处理由图底部的I / O线程生成的入站数据。入站数据通常通过实际的输入操作（如SocketChannel.read(ByteBuffer)从远程对等端SocketChannel.read(ByteBuffer) 。如果入站事件超出顶层入站处理程序，它将被静默放弃，或者在需要您关注时进行记录。
一个出站事件由出站处理程序在自上而下的方向进行处理，如图右侧所示。出站处理程序通常会生成或转换出站流量，如写入请求。如果出站事件超出底部出站处理程序，则由与Channel关联的I / O线程处理。 I / O线程经常执行实际的输出操作，例如SocketChannel.write(ByteBuffer) 。

例如，让我们假设我们创建了以下管道：
```
  ChannelPipeline p = ...;
 p.addLast("1", new InboundHandlerA());
 p.addLast("2", new InboundHandlerB());
 p.addLast("3", new OutboundHandlerA());
 p.addLast("4", new OutboundHandlerB());
 p.addLast("5", new InboundOutboundHandlerX()); 
```
在上面的示例中，名称以Inbound开头的类表示它是入站处理程序。名称以Outbound开头的类表示它是出站处理程序。
在给定的示例配置中，当事件进入时，处理程序评估顺序为1，2，3，4，5。当事件出站时，顺序为5,4,3,2,1。除此原则之外， ChannelPipeline跳过某些处理程序的评估以缩短堆栈深度：
- 3和4不实现ChannelInboundHandler ，因此入站事件的实际评估顺序将为：1,2和5。
- 1和2不执行ChannelOutboundHandler ，因此出站事件的实际评估顺序为： 5，4和3。
- 如果5实施了ChannelInboundHandler和ChannelOutboundHandler ，则入站和出站事件的评估顺序可分别为125和543。
将事件转发给下一个处理程序
正如您在图表中显示的那样，处理程序必须调用ChannelHandlerContext中的事件传播方法才能将事件转发到其下一个处理程序。这些方法包括：
- 入站事件传播方法：
- 出站事件传播方法：
以下示例显示了事件传播通常如何完成：
```
  public class MyInboundHandler extends ChannelInboundHandlerAdapter {
      @Override
     public void channelActive(ChannelHandlerContext ctx) {
         System.out.println("Connected!");
         ctx.fireChannelActive();
     }
 }

 public class MyOutboundHandler extends ChannelOutboundHandlerAdapter {
      @Override
     public void close(ChannelHandlerContext ctx, ChannelPromise promise) {
         System.out.println("Closing ..");
         ctx.close(promise);
     }
 } 
```
建立管道

用户应该在流水线中拥有一个或多个ChannelHandler以接收I / O事件（例如读取）并请求I / O操作（例如写入和关闭）。例如，一个典型的服务器在每个通道的管道中都会有以下处理程序，但是您的里程可能会因协议和业务逻辑的复杂性和特征而异：
1. 协议解码器 - 将二进制数据（例如ByteBuf ）转换为Java对象。
2. 协议编码器 - 将Java对象转换为二进制数据。
3. 业务逻辑处理程序 - 执行实际业务逻辑（例如数据库访问）。
它可以表示为如下例所示：
```
  static final EventExecutorGroup group = new DefaultEventExecutorGroup(16);
 ...

 ChannelPipeline pipeline = ch.pipeline();

 pipeline.addLast("decoder", new MyProtocolDecoder());
 pipeline.addLast("encoder", new MyProtocolEncoder());

 // Tell the pipeline to run MyBusinessLogicHandler's event handler methods
 // in a different thread than an I/O thread so that the I/O thread is not blocked by
 // a time-consuming task.
 // If your business logic is fully asynchronous or finished very quickly, you don't
 // need to specify a group.
 pipeline.addLast(group, "handler", new MyBusinessLogicHandler()); 
```
线程安全

ChannelHandler可随时添加或删除，因为ChannelPipeline是线程安全的。例如，您可以在敏感信息即将交换时插入加密处理程序，并在交换后将其删除。

方法摘要

所有方法接口方法抽象方法
Modifier and Type	Method and Description
`ChannelPipeline`	`addAfter(EventExecutorGroup group, java.lang.String baseName, java.lang.String name, ChannelHandler handler)` 在此管道的现有处理程序之后插入`ChannelHandler` 。
`ChannelPipeline`	`addAfter(java.lang.String baseName, java.lang.String name, ChannelHandler handler)` 在此流水线的现有处理程序之后插入`ChannelHandler` 。
`ChannelPipeline`	`addBefore(EventExecutorGroup group, java.lang.String baseName, java.lang.String name, ChannelHandler handler)` 在此管道的现有处理程序之前插入`ChannelHandler` 。
`ChannelPipeline`	`addBefore(java.lang.String baseName, java.lang.String name, ChannelHandler handler)` 在此管道的现有处理程序之前插入`ChannelHandler` 。
`ChannelPipeline`	`addFirst(ChannelHandler... handlers)` 在此管道的第一个位置插入`ChannelHandler` s。
`ChannelPipeline`	`addFirst(EventExecutorGroup group, ChannelHandler... handlers)` 在此管道的第一个位置插入`ChannelHandler` s。
`ChannelPipeline`	`addFirst(EventExecutorGroup group, java.lang.String name, ChannelHandler handler)` 在此管道的第一个位置插入`ChannelHandler` 。
`ChannelPipeline`	`addFirst(java.lang.String name, ChannelHandler handler)` 在此管道的第一个位置插入`ChannelHandler` 。
`ChannelPipeline`	`addLast(ChannelHandler... handlers)` 在此管道的最后位置插入`ChannelHandler` s。
`ChannelPipeline`	`addLast(EventExecutorGroup group, ChannelHandler... handlers)` 在此管道的最后位置插入`ChannelHandler` s。
`ChannelPipeline`	`addLast(EventExecutorGroup group, java.lang.String name, ChannelHandler handler)` 在此管道的最后位置追加`ChannelHandler` 。
`ChannelPipeline`	`addLast(java.lang.String name, ChannelHandler handler)` 在此管道的最后位置追加`ChannelHandler` 。
`Channel`	`channel()` 返回此管道所连接的`Channel` 。
`ChannelHandlerContext`	`context(ChannelHandler handler)` 返回此管道中指定的`ChannelHandler`的上下文对象。
`ChannelHandlerContext`	`context(java.lang.Class<? extends ChannelHandler> handlerType)` 返回此管道中指定类型的`ChannelHandler`的上下文对象。
`ChannelHandlerContext`	`context(java.lang.String name)` 在此管道中返回具有指定名称的`ChannelHandler`的上下文对象。
`ChannelPipeline`	`fireChannelActive()` A `Channel`现在处于活动状态，这意味着它已连接。
`ChannelPipeline`	`fireChannelInactive()` A `Channel`现在不活动，这意味着它已关闭。
`ChannelPipeline`	`fireChannelRead(java.lang.Object msg)` A `Channel`收到了一条消息。
`ChannelPipeline`	`fireChannelReadComplete()` 触发`ChannelInboundHandler.channelReadComplete(ChannelHandlerContext)`事件到下一个`ChannelInboundHandler`在`ChannelPipeline` 。
`ChannelPipeline`	`fireChannelRegistered()` A `Channel`已注册到其`EventLoop` 。
`ChannelPipeline`	`fireChannelUnregistered()` A `Channel`从其`EventLoop`未注册。
`ChannelPipeline`	`fireChannelWritabilityChanged()` 触发`ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext)`事件到`ChannelPipeline`中的下一个`ChannelInboundHandler` 。
`ChannelPipeline`	`fireExceptionCaught(java.lang.Throwable cause)` A `Channel`在其一次入境业务中收到`Throwable` 。
`ChannelPipeline`	`fireUserEventTriggered(java.lang.Object event)` A `Channel`收到用户定义的事件。
`ChannelHandler`	`first()` 返回此管道中的第一个`ChannelHandler` 。
`ChannelHandlerContext`	`firstContext()` 返回此管道中第一个`ChannelHandler`的上下文。
`ChannelPipeline`	`flush()` 请求通过此ChannelOutboundInvoker清除所有未决消息。
`<T extends ChannelHandler> T`	`get(java.lang.Class<T> handlerType)` 返回此管道中指定类型的`ChannelHandler` 。
`ChannelHandler`	`get(java.lang.String name)` 在此管道中返回具有指定名称的`ChannelHandler` 。
`ChannelHandler`	`last()` 返回此管道中的最后`ChannelHandler` 。
`ChannelHandlerContext`	`lastContext()` 返回此管道中最后一个`ChannelHandler`的上下文。
`java.util.List<java.lang.String>`	`names()` 返回处理程序名称的 `List` 。
`ChannelPipeline`	`remove(ChannelHandler handler)` 从此管道中删除指定的`ChannelHandler` 。
`<T extends ChannelHandler> T`	`remove(java.lang.Class<T> handlerType)` 从此管道中移除指定类型的`ChannelHandler` 。
`ChannelHandler`	`remove(java.lang.String name)` 从此管道中删除具有指定名称的`ChannelHandler` 。
`ChannelHandler`	`removeFirst()` 删除此管道中的第一个`ChannelHandler` 。
`ChannelHandler`	`removeLast()` 删除此管道中的最后`ChannelHandler` 。
`ChannelPipeline`	`replace(ChannelHandler oldHandler, java.lang.String newName, ChannelHandler newHandler)` 用此管道中的新处理程序替换指定的`ChannelHandler` 。
`<T extends ChannelHandler> T`	`replace(java.lang.Class<T> oldHandlerType, java.lang.String newName, ChannelHandler newHandler)` 用此管道中的新处理程序替换指定类型的`ChannelHandler` 。
`ChannelHandler`	`replace(java.lang.String oldName, java.lang.String newName, ChannelHandler newHandler)` 用此管道中的新处理程序替换指定名称的`ChannelHandler` 。
`java.util.Map<java.lang.String,ChannelHandler>`	`toMap()` 将此管道转换为有序的 `Map`其键是处理程序名称，其值是处理程序。

Methods inherited from interface io.netty.channel.ChannelOutboundInvoker
bind, bind, close, close, connect, connect, connect, connect, deregister, deregister, disconnect, disconnect, newFailedFuture, newProgressivePromise, newPromise, newSucceededFuture, read, voidPromise, write, write, writeAndFlush, writeAndFlush

Methods inherited from interface java.lang.Iterable
forEach, iterator, spliterator

- 方法详细信息
  - addFirst
```
ChannelPipeline addFirst(java.lang.String name,
                         ChannelHandler handler)
```
    在此管道的第一个位置插入ChannelHandler 。
    
    参数
    
    name - 首先插入的处理程序的名称
    
    handler - 首先插入的处理程序
    
    异常
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的处理程序是 null
  - addFirst
```
ChannelPipeline addFirst(EventExecutorGroup group,
                         java.lang.String name,
                         ChannelHandler handler)
```
    在此管道的第一个位置插入ChannelHandler 。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler种方法
    
    name - 首先插入的处理程序的名称
    
    handler - 首先插入的处理程序
    
    异常
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的处理程序是 null
  - addLast
```
ChannelPipeline addLast(java.lang.String name,
                        ChannelHandler handler)
```
    在此管道的最后位置追加ChannelHandler 。
    
    参数
    
    name - 要附加的处理程序的名称
    
    handler - 要附加的处理程序
    
    异常
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的处理程序是 null
  - addLast
```
ChannelPipeline addLast(EventExecutorGroup group,
                        java.lang.String name,
                        ChannelHandler handler)
```
    在此管道的最后位置追加ChannelHandler 。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler种方法
    
    name - 要附加的处理程序的名称
    
    handler - 要附加的处理程序
    
    异常
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的处理程序是 null
  - addBefore
```
ChannelPipeline addBefore(java.lang.String baseName,
                          java.lang.String name,
                          ChannelHandler handler)
```
    在此管道的现有处理程序之前插入ChannelHandler 。
    
    参数
    
    baseName - 现有处理程序的名称
    
    name - 之前要插入的处理程序的名称
    
    handler - 之前插入的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果没有指定的 baseName这样的条目
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的baseName或handler是 null
  - addBefore
```
ChannelPipeline addBefore(EventExecutorGroup group,
                          java.lang.String baseName,
                          java.lang.String name,
                          ChannelHandler handler)
```
    在此管道的现有处理程序之前插入ChannelHandler 。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler种方法
    
    baseName - 现有处理程序的名称
    
    name - 之前要插入的处理程序的名称
    
    handler - 之前插入的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果没有指定的 baseName这样的条目
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的baseName或处理程序是 null
  - addAfter
```
ChannelPipeline addAfter(java.lang.String baseName,
                         java.lang.String name,
                         ChannelHandler handler)
```
    在此管道的现有处理程序之后插入ChannelHandler 。
    
    参数
    
    baseName - 现有处理程序的名称
    
    name - 要插入的处理程序的名称
    
    handler - 之后插入的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果没有指定的 baseName这样的条目
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的baseName或处理程序是 null
  - addAfter
```
ChannelPipeline addAfter(EventExecutorGroup group,
                         java.lang.String baseName,
                         java.lang.String name,
                         ChannelHandler handler)
```
    在此管道的现有处理程序之后插入ChannelHandler 。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler种方法
    
    baseName - 现有处理程序的名称
    
    name - 要插入的处理程序的名称
    
    handler - 要插入的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果没有指定的 baseName这样的条目
    
    java.lang.IllegalArgumentException - 如果管道中已存在具有相同名称的条目
    
    java.lang.NullPointerException - 如果指定的baseName或handler是 null
  - addFirst
```
ChannelPipeline addFirst(ChannelHandler... handlers)
```
    在此管道的第一个位置插入ChannelHandler s。
    
    参数
    
    handlers - 首先插入的处理程序
  - addFirst
```
ChannelPipeline addFirst(EventExecutorGroup group,
                         ChannelHandler... handlers)
```
    在此管道的第一个位置插入ChannelHandler s。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler小号方法。
    
    handlers - 首先插入的处理程序
  - addLast
```
ChannelPipeline addLast(ChannelHandler... handlers)
```
    在此管道的最后位置插入ChannelHandler s。
    
    参数
    
    handlers - 最后插入的处理程序
  - addLast
```
ChannelPipeline addLast(EventExecutorGroup group,
                        ChannelHandler... handlers)
```
    在此管道的最后位置插入ChannelHandler s。
    
    参数
    
    group -所述EventExecutorGroup ，其将被用于执行所述ChannelHandler小号方法。
    
    handlers - 最后插入的处理程序
  - remove
```
ChannelPipeline remove(ChannelHandler handler)
```
    从此管道中删除指定的ChannelHandler 。
    
    参数
    
    handler - 将ChannelHandler删除
    
    异常
    
    java.util.NoSuchElementException - 如果在此管道中没有这样的处理程序
    
    java.lang.NullPointerException - 如果指定的处理程序是 null
  - remove
```
ChannelHandler remove(java.lang.String name)
```
    从此管道中删除具有指定名称的ChannelHandler 。
    
    参数
    
    name -在其名称ChannelHandler储存。
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果在此管道中不存在具有指定名称的此类处理程序
    
    java.lang.NullPointerException - 如果指定的名称是 null
  - remove
```
<T extends ChannelHandler> T remove(java.lang.Class<T> handlerType)
```
    从此管道中移除指定类型的ChannelHandler 。
    
    参数类型
    
    T - 处理程序的类型
    
    参数
    
    handlerType - 处理程序的类型
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果在此管道中没有指定类型的此类处理程序
    
    java.lang.NullPointerException - 如果指定的处理程序类型是 null
  - removeFirst
```
ChannelHandler removeFirst()
```
    删除此管道中的第一个ChannelHandler 。
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果此管道是空的
  - removeLast
```
ChannelHandler removeLast()
```
    删除此管道中的最后ChannelHandler 。
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果此管道是空的
  - replace
```
ChannelPipeline replace(ChannelHandler oldHandler,
                        java.lang.String newName,
                        ChannelHandler newHandler)
```
    用此管道中的新处理程序替换指定的ChannelHandler 。
    
    参数
    
    oldHandler - 将被替换的ChannelHandler
    
    newName - 应该添加替换的名称
    
    newHandler - 用作替换的ChannelHandler
    
    结果
    
    本身
    
    异常
    
    java.util.NoSuchElementException - 如果指定的旧处理程序不存在于此管道中
    
    java.lang.IllegalArgumentException - 如果具有指定新名称的处理程序已存在于此管道中，除了要替换的处理程序
    
    java.lang.NullPointerException - 如果指定的旧处理程序或新处理程序是 null
  - replace
```
ChannelHandler replace(java.lang.String oldName,
                       java.lang.String newName,
                       ChannelHandler newHandler)
```
    用此管道中的新处理程序替换指定名称的ChannelHandler 。
    
    参数
    
    oldName - 要替换的ChannelHandler的名称
    
    newName - 应该添加替换的名称
    
    newHandler - 用作替换的ChannelHandler
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果具有指定旧名称的处理程序在此管道中不存在
    
    java.lang.IllegalArgumentException - 如果具有指定新名称的处理程序已经存在于此管道中，除了要替换的处理程序
    
    java.lang.NullPointerException - 如果指定的旧处理程序或新处理程序是 null
  - replace
```
<T extends ChannelHandler> T replace(java.lang.Class<T> oldHandlerType,
                                     java.lang.String newName,
                                     ChannelHandler newHandler)
```
    用此管道中的新处理程序替换指定类型的ChannelHandler 。
    
    参数
    
    oldHandlerType - 要移除的处理程序的类型
    
    newName - 应该添加替换的名称
    
    newHandler - 用作替换的ChannelHandler
    
    结果
    
    删除的处理程序
    
    异常
    
    java.util.NoSuchElementException - 如果指定的旧处理程序类型的处理程序不存在于此管道中
    
    java.lang.IllegalArgumentException - 如果具有指定新名称的处理程序已经存在于此管道中，除了要替换的处理程序
    
    java.lang.NullPointerException - 如果指定的旧处理程序或新处理程序是 null
  - first
```
ChannelHandler first()
```
    返回此管道中的第一个ChannelHandler 。
    
    结果
    
    第一个处理程序。 null如果此管道是空的。
  - firstContext
```
ChannelHandlerContext firstContext()
```
    返回此管道中第一个ChannelHandler的上下文。
    
    结果
    
    第一个处理程序的上下文。 null如果此管道是空的。
  - last
```
ChannelHandler last()
```
    返回此管道中的最后ChannelHandler 。
    
    结果
    
    最后的处理程序。 null如果这条管道是空的。
  - lastContext
```
ChannelHandlerContext lastContext()
```
    返回此管道中最后一个ChannelHandler的上下文。
    
    结果
    
    最后一个处理程序的上下文。 null如果此管道是空的。
  - get
```
ChannelHandler get(java.lang.String name)
```
    在此管道中返回具有指定名称的ChannelHandler 。
    
    结果
    
    具有指定名称的处理程序。 null如果在这个管道中没有这样的处理程序。
  - get
```
<T extends ChannelHandler> T get(java.lang.Class<T> handlerType)
```
    返回此管道中指定类型的ChannelHandler 。
    
    结果
    
    指定处理程序类型的处理程序。 null如果在这个管道中没有这样的处理程序。
  - context
```
ChannelHandlerContext context(ChannelHandler handler)
```
    返回此管道中指定的ChannelHandler的上下文对象。
    
    结果
    
    指定处理程序的上下文对象。 null如果在这个管道中没有这样的处理程序。
  - context
```
ChannelHandlerContext context(java.lang.String name)
```
    返回此管道中具有指定名称的ChannelHandler的上下文对象。
    
    结果
    
    具有指定名称的处理程序的上下文对象。 null如果在这个管道中没有这样的处理程序。
  - context
```
ChannelHandlerContext context(java.lang.Class<? extends ChannelHandler> handlerType)
```
    返回此管道中指定类型的ChannelHandler的上下文对象。
    
    结果
    
    指定类型的处理程序的上下文对象。 null如果在这个管道中没有这样的处理程序。
  - channel
```
Channel channel()
```
    返回此管道所连接的Channel 。
    
    结果
    
    这个频道。 null如果此管道尚未连接。
  - names
```
java.util.List<java.lang.String> names()
```
    返回处理程序名称的 List 。
  - toMap
```
java.util.Map<java.lang.String,ChannelHandler> toMap()
```
    将此管道转换为有序的 Map其键为处理程序名称，其值为处理程序。
  - fireChannelRegistered
```
ChannelPipeline fireChannelRegistered()
```
    从接口复制的描述： ChannelInboundInvoker
    
    A Channel已注册到其EventLoop 。这将导致在具有ChannelInboundHandler.channelRegistered(ChannelHandlerContext)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireChannelRegistered ，界面 ChannelInboundInvoker
  - fireChannelUnregistered
```
ChannelPipeline fireChannelUnregistered()
```
    从接口复制的描述： ChannelInboundInvoker
    
    A Channel从其EventLoop未注册。这将导致在具有ChannelInboundHandler.channelUnregistered(ChannelHandlerContext)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireChannelUnregistered接口 ChannelInboundInvoker
  - fireChannelActive
```
ChannelPipeline fireChannelActive()
```
    从界面复制的描述： ChannelInboundInvoker
    
    A Channel现在处于活动状态，这意味着它已连接。这将导致在具有ChannelInboundHandler.channelActive(ChannelHandlerContext)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireChannelActive在界面 ChannelInboundInvoker
  - fireChannelInactive
```
ChannelPipeline fireChannelInactive()
```
    从接口ChannelInboundInvoker复制的描述
    
    A Channel现在不活动，这意味着它已关闭。这将导致在具有ChannelInboundHandler.channelInactive(ChannelHandlerContext)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireChannelInactive接口 ChannelInboundInvoker
  - fireExceptionCaught
```
ChannelPipeline fireExceptionCaught(java.lang.Throwable cause)
```
    从界面复制的描述： ChannelInboundInvoker
    
    A Channel在其一项入境业务中收到Throwable 。这将导致在具有ChannelInboundHandler.exceptionCaught(ChannelHandlerContext, Throwable)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireExceptionCaught接口 ChannelInboundInvoker
  - fireUserEventTriggered
```
ChannelPipeline fireUserEventTriggered(java.lang.Object event)
```
    从接口ChannelInboundInvoker复制的描述
    
    A Channel收到用户定义的事件。这将导致在具有ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireUserEventTriggered接口 ChannelInboundInvoker
  - fireChannelRead
```
ChannelPipeline fireChannelRead(java.lang.Object msg)
```
    从接口复制的描述： ChannelInboundInvoker
    
    A Channel收到消息。这将导致在具有ChannelInboundHandler.channelRead(ChannelHandlerContext, Object)方法称为下一个的ChannelInboundHandler包含在ChannelPipeline的的Channel 。
    
    Specified by:
    
    fireChannelRead在界面 ChannelInboundInvoker
  - fireChannelReadComplete
```
ChannelPipeline fireChannelReadComplete()
```
    从界面复制的描述： ChannelInboundInvoker
    
    触发ChannelInboundHandler.channelReadComplete(ChannelHandlerContext)事件到下一个ChannelInboundHandler在ChannelPipeline 。
    
    Specified by:
    
    fireChannelReadComplete接口 ChannelInboundInvoker
  - fireChannelWritabilityChanged
```
ChannelPipeline fireChannelWritabilityChanged()
```
    从接口复制的描述： ChannelInboundInvoker
    
    触发ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext)事件到ChannelPipeline中的下一个ChannelInboundHandler 。
    
    Specified by:
    
    fireChannelWritabilityChanged接口 ChannelInboundInvoker
  - flush
```
ChannelPipeline flush()
```
    从接口ChannelOutboundInvoker复制的描述
    
    请求通过此ChannelOutboundInvoker清除所有未决消息。
    
    Specified by:
    
    flush接口 ChannelOutboundInvoker

Interface ChannelPipeline

创建管道

事件如何在管道中流动

将事件转发给下一个处理程序

建立管道

线程安全

方法摘要

Methods inherited from interface io.netty.channel.ChannelOutboundInvoker

Methods inherited from interface java.lang.Iterable

方法详细信息

addFirst

addFirst

addLast

addLast

addBefore

addBefore

addAfter

addAfter

addFirst

addFirst

addLast

addLast

remove

remove

remove

removeFirst

removeLast

replace

replace

replace

first

firstContext

last

lastContext

get

get

context

context

context

channel

names

toMap

fireChannelRegistered

fireChannelUnregistered

fireChannelActive

fireChannelInactive

fireExceptionCaught

fireUserEventTriggered

fireChannelRead

fireChannelReadComplete

fireChannelWritabilityChanged

flush