ChannelPipeline (Netty/Transport 4.0.26.Final API)

All Superinterfaces:

Iterable<Map.Entry<String,ChannelHandler>>
```
public interface ChannelPipeline
extends Iterable<Map.Entry<String,ChannelHandler>>
```
A list of ChannelHandlers which handles or intercepts inbound events and outbound operations of a Channel. ChannelPipeline implements an advanced form of the Intercepting Filter pattern to give a user full control over how an event is handled and how the ChannelHandlers in a pipeline interact with each other.
Creation of a pipeline
Each channel has its own pipeline and it is created automatically when a new channel is created.
How an event flows in a pipeline
The following diagram describes how I/O events are processed by ChannelHandlers in a ChannelPipeline typically. An I/O event is handled by either a ChannelInboundHandler or a ChannelOutboundHandler and be forwarded to its closest handler by calling the event propagation methods defined in ChannelHandlerContext, such as ChannelHandlerContext.fireChannelRead(Object) and ChannelHandlerContext.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)            |
  +-------------------------------------------------------------------+
 
```
An inbound event is handled by the inbound handlers in the bottom-up direction as shown on the left side of the diagram. An inbound handler usually handles the inbound data generated by the I/O thread on the bottom of the diagram. The inbound data is often read from a remote peer via the actual input operation such as SocketChannel.read(ByteBuffer). If an inbound event goes beyond the top inbound handler, it is discarded silently, or logged if it needs your attention.
An outbound event is handled by the outbound handler in the top-down direction as shown on the right side of the diagram. An outbound handler usually generates or transforms the outbound traffic such as write requests. If an outbound event goes beyond the bottom outbound handler, it is handled by an I/O thread associated with the Channel. The I/O thread often performs the actual output operation such as SocketChannel.write(ByteBuffer).
For example, let us assume that we created the following pipeline:
```
 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());
 
```
In the example above, the class whose name starts with Inbound means it is an inbound handler. The class whose name starts with Outbound means it is a outbound handler.
In the given example configuration, the handler evaluation order is 1, 2, 3, 4, 5 when an event goes inbound. When an event goes outbound, the order is 5, 4, 3, 2, 1. On top of this principle, ChannelPipeline skips the evaluation of certain handlers to shorten the stack depth:
- 3 and 4 don't implement ChannelInboundHandler, and therefore the actual evaluation order of an inbound event will be: 1, 2, and 5.
- 1 and 2 don't implement ChannelOutboundHandler, and therefore the actual evaluation order of a outbound event will be: 5, 4, and 3.
- If 5 implements both ChannelInboundHandler and ChannelOutboundHandler, the evaluation order of an inbound and a outbound event could be 125 and 543 respectively.
Forwarding an event to the next handler
As you might noticed in the diagram shows, a handler has to invoke the event propagation methods in ChannelHandlerContext to forward an event to its next handler. Those methods include:
- Inbound event propagation methods:
- Outbound event propagation methods:
and the following example shows how the event propagation is usually done:
```
 public class MyInboundHandler extends ChannelInboundHandlerAdapter {
     @Override
     public void channelActive(ChannelHandlerContext ctx) {
         System.out.println("Connected!");
         ctx.fireChannelActive();
     }
 }

 public clas MyOutboundHandler extends ChannelOutboundHandlerAdapter {
     @Override
     public void close(ChannelHandlerContext ctx, ChannelPromise promise) {
         System.out.println("Closing ..");
         ctx.close(promise);
     }
 }
 
```
Building a pipeline

A user is supposed to have one or more ChannelHandlers in a pipeline to receive I/O events (e.g. read) and to request I/O operations (e.g. write and close). For example, a typical server will have the following handlers in each channel's pipeline, but your mileage may vary depending on the complexity and characteristics of the protocol and business logic:
1. Protocol Decoder - translates binary data (e.g. ByteBuf) into a Java object.
2. Protocol Encoder - translates a Java object into binary data.
3. Business Logic Handler - performs the actual business logic (e.g. database access).
and it could be represented as shown in the following example:
```
 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());
 
