netty源码分析之ChannelPipeline

         看了ChannelHandler我们就来看ChannelPipeline，这个类实现了责任链模式，我们就直接来看这个类的实现吧，看完后我们再看看javadoc的，这个写的很详细。

       

 static final InternalLogger logger = InternalLoggerFactory.getInstance(DefaultChannelPipeline.class);
    static final ChannelSink discardingSink = new DiscardingChannelSink();

    private volatile Channel channel;
    private volatile ChannelSink sink;
    private volatile DefaultChannelHandlerContext head;
    private volatile DefaultChannelHandlerContext tail;
    private final Map name2ctx =
        new HashMap(4);

       这个里面的很好理解，channel就是和这个pipeline相关联的，sink也是和这个chanel相关联的对象，在pipeline里面会调度channelhandler的运行，在运行之后交给sink去处理传输等比较底层的操作。head和tail和name2ctx是这个pipe里面的一个ChanelHandlerContext的一个链式结构。

 

 public ChannelSink getSink() {
        ChannelSink sink = this.sink;
        if (sink == null) {
            return discardingSink;
        }
        return sink;
    }

        在这个里面可以看到单不传递sink的时候，默认使用discardingSink。

 

public void attach(Channel channel, ChannelSink sink) {
        if (channel == null) {
            throw new NullPointerException("channel");
        }
        if (sink == null) {
            throw new NullPointerException("sink");
        }
        if (this.channel != null || this.sink != null) {
            throw new IllegalStateException("attached already");
        }
        this.channel = channel;
        this.sink = sink;
    }

          这个里面实现channel和sink与这个pipeline的绑定，可以看出来，一个pipe会和一个channel和sink相绑定。

         下来来看一下链表channelhandler的操作：

          

public synchronized void addFirst(String name, ChannelHandler handler) {
        if (name2ctx.isEmpty()) {
            init(name, handler);
        } else {
            checkDuplicateName(name);
            DefaultChannelHandlerContext oldHead = head;
            DefaultChannelHandlerContext newHead = new DefaultChannelHandlerContext(null, oldHead, name, handler);

            callBeforeAdd(newHead);

            oldHead.prev = newHead;
            head = newHead;
            name2ctx.put(name, newHead);

            callAfterAdd(newHead);
        }
    }

        如果链表是空的时候实现初始化的一些操作，初始化head、tail变量，然后如果这个handler是实现LifeCycleChannelHandler的，就触发相应的动作。如果不是初始化的时候，就修改一下head指针，这个是比较好理解的。

        同理addLast要修改相应的tail指针，addBefore修改prev，addAfter修改next指针，这些都比较好理解，就不多解释了。需要注意的是这些方法都是一些同步方法，都加了synchronized关键字，不知道这个地方是否可以使用ConcurrentHashMap。

       中间的一些链表操作我们就不多讲了，但是写的感觉比较好，都比较精彩，作者的功底很高，我们接下来看一下调度：

 

 public void sendUpstream(ChannelEvent e) {
        DefaultChannelHandlerContext head = getActualUpstreamContext(this.head);
        if (head == null) {
            logger.warn(
                    "The pipeline contains no upstream handlers; discarding: " + e);
            return;
        }

        sendUpstream(head, e);
    }

    void sendUpstream(DefaultChannelHandlerContext ctx, ChannelEvent e) {
        try {
            ((ChannelUpstreamHandler) ctx.getHandler()).handleUpstream(ctx, e);
        } catch (Throwable t) {
            notifyHandlerException(e, t);
        }
    }

            sendUpstream可以看到是从head开始走，然后找到下一个可以处理upstream的handler进行处理，然后让HandlerContext找到当前的下一个到下一个，慢慢的处理upstream事件，最后让交给ChannelSink组件。

         

 public void sendDownstream(ChannelEvent e) {
        DefaultChannelHandlerContext tail = getActualDownstreamContext(this.tail);
        if (tail == null) {
            try {
                getSink().eventSunk(this, e);
                return;
            } catch (Throwable t) {
                notifyHandlerException(e, t);
                return;
            }
        }

        sendDownstream(tail, e);
    }

    void sendDownstream(DefaultChannelHandlerContext ctx, ChannelEvent e) {
        if (e instanceof UpstreamMessageEvent) {
            throw new IllegalArgumentException("cannot send an upstream event to downstream");
        }
        
        try {
            ((ChannelDownstreamHandler) ctx.getHandler()).handleDownstream(ctx, e);
        } catch (Throwable t) {
            // Unlike an upstream event, a downstream event usually has an
            // incomplete future which is supposed to be updated by ChannelSink.
            // However, if an exception is raised before the event reaches at
            // ChannelSink, the future is not going to be updated, so we update
            // here.
            e.getFuture().setFailure(t);
            notifyHandlerException(e, t);
        }
    }

              sendDownstream我们可以看到是找到最后一个Handler，然后找到前一个可以处理downstream事件的handler进行处理。

           最后我们来看一下javadoc里面给的例子程序：

           

ChannelPipeline p = Channels.pipeline();
 p.addLast("1", new UpstreamHandlerA());
 p.addLast("2", new UpstreamHandlerB());
 p.addLast("3", new DownstreamHandlerA());
 p.addLast("4", new DownstreamHandlerB());
 p.addLast("5", new UpstreamHandlerX());

         我们可以看到，upstream事件的执行顺序是从头部找到第一个可以处理upstream事件的handler开始执行，所以执行顺序应该是1 --> 2 --> 5.

         downstream事件的执行顺序是从尾部找到第一个可以处理downstream事件的handler开始执行，所以执行顺序是 4 --> 3.

          在javadoc里面给我们指出了handler很灵活可以在运行的过程中自动的增加和删除，但是同时指出了下面的实现是错误的：

          

 public class FirstHandler extends SimpleChannelUpstreamHandler {

     @Override
     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) {
         // Remove this handler from the pipeline,
         ctx.getPipeline().remove(this);
         // And let SecondHandler handle the current event.
         ctx.getPipeline().addLast("2nd", new SecondHandler());
         ctx.sendUpstream(e);
     }
 }

       我们看出这个是错误的，remove方法会破坏这个链，所有应该在remove之前add，这个相信大家都不会犯这样的错误的。