文档章节

netty源码分析系列——ChannelHandler系列

杨武兵
 杨武兵
发布于 2017/06/14 22:24
字数 4824
阅读 343
收藏 0

总体介绍

使用netty开发网络应用,用户接触最多的就是ChannelHandler,它是用于处理接收到的消息以及发送处理后的结果给远端的,这些是与具体的应用层协议和业务逻辑相关的部分。

上图体现了ChannelHandler相关的几个类之间的关系和流程。

初始化阶段

当Channel对象在构造的时候会同时创建一个ChannelPipeline对象,两个对象相互关联,是一对一的关系,ChannelPipeline不会被多个Channel共享。ChannelPipeline对象创建之后会调用它的各种添加handler的方法向链中加入ChannelHandler对象,而在加入ChannelHandler对象的同时,会自动给每个ChannelHandler包装一个ChannelHandlerContext对象。

ChannelHandlerContext是ChannelHandler的上下文信息,它使得ChannelHandler可以和ChannelPipeline以及其它的ChannelHandler对象进行交互操作。通过ChannelHandlerContext对象,ChannelHandler可以通知同一个pipeline中的其他ChannelHandler,也可以在运行时动态改变ChannelPipeline中的内容。

输入消息处理

当输入消息触发的时候,例如registred,active,read或readComplete等输入的消息触发的时候,会通过Channel调用对应的ChannelPipeline的对应方法来处理,输入消息会首先通过head找到下一个ChanneInbountHandler来处理输入消息,然后逐一传递到下一个ChanneInbountHandler消息,直至到最后一个内置的tail处理器。

输出消息处理

当输入消息触发的时候,例如bind,connect,write等输出消息触发的时候,会通过Channel调用对应的ChannelPipeline的对应方法来处理,输入消息会首先通过tail找到下一个ChanneOutbountHandler来处理输入消息,然后逐一传递到下一个ChanneOutbountHandler消息,直至到最后一个内置的head处理器。

ChannelHandler相关类类图

上图展示的是ChannelHandler相关的一些类的关系,我们将从输入和输出的处理流程来逐一走查一遍相关的源码。

Channel

    /**
     * Return the assigned {@link ChannelPipeline}.
     */
    ChannelPipeline pipeline();

Channel接口中定义了一个返回关联的pipeline对象的方法,该方法使得Channel和ChannelPipeline关联在一起了,每个Channel都会有一个ChannelPipeline对象与之关联。

AbstractChannel

AbstractChannel类是Chanel的一个顶层抽象类,定义了公共的属性和方法,我们将分析它和pipeline产生关联部分的典型代码。

构造函数及pipeline()

在构造函数中对pipline属性进行了初始化。

    protected AbstractChannel(Channel parent) {
        this.parent = parent;
        id = newId();
        unsafe = newUnsafe();
        pipeline = newChannelPipeline();//创建一个pipeline对象。
    }


    protected DefaultChannelPipeline newChannelPipeline() {
        return new DefaultChannelPipeline(this);//直接构造一个默认的DefaultChannelPipeline类的对象。
    }

    public ChannelPipeline pipeline() {
        return pipeline;//实现了Channel接口定义的该方法,返回构造的pipeline对象。
    }

通过构造一个默认的实现类DefaultChannelPipeline的对象作为与Channel关联的pipeline对象,实现了pipeline方法,直接返回该对象。

Channel read()

通过该方法来代替所有的输入流处理方法。

    public Channel read() {
        pipeline.read();
        return this;
    }

调用了pipeline.read方法进行后续处理,接着进入道pipeline类的该方法继续分析。

write(Object msg)

通过该方法来代替所有的输出流处理方法。

    public ChannelFuture write(Object msg) {
        return pipeline.write(msg);
    }

调用了pipeline.write方法进行后续处理,接着进入道pipeline类的该方法继续分析。

DefaultChannelPipeline

DefaultChannelPipeline类作为ChannelPipeline接口默认且唯一的实现类,它包含了大部分核心处理逻辑,是我们要重点分析的类。

重要属性列表


    final AbstractChannelHandlerContext head;//双向链表的头部。
    final AbstractChannelHandlerContext tail;//双向链表的尾巴。

    private final Channel channel;//关联的Channel对象,这两个对象是相互关联的。

    /**
     * Set to {@code true} once the {@link AbstractChannel} is registered.Once set to {@code true} the value will never
     * change.
     */
    private boolean registered;//关联的Chanel是否已经注册。

