Netty3架构解析

DLevin — Fri, 04 Sep 2015 01:40:00 GMT

前记

很早以前��有读Netty源码的打��了�Q�然而第一�ơ尝试的时候从Netty4开始，一直抓不到核心的框架流�E�，后来因�ؓ(f��)其他事情忙着��放下了。这�ơ趁着休假重新捡�v�q�个��骨��_(d��)��因�ؓ(f��)Netty3现在�q�在被很多项目��用，因而这�ơ决定先从Netty3入手�Q�瞬间发现Netty3的代码比Netty4中规中矩的多�Q�很多概念在代码本��n中都有清晰的表达�Q�所以半天就把整个框架的骨架搞清楚了。再�?a >Netty4对Netty3的改�q��ȝ��Q�回去读Netty4的源码，反而觉得轻松了�Q�一�U�豁然开朗的感觉�?br />
记得��d��读Jetty源码的时候，因�ؓ(f��)代码太庞大，�q�且自己的HTTP Server的了解太��，因而只能自底向上的一个一个模块的叠加�Q�直到最后把所以的模块�q�接在一赯��(g��)�看清它的真正核心骨架。现在读源码�Q�开始习(f��n)惯先把骨架理清，然后延��C��同的器官、血肉而看清整个�h体�?br />
本文从Reactor模式在Netty3中的应用�Q�引出Netty3的整体架构以�?qi��ng)控制流�E�；然而除了Reactor模式�Q�Netty3�q�在ChannelPipeline中��用了Intercepting Filter模式�Q�这个模式也在Servlet的Filter中成功��用，因而本文还�?x��)从Intercepting Filter模式出发详细介绍ChannelPipeline的设计理��c(di��n)��本文假设读者已�l�对Netty有一定的了解�Q�因而不�?x��)包含过多入门介�l�，以及(qi��ng)帮Netty做宣传的文字�?br />

Netty3中的Reactor模式

