晴天哥_王志
晴天哥_王志

netty源码分析 - ChannelHandler

系列

Netty源码分析 - Bootstrap服务端
Netty源码分析 - Bootstrap客户端
netty源码分析 - ChannelHandler
netty源码分析 - EventLoop类关系
netty源码分析 - register分析
Netty源码分析 - NioEventLoop事件处理
netty源码分析 - accept过程分析
Netty源码分析 - ByteBuf
Netty源码分析 - 粘包和拆包问题


开篇

  • 本文基于netty-4.1.8.Final版本进行分析，主要是分析Netty Server初始化过程。
  • 建议先参考Netty源码分析 - Bootstrap客户端文章。
  • 核心点在于能够理解pipeline的串行调用的执行过程。


基本概念

pipeline

  • channel、pipeline、context、handler的关系图如上所示，handler由context进行封装，由双向链表的数据结构进行连接。

  • 当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处理器。

pipeline的handler添加过程

  • pipeline的hanndler添加过程分为两个阶段，第一个阶段为添加ChannelInitializer对应的handler，在Netty Client/Server在初始化channel的时候会执行；第二阶段为执行ChannelInitializer对象内部方法initChannel()的时候添加对应handler，在注册channel的时候会执行。


DiscardClient例子

public final class DiscardClient {

    public static void main(String[] args) throws Exception {

        EventLoopGroup group = new NioEventLoopGroup();

        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
              // 绑定handler对象
             .handler(new ChannelInitializer() {
                 @Override
                 protected void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline p = ch.pipeline();
                     if (sslCtx != null) {
                         p.addLast(sslCtx.newHandler(ch.alloc(), HOST, PORT));
                     }
                     p.addLast(new DiscardClientHandler());
                 }
             });

            // Make the connection attempt.
            ChannelFuture f = b.connect(HOST, PORT).sync();

            // Wait until the connection is closed.
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}


handler添加过程

public abstract class AbstractBootstrap, C extends Channel> implements Cloneable {

    volatile EventLoopGroup group;
    @SuppressWarnings("deprecation")
    private volatile ChannelFactory channelFactory;
    private volatile SocketAddress localAddress;
    private final Map, Object> options = new LinkedHashMap, Object>();
    private final Map, Object> attrs = new LinkedHashMap, Object>();
    private volatile ChannelHandler handler;

    final ChannelFuture initAndRegister() {
        Channel channel = null;
        try {
            // 1. newChannel创建对应的channel对象
            channel = channelFactory.newChannel();
            // 2. init真正执行的是Bootstrap的init()方法
            init(channel);
        } catch (Throwable t) {
          // 省略代码
        }
        // 3. 执行register()动作
        ChannelFuture regFuture = config().group().register(channel);
        if (regFuture.cause() != null) {
            if (channel.isRegistered()) {
                channel.close();
            } else {
                channel.unsafe().closeForcibly();
            }
        }

        return regFuture;
    }
}
  • AbstractBootstrap#initAndRegister执行操作三部曲：创建channel，初始化channel，注册channel。
  • channelFactory.newChannel()创建channel。
  • init(channel)初始化channel，init(channel)在子类Bootstrap被重写。
  • config().group().register(channel)注册channel。


init过程

public class Bootstrap extends AbstractBootstrap {

    void init(Channel channel) throws Exception {
        ChannelPipeline p = channel.pipeline();
        // 绑定ChannelInitializer到ChannelPipeline对象当中
        p.addLast(config.handler());

        final Map, Object> options = options0();
        synchronized (options) {
            setChannelOptions(channel, options, logger);
        }

        final Map, Object> attrs = attrs0();
        synchronized (attrs) {
            for (Entry, Object> e: attrs.entrySet()) {
                channel.attr((AttributeKey) e.getKey()).set(e.getValue());
            }
        }
    }
}
 
 
     
  
  • Bootstrap#init的核心操作在于将Bootstrap的handler添加到channel对应的pipeline当中。
    •  
  
  • config.handler()返回的handler是DiscardClient中handler(new ChannelInitializer())绑定的handler对象。
    •  
  
  • 划重点，在这里将ChannelHandler对象ChannelInitializer添加对应的pipeline当中
    •  
 
 
 

 
 
public class DefaultChannelPipeline implements ChannelPipeline {

    public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
        final AbstractChannelHandlerContext newCtx;
        synchronized (this) {
            checkMultiplicity(handler);
            // 1.channelHandler包装成DefaultChannelHandlerContext对象
            newCtx = newContext(group, filterName(name, handler), handler);
            // 2.添加DefaultChannelHandlerContext对象到pipeline当中。
            addLast0(newCtx);
            // 3.针对未注册的逻辑添加回调函数callHandlerCallbackLater
            if (!registered) {
                newCtx.setAddPending();
                // 添加回调函数callHandlerCallbackLater
                callHandlerCallbackLater(newCtx, true);
                return this;
            }

        // 省略代码
        return this;
    }

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

    private void callHandlerCallbackLater(AbstractChannelHandlerContext ctx, boolean added) {
        assert !registered;
        PendingHandlerCallback task = added ? new PendingHandlerAddedTask(ctx) : new PendingHandlerRemovedTask(ctx);
        PendingHandlerCallback pending = pendingHandlerCallbackHead;
        if (pending == null) {
            pendingHandlerCallbackHead = task;
        } else {
            while (pending.next != null) {
                pending = pending.next;
            }
            pending.next = task;
        }
    }
}

 
 
     
  
  • ChannelHandler添加到pipeline流程包含3个步骤：创建HandlerContext对象；添加HandlerContext对象到pipeline当中；注册callHandlerCallbackLater的回调task。
    •  
  
  • 创建HandlerContext对象，newContext(group, filterName(name, handler), handler)。
    •  
  
  • 添加HandlerContext对象到pipeline中，addLast0(newCtx)。
    •  
  
  • 注册callHandlerCallbackLater的回调task，callHandlerCallbackLater(newCtx, true)，入参参数为newCtx（封装channelHandler对象）。
    •  
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
     
  
  • Channel对象初始化后pipeline的状态如上图所示，增加了ChannelInitializer的这个handler对象。
    •  
 
 
 

 
 