head和tail是pipeline中最重要的两个属性,它表示了构造pipline是有一个双向链表来实现的,head是链表的头部,指向下一个ChannelContext对象,context中包含了一个ChannelHandler对象;tail是链表的尾部,它的上一个节点是最后一个ChannelContext对象;

构造函数

    protected DefaultChannelPipeline(Channel channel) {//受保护的构造函数,非公开。
        this.channel = ObjectUtil.checkNotNull(channel, "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;//初始化链表。尾部节点的上一个节点是头部节点。
    }

构造函数是关联一个channel对象,另外对链表的头部尾部节点进行了初始化。tail和head节点的功能下面章节ChannelHandlerContext会进行介绍。

链表节点维护

初始化后的链表是一个只有默认的head及tail节点的空链表,这2个节点未实现任何有价值的逻辑,如果我们要利用netty来处理输入输出事件,则需要往pipeline的链表里添加一些有意义的ChannelHandler。

pipeline中有一系列的增删改链表节点的方法,我们不逐一分析,只选择其中一个有代表性的addFirst方法来进行分析。

   @Override
    public final ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized (this) {//同步方法块,避免并发安全性问题。
            checkMultiplicity(handler);//检查handler是否重复添加。无@Shareable标记的ChannelHandler不允许共享被添加多次。
            name = filterName(name, handler);//过滤名称。检查名称不能重复。

            newCtx = newContext(group, name, handler);//给handler包装一个新的ChannelHandlerContext对象,这里默认创建了DefaultChannelHandlerContext对象。

            addFirst0(newCtx);//将新生成的context节点加入道双向链表中,从head节点开始修改原来的链表引用关系。

            //如果registered的值是false,意味着channel通道还没有注册到eventloop对象上,这种情况下我们添加的context状态是ADD_PENDING,并且会添加一个回调处理器,在channel被成功注册到eventloop后会回调ChannelHandler.handlerAdded(...)方法。
            if (!registered) {
                newCtx.setAddPending();
                callHandlerCallbackLater(newCtx, true);
                return this;
            }
            //如果不在eventloop中,则开启新的线程执行。
            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;
    }

    //典型的将新节点插入到头节点之后,需要修改双向链表的prev和next值。
    private void addFirst0(AbstractChannelHandlerContext newCtx) {
        AbstractChannelHandlerContext nextCtx = head.next;//暂存头节点的下一个节点值。
        newCtx.prev = head;//新节点的上一个节点改为head;
        newCtx.next = nextCtx;//新节点的下一个节点为原来head的next节点。
        head.next = newCtx;//头节点的下一个节点现在是新节点。
        nextCtx.prev = newCtx;//新节点的上一个几点是头节点。
    }

该方法是添加节点到头节点之后作为第一个节点。它的步骤如下:

1.检查名称是否重复,非共享的ChannelHandler是否被重复添加。

2.构造一个ChannelHandlerContext节点,对ChannelHandler进行包装,并将它添加到第一个节点。

3.完成添加后更新添加状态。

fireChannelRead()

读消息的处理方法,以该方法来代表所有的输入事件处理;若Channel读取到新的消息的时候,它触发调用pipeline的fireChannelRead方法,它负责读取消息后的处理。

    public final ChannelPipeline fireChannelRead(Object msg) {
        AbstractChannelHandlerContext.invokeChannelRead(head, msg);
        return this;
    }

它直接调用了AbstractChannelHandlerContext的invokeChannelRead方法,传入头节点,从这儿可以看出来,输入消息的处理是从head到tail的传递过程。下一节会介绍该方法的实现。

write()

写消息的处理方法,用该方法来代表所有的输出事件处理;

    public final ChannelFuture write(Object msg) {
        return tail.write(msg);
    }

该方法调用了尾节点write方法,而tail也是一个AbstractChannelHandlerContext类型的对象,证明输出事件是从尾节点开始处理,传到上一个节点,直到head节点,下一节详细分析其源码。

AbstractChannelHandlerContext

ChannelHandlerContext对ChannelHandler进行了包装,pipeline直接对它进行操作。从上面类图我们可以看出来AbstractChannelHandlerContext是ChannelHandler接口的一个抽象实现,它实现了绝大多数的逻辑,因此我们分析该类就足够了。

属性列表

    private final boolean inbound; //是否输入处理器。
    private final boolean outbound;//是否输出处理器。
    private final DefaultChannelPipeline pipeline;//关联的pipline
    private final String name;//名称。
    private final boolean ordered;//是否排序。
    // Will be set to null if no child executor should be used, otherwise it will be set to the
    // child executor.
    final EventExecutor executor;//子执行器。

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()) {//在eventLoop中直接执行,
            next.invokeChannelRead(m);//执行next对象的方法。
        } else {
            executor.execute(new Runnable() {//创建一个任务执行。
                @Override
                public void run() {
                    next.invokeChannelRead(m);
                }
            });
        }
    }
   

