Netty 之 ChannelPipeline 源码解析

概述

ChannelPipleline 是 ChannelHandler 的管理容器,它内部维护了一个 ChannelHandler 的链表,可以方便的实现 ChannelHandler 的查找、添加、删除、替换、遍历等。

消息经过 ChannelPipleline 在 ChannelHandler 中的流程图 如下:

 *                                                 I/O Request
 *                                            via {@link Channel} or
 *                                        {@link 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)            |
 *  +-------------------------------------------------------------------+

通过上一篇文章分析的 NioEventLoop 可以知道,当 NioEventLoop 处理 IO 任务时,最终会在 Channel 的 Unsafe 类中 调用 ChannelPipeline 来读取数据。

当消息传给 ChannelPipeline 时,消息依次经过链表的头部开始遍历所有实现 ChannelInboundHandler 的 ChannelHandler。在这个过程中任何 ChannelHandler 都可以中断当前的流程,结束消息的传递。跟 Filter 的原理类似。

当调用 ChannelHandlerContext 的write() 方法发送消息,消息从链表的尾部开始遍历所有实现 ChannelOutboundHandler 的 ChannelHandler。在这个过程中任何 ChannelHandler 都可以中断当前的流程,结束消息的传递。跟 Filter 的原理类似。

public class DefaultChannelPipeline implements ChannelPipeline {

    // 双向链表的头结点和尾节点
    final AbstractChannelHandlerContext head;
    final AbstractChannelHandlerContext tail;

    // 默认创建一个双向空链表,头结点指向尾节点
    protected DefaultChannelPipeline(Channel channel) {
        tail = new TailContext(this);
        head = new HeadContext(this);

        head.next = tail;
        tail.prev = head;
    }

DefaultChannelPipeline 中维护了一个链表,创建的时候初始化了一个只有头结点和尾节点的一个双向空链表。

addLast 链表尾部添加节点

public final ChannelPipeline addLast(ChannelHandler handler){
    return addLast(null, name, handler);
}

public final ChannelPipeline addLast(String name, ChannelHandler handler) {
    return addLast(null, name, handler);
}

public final ChannelPipeline addLast(ChannelHandler... handlers) {
    return addLast(null, handlers);
}

public final ChannelPipeline addLast(EventExecutorGroup executor, ChannelHandler... handlers) {
    if (handlers == null) {
        throw new NullPointerException("handlers");
    }
    for (ChannelHandler h: handlers) {
        if (h == null) {
            break;
        }
        addLast(executor, null, h);
    }
    return this;
}

public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler){
    final AbstractChannelHandlerContext newCtx;
    synchronized (this) {
        checkMultiplicity(handler);

        newCtx = newContext(group, filterName(name, handler), handler);

        addLast0(newCtx);

        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;
}

1、addLast 提供多种重载方法,name 如果不提供会通过 filterName(name, handler) 方法根据 handler 的 ClassName 生成一个名字,提供名字的好处是,可以指定某个 Handler 插入到具体的 name 前或后。
2、checkMultiplicity() 检查 ChannelHandler 是否是共享 @Sharable 类型的。如果是 @Sharable 类型的就可以添加到多个 ChannelPipeline 中,如果不是 @Sharable 类型添加到多个ChannelPipeline 中就会抛出 ChannelPipelineException。
3、构建一个新的 DefaultChannelHandlerContext 链表节点(ChannelHandler 上下文),然后调用 addLast0(newCtx) 添加到链表尾部
4、注意,这里 ChannelPipeline 是线程安全的,对 ChannelPipeline中链表操作都是通过 synchronized 加锁的。

addFirst 链表头部添加节点

public final ChannelPipeline addFirst(ChannelHandler handler)
public final ChannelPipeline addFirst(ChannelHandler... handlers)
public final ChannelPipeline addFirst(EventExecutorGroup executor, ChannelHandler... handlers)
public final ChannelPipeline addFirst(String name, ChannelHandler handler)
public final ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler)

addBefore 指定节点前添加节点

public final ChannelPipeline addBefore(String baseName, String name, ChannelHandler handler)
public final ChannelPipeline addBefore(
            EventExecutorGroup group, String baseName, String name, ChannelHandler handler)

可以通过指定 ChannelHandler 名字的节点前面添加新的 ChannelHandler


addAfter 指定节点后添加节点

public final ChannelPipeline addAfter(String baseName, String name, ChannelHandler handler)
public final ChannelPipeline addAfter(EventExecutorGroup group, String baseName, String name, ChannelHandler handler)

