简介
咱们在介绍channel的时候提到过，简直channel中所有的实现都是通过channelPipeline进行的，作为一个pipline，它到底是如何工作的呢？
一起来看看吧。
ChannelPipeline
ChannelPipeline是一个interface，它继承了三个接口，别离是ChannelInboundInvoker,ChannelOutboundInvoker和Iterable:
public interface ChannelPipeline
extends ChannelInboundInvoker, ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> 继承自ChannelInboundInvoker，示意ChannelPipeline能够触发channel inboud的一些事件，比方：
ChannelInboundInvoker fireChannelRegistered();
ChannelInboundInvoker fireChannelUnregistered();
ChannelInboundInvoker fireChannelActive();
ChannelInboundInvoker fireChannelInactive();
ChannelInboundInvoker fireExceptionCaught(Throwable cause);
ChannelInboundInvoker fireUserEventTriggered(Object event);
ChannelInboundInvoker fireChannelRead(Object msg);
ChannelInboundInvoker fireChannelReadComplete();
ChannelInboundInvoker fireChannelWritabilityChanged();继承自ChannelOutboundInvoker，示意ChannelPipeline能够进行一些channel的被动操作，如：bind,connect,disconnect,close,deregister,read,write,flush等操作。
继承自Iterable，示意ChannelPipeline是可遍历的，为什么ChannelPipeline是可遍历的呢？
因为ChannelPipeline中能够增加一个或者多个ChannelHandler,ChannelPipeline能够看做是一个ChannelHandler的汇合。
比方ChannelPipeline提供了一系列的增加ChannelHandler的办法:
ChannelPipeline addFirst(String name, ChannelHandler handler);
ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler);
ChannelPipeline addFirst(EventExecutorGroup group, ChannelHandler... handlers);
ChannelPipeline addFirst(ChannelHandler... handlers);
ChannelPipeline addLast(String name, ChannelHandler handler);
ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler);
ChannelPipeline addLast(ChannelHandler... handlers);
ChannelPipeline addLast(EventExecutorGroup group, ChannelHandler... handlers);
ChannelPipeline addBefore(String baseName, String name, ChannelHandler handler);
ChannelPipeline addBefore(EventExecutorGroup group, String baseName, String name, ChannelHandler handler);
ChannelPipeline addAfter(String baseName, String name, ChannelHandler handler);
ChannelPipeline addAfter(EventExecutorGroup group, String baseName, String name, ChannelHandler handler);
能够从后面增加，也能够从前面增加，或者从特定的地位增加handler。
另外还能够从pipeline中删除特定的channelHandler，或者移出和替换特定地位的handler：
ChannelPipeline remove(ChannelHandler handler);
ChannelHandler remove(String name);
ChannelHandler removeFirst();
ChannelHandler removeLast();
ChannelPipeline replace(ChannelHandler oldHandler, String newName, ChannelHandler newHandler);
ChannelHandler replace(String oldName, String newName, ChannelHandler newHandler);当然，更少不了对应的查问操作：
ChannelHandler first();
ChannelHandler last();
ChannelHandler get(String name);
List<String> names();还能够依据传入的ChannelHandler取得handler对应的ChannelHandlerContext。
ChannelHandlerContext context(ChannelHandler handler);ChannelPipeline中还有一些触发channel相干的事件，如：
ChannelPipeline fireChannelRegistered();
ChannelPipeline fireChannelUnregistered();
ChannelPipeline fireChannelActive();
ChannelPipeline fireChannelInactive();
ChannelPipeline fireExceptionCaught(Throwable cause);
ChannelPipeline fireUserEventTriggered(Object event);
ChannelPipeline fireChannelRead(Object msg);
ChannelPipeline fireChannelReadComplete();
ChannelPipeline fireChannelWritabilityChanged();事件传递
那么有些敌人可能会问了，既然ChannelPipeline中蕴含了很多个handler，那么handler中的事件是怎么传递的呢？
其实这些事件是通过调用ChannelHandlerContext中的相应办法来触发的。
对于Inbound事件来说，能够调用上面的办法，进行事件的传递：
ChannelHandlerContext.fireChannelRegistered()
ChannelHandlerContext.fireChannelActive()
ChannelHandlerContext.fireChannelRead(Object)
ChannelHandlerContext.fireChannelReadComplete()
ChannelHandlerContext.fireExceptionCaught(Throwable)
ChannelHandlerContext.fireUserEventTriggered(Object)
ChannelHandlerContext.fireChannelWritabilityChanged()
ChannelHandlerContext.fireChannelInactive()
ChannelHandlerContext.fireChannelUnregistered()对于Outbound事件来说，能够调用上面的办法，进行事件的传递：
ChannelHandlerContext.bind(SocketAddress, ChannelPromise)
ChannelHandlerContext.connect(SocketAddress, SocketAddress, ChannelPromise)
ChannelHandlerContext.write(Object, ChannelPromise)
ChannelHandlerContext.flush()
ChannelHandlerContext.read()
ChannelHandlerContext.disconnect(ChannelPromise)
ChannelHandlerContext.close(ChannelPromise)
ChannelHandlerContext.deregister(ChannelPromise)具体而言，就是在handler中调用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);
}
}
DefaultChannelPipeline
ChannelPipeline有一个官网的实现叫做DefaultChannelPipeline，因为对于pipeline来说，次要的性能就是进行handler的治理和事件传递，绝对于而言性能比较简单，然而他也有一些特地的实现中央,比方它有两个AbstractChannelHandlerContext类型的head和tail。
咱们晓得ChannelPipeline实际上是很多handler的汇合，那么这些汇合是怎么进行存储的呢？这种存储的数据结构就是AbstractChannelHandlerContext。每个AbstractChannelHandlerContext中都有一个next节点和一个prev节点，用来组成一个双向链表。
同样的在DefaultChannelPipeline中应用head和tail来将封装好的handler存储起来。
留神，这里的head和tail尽管都是AbstractChannelHandlerContext，然而两者有稍许不同。先看下head和tail的定义:
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
tail = new TailContext(this);
head = new HeadContext(this);
head.next = tail;
tail.prev = head;
}在DefaultChannelPipeline的构造函数中，对tail和head进行初始化，其中tail是TailContext，而head是HeadContext。
其中TailContext实现了ChannelInboundHandler接口：
final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler而HeadContext实现了ChannelOutboundHandler和ChannelInboundHandler接口：
final class HeadContext extends AbstractChannelHandlerContext
implements ChannelOutboundHandler, ChannelInboundHandler 上面咱们以addFirst办法为例，来看一下handler是怎么被退出pipline的：
public final ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler) {
final AbstractChannelHandlerContext newCtx;
synchronized (this) {
checkMultiplicity(handler);
name = filterName(name, handler);
newCtx = newContext(group, name, handler);
addFirst0(newCtx);
// If the registered is false it means that the channel was not registered on an eventLoop yet.
// In this case we add the context to the pipeline and add a task that will call
// ChannelHandler.handlerAdded(...) once the channel is registered.
if (!registered) {
newCtx.setAddPending();
callHandlerCallbackLater(newCtx, true);
return this;
}
EventExecutor executor = newCtx.executor();
if (!executor.inEventLoop()) {
callHandlerAddedInEventLoop(newCtx, executor);
return this;
}
}
callHandlerAdded0(newCtx);
return this;
}它的工作逻辑是首先依据传入的handler构建一个新的context，而后调用addFirst0办法，将context退出AbstractChannelHandlerContext组成的双向链表中：
private void addFirst0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext nextCtx = head.next;
newCtx.prev = head;
newCtx.next = nextCtx;
head.next = newCtx;
nextCtx.prev = newCtx;
}而后调用callHandlerAdded0办法来触发context的handlerAdded办法。
总结
channelPipeline负责管理channel的各种handler，在DefaultChannelPipeline中应用了AbstractChannelHandlerContext的head和tail来对多个handler进行存储，同时借用这个链式构造对handler进行各种治理，十分不便。
本文已收录于 http://www.flydean.com/04-3-netty-channelpipeline/
最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！
欢送关注我的公众号:「程序那些事」,懂技术，更懂你！
发表回复