上面的代码最终还是调用了另外一个对象方法invokeChannelRead来执行其逻辑。

    private void invokeChannelRead(Object msg) {
        if (invokeHandler()) {//是否执行处理器。
            try {
                ((ChannelInboundHandler) handler()).channelRead(this, msg);//调用context包装的一个输入处理器处理消息。
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRead(msg);
        }
    }

write

写入消息方法。

    public ChannelFuture write(Object msg) {
        return write(msg, newPromise());//调用重载方法。
    }


    @Override
    public ChannelFuture write(final Object msg, final ChannelPromise promise) {
        if (msg == null) {//检查消息。
            throw new NullPointerException("msg");
        }

        try {
            if (!validatePromise(promise, true)) {//promise不合法。
                ReferenceCountUtil.release(msg);//释放消息引用计数。
                // cancelled
                return promise;
            }
        } catch (RuntimeException e) {
            ReferenceCountUtil.release(msg);释放消息引用计数,抛出一场。
            throw e;
        }
        write(msg, false, promise);
        return promise;
    }


    private void write(Object msg, boolean flush, ChannelPromise promise) {//写消息私有方法。
        AbstractChannelHandlerContext next = findContextOutbound();//查找下一个输出处理器上下文。
        final Object m = pipeline.touch(msg, next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            if (flush) {//调用下一个输出处理器的执行invokeWrite 方法。
                next.invokeWriteAndFlush(m, promise);
            } else {
                next.invokeWrite(m, promise);
            }
        } else {
            AbstractWriteTask task;
            if (flush) {
                task = WriteAndFlushTask.newInstance(next, m, promise);
            }  else {
                task = WriteTask.newInstance(next, m, promise);
            }
            safeExecute(executor, task, promise, m);
        }
    }

从源码流程来看它是查找下一个输出context独享,然后调用该context的invokeWrite方法。

    private void invokeWrite(Object msg, ChannelPromise promise) {
        if (invokeHandler()) {执行处理器。
            invokeWrite0(msg, promise);
        } else {
            write(msg, promise);
        }
    }

    private void invokeWrite0(Object msg, ChannelPromise promise) {
        try {
            ((ChannelOutboundHandler) handler()).write(this, msg, promise);//调用处理器的write方法来处理。
        } catch (Throwable t) {
            notifyOutboundHandlerException(t, promise);
        }
    }

最后又会调用handler的write方法来处理写入消息事件。

DefaultChannelHandlerContext

该类作为抽象类AbstractChannelHandlerContext的唯一默认实现类。它实现了几个抽象方法,它只是增加了一个属性handler来引用context包装的handler对象,然后就是对于该对象的初始化和读取它的值实现。

    private final ChannelHandler handler;//context包装的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");
        }
        this.handler = handler;//设置handler。
    }

    @Override
    public ChannelHandler handler() {
        return handler;
    }

    private static boolean isInbound(ChannelHandler handler) {
        return handler instanceof ChannelInboundHandler;//判断handler是否是输入处理器。
    }

    private static boolean isOutbound(ChannelHandler handler) {
        return handler instanceof ChannelOutboundHandler;//判断handler是否是输出处理器。
    }

HeadContext

final class HeadContext extends AbstractChannelHandlerContext
            implements ChannelOutboundHandler, ChannelInboundHandler {

        private final Unsafe unsafe;

        HeadContext(DefaultChannelPipeline pipeline) {
            super(pipeline, null, HEAD_NAME, false, true);
            unsafe = pipeline.channel().unsafe();
            setAddComplete();
        }
        @Override
        public ChannelHandler handler() {
            return this;
        }

        @Override
        public void read(ChannelHandlerContext ctx) {
            unsafe.beginRead();
        }

        @Override
        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
            unsafe.write(msg, promise);
        }
}

HeadContext作为ping的ipeline中首个节点,它提供了一些默认的实现,它持有一个unsafe对象的应用,read和write方法都是调用unsafe对应的方法来实现,而unsafe是从channel()中获取的,实际上就是调用了channel底层的读写处理方法,对于底层网络连接通道进行输入输出的处理。