register过程
 
 
public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {

    protected abstract class AbstractUnsafe implements Unsafe {

        private void register0(ChannelPromise promise) {
            try {
                // 根据neverRegistered的标识判断是否执行invokeHandlerAddedIfNeeded。
                boolean firstRegistration = neverRegistered;
                // 1.执行channel到eventLoop的绑定动作
                doRegister();
                neverRegistered = false;
                registered = true;
                // 2.执行ChannelInitializer的初始化动作
                pipeline.invokeHandlerAddedIfNeeded();
                safeSetSuccess(promise);

                // 3.执行pipeline的fireChannelRegistered()方法
                pipeline.fireChannelRegistered();

                if (isActive()) {
                    if (firstRegistration) {
                        // 4.第一次注册会执行pipeline.fireChannelActive()的操作。
                        pipeline.fireChannelActive();
                    } else if (config().isAutoRead()) {
                        beginRead();
                    }
                }
            } catch (Throwable t) {
            }
        }
    }
}

 
 
     
  
  • channel的注册过程包含4部曲，分别是绑定channel到eventLoop；执行invokeHandlerAddedIfNeeded动作；执行fireChannelRegistered动作；执行fireChannelActive动作。
    •  
  
  • invokeHandlerAddedIfNeeded负责回调init过程中生成的PendingHandlerCallback对象，会执行ChannelInitializer对应的handler的initChannel方法。
    •  
  
  • fireChannelRegistered动作触发channel的状态变为ChannelRegistered。
    •  
  
  • fireChannelActive动作触发channel的状态变为ChannelActive。
    •  
 
 
 

 
 
invokeHandlerAddedIfNeeded
 
 
public class DefaultChannelPipeline implements ChannelPipeline {

    final void invokeHandlerAddedIfNeeded() {
        assert channel.eventLoop().inEventLoop();
        if (firstRegistration) {
            firstRegistration = false;
            // We are now registered to the EventLoop. It's time to call the callbacks for the ChannelHandlers,
            // that were added before the registration was done.
            callHandlerAddedForAllHandlers();
        }
    }

    private void callHandlerAddedForAllHandlers() {
        final PendingHandlerCallback pendingHandlerCallbackHead;
        synchronized (this) {
            assert !registered;

            registered = true;
            pendingHandlerCallbackHead = this.pendingHandlerCallbackHead;
            this.pendingHandlerCallbackHead = null;
        }

        // task是PendingHandlerAddedTask
        PendingHandlerCallback task = pendingHandlerCallbackHead;
        while (task != null) {
            task.execute();
            task = task.next;
        }
    }

    private final class PendingHandlerAddedTask extends PendingHandlerCallback {
        // PendingHandlerAddedTask的入参是ChannelInitializer对应的ctx对象
        PendingHandlerAddedTask(AbstractChannelHandlerContext ctx) {
            super(ctx);
        }

        @Override
        public void run() {
            callHandlerAdded0(ctx);
        }
    }

    private void callHandlerAdded0(final AbstractChannelHandlerContext ctx) {
        try {
            // ctx.handler()返回的是ChannelInitializer对象
            ctx.handler().handlerAdded(ctx);
            ctx.setAddComplete();
        } catch (Throwable t) {
        }
    }
}

 
 
     
  
  • invokeHandlerAddedIfNeeded的执行按照下面的顺序进行执行 invokeHandlerAddedIfNeeded => callHandlerAddedForAllHandlers => PendingHandlerAddedTask#execute => PendingHandlerAddedTask#callHandlerAdded0 => ChannelInitializer#handlerAdded。
    •  
  
  • ctx.handler()返回的是ChannelInitializer的handler对象。
     
     
    •  
 
 
 
public abstract class ChannelInitializer extends ChannelInboundHandlerAdapter {

    public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
        if (ctx.channel().isRegistered()) {
            initChannel(ctx);
        }
    }

    private boolean initChannel(ChannelHandlerContext ctx) throws Exception {
        if (initMap.putIfAbsent(ctx, Boolean.TRUE) == null) { // Guard against re-entrance.
            try {
                // initChannel会添加新的handler
                initChannel((C) ctx.channel());
            } catch (Throwable cause) {
            } finally {
                // 移除ChannelInitializer对应的handler。
                remove(ctx);
            }
            return true;
        }
        return false;
    }

    private void remove(ChannelHandlerContext ctx) {
        try {
            ChannelPipeline pipeline = ctx.pipeline();
            if (pipeline.context(this) != null) {
                pipeline.remove(this);
            }
        } finally {
            initMap.remove(ctx);
        }
    }
}

 
 
     
  
  • ChannelInitializer#handlerAdded执行对应的initChannel()方法，完成ChannelInitializer的initChannel()方法并添加新的handler。
    •  
  
  • remove(ctx)会移除ChannelInitializer对应的handler。
    •  
 
 
 
 
  
 
   
  
   
 
  
 
  
 
 
 
 
     
  
  • 执行ChannelInitializer#initChannel添加新handler同时移除ChannelInitializer自身handler的pipeline如上图。
    •  
 
 
 

 
 
输入消息处理流程
 
 
 
  
 
   
  
   
 
  
 
  

    ChannelInboundHandler 
  
 
 
 
 
     
  
  • channelRegistered 注册事件，channel注册到EventLoop上后调用，例如服务岗启动时，pipeline.fireChannelRegistered();
    •  
  
  • channelUnregistered 注销事件，channel从EventLoop上注销后调用，例如关闭连接成功后，pipeline.fireChannelUnregistered();
    •  
  
  • channelActive 激活事件，绑定端口成功后调用，pipeline.fireChannelActive();
    •  
  
  • channelInactive非激活事件，连接关闭后调用，pipeline.fireChannelInactive();
    •  
  
  • channelRead 读事件，channel有数据时调用，pipeline.fireChannelRead();
    •  
  
  • channelReadComplete 读完事件，channel读完之后调用，pipeline.fireChannelReadComplete();
    •  
  
  • channelWritabilityChanged 可写状态变更事件，当一个Channel的可写的状态发生改变的时候执行，可以保证写的操作不要太快，防止OOM，pipeline.fireChannelWritabilityChanged();
    •  
  
  • userEventTriggered 用户事件触发，例如心跳检测，ctx.fireUserEventTriggered(evt);
    •  
  
  • exceptionCaught 异常事件说明:我们可以看出，Inbound事件都是由I/O线程触发，用户实现部分关注的事件被动调用。
    •  
 
 
 
 
  
 
   
  
   
 
  
 
  

    ChannelInboundInvoker 
  
 
 
 
 
     
  
  • ChannelInboundInvoker负责fire上述的各类事件。
    •  
 
 
 

 
 
pipeline.fireChannelRead()读事件流程
 
 
public final class NioEventLoop extends SingleThreadEventLoop {
    private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();

