一个channel对应一个pipeline，pipeline是channel的成员变量，初始化channel的时候就初始化了pipeline，一个pipeline里面包含多个handler，其中在初始化handler的时候，会同时初始化head/tail两个handlerContext；一个DefaultChannelHandlerContext里面包含一个handler，换句话说handler是以handlerContext的形式存在。
public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {
private static final InternalLogger logger = InternalLoggerFactory.getInstance(AbstractChannel.class);
private final Channel parent; // 代表父类channel
private final ChannelId id; // 采用默认方式生成的全局唯一id
//实现具体的连接与读/写数据，如网络的读/写、链路关闭、发起连接等
private final Unsafe unsafe; // Unsafe实例
//一个Handler的容器，也可以将其理解为一个Handler链。Handler主要处理数据的编/解码和业务逻辑。
private final DefaultChannelPipeline pipeline; // 当前channel对应的DefaultChannelPipeline
private final VoidChannelPromise unsafeVoidPromise = new VoidChannelPromise(this, false);
private final CloseFuture closeFuture = new CloseFuture(this);
private volatile SocketAddress localAddress;
private volatile SocketAddress remoteAddress;
private volatile EventLoop eventLoop; // 当前channel注册的EventLoop 每个Channel对应一条EventLoop线程。
private volatile boolean registered;
private boolean closeInitiated;
private Throwable initialCloseCause;
/**
* Cache for the string representation of this channel
*/
private boolean strValActive;
private String strVal;
/**
* Creates a new instance.
*
* @param parent the parent of this channel. {@code null} if there's no parent.
*/
protected AbstractChannel(Channel parent) {
this.parent = parent;
id = newId();
unsafe = newUnsafe();
pipeline = newChannelPipeline(); // 创建pipeline
}
}
下面是pipeline的具体实现类，可以看到在初始化pipeline的时候，也初始化了head/tail两个变量， 同时改变了指向
public class DefaultChannelPipeline implements ChannelPipeline {
// pipeline里面
final AbstractChannelHandlerContext head;
final AbstractChannelHandlerContext tail;
private final Channel channel;
private final ChannelFuture succeededFuture;
private final VoidChannelPromise voidPromise;
private final boolean touch = ResourceLeakDetector.isEnabled();
private boolean registered;
protected DefaultChannelPipeline(Channel channel) {
this.channel = ObjectUtil.checkNotNull(channel, "channel");// 这个方法值得借鉴
succeededFuture = new SucceededChannelFuture(channel, null);
voidPromise = new VoidChannelPromise(channel, true);
// 创建两个节点
tail = new TailContext(this); //AbstractChannelHandlerContext
head = new HeadContext(this); //AbstractChannelHandlerContext的子类
head.next = tail;
tail.prev = head;
}
}
pipeline里面保存着链表的头结点和尾节点，因为很容易向链表中添加元素，具体方法如下：
// 这个方法向链表里面添加节点
private void addLast0(AbstractChannelHandlerContext newCtx) {
AbstractChannelHandlerContext prev = tail.prev;
newCtx.prev = prev;
newCtx.next = tail;
prev.next = newCtx;
tail.prev = newCtx;
}
在执行handler的过程中需要一个一个的遍历链表，具体方法如下：
private AbstractChannelHandlerContext findContextInbound(int mask) {// 这个是从链表里面获取一个元素 那么是怎么添加进去的呢？这个方法见上面
logger.info("findContextInbound-_-");
AbstractChannelHandlerContext ctx = this;
do {
ctx = ctx.next;
} while ((ctx.executionMask & mask) == 0);
return ctx;
}