```
Thread safety

A ChannelHandler can be added or removed at any time because a ChannelPipeline is thread safe. For example, you can insert an encryption handler when sensitive information is about to be exchanged, and remove it after the exchange.

Method Summary

Methods
Modifier and Type	Method and Description
`ChannelPipeline`	`addAfter(io.netty.util.concurrent.EventExecutorGroup group, String baseName, String name, ChannelHandler handler)` Inserts a `ChannelHandler` after an existing handler of this pipeline.
`ChannelPipeline`	`addAfter(String baseName, String name, ChannelHandler handler)` Inserts a `ChannelHandler` after an existing handler of this pipeline.
`ChannelPipeline`	`addBefore(io.netty.util.concurrent.EventExecutorGroup group, String baseName, String name, ChannelHandler handler)` Inserts a `ChannelHandler` before an existing handler of this pipeline.
`ChannelPipeline`	`addBefore(String baseName, String name, ChannelHandler handler)` Inserts a `ChannelHandler` before an existing handler of this pipeline.
`ChannelPipeline`	`addFirst(ChannelHandler... handlers)` Inserts a `ChannelHandler`s at the first position of this pipeline.
`ChannelPipeline`	`addFirst(io.netty.util.concurrent.EventExecutorGroup group, ChannelHandler... handlers)` Inserts a `ChannelHandler`s at the first position of this pipeline.
`ChannelPipeline`	`addFirst(io.netty.util.concurrent.EventExecutorGroup group, String name, ChannelHandler handler)` Inserts a `ChannelHandler` at the first position of this pipeline.
`ChannelPipeline`	`addFirst(String name, ChannelHandler handler)` Inserts a `ChannelHandler` at the first position of this pipeline.
`ChannelPipeline`	`addLast(ChannelHandler... handlers)` Inserts a `ChannelHandler`s at the last position of this pipeline.
`ChannelPipeline`	`addLast(io.netty.util.concurrent.EventExecutorGroup group, ChannelHandler... handlers)` Inserts a `ChannelHandler`s at the last position of this pipeline.
`ChannelPipeline`	`addLast(io.netty.util.concurrent.EventExecutorGroup group, String name, ChannelHandler handler)` Appends a `ChannelHandler` at the last position of this pipeline.
`ChannelPipeline`	`addLast(String name, ChannelHandler handler)` Appends a `ChannelHandler` at the last position of this pipeline.
`ChannelFuture`	`bind(SocketAddress localAddress)` Request to bind to the given `SocketAddress` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`bind(SocketAddress localAddress, ChannelPromise promise)` Request to bind to the given `SocketAddress` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`Channel`	`channel()` Returns the `Channel` that this pipeline is attached to.
`ChannelFuture`	`close()` Request to close the `Channel` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`close(ChannelPromise promise)` Request to close the `Channel` bound to this `ChannelPipeline` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`connect(SocketAddress remoteAddress)` Request to connect to the given `SocketAddress` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`connect(SocketAddress remoteAddress, ChannelPromise promise)` Request to connect to the given `SocketAddress` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`connect(SocketAddress remoteAddress, SocketAddress localAddress)` Request to connect to the given `SocketAddress` while bind to the localAddress and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`connect(SocketAddress remoteAddress, SocketAddress localAddress, ChannelPromise promise)` Request to connect to the given `SocketAddress` while bind to the localAddress and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelHandlerContext`	`context(ChannelHandler handler)` Returns the context object of the specified `ChannelHandler` in this pipeline.
`ChannelHandlerContext`	`context(Class<? extends ChannelHandler> handlerType)` Returns the context object of the `ChannelHandler` of the specified type in this pipeline.
`ChannelHandlerContext`	`context(String name)` Returns the context object of the `ChannelHandler` with the specified name in this pipeline.
`ChannelFuture`	`deregister()` Request to deregister the `Channel` from the previous assigned `EventExecutor` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`deregister(ChannelPromise promise)` Request to deregister the `Channel` bound this `ChannelPipeline` from the previous assigned `EventExecutor` and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`disconnect()` Request to disconnect from the remote peer and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelFuture`	`disconnect(ChannelPromise promise)` Request to disconnect from the remote peer and notify the `ChannelFuture` once the operation completes, either because the operation was successful or because of an error.
`ChannelPipeline`	`fireChannelActive()` A `Channel` is active now, which means it is connected.
`ChannelPipeline`	`fireChannelInactive()` A `Channel` is inactive now, which means it is closed.
`ChannelPipeline`	`fireChannelRead(Object msg)` A `Channel` received a message.
`ChannelPipeline`	`fireChannelReadComplete()` Triggers an `ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext)` event to the next `ChannelInboundHandler` in the `ChannelPipeline`.
`ChannelPipeline`	`fireChannelRegistered()` A `Channel` was registered to its `EventLoop`.
`ChannelPipeline`	`fireChannelUnregistered()` A `Channel` was unregistered from its `EventLoop`.
`ChannelPipeline`	`fireChannelWritabilityChanged()` Triggers an `ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext)` event to the next `ChannelInboundHandler` in the `ChannelPipeline`.
`ChannelPipeline`	`fireExceptionCaught(Throwable cause)` A `Channel` received an `Throwable` in one of its inbound operations.
`ChannelPipeline`	`fireUserEventTriggered(Object event)` A `Channel` received an user defined event.
`ChannelHandler`	`first()` Returns the first `ChannelHandler` in this pipeline.
`ChannelHandlerContext`	`firstContext()` Returns the context of the first `ChannelHandler` in this pipeline.
`ChannelPipeline`	`flush()` Request to flush all pending messages.
`<T extends ChannelHandler> T`	`get(Class<T> handlerType)` Returns the `ChannelHandler` of the specified type in this pipeline.
`ChannelHandler`	`get(String name)` Returns the `ChannelHandler` with the specified name in this pipeline.
`ChannelHandler`	`last()` Returns the last `ChannelHandler` in this pipeline.
`ChannelHandlerContext`	`lastContext()` Returns the context of the last `ChannelHandler` in this pipeline.
`List<String>`	`names()` Returns the `List` of the handler names.
`ChannelPipeline`	`read()` Request to Read data from the `Channel` into the first inbound buffer, triggers an `ChannelInboundHandler.channelRead(ChannelHandlerContext, Object)` event if data was read, and triggers a `channelReadComplete` event so the handler can decide to continue reading.
`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.
`ChannelFuture`	`write(Object msg)` Request to write a message via this `ChannelPipeline`.
`ChannelFuture`	`write(Object msg, ChannelPromise promise)` Request to write a message via this `ChannelPipeline`.
`ChannelFuture`	`writeAndFlush(Object msg)` Shortcut for call `write(Object)` and `flush()`.
`ChannelFuture`	`writeAndFlush(Object msg, ChannelPromise promise)` Shortcut for call `write(Object, ChannelPromise)` and `flush()`.