        // 省略相关代码
        try {
            // 省略相关代码
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) {
                unsafe.read();
            }
        } catch (CancelledKeyException ignored) {
            unsafe.close(unsafe.voidPromise());
        }
    }
}

 
 
     
  
  • NioEventLoop关注OP_READ|OP_ACCEPT两类事件，都属于输入事件类型。
    •  
  
  • 进入unsafe.read()进入读取操作，unsafe为AbstractNioByteChannel#NioByteUnsafe。
    •  
 
 
 

 
 
public abstract class AbstractNioByteChannel extends AbstractNioChannel {

    protected class NioByteUnsafe extends AbstractNioUnsafe {
        public final void read() {
            // 省略相关代码
            try {
                do {
                    pipeline.fireChannelRead(byteBuf);
                } while (allocHandle.continueReading());
            } catch (Throwable t) {
            } finally {
            }
        }
    }
}


public class DefaultChannelPipeline implements ChannelPipeline {

    public final ChannelPipeline fireChannelRead(Object msg) {
        // 从pipeline对象当中的head开始执行遍历
        AbstractChannelHandlerContext.invokeChannelRead(head, msg);
        return this;
    }
}


abstract class AbstractChannelHandlerContext extends DefaultAttributeMap
        implements ChannelHandlerContext, ResourceLeakHint {

    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()) {
            next.invokeChannelRead(m);
        } else {
        }
    }
}

 
 
     
  
  • AbstractNioByteChannel#NioByteUnsafe的read触发pipeline.fireChannelRead()操作，进入pipeline的事件触发流程，参数head表示从pipeline的head开始遍历。
    •  
  
  •  AbstractChannelHandlerContext#invokeChannelRead属于静态方法，个人认为是AbstractChannelHandlerContext提供的为ChannelContext执行的入口。
    •  
  
  • AbstractChannelHandlerContext#invokeChannelRead方法内部执行next.invokeChannelRead进行了Context的执行域，第一次Context为HeadContext对象。
    •  
 
 
 

 
 
abstract class AbstractChannelHandlerContext extends DefaultAttributeMap
        implements ChannelHandlerContext, ResourceLeakHint {

    private void invokeChannelRead(Object msg) {
        if (invokeHandler()) {
            try {
                // handler()返回Context对象，第一次返回HeadContext对象。
                ((ChannelInboundHandler) handler()).channelRead(this, msg);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRead(msg);
        }
    }
}

final class HeadContext extends AbstractChannelHandlerContext
            implements ChannelOutboundHandler, ChannelInboundHandler {

    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ctx.fireChannelRead(msg);
    }
}

 
 
     
  
  • ((ChannelInboundHandler) handler()).channelRead(this, msg)的handler()方法返回的是Context对象本身，第一次表示为HeadContext对象。
    •  
  
  • HeadContext#channelRead表示该handler的处理逻辑（只是这里没有任何处理逻辑），然后通过ctx.fireChannelRead(msg)唤醒当前Context对象下的下一个Context对象。
    •  
  
  • 唤醒当前Context对象下的下一个Context对象的处理逻辑统一在AbstractChannelHandlerContext当中实现的。
    •  
 
 
 

 
 
abstract class AbstractChannelHandlerContext extends DefaultAttributeMap
        implements ChannelHandlerContext, ResourceLeakHint {

    public ChannelHandlerContext fireChannelRead(final Object msg) {
        // findContextInbound寻找当前Context的下一个Context对象
        invokeChannelRead(findContextInbound(), msg);
        return this;
    }

    //  findContextInbound寻找当前Context的下一个Context对象
    private AbstractChannelHandlerContext findContextInbound() {
        AbstractChannelHandlerContext ctx = this;
        do {
            ctx = ctx.next;
        } while (!ctx.inbound);
        return ctx;
    }
    // 进入到转为下一个Context的执行逻辑的核心函数
    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()) {
            // 下一个待执行的Context对象
            next.invokeChannelRead(m);
        } else {
        }
    }

    private void invokeChannelRead(Object msg) {
        if (invokeHandler()) {
            try {
                // handler()返回Context对象
                // channelRead被重载执行逻辑，需要在实现中再次执行ctx.fireChannelRead(msg);
                ((ChannelInboundHandler) handler()).channelRead(this, msg);
            } catch (Throwable t) {
                notifyHandlerException(t);
            }
        } else {
            fireChannelRead(msg);
        }
    }
}

 
 
     
  
  • AbstractChannelHandlerContext作为Context的父类，其核心逻辑在于负责寻找下一个Context对象并开始下一个Context对象的执行逻辑。
    •  
  
  •  AbstractChannelHandlerContext#fireChannelRead负责查找下一个Context对象并通过AbstractChannelHandlerContext#invokeChannelRead实现当前Context到下一个Context执行的交接。
    •  
  
  •  AbstractChannelHandlerContext#invokeChannelRead内部执行已经是下一个Context对象的channelRead方法。
     -AbstractChannelHandlerContext作为Context的父类，提供了通用的查询Context、执行Context的方法，本质这些逻辑都是在前一个Context对象的方法中执行，然后通过查询下一个Context对象进行切换。
    •  
 
 
 

 
 
public class LoggingHandler extends ChannelDuplexHandler {
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (logger.isEnabled(internalLevel)) {
            logger.log(internalLevel, format(ctx, "RECEIVED", msg));
        }
        ctx.fireChannelRead(msg);
    }
}

 
 
     
  
  • 以LoggingHandler为例，channelRead()内部负责执行本职的log功能，同时通过ctx.fireChannelRead(msg)继续触发下一个Handler的操作。
    •  
  
  • 所有的Handler操作本职都是方法的串行。
    •  
 
 
 

 
 
输出消息处理流程
 
 
 
  
 
   
  
   
 
  
 
  

    ChannelOutboundHandler 
  
 
 
 
 
     
  
  • bind 事件,绑定端口。
    •  
  
  • close事件，关闭channel。
    •  
  
  • connect事件，用于客户端，连接一个远程机器。
    •  
  
  • disconnect事件，用于客户端，关闭远程连接。
    •  
  
  • deregister事件，用于客户端，在执行断开连接disconnect操作后调用，将channel从EventLoop中注销。
    •  
  
  • read事件，用于新接入连接时，注册成功多路复用器上后，修改监听为OP_READ操作位。
    •  
  
  • write事件，向通道写数据。
    •  
  
  • flush事件，将通道排队的数据刷新到远程机器上。
    •  
 
 
 
 
  
 
   
  
   
 
  
 
  

    ChannelOutboundInvoker 
  
 
 
 
 
     
  
  • ChannelOutboundInvoker负责处理上述各类事件。
    •  
 
 
 

 
 
DefaultChannelPipeline#write
 
 
public abstract class AbstractChannel extends DefaultAttributeMap implements Channel {
    public ChannelFuture write(Object msg) {
        // 进入pipeline的处理流程
        return pipeline.write(msg);
    }
}