可以通过指定 ChannelHandler 名字的节点后面添加新的 ChannelHandler

remove 删除节点

public final ChannelPipeline remove(ChannelHandler handler)
public final ChannelHandler remove(String name)
public final <T extends ChannelHandler> T remove(Class<T> handlerType)

ChannelPipeline 对外提供了 增删改查 的功能,这样对开发来说也有更多的操作空间。
我们可以在程序运行的时候动态的添加或删除 ChannelHandler 来更灵活的实现不同的场景。

ChannelHandler 链读取过程

首先我们接着上次分析的 NioEventLoop 源码来分析 ChannelPipeline 中链表怎么一个一个处理请求的过程。

  • 读的时候是 从 ChannelPipeline 链表的 head 节点开始处理。
  • 写的时候是从 ChannelPipeline 的 tail 节点开始处理。
private final class NioMessageUnsafe extends AbstractNioUnsafe {

        @Override
        public void read() {
            // 省略代码 ......
            // 获取 Channel 对应的 ChannelPipeline
            final ChannelPipeline pipeline = pipeline();

            boolean closed = false;
            Throwable exception = null;
            try {
                // 省略代码 ......
                int size = readBuf.size();
                for (int i = 0; i < size; i ++) {
                    readPending = false;
                    // 委托给 pipeline 中的 Handler 进行读取数据
                    pipeline.fireChannelRead(readBuf.get(i));
                }

NioMessageUnsafe 中调用 pipeline.fireChannelRead(readBuf.get(i)) 进行读取数据。

//io.netty.channel.DefaultChannelPipeline#fireChannelRead
public final ChannelPipeline fireChannelRead(Object msg) {
    AbstractChannelHandlerContext.invokeChannelRead(head, msg);
    return this;
}

获取 ChannelPipeline 的 head 节点,然后调用。
每个节点就是 ChannelHandler 的上下文信息。

// io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead
static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
    final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeChannelRead(m);
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelRead(m);
            }
        });
    }
}


private void invokeChannelRead(Object msg) {
    if (invokeHandler()) {
        try {
            ((ChannelInboundHandler) handler()).channelRead(this, msg);
        } catch (Throwable t) {
            notifyHandlerException(t);
        }
    } else {
        fireChannelRead(msg);
    }
}

通过 invokeHandler() 判断该 ChanelHandler 是否可以调用,如果可以则执行 channelRead(this, msg) 方法读取。

//io.netty.channel.DefaultChannelPipeline$HeadContext.channelRead
public void channelRead(ChannelHandlerContext ctx, Object msg) {
    ctx.fireChannelRead(msg);
}
//io.netty.channel.AbstractChannelHandlerContext.fireChannelRead
public ChannelHandlerContext fireChannelRead(final Object msg) {
    invokeChannelRead(findContextInbound(), msg);
    return this;
}

static void invokeChannelRead(final AbstractChannelHandlerContext next, Object msg) {
    final Object m = next.pipeline.touch(ObjectUtil.checkNotNull(msg, "msg"), next);
    EventExecutor executor = next.executor();
    if (executor.inEventLoop()) {
        next.invokeChannelRead(m);
    } else {
        executor.execute(new Runnable() {
            @Override
            public void run() {
                next.invokeChannelRead(m);
            }
        });
    }
}

通过 findContextInbound() 方法从链表的当前节点查找下一个 ChannelInboundHandler ,然后继续调用下一个 ChannelInboundHandler 的
invokeChannelRead() 方法。

获取下一个 ChannelInboundHandler

Netty 的读取操作是从链表的头部开始顺序执行所有的 ChannelInboundHandler 的读操作。

private AbstractChannelHandlerContext findContextInbound() {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.next;
    } while (!ctx.inbound);
    return ctx;
}

从链表中查找下一个元素,如果该元素是 ChannelInboundHandler 则返回。

获取下一个 ChannelOutboundHandler

Netty 的写操作是从链表的尾部开始顺序执行所有的 ChannelOutboundHandler 的写操作。

private AbstractChannelHandlerContext findContextOutbound() {
    AbstractChannelHandlerContext ctx = this;
    do {
        ctx = ctx.prev;
    } while (!ctx.outbound);
    return ctx;
}

从链表中查找上一个元素,如果该元素是 ChannelOutboundHandler 则返回。

推荐阅读更多精彩内容