Methods inherited from interface java.lang.Iterable
iterator

- Method Detail
  - addFirst
```
ChannelPipeline addFirst(String name,
                       ChannelHandler handler)
```
    Inserts a ChannelHandler at the first position of this pipeline.
    
    Parameters:
    name - the name of the handler to insert first
    handler - the handler to insert first
    
    Throws:
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified name or handler is null
  - addFirst
```
ChannelPipeline addFirst(io.netty.util.concurrent.EventExecutorGroup group,
                       String name,
                       ChannelHandler handler)
```
    Inserts a ChannelHandler at the first position of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    name - the name of the handler to insert first
    handler - the handler to insert first
    
    Throws:
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified name or handler is null
  - addLast
```
ChannelPipeline addLast(String name,
                      ChannelHandler handler)
```
    Appends a ChannelHandler at the last position of this pipeline.
    
    Parameters:
    name - the name of the handler to append
    handler - the handler to append
    
    Throws:
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified name or handler is null
  - addLast
```
ChannelPipeline addLast(io.netty.util.concurrent.EventExecutorGroup group,
                      String name,
                      ChannelHandler handler)
```
    Appends a ChannelHandler at the last position of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    name - the name of the handler to append
    handler - the handler to append
    
    Throws:
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified name or handler is null
  - addBefore
