netty源码分析（19）- 添加ChannelHandler过程

上一节学习了pipeline初始化的过程。初始化了HeadContext和TailContext，并构建了pipeline双向链表，每个节点存储ChannelHandlerContext。

本节研究添加ChannelHandler的过程。在学习之前先整理一些之前学到的内容。

• 在服务端channel初始化channle的过程中，bossGroup为服务端channel的pipeline添加了一个特殊的ChannelHandler:ServerBootstrapAcceptor,如下这幅图。

image.png

• 可客户端channel所在的workGroup处理所有childHandler,这里的Handler属于客户端channel

• 因此在bossGroup在初始化channel的过程中，会调用addLast()增加handler，促发HandlerAdded事件，而引导配置的时候触发的是ChannelInitializer#handlerAdded()。

入口

在引导的过程当中，重写了ChannelInitializer#initChannel()，其中获取了pipeline并调用了addLast()方法，同事将ChannelHandler作为参数传入addLast方法中。

class DataServerInitializer extends ChannelInitializer {
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {

        ch.pipeline()
                .addLast(new DefaultEventExecutorGroup(2),
                        new DataServerHandler(),
                        new DataServerOutHandler2(),
                        new DataServerOutHandler(),
                        new DataServerHandler2());
    }
}

• DefaultChannelPipeline#addLast()

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

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

具体的addLast方法做了以下几件事

1. 检查Handler是否重复添加
2. 创建数节点ChannelHandlerContext
3. 添加数据节点
4. 触发handlerAdded事件，执行对应Handler的回调函数

    @Override
    public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized (this) {
            //检查是否重复添加
            checkMultiplicity(handler);

            //group：异步线程
            //创建数据节点
            //filterName：从头节点开始遍历检查名字是否重复，如果没有传入name则生成一个name
            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;
            }

            //触发事件回调函数：handlerAdded
            EventExecutor executor = newCtx.executor();
            if (!executor.inEventLoop()) {
                callHandlerAddedInEventLoop(newCtx, executor);
                return this;
            }
        }
        //触发事件回调函数：handlerAdded
        callHandlerAdded0(newCtx);
        return this;
    }

• checkMultiplicity(handler);检查Handler是否重复添加
  逻辑主要时判断是否有@Sharable注解，从而判断是否允许从夫，其次通过成员变量added属性判断是否被添加过。如果重复的话则排除异常。

    private static void checkMultiplicity(ChannelHandler handler) {
        if (handler instanceof ChannelHandlerAdapter) {
            ChannelHandlerAdapter h = (ChannelHandlerAdapter) handler;
            //判断是否是共享 同时  是否时被添加过的
            if (!h.isSharable() && h.added) {
                throw new ChannelPipelineException(
                        h.getClass().getName() +
                        " is not a @Sharable handler, so can't be added or removed multiple times.");
            }
            h.added = true;
        }
    }

    public boolean isSharable() {
        /**
         * Cache the result of {@link Sharable} annotation detection to workaround a condition. We use a
         * {@link ThreadLocal} and {@link WeakHashMap} to eliminate the volatile write/reads. Using different
         * {@link WeakHashMap} instances per {@link Thread} is good enough for us and the number of
         * {@link Thread}s are quite limited anyway.
         *
         * See #2289.
         */
        Class clazz = getClass();
        Map, Boolean> cache = InternalThreadLocalMap.get().handlerSharableCache();
        Boolean sharable = cache.get(clazz);
        if (sharable == null) {
            sharable = clazz.isAnnotationPresent(Sharable.class);
            cache.put(clazz, sharable);
        }
        return sharable;
    }

• newCtx = newContext(group, filterName(name, handler), handler);，创建数据节点
  实例化DefaultChannelHandlerContext的过程中将handler作为成员变量持有，并且标记了handler是inbound还是outbound，并将一些重要的组件pipeline,executor保存起来。

    private AbstractChannelHandlerContext newContext(EventExecutorGroup group, String name, ChannelHandler handler) {
        //实例化DefaultChannelHandlerContext
        return new DefaultChannelHandlerContext(this, childExecutor(group), name, handler);
    }

    private final ChannelHandler handler;

    DefaultChannelHandlerContext(
            DefaultChannelPipeline pipeline, EventExecutor executor, String name, ChannelHandler handler) {
        //标记类型
        super(pipeline, executor, name, isInbound(handler), isOutbound(handler));
        if (handler == null) {
            throw new NullPointerException("handler");
        }
        //持有handler
        this.handler = handler;
    }

    AbstractChannelHandlerContext(DefaultChannelPipeline pipeline, EventExecutor executor, String name,
                                  boolean inbound, boolean outbound) {
        this.name = ObjectUtil.checkNotNull(name, "name");
        this.pipeline = pipeline;
        this.executor = executor;
        this.inbound = inbound;
        this.outbound = outbound;
        // Its ordered if its driven by the EventLoop or the given Executor is an instanceof OrderedEventExecutor.
        ordered = executor == null || executor instanceof OrderedEventExecutor;
    }

指的注意的是childExecutor,该方法处理添加handler时，传入的EventExecutorGroup。该Executor可用于用户在回调方法中处理异步计算。

    private EventExecutor childExecutor(EventExecutorGroup group) {
        if (group == null) {
            return null;
        }
        Boolean pinEventExecutor = channel.config().getOption(ChannelOption.SINGLE_EVENTEXECUTOR_PER_GROUP);
        if (pinEventExecutor != null && !pinEventExecutor) {
            return group.next();
        }
        //存储异步线程的容器：管理异步线程
        Map childExecutors = this.childExecutors;
        if (childExecutors == null) {
            // Use size of 4 as most people only use one extra EventExecutor.
            //新建一个Map存储异步线程
            childExecutors = this.childExecutors = new IdentityHashMap(4);
        }
        // Pin one of the child executors once and remember it so that the same child executor
        // is used to fire events for the same channel.
        //存储异步线程
        EventExecutor childExecutor = childExecutors.get(group);
        if (childExecutor == null) {
            childExecutor = group.next();
            childExecutors.put(group, childExecutor);
        }
        //返回异步线程
        return childExecutor;
    }

用户配置异步线程，处理异步计算。

class DataServerInitializer extends ChannelInitializer {

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {

        ch.pipeline()
                //配置异步线程处理异步计算
                .addLast(new DefaultEventExecutorGroup(2),
                        new DataServerHandler(),
                        new DataServerOutHandler2(),
                        new DataServerOutHandler(),
                        new DataServerHandler2());
    }
}

class DataServerHandler extends SimpleChannelInboundHandler