TailContext

  final class TailContext extends AbstractChannelHandlerContext implements ChannelInboundHandler {

        TailContext(DefaultChannelPipeline pipeline) {
            super(pipeline, null, TAIL_NAME, true, false);
            setAddComplete();
        }

        @Override
        public ChannelHandler handler() {
            return this;
        }
 @Override
        public void channelRegistered(ChannelHandlerContext ctx) throws Exception { }

        @Override
        public void channelUnregistered(ChannelHandlerContext ctx) throws Exception { }
.....

}

TailContext是pipeline尾部节点,它的处理方法几乎都是空的,没有实际的逻辑处理。

ChannelHandler及核心子类类图

ChannelHandler系列核心的接口及实现类如上图所示,我们将按照继承关系逐一研究这些类的源码,该部分不包含具体应用层协议的编码解码器,后面系列可能会分析一下某些协议的编码解码器。例如http和http2。

ChannelHandler

    void handlerAdded(ChannelHandlerContext ctx) throws Exception;//handler被加入到pipeline事件处理。
    void handlerRemoved(ChannelHandlerContext ctx) throws Exception;//handler从pipeline中删除事件处理。
    @Deprecated
    void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;//异常捕获事件处理。
    @Inherited
    @Documented
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @interface Sharable {//定义了一个注解,标记Handler是可共享的。
        // no value
    }

ChannelHandler是顶层的一个接口,它定义了三个事件处理方法。还定义了一个注解Sharable,该注解标记了Handler对象是可共享的,意味着如果一个Handler实现类标记了Sharable注解则它的同一个对象可以多次被加入到多个不同的pipeline中,而默认未标注注解的话则每个pipeline都会生成新的Handler对象,被不同的Channel共享,因此它可能会在多个线程中执行,所以标记未Sharable的Handler类的处理方法要实现线程安全,考虑多线程环境下能够安全地运行,最好做到无线程共享状态,若不能做到无状态,则需要通过锁等技术来控制并发。

ChannelOutboundHandler

    void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise) throws Exception;//绑定本地一个地址。
    void connect(
            ChannelHandlerContext ctx, SocketAddress remoteAddress,
            SocketAddress localAddress, ChannelPromise promise) throws Exception;//连接到远程服务器。
    void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;//断开远程连接。
    void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;//关闭。
    void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception;//取消注册到EventLoop上。
    void read(ChannelHandlerContext ctx) throws Exception;//拦截Context触发的read事件。
    void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception;//写消息,该方法将消息写入到待发送的缓冲区中。
    void flush(ChannelHandlerContext ctx) throws Exception;//将本地缓冲区中待发送的消息刷到物理连接上,真正触发发送消息。

ChannelOutboundHandler是ChannelHandler接口的子接口,它的职责是负责接收输出的I/O事件,并处理这些输出事件。它增加了几个输出事件处理方法。

ChannelInboundHandler


    void channelRegistered(ChannelHandlerContext ctx) throws Exception;//连接注册到EventLoop的事件处理。

    void channelUnregistered(ChannelHandlerContext ctx) throws Exception;//取消注册到EventLoop的事件处理。
    void channelActive(ChannelHandlerContext ctx) throws Exception;//远程连接激活事件。
    void channelInactive(ChannelHandlerContext ctx) throws Exception;//远程连接断开事件。
    void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception;//从远端读取消息事件。

    void channelReadComplete(ChannelHandlerContext ctx) throws Exception;//最后一个消息读取完毕事件。

    void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception;//用户自定义事件触发。

    void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception;//连接可写状态变更事件,例如限流可导致连接不可写,当连接重新可写情况下则会发送给事件通知客户端。

    void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception;//异常捕获事件。

ChannelOutboundHandler是ChannelHandler接口的子接口,它的职责是负责接收输入的I/O事件,并处理这些输入事件。它增加了几个输入事件处理方法。