```
ChannelPipeline addBefore(String baseName,
                        String name,
                        ChannelHandler handler)
```
    Inserts a ChannelHandler before an existing handler of this pipeline.
    
    Parameters:
    baseName - the name of the existing handler
    name - the name of the handler to insert before
    handler - the handler to insert before
    
    Throws:
    
    NoSuchElementException - if there's no such entry with the specified baseName
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified baseName, name, or handler is null
  - addBefore
```
ChannelPipeline addBefore(io.netty.util.concurrent.EventExecutorGroup group,
                        String baseName,
                        String name,
                        ChannelHandler handler)
```
    Inserts a ChannelHandler before an existing handler of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    baseName - the name of the existing handler
    name - the name of the handler to insert before
    handler - the handler to insert before
    
    Throws:
    
    NoSuchElementException - if there's no such entry with the specified baseName
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified baseName, name, or handler is null
  - addAfter
```
ChannelPipeline addAfter(String baseName,
                       String name,
                       ChannelHandler handler)
```
    Inserts a ChannelHandler after an existing handler of this pipeline.
    
    Parameters:
    baseName - the name of the existing handler
    name - the name of the handler to insert after
    handler - the handler to insert after
    
    Throws:
    
    NoSuchElementException - if there's no such entry with the specified baseName
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified baseName, name, or handler is null
  - addAfter
```
ChannelPipeline addAfter(io.netty.util.concurrent.EventExecutorGroup group,
                       String baseName,
                       String name,
                       ChannelHandler handler)
```
    Inserts a ChannelHandler after an existing handler of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandler methods
    baseName - the name of the existing handler
    name - the name of the handler to insert after
    handler - the handler to insert after
    
    Throws:
    
    NoSuchElementException - if there's no such entry with the specified baseName
    
    IllegalArgumentException - if there's an entry with the same name already in the pipeline
    
    NullPointerException - if the specified baseName, name, or handler is null
  - addFirst
```
ChannelPipeline addFirst(ChannelHandler... handlers)
```
    Inserts a ChannelHandlers at the first position of this pipeline.
    
    Parameters:
    handlers - the handlers to insert first
  - addFirst
```
ChannelPipeline addFirst(io.netty.util.concurrent.EventExecutorGroup group,
                       ChannelHandler... handlers)
```
    Inserts a ChannelHandlers at the first position of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandlers methods.
    handlers - the handlers to insert first
  - addLast
```
ChannelPipeline addLast(ChannelHandler... handlers)
```
    Inserts a ChannelHandlers at the last position of this pipeline.
    
    Parameters:
    handlers - the handlers to insert last
  - addLast
```
ChannelPipeline addLast(io.netty.util.concurrent.EventExecutorGroup group,
                      ChannelHandler... handlers)
```
    Inserts a ChannelHandlers at the last position of this pipeline.
    
    Parameters:
    group - the EventExecutorGroup which will be used to execute the ChannelHandlers methods.
    handlers - the handlers to insert last
  - remove
```
ChannelPipeline remove(ChannelHandler handler)
```
    Removes the specified ChannelHandler from this pipeline.
    
    Parameters:
    handler - the ChannelHandler to remove
    
    Throws:
    
    NoSuchElementException - if there's no such handler in this pipeline
    
    NullPointerException - if the specified handler is null
  - remove
