public class LeaveApproval
{
    public boolean process(String request, int number) {
        boolean result = handleByDirector(request); // 主管處理
        if (result == false) {  // 主管不批準(zhǔn)
            return false;
        } else if (number < 3) {    // 主管批準(zhǔn)且天數(shù)小于 3
            return true;
        }
        result = handleByManager(request); // 準(zhǔn)管批準(zhǔn)且天數(shù)大于等于 3，提交給經(jīng)理處理
        if (result == false) {   // 經(jīng)理不批準(zhǔn)
            return false;
        } else if (number < 7) { // 經(jīng)理批準(zhǔn)且天數(shù)小于 7
            return true;
        }
        result = handleByTopManager(request);   // 經(jīng)理批準(zhǔn)且天數(shù)大于等于 7，提交給總經(jīng)理處理
        if (result == false) { // 總經(jīng)理不批準(zhǔn)
            return false;
        }
        return true;    // 總經(jīng)理最后批準(zhǔn)
    }
    private boolean handleByDirector(String request)
    {
        // 主管處理該請(qǐng)假申請(qǐng)
        if(request.length()>10)
            return false;
        return true;
    }
    private boolean handleByManager(String request) {
        // 經(jīng)理處理該請(qǐng)假申請(qǐng)
        if(request.length()>5)
        return false;
        return true;
    }
    private boolean handleByTopManager(String request) {
        // 總經(jīng)理處理該請(qǐng)假申請(qǐng)
        if(request.length()>3)
            return false;
        return true;
    }
}

public abstract class Handler {
    // protected ：維持對(duì)下家的引用
    protected Handler successor;
    public void setSuccessor(Handler successor) {
        this.successor=successor;
    }
    public abstract void handleRequest(String request);
}

public class ConcreteHandler extends Handler {
    public void handleRequest(String request) {
        if (請(qǐng)求滿足條件) {
            //處理請(qǐng)求
        }else {
            this.successor.handleRequest(request);  //轉(zhuǎn)發(fā)請(qǐng)求
        }
    }
}

@Data
@AllArgsConstructor
public class LeaveRequest
{
 String name;//請(qǐng)假人的姓名
 Integer num;//請(qǐng)假天數(shù)
}

//抽象處理者
@Data
public abstract class Handler
{
    //維護(hù)自身引用
    protected Handler handler;
   //當(dāng)前處理者的姓名
    protected String name;
    //傳入當(dāng)前處理者的姓名
    public Handler(String name)
    {
        this.name=name;
    }
    //抽象方法，用來處理請(qǐng)假的請(qǐng)求
    public abstract Boolean process(LeaveRequest leaveRequest);
}

public class Director extends Handler{
    public Director(String name) {
        super(name);
    }
    //處理請(qǐng)假的請(qǐng)求
    @Override
    public Boolean process(LeaveRequest leaveRequest) {
       //隨機(jī)數(shù)大于3，就批準(zhǔn)請(qǐng)求
        boolean result = (new Random().nextInt(10)) > 3;
        String log = "主管: %s,審批:%s的請(qǐng)假申請(qǐng),請(qǐng)假天數(shù):%d,審批結(jié)果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"通過":"不通過"));
        if(result)//批準(zhǔn)
        {
            //如果請(qǐng)假天數(shù)，超過了3天，那么交給上級(jí)繼續(xù)審批
           if(leaveRequest.num>3)
           {
               return nextHandler.process(leaveRequest);
           }
           //請(qǐng)假天數(shù)小于3，審批通過
            return true;
        }
        //沒有通過審批
        return false;
    }
}

public class Manager extends Handler{
    public Manager(String name) {
        super(name);
    }
    //處理請(qǐng)假的請(qǐng)求
    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        boolean result = (new Random().nextInt(10)) > 3; // 隨機(jī)數(shù)大于3則為批準(zhǔn)，否則不批準(zhǔn)
        String log = "經(jīng)理: %s,審批:%s的請(qǐng)假申請(qǐng),請(qǐng)假天數(shù):%d,審批結(jié)果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"批準(zhǔn)":"不通過"));
        if(result)
        {
            //請(qǐng)假天數(shù)過多，還是需要提交到更高的一級(jí)去審批
            if(leaveRequest.getNum()>7)
            {
                return nextHandler.process(leaveRequest);
            }
            //否則直接通過
            return true;
        }
        return false;
    }
}