ChannelHandlerAdapter

   //是否添加标志,不使用volatile关键字,因为它仅用于完整性检查。
    boolean added;

    /**
     * 如果当前实现类被注解@Sharable标记,则它可以被加入到不同的ChannelPipeline中,表示可共享。
     */
    public boolean isSharable() {
        Class<?> clazz = getClass();
        //使用线程变量来缓存结果。
        Map<Class<?>, Boolean> cache = InternalThreadLocalMap.get().handlerSharableCache();
        Boolean sharable = cache.get(clazz);
        if (sharable == null) {
            sharable = clazz.isAnnotationPresent(Sharable.class);
            cache.put(clazz, sharable);
        }
        return sharable;
    }
    /**
     *  空实现。
     */
    @Override
    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        // NOOP
    }
    ...
    /**
     * 直接调用 ChannelHandlerContext#fireExceptionCaught(Throwable)}方法传递到ChannelPipeline中的下一个ChannelHandler对象。
     */
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        ctx.fireExceptionCaught(cause);
    }

ChannelHandlerAdapter是ChannelHandler接口的一个适配器抽象实现,它提供了所有方法的默认实现,多数方法都是空实现,里面什么都不干,还提供了一个公共的属性added,提供一个公共方法isSharable()可判断当前类是否可共享。子类继承它之后无需实现所有方法,只需要覆盖那些有必要覆盖的方法。

ChannelOutboundHandlerAdapter

public class ChannelOutboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelOutboundHandler {  

  /**
     * 调用ChannelHandlerContext#bind(SocketAddress, ChannelPromise)}传递给ChannelPipeline中的下一个ChannelOutboundHandler对象。
     * 子类可以覆盖该方法以改变它的行为
     */
    @Override
    public void bind(ChannelHandlerContext ctx, SocketAddress localAddress,
            ChannelPromise promise) throws Exception {
        ctx.bind(localAddress, promise);
    }
    ...

}

ChannelOutboundHandlerAdapter是ChannelOutboundHandler类的适配器实现类,它对ChannelOutboundHandler的所有方法的实现都是直接调用了ChannelHandlerContext类的对应方法来处理,它的子类都无需实现这些方法了,简化了子类的实现。

ChannelInboundHandlerAdapter

public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {

  /**
     * 调用ChannelHandlerContext#fireChannelRegistered()}方法传递给ChannelPipeline中的下一个ChannelInboundHandler对象。
     *子类可覆盖该方法以改变它的行为。
     */
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        ctx.fireChannelRegistered();
    }

}

ChannelInboundHandlerAdapter是ChannelInboundHandler类的适配器实现类,它对ChannelInboundHandler的所有方法的实现都是直接调用了ChannelHandlerContext类的对应方法来处理,它的子类都无需实现这些方法了,简化了子类的实现。注意该实现类在调用了channelRead方法后不会自动释放message对象引用,而SimpleChannelInboundHandler实现类可以。

SimpleChannelInboundHandler

public abstract class SimpleChannelInboundHandler<I> extends ChannelInboundHandlerAdapter {

    private final TypeParameterMatcher matcher;//类型参数匹配器。
    private final boolean autoRelease;//是否自动释放。

    /**
     * 构造方法,它会试图使用当前类查找一个类型参数匹配器。
     * @param autoRelease  true表示如果处理消息后,会自动调用ReferenceCountUtil#release(Object)}方法来释放引用。     false表示不会自动释放。
     */
    protected SimpleChannelInboundHandler(boolean autoRelease) {
        matcher = TypeParameterMatcher.find(this, SimpleChannelInboundHandler.class, "I");
        this.autoRelease = autoRelease;
    }
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        boolean release = true;
        try {
            if (acceptInboundMessage(msg)) {//是否可接收的输入消息类型。
                @SuppressWarnings("unchecked")
                I imsg = (I) msg;//转换为类型参数指定的类。
                channelRead0(ctx, imsg);//调用子类的方法来实现。
            } else {
                release = false;//不自动释放该消息引用。
                ctx.fireChannelRead(msg);//传递给下一个handler处理。
            }
        } finally {
            if (autoRelease && release) {//如果全局标志和当前消息释放标志都是true,则可调用方法释放。
                ReferenceCountUtil.release(msg);//释放当前消息的应用。
            }
        }
    }

    /**
     * 抽象方法,真正的消息读取处理,交给子类实现该方法。该方法中无需考虑msg引用释放的问题,因为在调用该方法的魔板方法中已经处理了。
     * 请注意该方法已经被重名为messageReceived(ChannelHandlerContext, I)}在netty5.0中。
     */
    protected abstract void channelRead0(ChannelHandlerContext ctx, I msg) throws Exception;
}