public class DefaultChannelPipeline implements ChannelPipeline {
    public final ChannelFuture write(Object msg) {
        // 从tail开始执行
        return tail.write(msg);
    }
}

 
 
     
  
  • DefaultChannelPipeline#write从pipeline的tail开始进行访问。
    •  
  
  • tail.write()会调用父类AbstractChannelHandlerContext#write开始pipeline的handler的调用。
    •  
 
 
 

 
 
abstract class AbstractChannelHandlerContext extends DefaultAttributeMap
        implements ChannelHandlerContext, ResourceLeakHint {

    // 负责从tail开始往head进行遍历，查找输出事件的handler
    private AbstractChannelHandlerContext findContextOutbound() {
        AbstractChannelHandlerContext ctx = this;
        do {
            ctx = ctx.prev;
        } while (!ctx.outbound);
        return ctx;
    }

    public ChannelFuture write(Object msg) {
        return write(msg, newPromise());
    }

    public ChannelFuture write(final Object msg, final ChannelPromise promise) {
        // 省略代码
        write(msg, false, promise);

        return promise;
    }

    private void write(Object msg, boolean flush, ChannelPromise promise) {
        // 从tail开始遍历查找下一个Context进行操作
        AbstractChannelHandlerContext next = findContextOutbound();
        final Object m = pipeline.touch(msg, next);
        EventExecutor executor = next.executor();
        if (executor.inEventLoop()) {
            if (flush) {
                next.invokeWriteAndFlush(m, promise);
            } else {
                // 执行Context对象的invokeWrite方法
                next.invokeWrite(m, promise);
            }
        } else {
        }
    }

    private void invokeWrite(Object msg, ChannelPromise promise) {
        if (invokeHandler()) {
            // 执行handler自己重载的write方法
            invokeWrite0(msg, promise);
        } else {
            // 执行handler自己重载的write方法或者直接使用父类的write方法
            write(msg, promise);
        }
    }

    private void invokeWrite0(Object msg, ChannelPromise promise) {
        try {
            // 参考LoggingHandler为例进行说明
            ((ChannelOutboundHandler) handler()).write(this, msg, promise);
        } catch (Throwable t) {
            notifyOutboundHandlerException(t, promise);
        }
    }
}

 
 
     
  
  • AbstractChannelHandlerContext#write通过findContextOutbound()查找tail的前一个输出事件的handler。
    •  
  
  • AbstractChannelHandlerContext按照write => invokeWrite => invokeWrite0的顺序进行调用，在invokeWrite0的内部执行实际业务handler的write()方法。
    •  
  
  • ((ChannelOutboundHandler) handler())返回实际的handler对象，如LoggingHandler。
    •  
  
  • 实际handler对象如LoggingHandler内部会通过ctx.write(msg, promise)重新开始pipeline的handler对象的寻找，完成一次传递调用。
    •  
 
 
 

 
 
public class LoggingHandler extends ChannelDuplexHandler {

    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        if (logger.isEnabled(internalLevel)) {
            logger.log(internalLevel, format(ctx, "WRITE", msg));
        }
        ctx.write(msg, promise);
    }
}

 
 

 
 
ChannelPipeline顺序
 
 
 
  
 
   
  
   
 
  
 
  

    ChannelPipeline 
  
 
 
 
 
     
  
  • 图片来自 陶章好 
    •  
 
 
 
 *                                                 I/O Request
 *                                            via {@link Channel} or
 *                                        {@link ChannelHandlerContext}
 *                                                      |
 *  +---------------------------------------------------+---------------+
 *  |                           ChannelPipeline         |               |
 *  |                                                  \|/              |
 *  |    +---------------------+            +-----------+----------+    |
 *  |    | Inbound Handler  N  |            | Outbound Handler  1  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  |               |                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler N-1 |            | Outbound Handler  2  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  .               |
 *  |               .                                   .               |
 *  | ChannelHandlerContext.fireIN_EVT() ChannelHandlerContext.OUT_EVT()|
 *  |        [ method call]                       [method call]         |
 *  |               .                                   .               |
 *  |               .                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler  2  |            | Outbound Handler M-1 |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  |               |                                  \|/              |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |    | Inbound Handler  1  |            | Outbound Handler  M  |    |
 *  |    +----------+----------+            +-----------+----------+    |
 *  |              /|\                                  |               |
 *  +---------------+-----------------------------------+---------------+
 *                  |                                  \|/
 *  +---------------+-----------------------------------+---------------+
 *  |               |                                   |               |
 *  |       [ Socket.read() ]                    [ Socket.write() ]     |
 *  |                                                                   |
 *  |  Netty Internal I/O Threads (Transport Implementation)            |
 *  +-------------------------------------------------------------------+



 * For example, let us assume that we created the following pipeline:
 * 
 * {@link ChannelPipeline} p = ...;
 * p.addLast("1", new InboundHandlerA());
 * p.addLast("2", new InboundHandlerB());
 * p.addLast("3", new OutboundHandlerA());
 * p.addLast("4", new OutboundHandlerB());
 * p.addLast("5", new InboundOutboundHandlerX());
 * 

 * In the example above, the class whose name starts with {@code Inbound} means it is an inbound handler.
 * The class whose name starts with {@code Outbound} means it is a outbound handler.
 * 

 * In the given example configuration, the handler evaluation 
 * order is 1, 2, 3, 4, 5 when an event goes inbound.
 * When an event goes outbound, the order is 5, 4, 3, 2, 1. 

 
 

 
 
参考
 
 
Netty 源码分析之 一 揭开 Bootstrap 神秘的红盖头 (客户端)
 netty源码分析系列——ChannelHandler系列
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(netty源码分析 - ChannelHandler)

        

            

                
    
                    
  • Netty源码分析:NioEventLoopGroup
                        HelloWorld_EE
netty源码分析源代码nettyEventLoop
                        
    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    
                    
    • 
                    
  • 基础学习之——Netty
                        北欧人写代码
学习网络服务器
                        
    Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
    
                    
    • 
                    
  • Netty架构详解
                        思静语
Netty网络通信
                        
    文章目录概述整体结构Netty的核心组件逻辑架构BootStrap&ServerBootStrapChannelPipelineFuture、回调和ChannelHandler选择器、事件和EventLoopChannelHandler的各种ChannelInitializer类图ProtocolSupport协议支持层TransportService传输服务层Core核心层模块netty-com
    
                    
    • 
                    
  • HTTP2: netty server端同一个端口支持 http1.1/http2
                        Saleson