```
ChannelHandler remove(String name)
```
    Removes the ChannelHandler with the specified name from this pipeline.
    
    Parameters:
    name - the name under which the ChannelHandler was stored.
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if there's no such handler with the specified name in this pipeline
    
    NullPointerException - if the specified name is null
  - remove
```
<T extends ChannelHandler> T remove(Class<T> handlerType)
```
    Removes the ChannelHandler of the specified type from this pipeline.
    
    Type Parameters:
    T - the type of the handler
    Parameters:
    handlerType - the type of the handler
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if there's no such handler of the specified type in this pipeline
    
    NullPointerException - if the specified handler type is null
  - removeFirst
```
ChannelHandler removeFirst()
```
    Removes the first ChannelHandler in this pipeline.
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if this pipeline is empty
  - removeLast
```
ChannelHandler removeLast()
```
    Removes the last ChannelHandler in this pipeline.
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if this pipeline is empty
  - replace
```
ChannelPipeline replace(ChannelHandler oldHandler,
                      String newName,
                      ChannelHandler newHandler)
```
    Replaces the specified ChannelHandler with a new handler in this pipeline.
    
    Parameters:
    oldHandler - the ChannelHandler to be replaced
    newName - the name under which the replacement should be added
    newHandler - the ChannelHandler which is used as replacement
    
    Returns:
    itself
    
    Throws:
    
    NoSuchElementException - if the specified old handler does not exist in this pipeline
    
    IllegalArgumentException - if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced
    
    NullPointerException - if the specified old handler, new name, or new handler is null
  - replace
```
ChannelHandler replace(String oldName,
                     String newName,
                     ChannelHandler newHandler)
```
    Replaces the ChannelHandler of the specified name with a new handler in this pipeline.
    
    Parameters:
    oldName - the name of the ChannelHandler to be replaced
    newName - the name under which the replacement should be added
    newHandler - the ChannelHandler which is used as replacement
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if the handler with the specified old name does not exist in this pipeline
    
    IllegalArgumentException - if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced
    
    NullPointerException - if the specified old handler, new name, or new handler is null
  - replace