SimpleChannelInboundHandler是我们常用的一个实现类,它对ChannelInboundHandlerAdapter作了扩展,它主要增加的特性是覆盖了父类的channelRead方法,增加了自动释放消息引用的处理逻辑,在处理完消息后,会调用ReferenceCountUtil.release自动释放消息应用,从而简化子类的实现,子类的实现只需要关心业务逻辑,而无需关注消息的引用释放问题,也避免了消息忘记释放的问题。

总结

至此,我们将ChannelHandler相关的类都分析了一遍,我们理清楚了Channel,ChannePipeline,ChannelHandlerContext以及ChannelHandler之间的关系,还分析了一遍ChannelHandler几个基础接口及适配器实现类的代码,可以说对于ChannelHandler相关类有了一个进一步的认识,我们可以更好地去使用ChannelHandler相关适配器实现类来实现自己的协议,对于各方法也有了进一步的认知。

接下来我们会分析netty内部自带的一些协议的实现,例如http和http2这2个在互联网,移动互联网广泛使用的协议。

© 著作权归作者所有

共有 人打赏支持
杨武兵

杨武兵

粉丝 255
博文 61
码字总数 123254
作品 1
昌平
架构师
私信 提问
dubbo源码分析系列(4)dubbo通信设计

1 系列目录 - dubbo源码分析系列(1)扩展机制的实现- dubbo源码分析系列(2)服务的发布- dubbo源码分析系列(3)服务的引用- dubbo源码分析系列(4)dubbo通信设计 2 NIO通信层的抽象 目前...

乒乓狂魔
2015/10/26
5.7K
5
Netty in Action ——— ChannelHandler 和 ChannelPipeline

本文是Netty文集中“Netty in action”系列的文章。主要是对Norman Maurer and Marvin Allen Wolfthal 的 《Netty in action》一书简要翻译,同时对重要点加上一些自己补充和扩展。 概要 Ch...

tomas家的小拨浪鼓
2017/10/30
0
0
Dubbo分析之Transport层

系列文章 Dubbo分析Serialize层 Dubbo分析之Transport层 Dubbo分析之Exchange 层 Dubbo分析之Protocol层 前言 上一篇文章Dubbo分析之Serialize层,介绍了最底层的序列化/反序列化层,本文继续...

ksfzhaohui
2018/10/23
0
0
《深入探索Netty原理及源码分析》文集小结

写在2017年末尾,翻看文集的第一篇文章已经是三个月前的事了,也没想过这文集会写那么久,这么慢。。。 Netty文集中的文章主要都是我学习过程的笔记,写博客的主要目的是为了通过输出来倒逼输...

tomas家的小拨浪鼓
2017/12/30
0
0
Netty in Action ——— Netty的组件和设计

本文是Netty文集中“Netty in action”系列的文章。主要是对Norman Maurer and Marvin Allen Wolfthal 的 《Netty in action》一书简要翻译,同时对重要点加上一些自己补充和扩展。 本章涵盖...

tomas家的小拨浪鼓
2017/11/06
0
0

没有更多内容

加载失败,请刷新页面

加载更多

看过上百部片子的这个人教你视频标签算法解析

本文由云+社区发表 随着内容时代的来临,多媒体信息,特别是视频信息的分析和理解需求,如图像分类、图像打标签、视频处理等等,变得越发迫切。目前图像分类已经发展了多年,在一定条件下已经...

腾讯云加社区
13分钟前
0
0
2. 红黑树

定义:红黑树(Red-Black Tree,简称R-B Tree),它一种特殊的二叉查找树(Binary Search Tree)。 要理解红黑树,先要了解什么是二叉查找树。在上一章中,我们学习了什么是二叉树,以及二叉树...

火拳-艾斯
15分钟前
0
0
input的button类型,点击页面跳转

一、input type=button 不做任何操作 例如: <input type="button" class="btn btn-primary" style="width: 30%" value="返回" onclick="window.location.href='/users/list'"></input> onc......

Sunki
21分钟前
0
0
踩坑:js 小数运算出现精度问题

背景 在学习小程序商城源码时发现了这个问题,单价可能出现小数,小数之间运算结果会莫名其妙多出一大串数字,比如下面这样👇。 在此之前我是知道 js 中著名的 0.1 + 0.2 != 0.3 的问题的,...

dkvirus
26分钟前
0
0
zookeeper和HBASE总结

zookeeper快速上手 zookeeper的基本功能和应用场景 zookeeper的整体运行机制 zookeeper的数据存储机制 数据存储形式 zookeeper中对用户的数据采用kv形式存储 只是zk有点特别: key:是以路径...

瑞查德-Jack
49分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部