public class TopManager extends Handler{
    public TopManager(String name) {
        super(name);
    }
    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        //隨機(jī)數(shù)大于3，就批準(zhǔn)請(qǐng)求
        boolean result = (new Random().nextInt(10)) > 3;
        String log = "總經(jīng)理: %s,審批:%s的請(qǐng)假申請(qǐng),請(qǐng)假天數(shù):%d,審批結(jié)果:%s";
        System.out.println(String.format(log,name,leaveRequest.getName(),leaveRequest.getNum(),result==true?"通過":"不通過"));
        if(result)//批準(zhǔn)
        {
            //默認(rèn)只有三個(gè)處理器，但是如果后續(xù)還要加，也需要留個(gè)位置
            //如果后續(xù)繼續(xù)添加
            if(nextHandler!=null)
            {
                return nextHandler.process(leaveRequest);
            }
            return true;
        }
        //沒有通過審批
        return false;
    }
}

//處理器鏈
public class HandlerChain
{
    //維護(hù)第一個(gè)處理器
    private Handler director=new Director("小忽悠");
    //默認(rèn)有三個(gè)處理器
    public HandlerChain()
    {
        //默認(rèn)有三個(gè)處理器鏈
        //并且這三個(gè)處理器有先后關(guān)系
        director.nextHandler=new Manager("小朋友");
        director.nextHandler.nextHandler=new TopManager("超級(jí)大忽悠");
    }
    //添加一個(gè)處理器進(jìn)集合
    public void addHandler(Handler handler)
    {
        Handler temp=director;
     while(temp.nextHandler!=null)
     {
         temp=temp.nextHandler;
     }
        temp.nextHandler=handler;
    }
    //執(zhí)行處理器鏈
     public void process(LeaveRequest leaveRequest)
    {
        //第一個(gè)處理器，如果可以處理器就不需要交給下一個(gè)處理器處理了
        //否則，繼續(xù)交給下一個(gè)處理器處理
        director.process(leaveRequest);
    }
}

public class Client
{
    public static void main(String[] args) {
        LeaveRequest leaveRequest=new LeaveRequest("大忽悠",10);
        HandlerChain handlerChain=new HandlerChain();
        handlerChain.process(leaveRequest);
    }
}

public class God extends Handler{
    public God(String name) {
        super(name);
    }

    @Override
    public Boolean process(LeaveRequest leaveRequest) {
        System.out.println("上帝保佑你，所以你可以放假了");
        return true;
    }
}

public class Client
{
    public static void main(String[] args) {
        LeaveRequest leaveRequest=new LeaveRequest("大忽悠",10);
        HandlerChain handlerChain=new HandlerChain();
        handlerChain.addHandler(new God("上帝"));
        handlerChain.process(leaveRequest);
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Reponse
{
    private List<String> data=new ArrayList<>();
    public void addData(String data)
    {
        this.data.add(data);
    }
}

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Request
{
   private Object data;
}

/*
 * 定義接口Filter,具體的過濾規(guī)則需要實(shí)現(xiàn)這個(gè)接口，最后一個(gè)參數(shù)添加的意義是我們?cè)贛ain函數(shù)中:
 * fc.doFilter(request, response,fc);執(zhí)行這一步的時(shí)候可以按照規(guī)則鏈條一次使用三個(gè)過濾規(guī)則對(duì)字符串進(jìn)行處理
 */
public interface Filter
{
    void doFilter(Request request,Reponse reponse,FilterChain filterChain);
}

public class StuAgeFilter implements Filter
{
    @Override
    public void doFilter(Request request, Reponse reponse, FilterChain filterChain) {
        Stu stu = (Stu) request.getData();
        if(stu.getName().contains("忽悠"))
        {
            //名字不符合要求
            reponse.addData("名字不符合要求");
        }
        //名字符合要求
         reponse.addData("名字符合要求");
        filterChain.doFilter(request,reponse,filterChain);
    }
}
//學(xué)生過濾器--過濾出18歲以上的
public class StuFilter implements Filter
{
    @Override
    public void doFilter(Request request, Reponse reponse, FilterChain filterChain) {
        Stu stu = (Stu)request.getData();
        if(stu.getAge()<18)
        {
            //不放行
            reponse.addData("年齡不符合要求");
        }
        //放行
        reponse.addData("年齡滿足要求");
        filterChain.doFilter(request,reponse,filterChain);
    }
}

//過濾鏈條
@Data
public class FilterChain
{
    //用List集合來存過濾器
    private List<Filter> filters = new ArrayList<Filter>();
    //用于標(biāo)記規(guī)則的引用順序
   private int index;
   public FilterChain()
   {
       //初始化為0
       index=0;
   }
    //往過濾器鏈條中添加新的過濾器
    public FilterChain addFilter(Filter f)
    {
        filters.add(f);
        //代碼的設(shè)計(jì)技巧:Chain鏈添加過濾規(guī)則結(jié)束后返回添加后的Chain，方便我們下面doFilter函數(shù)的操作
        return this;
    }
    public void doFilter(Request request, Reponse response, FilterChain chain){
        //index初始化為0,filters.size()為3，不會(huì)執(zhí)行return操作
        //說明所有過濾器都執(zhí)行完了
        if(index==filters.size()){
            return;
        }
        //獲取當(dāng)前過濾器
        Filter f=filters.get(index);
        //下一次獲取的時(shí)候，就是下一個(gè)過濾器了
        index++;
        //執(zhí)行當(dāng)前過濾器的過濾方法
        f.doFilter(request, response, chain);
   }
}

public class Client
{
    public static void main(String[] args)
    {
      //創(chuàng)建請(qǐng)求對(duì)象
        Request request=new Request();
        request.setData(new Stu("小朋友",19));
        //創(chuàng)建響應(yīng)對(duì)象
        Reponse reponse=new Reponse();
        //創(chuàng)建一個(gè)過濾器鏈
        FilterChain filterChain=new FilterChain();
        filterChain.addFilter(new StuAgeFilter());
        filterChain.addFilter(new StuFilter());
        //執(zhí)行
        filterChain.doFilter(request,reponse,filterChain);
        reponse.getData().forEach(x->{
            System.out.println(x);
        });
    }
}

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 {
    void doFilter(ServletRequest var1, ServletResponse var2) throws IOException, ServletException;
}

public class MyFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        // 做一些自定義處理....
        System.out.println("執(zhí)行doFilter()方法之前...");
        chain.doFilter(request, response);              // 傳遞請(qǐng)求給下一個(gè)過濾器
        System.out.println("執(zhí)行doFilter()方法之后...");
    }
    @Override
    public void destroy() {
    }
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
    }
}