Reactor模式在Netty中应用非常成功，因而它也是在Netty中受大肆宣传的模式，关于Reactor模式可以详细参考本人的另一��文�?a href="http://www.tkk7.com/DLevin/archive/2015/09/02/427045.html">《Reactor模式详解�?/a>�Q�对Reactor模式的实现是Netty3的基本骨�Ӟ��因而本��节�?x��)详�l�介�l�Reactor模式如何应用Netty3中�?br />
如果诅R��Reactor模式详解》，我们知道Reactor模式由Handle、Synchronous Event Demultiplexer、Initiation Dispatcher、Event Handler、Concrete Event Handler构成�Q�在Java的实现版本中�Q�Channel对应Handle�Q�Selector对应Synchronous Event Demultiplexer�Q��ƈ且Netty3�q��用了两层Reactor�Q�Main Reactor用于处理Client的连接请求，Sub Reactor用于处理和Client�q�接后的��d��h��Q�关于这个概念还可以参考Doug Lea的这��PPT�Q?a >Scalable IO In Java�Q�。所以我们先要解决Netty3中��用什么类实现所有的上述模块�q�把他们联系在一��L(f��ng)��Q�以NIO实现方式��Z��Q?br />
模式是一�U�抽象，但是在实��C��Q�经�怼�(x��)因�ؓ(f��)语言�Ҏ(gu��)��、框架和性能需要而做一些改变，因而Netty3对Reactor模式的实现有一套自��q��设计�Q?br />1. ChannelEvent�Q?/strong>Reactor是基于事件编�E�的�Q�因而在Netty3中��用ChannelEvent抽象的表达Netty3内部可以产生的各�U�事�Ӟ��所有这些事件对象在Channels帮助�c�M��产生�Q��ƈ且由它将事�g推入到ChannelPipeline中，ChannelPipeline构徏ChannelHandler��道�Q�ChannelEvent��经�q�个��道实现所有的业务逻辑处理。ChannelEvent对应的事件有�Q�ChannelStateEvent表示Channel状态的变化事�g�Q�而如果当前Channel存在Parent Channel�Q�则该事件还�?x��)传递到Parent Channel的ChannelPipeline中，如OPEN、BOUND、CONNECTED、INTEREST_OPS�{�，该事件可以在各种不同实现的Channel、ChannelSink中��生；MessageEvent表示从Socket中读取数据完成、需要向Socket写数据或ChannelHandler对当前Message解析(如Decoder、Encoder)后触发的事�g�Q�它由NioWorker、需要对Message做进一步处理的ChannelHandler产生�Q�WriteCompletionEvent表示写完成而触发的事�g�Q�它由NioWorker产生�Q�ExceptionEvent表示在处理过�E�中出现的Exception�Q�它可以发生在各个构件中�Q�如Channel、ChannelSink、NioWorker、ChannelHandler中；IdleStateEvent由IdleStateHandler触发�Q�这也是一个ChannelEvent可以无缝扩展的例子。注�Q�在Netty4后，已经没有ChannelEvent�c�，所有不同事仉��用对应方法表达，�q�也意味�q�C(j��)hannelEvent不可扩展�Q�Netty4采用在ChannelInboundHandler中加入userEventTriggered()�Ҏ(gu��)��来实现这�U�扩展，具体可以参�?a >�q�里�?br />2. ChannelHandler�Q?/strong>在Netty3中，ChannelHandler用于表示Reactor模式中的EventHandler。ChannelHandler只是一个标记接口，它有两个子接口：(x��)ChannelDownstreamHandler和ChannelUpstreamHandler�Q�其中ChannelDownstreamHandler表示从用户应用程序流向Netty3内部直到向Socket写数据的��道�Q�在Netty4中改名�ؓ(f��)ChannelOutboundHandler�Q�ChannelUpstreamHandler表示数据从Socket�q�入Netty3内部向用户应用程序做数据处理的管道，在Netty4中改名�ؓ(f��)ChannelInboundHandler�?br />3. ChannelPipeline�Q?/strong>用于��理ChannelHandler的管道，每个Channel一个ChannelPipeline实例�Q�可以运行过�E�中动态的向这个管道中��d��、删除ChannelHandler�Q�由于实现的限制�Q�在最末端的ChannelHandler向后��d��或删除ChannelHandler不一定在当前执行��程中�v效，参�?a >�q�里�Q�。ChannelPipeline内部�l�护一个ChannelHandler的双向链表，它以Upstream(Inbound)方向为正向，Downstream(Outbound)方向为方向。ChannelPipeline采用Intercepting Filter模式实现�Q�具体可以参�?a href="http://www.tkk7.com/DLevin/archive/2015/09/03/427086.html">�q�里�Q�这个模式的实现在后一节中�q�是详细介绍�?br />4. NioSelector�Q?/strong>Netty3使用NioSelector来存放Selector�Q�Synchronous Event Demultiplexer�Q�，每个��C�生的NIO Channel都向�q�个Selector注册自己以让�q�个Selector监听�q�个NIO Channel中发生的事�g�Q�当事�g发生�Ӟ��调用帮助�c�Channels中的�Ҏ(gu��)��生成ChannelEvent实例�Q�将该事件发送到�q�个Netty Channel对应的ChannelPipeline中，而交�l�各�U�ChannelHandler处理。其中在向Selector注册NIO Channel�Ӟ��Netty Channel实例以Attachment的�Ş式传入，该Netty Channel在其内部的NIO Channel事�g发生�Ӟ��?x��)以Attachment的�Ş式存在于SelectionKey中，因而每个事件可以直接从�q�个Attachment中获取相关链的Netty Channel�Q��ƈ从Netty Channel中获取与之相兌��的ChannelPipeline�Q�这个实现和Doug Lea�?a >Scalable IO In Java一模一栗��另外Netty3�q�采用了Scalable IO In Java中相同的Main Reactor和Sub Reactor设计�Q�其中NioSelector的两个实玎ͼ�(x��)Boss即�ؓ(f��)Main Reactor�Q�NioWorker为Sub Reactor。Boss用来处理新连接加入的事�g�Q�NioWorker用来处理各个�q�接对Socket的读写事�Ӟ��其中Boss通过NioWorkerPool获取NioWorker实例�Q�Netty3模式使用RoundRobin方式攑֛�NioWorker实例。更形象一点的�Q�可以通过Scalable IO In Java的这张图表达�Q?br />
若与Ractor模式对应�Q�NioSelector中包含了Synchronous Event Demultiplexer�Q�而ChannelPipeline中管理着所有EventHandler�Q�因而NioSelector和ChannelPipeline共同构成了Initiation Dispatcher�?br />5. ChannelSink�Q?/strong>在ChannelHandler处理完成所有逻辑需要向客户端写响应数据�Ӟ��一般会(x��)调用Netty Channel中的write�Ҏ(gu��)��Q�然而在�q�个write�Ҏ(gu��)��实现中，它不是直接向其内部的Socket写数据，而是交给C(j��)hannels帮助�c�，内部创徏DownstreamMessageEvent�Q�反向从ChannelPipeline的管道中��过去，直到�W�一个ChannelHandler处理完毕�Q�最后交�l�C(j��)hannelSink处理�Q�以避免��d��写而媄(ji��ng)响程序的吞吐量。ChannelSink��这个MessageEvent提交�l�Netty Channel中的writeBufferQueue�Q�最后NioWorker�?x��)等到这个NIO Channel已经可以处理写事件时无阻塞的向这个NIO Channel写数据。这��是上图的send是从SubReactor直接出发的原因�?br />6. Channel�Q?/strong>Netty有自��q��Channel抽象�Q�它是一个资源的容器�Q�包含了所有一个连接涉�?qi��ng)到的所有资源的饮用�Q�如��装NIO Channel、ChannelPipeline、Boss、NioWorkerPool�{�。另外它�q�提供了向内部NIO Channel写响应数据的接口write、连�?�l�定到某个地址的connect/bind接口�{�，个�h感觉虽然对Channel本��n来说�Q�因为它?y��u)��装了NIO Channel�Q�因而这些接口定义在�q�里是合理的�Q�但是如果考虑到Netty的架构，它的Channel只是一个资源容器，有这个Channel实例��可以得到和它相关的基本所有资源，因而这�U�write、connect、bind动作不应该再由它负责�Q�而是应该由其他类来负责，比如在Netty4中就在ChannelHandlerContext��d��了write�Ҏ(gu��)��Q�虽然netty4�q�没有删除Channel中的write接口�?br />
Netty3中的Intercepting Filter模式
如果说Reactor模式是Netty3的骨�Ӟ��那么Intercepting Filter模式则是Netty的中枢。Reactor模式主要应用在Netty3的内部实玎ͼ�它是Netty3��h��良好性能的基��Q�而Intercepting Filter模式则是ChannelHandler�l�合实现一个应用程序逻辑的基��Q�只有很好的理解了这个模式才能��用好Netty�Q�甚臌��得心应手�?br />
关于Intercepting Filter模式的详�l�介�l�可以参�?a href="http://www.tkk7.com/DLevin/archive/2015/09/03/427086.html">�q�里�Q�本节主要介�l�Netty3中对Intercepting Filter模式的实玎ͼ�其实��是DefaultChannelPipeline对Intercepting Filter模式的实现。在上文有提到Netty3的ChannelPipeline是ChannelHandler的容器，用于存储与管理ChannelHandler�Q�同时它在Netty3中也起到桥梁的作用，卛_��是连接Netty3内部到所有ChannelHandler的桥梁。作为ChannelPipeline的实现者DefaultChannelPipeline�Q�它使用一个ChannelHandler的双向链表来存储�Q�以DefaultChannelPipelineContext作�ؓ(f��)节点�Q?br />
public interface ChannelHandlerContext {
    Channel getChannel();
    ChannelPipeline getPipeline();
    String getName();
    ChannelHandler getHandler();
    boolean canHandleUpstream();
    boolean canHandleDownstream();
    void sendUpstream(ChannelEvent e);
    void sendDownstream(ChannelEvent e);
    Object getAttachment();
    void setAttachment(Object attachment);
}

private final class DefaultChannelHandlerContext implements ChannelHandlerContext {
    volatile DefaultChannelHandlerContext next;
    volatile DefaultChannelHandlerContext prev;
    private final String name;
    private final ChannelHandler handler;
    private final boolean canHandleUpstream;
    private final boolean canHandleDownstream;
    private volatile Object attachment;
.....
}
在DefaultChannelPipeline中，它存储了和当前ChannelPipeline相关联的Channel、ChannelSink以及(qi��ng)ChannelHandler链表的head、tail�Q�所有ChannelEvent通过sendUpstream、sendDownstream为入口流�l�整个链表：(x��)
public class DefaultChannelPipeline implements ChannelPipeline {
    private volatile Channel channel;
    private volatile ChannelSink sink;
    private volatile DefaultChannelHandlerContext head;
    private volatile DefaultChannelHandlerContext tail;
......
    public void sendUpstream(ChannelEvent e) {
        DefaultChannelHandlerContext head = getActualUpstreamContext(this.head);
        if (head == null) {
            return;
        }
        sendUpstream(head, e);
    }

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

    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) {
            e.getFuture().setFailure(t);
            notifyHandlerException(e, t);
        }
    }
