Netty学习——源码篇6 Pipeline设计原理

1 Pipeline设计原理

        在Netty中每个Channel都有且仅有一个ChannelPipeline与之对应，它们的组成关系如下图：

        通过上图可以看到，一个Channel包含了一个ChannelPipeline，而ChannelPipeline中又维护了一个由ChannelHandlerContext组成的双向链表。这个链表的头是HeadContext，链表的尾是TailContext，并且每个ChannelHandlerContext又关联着一个ChannelHandler。

        通过分析代码，已经知道了一个Channel初始化的基本过程，下面在回顾一下。AbstractChannel构造器的代码如下：

    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }

         AbstractChannel有一个pipeline属性，在构造器中会把它初始化为DefaultChannelPipeline的实例。这里的代码就印证了这一点：每个Channel都有一个ChannelPipeline。来看一下DefaultChannelPipeline的构造器，代码如下：

    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构造器中，首先将与之关联的Channel保存到属性channel中。然后实例化两个ChannelHandlerContext：一个是HeadContext实例Head，另一个是TailContext实例Tail。接着将Head和Tail互相指向，构成一个双向链表。

        特别注意的是：在开始的示意图中，Head和Tail并没有包含ChannelHandler，这是因为HeadContext和TailContext继承于AbstractChannelHandlerContext的同时，也实现了ChannelHandler接口，所以它们有Context和Handler的双重属性。

2 ChannelPipeline初始化

        下面看一下ChannelPipeline的初始化具体做了哪些工作。先回顾一下，在实例化一个Channel时，会伴随着一个ChannelPipeline的实例化，并且此Channel会与这个ChannelPipeline相互关联，这一点可以通过NioEventLoop的父类AbstractChannel的构造器予以佐证，代码如下：

    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();
    }

        当实例化一个NioSocketChannel时，其pipeline属性就是新创建的DefaultChannelPipeline对象，再来回顾一下DefaultChannelPipeline的构造方法，代码如下：

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

        上面代码中的Head实现了ChannelInboundHandler接口，而Tail实现了ChannelOutboundHandler接口，因此可以说Head和Tail就是ChannelHandler，又是ChannelHandlerContext。

3 ChannelInitializer的添加

        前面分析过Channel的组成，最开始的时候ChannelPipeline中含有两个ChannelHandlerContext，但是此时的Pipeline并不能实现特定的功能，因为还没有添加自定义的ChannelHandler。通常来说，在初始化Bootstrap时，会添加自定义的ChannelHandler，下面就以具体的客户端启动代码片段举例：

Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.SO_KEEPALIVE,true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            ChannelPipeline pipeline = socketChannel.pipeline();
                            pipeline.addLast(new StringDecoder());
                            pipeline.addLast(new StringEncoder());
                            System.out.println("初始化channel:" + socketChannel);
                        }
                    });

        在调用Handler时，传入ChannelInitializer对象，它提供了一个initChannel方法来初始化ChannelHandler。通过代码跟踪，发现ChannelInitializer是在Bootstrap的init方法中添加到ChannelPipiline中的，代码如下：

    void init(Channel channel) throws Exception {
        ChannelPipeline p = channel.pipeline();
        p.addLast(new ChannelHandler[]{this.config.handler()});
        Map<ChannelOption<?>, Object> options = this.options0();
        synchronized(options) {
            Iterator i$ = options.entrySet().iterator();

            while(true) {
                if (!i$.hasNext()) {
                    break;
                }

                Entry e = (Entry)i$.next();

                try {
                    if (!channel.config().setOption((ChannelOption)e.getKey(), e.getValue())) {
                        logger.warn("Unknown channel option: " + e);
                    }
                } catch (Throwable var10) {
                    logger.warn("Failed to set a channel option: " + channel, var10);
                }
            }
        }

        Map<AttributeKey<?>, Object> attrs = this.attrs0();
        synchronized(attrs) {
            Iterator i$ = attrs.entrySet().iterator();

            while(i$.hasNext()) {
                Entry<AttributeKey<?>, Object> e = (Entry)i$.next();
                channel.attr((AttributeKey)e.getKey()).set(e.getValue());
            }

        }
    }

        从上面的代码可见，将handler()方法返回的ChannelHandler添加到Pipeline中，而handler()方法返回的其实就是在初始化Bootstrap时通过handler方法设置的ChannelInitializer实例，因此这里就将ChannelInitializer插到了Pipieline的末端。此时Pipeline的结构如下图所示：

        这是会有一个疑问，明明插入的是 ChannelInitializer实例，为什么在ChannelPipeline的双向链表中的元素却是一个ChannelHandlerContext呢？继续看源码，在Bootstrap的init方法中会调用p.addList()方法，将ChannelInitializer插入链表的末端，代码如下：

    @Override
    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 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()) {
                newCtx.setAddPending();
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        callHandlerAdded0(newCtx);
                    }
                });
                return this;
            }
        }
        callHandlerAdded0(newCtx);
        return this;
    }

        addList方法有很多重载的方法，只需要关注这个方法即可。上面的addList方法中，首先检查ChannelHandler的名字是否重复，如果不重复，则调用newContext方法为这个Handler创建一个对应的DefaultChannelHandlerContext实例，并与之关联起来。

        为了添加一个Handler到Pipeline中，必须把此Handler包装成ChannelHandlerContext。因此在上面的代码中，我们新实例化一个newCx对象，并将Handler作为参数传递到构造方法中。下面来看一下DefaultChannelHandlerContext的构造器。

    DefaultChannelHandlerContext(
            DefaultChannelPipeline pipeline, EventExecutor executor, String name, ChannelHandler handler) {
        super(pipeline, executor, name, isInbound(handler), isOutbound(handler));
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        this.handler = handler;
    }

        在DefaultChannelHandlerContext的构造器中，调用了isInbound()方法和isOutbound()方法，这两个方法的代码如下：

    private static boolean isInbound(ChannelHandler handler) {
        return handler instanceof ChannelInboundHandler;
    }

    private static boolean isOutbound(ChannelHandler handler) {
        return handler instanceof ChannelOutboundHandler;
    }

        从上面代码中可以看到，当一个Handler实现了ChannelInboundHandler接口，则isInbound返回true；类似的，当一个Handler实现了ChannelOutboundHandler接口，则isOuntbound返回true。而这两个boolean类型变量会传递给父类AbstractChannelHandlerContext中，并初始化父类的两个属性：inbound和outbound。

        这里的ChannelInitializer所对应的DefaultChannelHandlerContext的inbound与outbound属性分别是什么呢？先来看ChannelInitializer的类层次结构图，如下图：

        可以看到，ChannelInitializer仅仅实现了ChannelInboundHandler接口，因此这里实例化的DefaultChannelHandlerContext的inbound是true，outbound是false。

        inbound和outbound这两个属性关系到Pipeline事件的流向与分类，因此十分关键。这里先记住一个结论：ChannelInitializer所对应的DefaultChannelHandlerContext的inbound=true，outbound=false。

        当创建好Context之后，就将这个Context插入Pipeline的双向链表中。