```
<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.
    
    Parameters:
    oldHandlerType - the type of the handler to be removed
    newName - the name under which the replacement should be added
    newHandler - the ChannelHandler which is used as replacement
    
    Returns:
    the removed handler
    
    Throws:
    
    NoSuchElementException - if the handler of the specified old handler type does not exist in this pipeline
    
    IllegalArgumentException - if a handler with the specified new name already exists in this pipeline, except for the handler to be replaced
    
    NullPointerException - if the specified old handler, new name, or new handler is null
  - first
```
ChannelHandler first()
```
    Returns the first ChannelHandler in this pipeline.
    
    Returns:
    the first handler. null if this pipeline is empty.
  - firstContext
```
ChannelHandlerContext firstContext()
```
    Returns the context of the first ChannelHandler in this pipeline.
    
    Returns:
    the context of the first handler. null if this pipeline is empty.
  - last
```
ChannelHandler last()
```
    Returns the last ChannelHandler in this pipeline.
    
    Returns:
    the last handler. null if this pipeline is empty.
  - lastContext
```
ChannelHandlerContext lastContext()
```
    Returns the context of the last ChannelHandler in this pipeline.
    
    Returns:
    the context of the last handler. null if this pipeline is empty.
  - get
```
ChannelHandler get(String name)
```
    Returns the ChannelHandler with the specified name in this pipeline.
    
    Returns:
    the handler with the specified name. null if there's no such handler in this pipeline.
  - get
```
<T extends ChannelHandler> T get(Class<T> handlerType)
```
    Returns the ChannelHandler of the specified type in this pipeline.
    
    Returns:
    the handler of the specified handler type. null if there's no such handler in this pipeline.
  - context
```
ChannelHandlerContext context(ChannelHandler handler)
```
    Returns the context object of the specified ChannelHandler in this pipeline.
    
    Returns:
    the context object of the specified handler. null if there's no such handler in this pipeline.
  - context
```
ChannelHandlerContext context(String name)
```
    Returns the context object of the ChannelHandler with the specified name in this pipeline.
    
    Returns:
    the context object of the handler with the specified name. null if there's no such handler in this pipeline.
  - context
```
ChannelHandlerContext context(Class<? extends ChannelHandler> handlerType)
```
    Returns the context object of the ChannelHandler of the specified type in this pipeline.
    
    Returns:
    the context object of the handler of the specified type. null if there's no such handler in this pipeline.
  - channel
```
Channel channel()
```
    Returns the Channel that this pipeline is attached to.
    
    Returns:
    the channel. null if this pipeline is not attached yet.
  - names
```
List<String> names()
```
    Returns the List of the handler names.
  - toMap
```
Map<String,ChannelHandler> toMap()
```
    Converts this pipeline into an ordered Map whose keys are handler names and whose values are handlers.
  - fireChannelRegistered
```
ChannelPipeline fireChannelRegistered()
```
    A Channel was registered to its EventLoop. This will result in having the ChannelInboundHandler.channelRegistered(ChannelHandlerContext) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireChannelUnregistered
```
ChannelPipeline fireChannelUnregistered()
```
    A Channel was unregistered from its EventLoop. This will result in having the ChannelInboundHandler.channelUnregistered(ChannelHandlerContext) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireChannelActive
```
ChannelPipeline fireChannelActive()
```
    A Channel is active now, which means it is connected. This will result in having the ChannelInboundHandler.channelActive(ChannelHandlerContext) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireChannelInactive
```
ChannelPipeline fireChannelInactive()
```
    A Channel is inactive now, which means it is closed. This will result in having the ChannelInboundHandler.channelInactive(ChannelHandlerContext) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireExceptionCaught
```
ChannelPipeline fireExceptionCaught(Throwable cause)
```
    A Channel received an Throwable in one of its inbound operations. This will result in having the ChannelInboundHandler.exceptionCaught(ChannelHandlerContext, Throwable) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireUserEventTriggered
```
ChannelPipeline fireUserEventTriggered(Object event)
```
    A Channel received an user defined event. This will result in having the ChannelInboundHandler.userEventTriggered(ChannelHandlerContext, Object) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireChannelRead
```
ChannelPipeline fireChannelRead(Object msg)
```
    A Channel received a message. This will result in having the ChannelInboundHandler.channelRead(ChannelHandlerContext, Object) method called of the next ChannelInboundHandler contained in the ChannelPipeline of the Channel.
  - fireChannelReadComplete
```
ChannelPipeline fireChannelReadComplete()
```
    Triggers an ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext) event to the next ChannelInboundHandler in the ChannelPipeline.
  - fireChannelWritabilityChanged
```
ChannelPipeline fireChannelWritabilityChanged()
```
    Triggers an ChannelInboundHandler.channelWritabilityChanged(ChannelHandlerContext) event to the next ChannelInboundHandler in the ChannelPipeline.
  - bind
```
ChannelFuture bind(SocketAddress localAddress)
```
    Request to bind to the given SocketAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelOutboundHandler.bind(ChannelHandlerContext, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - connect
```
ChannelFuture connect(SocketAddress remoteAddress)
```
    Request to connect to the given SocketAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error.
    If the connection fails because of a connection timeout, the ChannelFuture will get failed with a ConnectTimeoutException. If it fails because of connection refused a ConnectException will be used.
    This will result in having the ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - connect
```
ChannelFuture connect(SocketAddress remoteAddress,
                    SocketAddress localAddress)