对Upstream事�g�Q�向后找到所有实��C��ChannelUpstreamHandler接口的ChannelHandler�l�成链（getActualUpstreamContext()�Q?/span>�Q�而对Downstream事�g�Q�向前找到所有实��C��ChannelDownstreamHandler接口的ChannelHandler�l�成链（getActualDownstreamContext()�Q�：(x��)
    private DefaultChannelHandlerContext getActualUpstreamContext(DefaultChannelHandlerContext ctx) {
        if (ctx == null) {
            return null;
        }
        DefaultChannelHandlerContext realCtx = ctx;
        while (!realCtx.canHandleUpstream()) {
            realCtx = realCtx.next;
            if (realCtx == null) {
                return null;
            }
        }
        return realCtx;
    }
    private DefaultChannelHandlerContext getActualDownstreamContext(DefaultChannelHandlerContext ctx) {
        if (ctx == null) {
            return null;
        }
        DefaultChannelHandlerContext realCtx = ctx;
        while (!realCtx.canHandleDownstream()) {
            realCtx = realCtx.prev;
            if (realCtx == null) {
                return null;
            }
        }
        return realCtx;
    }
在实际实现ChannelUpstreamHandler或ChannelDownstreamHandler�Ӟ��调用 ChannelHandlerContext中的sendUpstream或sendDownstream�Ҏ(gu��)��控制流�E�交�l�下一�? ChannelUpstreamHandler或下一个ChannelDownstreamHandler�Q�或调用Channel中的write�Ҏ(gu��)��发�? 响应消息�?br />
public class MyChannelUpstreamHandler implements ChannelUpstreamHandler {
    public void handleUpstream(ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
        // handle current logic, use Channel to write response if needed.
        // ctx.getChannel().write(message);
        ctx.sendUpstream(e);
    }
}