http2netty
                        
    同时支持http1和http2比较推荐的方法是通过HttpServerUpgradeHandler将http1.1升级到http2，网上有很多资料。这里采用的是另一种方式。在对接收到的请求字节进行解码时，判断client采用的是http1还是http2，然后再将相应的ChannelHandler添加到ChannelPipeline中。netty建立http2server的代码见上一篇文章：HTTP
    
                    
    • 
                    
  • Netty应用(十一) 之 ChannelHandler & Channel生命周期 & @Sharable & 心跳
                        etcEriksen
Netty应用java后端netty
                        
    目录27.ChannelHandler总结27.1一些概念27.2到底有几个handler？真的只有你想的那样吗？27.3channel.writeAndFlush和ctx.writeAndFlush的区别27.4ByteBuf的创建和销毁27.5Channel的生命周期方法27.5.1handlerAdded27.5.2channelRegistered27.5.3channelActive27
    
                    
    • 
                    
  • Netty中的常用组件(三)
                        coffee_babe
NettyjavaNetty
                        
    ChannelPipeline基于Netty的网路应用程序中根据业务需求会使用Netty已经提供的Channelhandler或者自行开发ChannelHandler，这些ChannelHandler都放在ChannelPipeline中统一管理，事件就会在ChannelPipeline中流动，并被其中一个或者多个ChannelHandler处理ChannelPipeline提供了ChannelH
    
                    
    • 
                    
  • 深入理解Netty及核心组件使用—下
                        山鸟与鱼！
分布式中间件java服务器开发语言后端nio网络
                        
    目录ChannelHandlerChannelHandler接口ChannelInboundHandler接口ChannelHandler的适配器Handler的共享和并发安全性资源管理和SimpleChannelInboundHandlerBootstrapChannelInitializerChannelOptionChannelHandlerChannelHandler接口从开发人员的角度来
    
                    
    • 
                    
  • 深入理解Netty及核心组件使用—上
                        山鸟与鱼！
分布式中间件java开发语言网络nio后端服务器
                        
    目录Netty的优势为什么Netty使用NIO而不是AIO？Netty基本组件Bootstrap、EventLoop(Group)、Channel事件和ChannelHandler、ChannelPipelineChannelFutureNetty入门程序服务端代码客户端代码运行结果Netty的优势1.API使用简单，开发门槛低。2.功能强大，预置了多种编解码功能，支持多种主流协议。3.定制能力强
    
                    
    • 
                    
  • 手写RPC框架：Netty高性能的秘密是？
                        Java识堂
Dubbo全攻略
                        
    介绍Netty是一个高性能的NIO网络框架，极大的的降低了网络编程的门槛，并且提供了简单易用的api。客户端和服务端的启动是一个很简单的模版代码，我们更多的精力是的写处理业务逻辑的ChannelHandler，看几个Demo你就能写一个简单的Http服务器，Im系统等。相对于Javanio原生api来说，Netty有如下的优点提供的简单易用的api，实现同一个功能你可以用javanio和netty
    
                    
    • 
                    
  • 【Netty】Netty常用概念
                        疯癫的老码农
网络结构javarpcjavanio
                        
    Channel，表示一个连接，可以理解为每一个请求，就是一个Channel。ChannelHandler，核心处理业务就在这里，用于处理业务请求。ChannelHandlerContext，用于传输业务数据。ChannelPipeline，用于保存处理过程需要用到的ChannelHandler和ChannelHandlerContext。
    
                    
    • 
                    
  • 11 netty的ChannelHander
                        沉沦2014

                        
    ChannelHander在nio编程中，我们经常需要对channel的输入和输出事件进行处理，Netty抽象出一个ChannelHandler概念，专门用于处理此类事件。因为IO事件分为输入和输出，因此ChannelHandler又具体的分为ChannelInboundHandler和ChannelOutboundHandler，分别用于某个阶段输入输出事件的处理。ChannelHandler的
    
                    
    • 
                    
  • Netty Pipeline
                        yzp-
java
                        
    Netty中的业务处理流程都是在Pipeline中被处理的，它底层是一个双向链表，链表元素是ChannelInBoundHandler和ChannelOutBoundHandler，二者都是ChannelHandler接口类，一个Channel拥有一个Pipeline，当Channel被创建时会创建一个空的Pipeline。publicabstractclassAbstractChannelimp
    
                    
    • 
                    
  • 六、Netty核心模块组件
                        小晨想好好学习
Nettynetty
                        
    目录6.1BootStrap，ServerBootStrap6.2Future，ChannelFuture6.3Channel6.4Selector6.5ChannelHandler以及其实现类6.6Pipeline和ChannelPipeline6.7ChannelHandlerContext6.8ChannelOption6.9EventLoopGroup和其实现类NioEventLoopGr
    
                    
    • 
                    
  • Netty-Netty源码分析
                        长情知热爱
java开发语言
                        
    Netty线程模型图Netty线程模型源码剖析图Netty高并发高性能架构设计精髓主从Reactor线程模型NIO多路复用非阻塞无锁串行化设计思想支持高性能序列化协议零拷贝(直接内存的使用)ByteBuf内存池设计灵活的TCP参数配置能力并发优化无锁串行化设计思想在大多数场景下，并行多线程处理可以提升系统的并发性能。但是，如果对于共享资源的并发访问处理不当，会带来严重的锁竞争，这最终会导致性能的下
    
                    
    • 
                    
  • 深入学习SpringMVC以及学习总结
                        程序员日常填坑

                        
    一、优点：1.SpringMVC简化web程序开发;2.SpringMVC效率很好（单例模式）；3.SpringMVC提供了大量扩展点，方便程序员自定义功能；如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：854630135，群里有阿里大牛直播讲解技术，以及Java大型互联网技术的视频免费分享给大家。①.
    
                    
    • 
                    
  • Java网络编程：看不懂你来找我！Netty框架一万五千字长文带你入门。
                        星光闪闪k
