设计模式（九）责任链（Chain of Responsibility）

// 典型的"抽象处理者"代码
abstract class Handler {
    // 为了使得handler之间连接起来像一个链，这里用来存储下处理者
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(String request);
}

// 典型的"具体处理者"代码
class ConcreteHandler extends  Handler{
    @Override
    public void handleRequest(String request) {
        // 场景1）自己满足处理条件，就不往下流转；自己不满足处理条件，就往下流转
        if(满足条件){
            //1）处理
        }else{
            //2） 交给其他处理者处理
            this.successor.handleRequest(request);
        }

        // 场景2）当然也可能是自己处理完，之后又交给下一个处理者处理
        //1）当前处理
        //2）交个下一个处理者处理
        this.successor.handleRequest(request);

    }
}

Handler handler1=new ConcreteHandler1();
Handler handler2=new ConcreteHandler2();
Handler handler3=new ConcreteHandler3();

// 创建职责链
handler1.setSuccessor(handler2);
handler2.setSuccessor(handler3);

// 发送请求，请求对象通常为根据需求而定。
handler1.handleRequest("xxx");

// 首先定义一个 过滤器链接口，包含一个doFilter方法
interface IFilterChain { 
    void doFilter(); 
}

// Filter接口类，包含一个doFilter方法，方法包含一个FilterChain参数
interface IFilter {
    void doFilter(IFilterChain chain); 
}

// Servlet接口类，包含一个servcie方法
interface IServlet {
    void service(); 
}

class MyServlet implements IServlet {
    @Override
    public void service() {
        System.out.println("MyServlet#service()");
    }
}

class MyFilter1 implements IFilter {
    @Override
    public void doFilter(IFilterChain chain) {
        System.out.println("MyFilter1#doFilter() before");
        chain.doFilter();
        System.out.println("MyFilter1#doFilter() after");
    }
}

class MyFilter2 implements IFilter {
    @Override
    public void doFilter(IFilterChain chain) {
        System.out.println("MyFilter2#doFilter() before");
        chain.doFilter();
        System.out.println("MyFilter2#doFilter() after");
    }
}

class MyFilterChain implements IFilterChain {
    private int pos = 0; // 标记filter执行索引位置
    private int n = 0; // 已经拥有的filter个数
    private IServlet servlet; // 存储 当前servlet
    private List<IFilter> filters = new ArrayList<>(); // 存储过滤器

    public void addFilter(IFilter filter) {
        this.filters.add(filter);
        n++;
    }

    public void setServlet(IServlet servlet) {
        this.servlet = servlet;
    }

    // 责任链的核心方法，执行filter到最底一层后调用 servlet#service 方法。
    @Override
    public void doFilter() {
        // Call the next filter if there is one
        if (pos < n) {
            IFilter filter = filters.get(pos++);
            filter.doFilter(this);

            return;
        }

        servlet.service();
    }
}

import java.util.ArrayList;
import java.util.List;

public class FilterTest {
    public static void main(String[] args) {
        MyFilterChain filterChain = new MyFilterChain();
        filterChain.addFilter(new MyFilter1());
        filterChain.addFilter(new MyFilter2());
        filterChain.setServlet(new MyServlet());

        filterChain.doFilter();
    }
}

MyFilter1#doFilter() before
MyFilter2#doFilter() before
MyServlet#service()
MyFilter2#doFilter() after
MyFilter1#doFilter() after