public class MyChannelDownstreamHandler implements ChannelDownstreamHandler {
    public void handleDownstream(
            ChannelHandlerContext ctx, ChannelEvent e) throws Exception {
        // handle current logic
        ctx.sendDownstream(e);
    }
}
当ChannelHandler向ChannelPipelineContext发送事件时�Q�其内部从当前ChannelPipelineContext节点出发扑ֈ�下一个ChannelUpstreamHandler或ChannelDownstreamHandler实例�Q��ƈ向其发送ChannelEvent�Q�对于Downstream链，如果到达铑ְ��Q�则��ChannelEvent发送给C(j��)hannelSink�Q?br />
public void sendDownstream(ChannelEvent e) {
    DefaultChannelHandlerContext prev = getActualDownstreamContext(this.prev);
    if (prev == null) {
      try {
            getSink().eventSunk(DefaultChannelPipeline.this, e);
        } catch (Throwable t) {
            notifyHandlerException(e, t);
        }
    } else {
        DefaultChannelPipeline.this.sendDownstream(prev, e);
    }
}

public void sendUpstream(ChannelEvent e) {
    DefaultChannelHandlerContext next = getActualUpstreamContext(this.next);
    if (next != null) {
        DefaultChannelPipeline.this.sendUpstream(next, e);
    }
}
正是因�ؓ(f��)�q�个实现�Q�如果在一个末��ChannelUpstreamHandler中先�U�除自己�Q�在向末��添加一个新的ChannelUpstreamHandler�Q�它是无效的�Q�因为它的next已经在调用前��固定设�|��ؓ(f��)null了�?br />
ChannelPipeline作�ؓ(f��)ChannelHandler的容器，它还提供了各�U�增、删、改ChannelHandler链表中的�Ҏ(gu��)��Q�而且如果某个ChannelHandler�q�实��C��LifeCycleAwareChannelHandler�Q�则该ChannelHandler在被��d��q�ChannelPipeline或从中删除时都会(x��)得到同志�Q?br />
public interface LifeCycleAwareChannelHandler extends ChannelHandler {
    void beforeAdd(ChannelHandlerContext ctx) throws Exception;
    void afterAdd(ChannelHandlerContext ctx) throws Exception;
    void beforeRemove(ChannelHandlerContext ctx) throws Exception;
    void afterRemove(ChannelHandlerContext ctx) throws Exception;
}

