策略模式和责任链模式（5）

public class Test {
    public static void main(String[] args) {
        MemberService memberService = new MemberService();
        memberService.login("tom","666");
    }
}

用户名和密码校验成功，可以往下执行
登录成功!
您是管理员，允许操作

public abstract class Handler<T> {
    protected Handler next;
    public void next(Handler next){ this.next = next;}
    public abstract void doHandler(Member member);
    public static class Builder<T>{
        private Handler<T> head;
        private Handler<T> tail;
        public Builder<T> addHandler(Handler handler){
           // do {
                if (this.head == null) {
                    this.head = this.tail = handler;
                    return this;
                }
                this.tail.next(handler);
                this.tail = handler;
           // }while (false);//真正框架中，如果是双向链表，会判断是否已经到了尾部
            return this;
        }
        public Handler<T> build(){
            return this.head;
        }
    }
}

public class MemberService {
    public void login(String loginName,String loginPass){
        Handler.Builder builder = new Handler.Builder();
        builder.addHandler(new ValidateHandler())
               .addHandler(new LoginHandler())
               .addHandler(new AuthHandler());
        builder.build().doHandler(new Member(loginName,loginPass));
        //用过Netty的人，肯定见过
    }
}

public abstract class Handler<T> {
    protected Handler chain;
    private void next(Handler handler) {
        this.chain = handler;
    }
}

public interface Filter {
    public void init(FilterConfig filterConfig) throws ServletException;
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;
    public void destroy();
}

public interface FilterChain {
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException;
}

public class MockFilterChain implements FilterChain {
   @Nullable
   private ServletRequest request;
   @Nullable
   private ServletResponse response;
   private final List<Filter> filters;
   @Nullable
   private Iterator<Filter> iterator;
   public MockFilterChain() {
      this.filters = Collections.emptyList();
   }
   public MockFilterChain(Servlet servlet) {
      this.filters = initFilterList(servlet);
   }
   public MockFilterChain(Servlet servlet, Filter... filters) {
      Assert.notNull(filters, "filters cannot be null");
      Assert.noNullElements(filters, "filters cannot contain null values");
      this.filters = initFilterList(servlet, filters);
   }
   private static List<Filter> initFilterList(Servlet servlet, Filter... filters) {
      Filter[] allFilters = ObjectUtils.addObjectToArray(filters, new ServletFilterProxy(servlet));
      return Arrays.asList(allFilters);
   }
   @Nullable
   public ServletRequest getRequest() {
      return this.request;
   }
   @Nullable
   public ServletResponse getResponse() {
      return this.response;
   }
   @Override
   public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
      Assert.notNull(request, "Request must not be null");
      Assert.notNull(response, "Response must not be null");
      Assert.state(this.request == null, "This FilterChain has already been called!");
      if (this.iterator == null) {
         this.iterator = this.filters.iterator();
      }
      if (this.iterator.hasNext()) {
         Filter nextFilter = this.iterator.next();
         nextFilter.doFilter(request, response, this);
      }
      this.request = request;
      this.response = response;
   }
   public void reset() {
      this.request = null;
      this.response = null;
      this.iterator = null;
   }
   private static class ServletFilterProxy implements Filter {
      private final Servlet delegateServlet;
      private ServletFilterProxy(Servlet servlet) {
         Assert.notNull(servlet, "servlet cannot be null");
         this.delegateServlet = servlet;
      }
      @Override
      public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
         this.delegateServlet.service(request, response);
      }
      @Override
      public void init(FilterConfig filterConfig) throws ServletException {
      }
      @Override
      public void destroy() {
      }
      @Override
      public String toString() {
         return this.delegateServlet.toString();
      }
   }
}

public interface ChannelHandler {
    // 当 handler被添加到真实的上下文中，并且准备处理事件时被调用
  // handler被添加进去的回调 
    void handlerAdded(ChannelHandlerContext var1) throws Exception;
    // 是 handler被移出的后的回调
    void handlerRemoved(ChannelHandlerContext var1) throws Exception;
    /** @deprecated */
    @Deprecated
    void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception;
    @Inherited
    @Documented
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Sharable {
    }
}

public interface ChannelPipeline extends ChannelInboundInvoker,ChannelOutboundInvoker, Iterable<Entry<String, ChannelHandler>> {
    ChannelPipeline addFirst(String name, ChannelHandler handler);
    ChannelPipeline addFirst(EventExecutorGroup group, String name, ChannelHandler handler);
    ChannelPipeline addLast(String name, ChannelHandler handler);
    ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler);
    ChannelPipeline addBefore(String baseName, String name, ChannelHandler handler);
    ...
}

public class DefaultChannelPipeline implements ChannelPipeline {
    static final InternalLogger logger = InternalLoggerFactory.getInstance(DefaultChannelPipeline.class);
    final AbstractChannelHandlerContext head;
    final AbstractChannelHandlerContext tail;
    ...
}