Javajava开发语言后端网络架构
                        
    目录1.导言Netty构建高性能网络应用的魔法工具2.Netty框架概述2.1什么是Netty？2.2Netty的独特之处2.3Netty的应用领域3.核心组件4.组件使用示例4.1Channel：通信的载体4.1.1`Channel`的种类4.1.2`Channel`的生命周期4.2`ChannelHandler`：业务逻辑的处理者4.2.1`ChannelPipeline`：处理链4.2.2事
    
                    
    • 
                    
  • Netty源码之ChannelHandler
                        0爱上1

                        
    前一篇文章我们介绍了Netty中的ChannelPipeline，本文我们会继续基于源码，学习Netty中的重要接口ChannelHandler前言我们知道Netty中将I/O事件分为了两类：入站（Inbound）和出站（Outbound）而入站事件又细分为了：通道注册完成/取消注册，通道激活/通道失活，通道读/读完成，异常处理等出站事件分为：绑定端口，连接/取消连接端口，关闭，写事件以及冲刷事件
    
                    
    • 
                    
  • Netty入门--使用SSL/TLS加密Netty程序
                        Java小生

                        
    为了支持SSL/TLS，Java提供了javax.net.sslAPI的类SslContext和SslEngine使它相对简单的实现解密和加密。Netty利用该API实现了ChannelHandler的子类SslHandler。下图为Sslhandler的数据流图：加密的入站数据被SslHandler拦截，进行解密数据被解密后，原始数据入站原始数据经过SslHandlerSslHandler加密数
    
                    
    • 
                    
  • Netty基础入门与组件介绍
                        Fisher3652
网络协议Netty
                        
    目录Netty简介为什么要用Netty为什么Netty使用NIO而不是AIO？EventLoop(Group)、Channel事件和ChannelHandler、ChannelPipelineChannelFutureNetty组件详解Channel、EventLoop(Group)和ChannelFutureChannel接口EventLoop和EventLoopGroupChannelFutu
    
                    
    • 
                    
  • Netty-Netty基础应用与了解
                        长情知热爱