```
    Request to connect to the given SocketAddress while bind to the localAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - disconnect
```
ChannelFuture disconnect()
```
    Request to disconnect from the remote peer and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - close
```
ChannelFuture close()
```
    Request to close the Channel and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. After it is closed it is not possible to reuse it again.
    This will result in having the ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - deregister
```
ChannelFuture deregister()
```
    Request to deregister the Channel from the previous assigned EventExecutor and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error.
    This will result in having the ChannelOutboundHandler.deregister(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - bind
```
ChannelFuture bind(SocketAddress localAddress,
                 ChannelPromise promise)
```
    Request to bind to the given SocketAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. The given ChannelPromise will be notified.
    This will result in having the ChannelOutboundHandler.bind(ChannelHandlerContext, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - connect
```
ChannelFuture connect(SocketAddress remoteAddress,
                    ChannelPromise promise)
```
    Request to connect to the given SocketAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. The given ChannelFuture will be notified.
    If the connection fails because of a connection timeout, the ChannelFuture will get failed with a ConnectTimeoutException. If it fails because of connection refused a ConnectException will be used.
    This will result in having the ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - connect
```
ChannelFuture connect(SocketAddress remoteAddress,
                    SocketAddress localAddress,
                    ChannelPromise promise)
```
    Request to connect to the given SocketAddress while bind to the localAddress and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. The given ChannelPromise will be notified and also returned.
    This will result in having the ChannelOutboundHandler.connect(ChannelHandlerContext, SocketAddress, SocketAddress, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - disconnect
```
ChannelFuture disconnect(ChannelPromise promise)
```
    Request to disconnect from the remote peer and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. The given ChannelPromise will be notified.
    This will result in having the ChannelOutboundHandler.disconnect(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - close
```
ChannelFuture close(ChannelPromise promise)
```
    Request to close the Channel bound to this ChannelPipeline and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. After it is closed it is not possible to reuse it again. The given ChannelPromise will be notified.
    This will result in having the ChannelOutboundHandler.close(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - deregister
```
ChannelFuture deregister(ChannelPromise promise)
```
    Request to deregister the Channel bound this ChannelPipeline from the previous assigned EventExecutor and notify the ChannelFuture once the operation completes, either because the operation was successful or because of an error. The given ChannelPromise will be notified.
    This will result in having the ChannelOutboundHandler.deregister(ChannelHandlerContext, ChannelPromise) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - read
```
ChannelPipeline read()
```
    Request to Read data from the Channel into the first inbound buffer, triggers an ChannelInboundHandler.channelRead(ChannelHandlerContext, Object) event if data was read, and triggers a channelReadComplete event so the handler can decide to continue reading. If there's a pending read operation already, this method does nothing.
    This will result in having the ChannelOutboundHandler.read(ChannelHandlerContext) method called of the next ChannelOutboundHandler contained in the ChannelPipeline of the Channel.
  - write
```
ChannelFuture write(Object msg)
```
    Request to write a message via this ChannelPipeline. This method will not request to actual flush, so be sure to call flush() once you want to request to flush all pending data to the actual transport.
  - write
```
ChannelFuture write(Object msg,
                  ChannelPromise promise)
```
    Request to write a message via this ChannelPipeline. This method will not request to actual flush, so be sure to call flush() once you want to request to flush all pending data to the actual transport.
  - flush
```
ChannelPipeline flush()
```
    Request to flush all pending messages.
  - writeAndFlush
```
ChannelFuture writeAndFlush(Object msg,
                          ChannelPromise promise)
```
    Shortcut for call write(Object, ChannelPromise) and flush().
  - writeAndFlush
```
ChannelFuture writeAndFlush(Object msg)
```
    Shortcut for call write(Object) and flush().

Interface ChannelPipeline

Creation of a pipeline

How an event flows in a pipeline

Forwarding an event to the next handler

Building a pipeline

Thread safety

Method Summary

Methods inherited from interface java.lang.Iterable

Method Detail

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

bind

connect

connect

disconnect

close

deregister

bind

connect

connect

disconnect

close

deregister

read

write

write

flush

writeAndFlush

writeAndFlush