public interface ChannelPipeline {
    void addFirst(String name, ChannelHandler handler);
    void addLast(String name, ChannelHandler handler);
    void addBefore(String baseName, String name, ChannelHandler handler);
    void addAfter(String baseName, String name, ChannelHandler handler);
    void remove(ChannelHandler handler);
    ChannelHandler remove(String name);
    <T extends ChannelHandler> T remove(Class<T> handlerType);
    ChannelHandler removeFirst();
    ChannelHandler removeLast();
    void replace(ChannelHandler oldHandler, String newName, ChannelHandler newHandler);
    ChannelHandler replace(String oldName, String newName, ChannelHandler newHandler);
    <T extends ChannelHandler> T replace(Class<T> oldHandlerType, String newName, ChannelHandler newHandler);
    ChannelHandler getFirst();
    ChannelHandler getLast();
    ChannelHandler get(String name);
    <T extends ChannelHandler> T get(Class<T> handlerType);
    ChannelHandlerContext getContext(ChannelHandler handler);
    ChannelHandlerContext getContext(String name);
    ChannelHandlerContext getContext(Class extends ChannelHandler> handlerType);
    void sendUpstream(ChannelEvent e);
    void sendDownstream(ChannelEvent e);
    ChannelFuture execute(Runnable task);
    Channel getChannel();
    ChannelSink getSink();
    void attach(Channel channel, ChannelSink sink);
    boolean isAttached();
    List<String> getNames();
    Map<String, ChannelHandler> toMap();
}

在DefaultChannelPipeline的ChannelHandler链条的处理流�E��ؓ(f��)�Q?br />
参考：(x��)
《Netty主页�?/a>
《Netty源码解读�Q�四�Q�Netty与Reactor模式�?/a>
《Netty代码分析�?/a>
Scalable IO In Java
Intercepting Filter Pattern

DLevin 2015-09-04 09:40 发表评论

亚洲一区二区三区高清视频,亚洲精彩视频在线观看,亚洲第一AV网站

Netty3架构解析

前记

Netty3中的Reactor模式

Netty3中的Intercepting Filter模式

参考：(x��)