DefaultChannelPipeline.java

    private void addLast0(AbstractChannelHandlerContext newCtx) {
        AbstractChannelHandlerContext prev = tail.prev;
        newCtx.prev = prev;
        newCtx.next = tail;
        prev.next = newCtx;
        tail.prev = newCtx;
    }

        添加完ChannelInitializer的Pipeline内部如下图所示

4 自定义ChannelHandler的添加过程

        上面分析了ChannelInitializer是如何插入Pipeline中的，接下来探讨ChannelInitializer在哪里被调用、ChannelInitializer的作用以及自定义的ChannelHandler是如何插入Pipeline中的。

        自定义ChannelHandler的添加过程，发生在AbstractUnsafe的register方法中，在这个方法中调用了pipeline.fireChannelRegister()方法，代码如下：

    @Override
    public final ChannelPipeline fireChannelRegistered() {
        AbstractChannelHandlerContext.invokeChannelRegistered(head);
        return this;
    }

        再看AbstractChannelHandlerContext的invokeChannelRegister()方法。

    static void invokeChannelRegistered(final AbstractChannelHandlerContext next) {
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            next.invokeChannelRegistered();
        } else {
            executor.execute(new Runnable() {
                @Override
                public void run() {
                    next.invokeChannelRegistered();
                }
            });
        }
    }

        很显然，这个代码将从Head开始遍历Pipeline的双向链表，然后找到第一个属性inbound为true的ChannelHandlerContext实例。在分析ChannelInitializer时，专门分析了inbound和outbound属性，现在这里就用上了。回想一下，ChannelInitializer实现了ChannelInboundHandler，因此它所对应的ChannelHandlerContext的inbound属性为true，因此这里返回的就是ChannelInitializer实例所对应的ChannelHandlerContext对象，如下图所示

        当获取inbound的Context后，就调用它的invokeChannelRegistered()方法。

    private void invokeChannelRegistered() {
        if (invokeHandler()) {
            try {
                ((ChannelInboundHandler) handler()).channelRegistered(this);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRegistered();
        }
    }

         我们已经知道，每个ChannelHandler都和一个ChannelHandlerContext关联，可以通过ChannelHandlerContext获取对应的ChannelHandler。很明显，这里handler()方法返回的对象其实就是一开始实例化的ChannelInitializer对象，接着调用了ChannelInitializer的channelRegister()方法。ChannelInitializer的channelRegister()方法的代码如下：

    public final void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        if (this.initChannel(ctx)) {
            ctx.pipeline().fireChannelRegistered();
        } else {
            ctx.fireChannelRegistered();
        }

    }
    private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
        if (this.initMap.putIfAbsent(ctx, Boolean.TRUE) == null) {
            try {
                this.initChannel(ctx.channel());
            } catch (Throwable var6) {
                this.exceptionCaught(ctx, var6);
            } finally {
                this.remove(ctx);
            }

            return true;
        } else {
            return false;
        }
    

        initChannel()方法就是在初始化Bootstrap时，调用handler方法传入的匿名内部类所实现的方法。因此，在调用这个方法之后，自定义的ChannelHandler就插入到Pipeline中，此时Pipeline的状态如下图：

        当添加完自定义的ChannelHandler后，在finally代码块会删除自定义的ChannelHandler，也就是remove(ctx)，最终调用ctx.pipeline().remove(this)，因此最后Pipeline的状态如下图：

        到此，自定义ChannelHandler的添加过程也就分析完成了。 

5 给ChannelHandler命名

        pipeline.addXXX()都有一个重载方法，例如addList()有一个重载的版本，代码如下：

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

        第一个参数指定添加的是Handler的名字（更准确的说是ChannelHandlerContext的名字）。那么Handler的名字有什么用呢？如果不设置name，那么Handler默认的名字是怎么样的？上面的方法会调用重载的addLast()方法，代码如下：

    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 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()) {
                newCtx.setAddPending();
                executor.execute(new Runnable() {
                    @Override
                    public void run() {
                        callHandlerAdded0(newCtx);
                    }
                });
                return this;
            }
        }
        callHandlerAdded0(newCtx);
        return this;
    }

        第一个参数设置为null，不用关心。第二个参数就是Handler的名字。有代码可知，再添加一个Handler之前，需要调用checkMultiplicity()方法来确定新添加的Handler名字是否与已添加的Handler名字重复。