microsoft
                        
    前言Netty的优势1、API使用简单，开发门槛低；2、功能强大，预置了多种编解码功能，支持多种主流协议；3、定制能力强，可以通过ChannelHandler对通信框架进行灵活地扩展；4、性能高，通过与其他业界主流的NIO框架对比，Netty的综合性能最优；5、成熟、稳定，Netty修复了已经发现的所有JDKNIOBUG，业务开发人员不需要再为NIO的BUG而烦恼；6、社区活跃，版本迭代周期短，发
    
                    
    • 
                    
  • 被标记为事务的方法互相调用的坑（下）
                        程序员日常填坑

                        
    上一节，主要分析了被标记为事务的方法互相调用，事务失效的原因，思考比较多，这一节主要说说解决方案，思考会少一些。解决方案的核心：通过代理对象去调用方法1.把方法放到不同的类：如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：854630135，群里有阿里大牛直播讲解技术，以及Java大型互联网技术的视频免费
    
                    
    • 
                    
  • 第十六节 netty源码分析之 server端的源码分析
                        勃列日涅夫

                        
    nettyserver端以netty官方EchoServer服务器端的启动代码分析:publicfinalclassEchoServer{staticfinalbooleanSSL=System.getProperty("ssl")!=null;staticfinalintPORT=Integer.parseInt(System.getProperty("port","8007"));public
    
                    
    • 
                    
  • 被标记为事务的方法互相调用的坑（上）
                        程序员日常填坑

                        
    相信大家一定用过Spring中的注解型事务，配合上SpringBoot，只需要在方法上打一个@Transactional就可以完成，真香。但是如果大家对其中的机制一知半解的话，可能一不小心就会掉进坑，然后久久无法爬出来。下面我就分享下被标记为事务的方法互相调用的坑。如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高
    
                    
    • 
                    
  • Netty框架中的一些概念
                        JasonZhang~
java开发语言
                        
    编码解码回顾Netty的几个组件Channel服务器和客户端建立的连接通道ChannelPipeline管道，一个通道包含一个管道，管道包含一个处理器链ChannelHandler管道中的处理器链包含多个处理器，每个处理器可以处理不同的IO事件，是双向链表结构，包含head头部和tail尾部。处理器分为：ChannelInboundHandler入站消息处理器（处理进入的消息）ChannelOut
    
                    
    • 
                    
  • Spring Boot中如何干掉if else
                        程序员日常填坑

                        
    需求这里虚拟一个业务需求，让大家容易理解。假设有一个订单系统，里面的一个功能是根据订单的不同类型作出不同的处理。如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：787707172，群里有阿里大牛直播讲解技术，以及Java大型互联网技术的视频免费分享给大家。订单实体：service接口：传统实现根据订单类型
    
                    
    • 
                    
  • Netty源码分析--PoolSubPage
                        shoulda

                        
    PoolSubPage内部数据结构分析finalclassPoolSubpage{finalPoolChunkchunk;//所属的PoolChunkprivatefinalintmemoryMapIdx;//在memoryMap的索引idmemoryMap[id]privatefinalintrunOffset;//在PoolChunk的运行时内存偏移量privatefinalintpageSi
    
                    
    • 
                    
  • Netty源码分析系列1:BootStrap的分析
                        maskwang520

                        
    Bootstrap是Netty提供的一个便利的工厂类,我们可以通过它来完成Netty的客户端或服务器端的Netty初始化.利用BootStrap我们可以实现创建channel,把channel注册在EventLoop上,发起连接等功能.BootStrap的类结构如下:image.png1.Client端启动实例下面是个简单的客户端实例,我们用这个来分析BootStrap的整个流程.publiccl
    
                    
    • 
                    
  • 程序员到底有多累，多辛苦？上百万程序员‘知乎上’吐槽
                        程序员日常填坑

                        
    累不累，在于你自己。这几年来，IT这个行业涌入太多的急功近利的求职者，培训学校批量生产的码农，一批一批又一批。下面来看看其他的程序员是怎么评论的吧！工作要紧也请大家要多多注意自己的身体，要是身体夸了，那就什么都没有了。如果想学习Java工程化、高性能及分布式、深入浅出。微服务、Spring，MyBatis，Netty源码分析的朋友可以加我的Java高级交流：787707172，群里有阿里大牛直播讲
    
                    
    • 
                    
  • 学习Netty(四)------ChannelPipeline 和 ChannelHandler
                        犯困嫌疑人（）
学习javajvm开发语言后端http
                        
    文章目录前言Pipeline的作用1.ChannelPipeline的设计及作用1.1使用ChannelPipeline的好处：1.2ChannelPipeline的组成：1.3事件传播与处理:1.4ChannelPipeline的设计原理Handler的生命周期1.ChannelHandler的添加2ChannelHandler的执行过程3.ChannelHandler的移除4ChannelHa
    
                    
    • 
                    
  • netty源码分析笔记
                        抬头挺胸才算活着

                        
    参考资料：[1].netty源码分析之揭开reactor线程的面纱（二）[2].Netty源码分析之一揭开Bootstrap神秘的红盖头(服务器端)[3].netty源码分析之揭开reactor线程的面纱（三）[4].netty源码分析之揭开reactor线程的面纱（一）[5].netty源码分析之pipeline(二)[6].Netty中的装饰者模式[7].深入浅出Netty内存管理PoolCh
    
                    
    • 
                                
  • 解读Servlet原理篇二---GenericServlet与HttpServlet
                                    周凡杨
javaHttpServlet源理GenericService源码
                                    
    在上一篇《解读Servlet原理篇一》中提到，要实现javax.servlet.Servlet接口（即写自己的Servlet应用），你可以写一个继承自javax.servlet.GenericServletr的generic Servlet ，也可以写一个继承自java.servlet.http.HttpServlet的HTTP Servlet（这就是为什么我们自定义的Servlet通常是exte
    
                                
    • 
                                
  • MySQL性能优化
                                    bijian1013
数据库mysql
                                    
            性能优化是通过某些有效的方法来提高MySQL的运行速度，减少占用的磁盘空间。性能优化包含很多方面，例如优化查询速度，优化更新速度和优化MySQL服务器等。本文介绍方法的主要有： 
        a.优化查询 
        b.优化数据库结构 
  
    
                                
    • 
                                
  • ThreadPool定时重试
                                    dai_lm
javaThreadPoolthreadtimertimertask
                                    
    项目需要当某事件触发时，执行http请求任务，失败时需要有重试机制，并根据失败次数的增加，重试间隔也相应增加，任务可能并发。 
由于是耗时任务，首先考虑的就是用线程来实现，并且为了节约资源，因而选择线程池。 
为了解决不定间隔的重试，选择Timer和TimerTask来完成 
 
 

package threadpool;

public class ThreadPoolTest {


    
                                
    • 
                                
  • Oracle 查看数据库的连接情况
                                    周凡杨
sqloracle 连接
                                    
    首先要说的是，不同版本数据库提供的系统表会有不同，你可以根据数据字典查看该版本数据库所提供的表。 
 
select * from dict where table_name like '%SESSION%'; 
就可以查出一些表，然后根据这些表就可以获得会话信息 
 
select sid,serial#,status,username,schemaname,osuser,terminal,ma
    
                                
    • 
                                
  • 类的继承
                                    朱辉辉33
java
                                    
    类的继承可以提高代码的重用行，减少冗余代码；还能提高代码的扩展性。Java继承的关键字是extends 
格式:public class 类名（子类）extends 类名（父类）{ } 
子类可以继承到父类所有的属性和普通方法，但不能继承构造方法。且子类可以直接使用父类的public和 
protected属性，但要使用private属性仍需通过调用。 
子类的方法可以重写，但必须和父类的返回值类
    
                                
    • 
                                
  • android 悬浮窗特效
                                    肆无忌惮_
android
                                    
    最近在开发项目的时候需要做一个悬浮层的动画，类似于支付宝掉钱动画。但是区别在于，需求是浮出一个窗口，之后边缩放边位移至屏幕右下角标签处。效果图如下： 
  
一开始考虑用自定义View来做。后来发现开线程让其移动很卡，ListView+动画也没法精确定位到目标点。 
  
后来想利用Dialog的dismiss动画来完成。 
  
自定义一个Dialog后，在styl
    
                                
    • 
                                
  • hadoop伪分布式搭建
                                    林鹤霄
hadoop
                                    
    要修改4个文件    1: vim hadoop-env.sh  第九行    2: vim core-site.xml            <configuration>     &n
    
                                
    • 
                                
  • gdb调试命令
                                    aigo
gdb
                                    
    原文：http://blog.csdn.net/hanchaoman/article/details/5517362 
  
一、GDB常用命令简介 
     r run 运行.程序还没有运行前使用   c             cuntinue 
    
                                
    • 
                                
  • Socket编程的HelloWorld实例
                                    alleni123
socket
                                    
    public class Client
{
	
	
	public static void main(String[] args)
	{	
		Client c=new Client();
	 	c.receiveMessage();
	}
	
	public void receiveMessage(){
		Socket s=null;
		
		BufferedRea
    
                                
    • 
                                
  • 线程同步和异步
                                    百合不是茶
线程同步异步
                                    
    多线程和同步 : 如进程、线程同步，可理解为进程或线程A和B一块配合，A执行到一定程度时要依靠B的某个结果，于是停下来，示意B运行；B依言执行，再将结果给A；A再继续操作。  所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回，同时其它线程也不能调用这个方法  
  
多线程和异步:多线程可以做不同的事情,涉及到线程通知 
  
  
&
    
                                
    • 
                                
  • JSP中文乱码分析
                                    bijian1013
javajsp中文乱码
                                    
            在JSP的开发过程中，经常出现中文乱码的问题。 
        首先了解一下Java中文问题的由来： 
        Java的内核和class文件是基于unicode的，这使Java程序具有良好的跨平台性，但也带来了一些中文乱码问题的麻烦。原因主要有两方面，
    
                                
    • 
                                
  • js实现页面跳转重定向的几种方式
                                    bijian1013
JavaScript重定向
                                    
            js实现页面跳转重定向有如下几种方式： 
一.window.location.href 
<script language="javascript"type="text/javascript"> 
	window.location.href="http://www.baidu.c
    
                                
    • 
                                
  • 【Struts2三】Struts2 Action转发类型
                                    bit1129
struts2
                                    
     在【Struts2一】 Struts Hello World http://bit1129.iteye.com/blog/2109365中配置了一个简单的Action，配置如下 
  
<!DOCTYPE struts PUBLIC  
        "-//Apache Software Foundation//DTD Struts Configurat
    
                                
    • 
                                
  • 【HBase十一】Java API操作HBase
                                    bit1129
hbase
                                    
    Admin类的主要方法注释： 
  1. 创建表 
 /**
   * Creates a new table. Synchronous operation.
   *
   * @param desc table descriptor for table
   * @throws IllegalArgumentException if the table name is res
    
                                
    • 
                                
  • nginx gzip
                                    ronin47
nginx gzip
                                    
    Nginx GZip 压缩  
Nginx GZip 模块文档详见：http://wiki.nginx.org/HttpGzipModule 
常用配置片段如下：  
gzip on; gzip_comp_level 2; # 压缩比例，比例越大，压缩时间越长。默认是1 gzip_types text/css text/javascript; # 哪些文件可以被压缩 gzip_disable &q
    
                                
    • 
                                
  • java-7.微软亚院之编程判断俩个链表是否相交 给出俩个单向链表的头指针，比如 h1 ， h2 ，判断这俩个链表是否相交
                                    bylijinnan
java
                                    
    

public class LinkListTest {

	/**
	 * we deal with two main missions:
	 * 
	 * A.
	 * 1.we create two joined-List(both have no loop)
	 * 2.whether list1 and list2 join
	 * 3.print the join
    
                                
    • 
                                
  • Spring源码学习-JdbcTemplate batchUpdate批量操作
                                    bylijinnan
javaspring
                                    
    Spring JdbcTemplate的batch操作最后还是利用了JDBC提供的方法，Spring只是做了一下改造和封装 
 
JDBC的batch操作： 
 
 


String sql = "INSERT INTO CUSTOMER " +
				  "(CUST_ID, NAME, AGE) VALUES (?, ?, ?)";
				
    
                                
    • 
                                
  • [JWFD开源工作流]大规模拓扑矩阵存储结构最新进展
                                    comsci
工作流
                                    
        生成和创建类已经完成,构造一个100万个元素的矩阵模型,存储空间只有11M大,请大家参考我在博客园上面的文档"构造下一代工作流存储结构的尝试",更加相信的设计和代码将陆续推出......... 
 
    竞争对手的能力也很强.......,我相信..你们一定能够先于我们推出大规模拓扑扫描和分析系统的....
    
                                
    • 
                                
  • base64编码和url编码
                                    cuityang
base64url
                                    
    import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.PrintWriter; 
import java.io.StringWriter; 
import java.io.UnsupportedEncodingException; 
    
                                
    • 
                                
  • web应用集群Session保持
                                    dalan_123
session
                                    
    关于使用 memcached 或redis 存储 session ，以及使用 terracotta 服务器共享。建议使用 redis，不仅仅因为它可以将缓存的内容持久化，还因为它支持的单个对象比较大，而且数据类型丰富，不只是缓存 session，还可以做其他用途，一举几得啊。1、使用 filter 方法存储这种方法比较推荐，因为它的服务器使用范围比较多，不仅限于tomcat ，而且实现的原理比较简
    
                                
    • 
                                
  • Yii 框架里数据库操作详解-[增加、查询、更新、删除的方法 'AR模式']
                                    dcj3sjt126com
数据库
                                    
        public function getMinLimit () {        $sql = "...";        $result = yii::app()->db->createCo
    
                                
    • 
                                
  • solr StatsComponent（聚合统计）
                                    eksliang
solr聚合查询solr stats
                                    
    StatsComponent 
转载请出自出处：http://eksliang.iteye.com/blog/2169134 
http://eksliang.iteye.com/ 一、概述 
       Solr可以利用StatsComponent 实现数据库的聚合统计查询，也就是min、max、avg、count、sum的功能 
  二、参数
    
                                
    • 
                                
  • 百度一道面试题
                                    greemranqq
位运算百度面试寻找奇数算法bitmap 算法
                                    
    那天看朋友提了一个百度面试的题目：怎么找出{1,1,2,3,3,4,4,4,5,5,5,5}  找出出现次数为奇数的数字. 
  
我这里复制的是原话，当然顺序是不一定的，很多拿到题目第一反应就是用map,当然可以解决，但是效率不高。 
  
还有人觉得应该用算法xxx,我是没想到用啥算法好...！ 
  
还有觉得应该先排序... 
  
还有觉
    
                                
    • 
                                
  • Spring之在开发中使用SpringJDBC
                                    ihuning
spring
                                    
      
在实际开发中使用SpringJDBC有两种方式： 
  
1. 在Dao中添加属性JdbcTemplate并用Spring注入； 
    JdbcTemplate类被设计成为线程安全的，所以可以在IOC 容器中声明它的单个实例，并将这个实例注入到所有的 DAO 实例中。JdbcTemplate也利用了Java 1.5 的特定(自动装箱，泛型，可变长度
    
                                
    • 
                                
  • JSON API 1.0 核心开发者自述 | 你所不知道的那些技术细节
                                    justjavac
json
                                    
    2013年5月，Yehuda Katz 完成了JSON API(英文，中文) 技术规范的初稿。事情就发生在 RailsConf 之后，在那次会议上他和 Steve Klabnik 就 JSON 雏形的技术细节相聊甚欢。在沟通单一 Rails 服务器库—— ActiveModel::Serializers 和单一 JavaScript 客户端库——&
    
                                
    • 
                                
  • 网站项目建设流程概述
                                    macroli
工作
                                    
    一.概念 
网站项目管理就是根据特定的规范、在预算范围内、按时完成的网站开发任务。 
二.需求分析 
项目立项 
　　我们接到客户的业务咨询，经过双方不断的接洽和了解，并通过基本的可行性讨论够，初步达成制作协议，这时就需要将项目立项。较好的做法是成立一个专门的项目小组，小组成员包括：项目经理，网页设计，程序员，测试员，编辑/文档等必须人员。项目实行项目经理制。 
客户的需求说明书 
　　第一步是需
    
                                
    • 
                                
  • AngularJs 三目运算 表达式判断
                                    qiaolevip
每天进步一点点学习永无止境众观千象AngularJS
                                    
    事件回顾：由于需要修改同一个模板，里面包含2个不同的内容，第一个里面使用的时间差和第二个里面名称不一样，其他过滤器，内容都大同小异。希望杜绝If这样比较傻的来判断if-show or not，继续追究其源码。 
var b = "{{",
      a = "}}";
        this.startSymbol = function(a) {

    
                                
    • 
                                
  • Spark算子：统计RDD分区中的元素及数量
                                    superlxw1234
sparkspark算子Spark RDD分区元素
                                    
    关键字：Spark算子、Spark RDD分区、Spark RDD分区元素数量 
  
  
Spark RDD是被分区的，在生成RDD时候，一般可以指定分区的数量，如果不指定分区数量，当RDD从集合创建时候，则默认为该程序所分配到的资源的CPU核数，如果是从HDFS文件创建，默认为文件的Block数。 
  
可以利用RDD的mapPartitionsWithInd
    
                                
    • 
                                
  • Spring 3.2.x将于2016年12月31日停止支持
                                    wiselyman
Spring 3
                                    
          
        Spring 团队公布在2016年12月31日停止对Spring Framework 3.2.x（包含tomcat 6.x）的支持。在此之前spring团队将持续发布3.2.x的维护版本。 
  
       请大家及时准备及时升级到Spring 
    
                                
    • 
                                
  • fis纯前端解决方案fis-pure
                                    zccst
JavaScript
                                    
    作者：zccst 
 
FIS通过插件扩展可以完美的支持模块化的前端开发方案，我们通过FIS的二次封装能力，封装了一个功能完备的纯前端模块化方案pure。 
 
 
1，fis-pure的安装 
$ fis install -g fis-pure 
$ pure -v 
0.1.4 
 
 
2，下载demo到本地 
git clone https://github.com/hefangshi/f
    
                                
    •