public class Request {

 private String name;

 private int days;
 
}

public class Result {

 private boolean agree;

 public Result(boolean agree) {
 this.agree = agree;
 }
}

public interface Handler {
 // 每個處理器持有鏈，能取到鏈上的請求或者傳遞請求
 Result deal(Chain chain);
 
 interface Chain {
 // 獲取請求
 Request request();
 // 傳遞請求
 Result proceed(Request request);
 }
}

public class HandlerChain implements Handler.Chain {
 // 持有鏈要處理的請求
 private Request request;
 // 持有鏈上所有的處理器
 private Queue<Handler> handlers;

 public HandlerChain(Request request) {
 this.request = request;
 }
 // 添加一個處理器
 public HandlerChain addHandler(Handler handler) {
 if (handlers == null) {
 handlers = new LinkedList<>();
 }
 handlers.add(handler);
 return this;
 }
 // 實現(xiàn)接口的方法- 獲取請求
 public Request request() {
 return request;
 }
 // 實現(xiàn)接口的方法- 處理請求
 public Result proceed(Request request) {
 // 取隊首的處理器開始請求。如果隊首的處理器處理了，直接返回結果
 // 如果隊首的處理器選擇傳遞請求，又會進這個proceed方法。取新的隊首處理
 // 為什么是傳遞而不是直接遍歷隊列，如果result = null,繼續(xù)；result != null，返回呢？ 因為傳遞的方式，可以對request再次處理。A處理器可以做簡單處理，再傳遞給B。
 Handler handler = handlers.poll();
 return handler.deal(this);
 }
}

public class AHandler implements Handler{
 public Result deal(Chain chain) {
 Request request = chain.request();
 // 只處理小于等于1的請求，大于1的請求被傳遞了
 if (request.getDays() > 1) {
 // 這里可以對request做部分處理，再傳遞
 return chain.proceed(request);
 }
 System.out.println("A處理了");
 return new Result(true);
 }
} 

public class BHandler implements Handler {
 public Result deal(Chain chain) {
 Request request = chain.request();
 // 只處理小于等于2的請求，大于2的請求被傳遞了
 if (request.getDays() > 2) {
 return chain.proceed(request);
 }
 System.out.println("B處理了");
 return new Result(true);
 }
}

public class CHandler implements Handler {
 public Result deal(Chain chain) {
 Request request = chain.request();
 // 只處理小于等于3的請求，大于3的請求被傳遞了
 if (request.getDays() > 3) {
 return chain.proceed(request);
 }
 System.out.println("C處理了");
 return new Result(true);
 }
}

public class Test {

 public static void main(String[] args) {
 // new 一個鏈，往鏈上添加處理器
 Request request1 = new Request("hhy", 3);
 HandlerChain chains = new HandlerChain(request1).addHandler(new AHandler()).addHandler(new BHandler()).addHandler(new CHandler());
 Result result1 = chains.proceed(request1);
 System.out.println("結果：" + result1.isAgree());

 }
} 

public static void main(String[] args) {
 EventLoopGroup group = new NioEventLoopGroup();
 NioSocketChannel channel = new NioSocketChannel();
 Bootstrap bootstrap = new Bootstrap();
 bootstrap.group(group).option(ChannelOption.TCP_NODELAY, true);
 InetSocketAddress address = new InetSocketAddress(InetAddress.getByName(httpRequest.host), httpRequest.port);
 group.register(channel);
 channel.connect(address).sync();
 channel.pipeline().addLast("http-decoder", new HttpResponseDecoder());
 channel.pipeline().addLast("http-encoder", new HttpRequestEncoder());
 channel.pipeline().addLast("http-client", new HttpHandler(HttpClient.this));
 channel.writeAndFlush(httpRequest);
}

public class DefaultChannelPipeline implements ChannelPipeline {
 final AbstractChannelHandlerContext head;
 final AbstractChannelHandlerContext tail;

 @Override
 public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) {
 final AbstractChannelHandlerContext newCtx;
 synchronized (this) {
 checkMultiplicity(handler);
 // 把handler封裝成AbstractChannelHandlerContext
 newCtx = newContext(group, filterName(name, handler), handler);
 // 調用了 addLast0方法
 addLast0(newCtx);
 ...
 }
 callHandlerAdded0(newCtx);
 return this;
 }

 private void addLast0(AbstractChannelHandlerContext newCtx) {
 // 把新加入的處理器設置成尾部的前驅，原尾部的前驅設置成新處理器的后繼
 AbstractChannelHandlerContext prev = tail.prev;
 newCtx.prev = prev;
 newCtx.next = tail;
 prev.next = newCtx;
 tail.prev = newCtx;
 }
}

public class DefaultChannelPipeline implements ChannelPipeline {
 ...
 @Override
 public final Channel channel() {
 return channel;
 }

 @Override
 public final ChannelPipeline fireChannelActive() {
 AbstractChannelHandlerContext.invokeChannelActive(head);
 return this;
 }
 ...
}

abstract class AbstractChannelHandlerContext implements ChannelHandlerContext, ResourceLeakHint {
 static void invokeChannelActive(final AbstractChannelHandlerContext next) {
 EventExecutor executor = next.executor();
 if (executor.inEventLoop()) {
  next.invokeChannelActive();
 } else {
  executor.execute(new Runnable() {
  @Override
  public void run() {
   next.invokeChannelActive();
  }
  });
 }
 }
 // 調用了invokeChannelActive
 
 private void invokeChannelActive() {
 // 判斷是不是要處理
 if (invokeHandler()) {
  try {
  // 處理
  ((ChannelInboundHandler) handler()).channelActive(this);
  } catch (Throwable t) {
  invokeExceptionCaught(t);
  }
 } else {
  // 事件傳遞
  fireChannelActive();
 }
 }
 
 @Override
 public ChannelHandlerContext fireChannelActive() {
 // 執(zhí)行前需要先找到一個合適的處理器 invokeChannelActive
 invokeChannelActive(findContextInbound(MASK_CHANNEL_ACTIVE));
 return this;
 }
 
 private AbstractChannelHandlerContext findContextInbound(int mask) {
 AbstractChannelHandlerContext ctx = this;
 EventExecutor currentExecutor = executor();
 do {
  // 循環(huán)，找到一個合適的處理器并返回
  ctx = ctx.next;
 } while (skipContext(ctx, currentExecutor, mask, MASK_ONLY_INBOUND));
 return ctx;
 }
}

public class ChannelInboundHandlerAdapter extends ChannelHandlerAdapter implements ChannelInboundHandler {
 ......
 @Override
 public void channelActive(ChannelHandlerContext ctx) throws Exception {
 ctx.fireChannelActive();
 }
 ......
}