<filter>  
        <filter-name>MyFilter</filter-name>  
        <filter-class>com.whirly.filter.MyFilter</filter-class>  
</filter>
<filter-mapping>  
        <filter-name>MyFilter</filter-name>  
        <url-pattern>/*</url-pattern>  
</filter-mapping>

final class StandardWrapperValve extends ValveBase {
    public final void invoke(Request request, Response response) throws IOException, ServletException {
        // 省略其他的邏輯處理...
        // 調(diào)用 ApplicationFilterChain.createFilterChain() 創(chuàng)建過濾器鏈
        ApplicationFilterChain filterChain = ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);
        if (servlet != null && filterChain != null) {
            // 省略
        } else if (request.isAsyncDispatching()) {
            request.getAsyncContextInternal().doInternalDispatch();
        } else if (comet) {
            filterChain.doFilterEvent(request.getEvent());
        } else {
            // 調(diào)用過濾器鏈的 doFilter 方法開始過濾
            filterChain.doFilter(request.getRequest(), response.getResponse());
        }

final class ApplicationFilterChain implements FilterChain, CometFilterChain {
    private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0]; // 過濾器鏈
    private Servlet servlet = null; // 目標(biāo)
    // ...
    @Override
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        if( Globals.IS_SECURITY_ENABLED ) {
            // ...
        } else {
            internalDoFilter(request,response); // 調(diào)用 internalDoFilter 方法
        }
    }
    private void internalDoFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        // Call the next filter if there is one
        if (pos < n) {
            // 從過濾器數(shù)組中取出當(dāng)前過濾器配置，然后下標(biāo)自增1
            ApplicationFilterConfig filterConfig = filters[pos++];
            Filter filter = null;
            try {
                filter = filterConfig.getFilter();  // 從過濾器配置中取出該 過濾器對(duì)象
                if( Globals.IS_SECURITY_ENABLED ) {
                    final ServletRequest req = request;
                    final ServletResponse res = response;
                    Principal principal = ((HttpServletRequest) req).getUserPrincipal();
                    Object[] args = new Object[]{req, res, this};
                    SecurityUtil.doAsPrivilege("doFilter", filter, classType, args, principal);
                } else {
                    // 調(diào)用過濾器的 doFilter，完成一個(gè)過濾器的過濾功能
                    filter.doFilter(request, response, this);
                }
            return;  // 這里很重要，不會(huì)重復(fù)執(zhí)行后面的  servlet.service(request, response)
        }
        // 執(zhí)行完過濾器鏈的所有過濾器之后，調(diào)用 Servlet 的 service 完成請(qǐng)求的處理
        if ((request instanceof HttpServletRequest) && (response instanceof HttpServletResponse)) {
            if( Globals.IS_SECURITY_ENABLED ) {

            } else {
                servlet.service(request, response);
            }
        } else {
            servlet.service(request, response);
        }
    }
    // 省略...
}

 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        System.out.println("執(zhí)行doFilter()方法之前...");
        chain.doFilter(request, response);              // 傳遞請(qǐng)求給下一個(gè)過濾器
        System.out.println("執(zhí)行doFilter()方法之后...");
    }