责任链模式的两个简单demo

责任链模式的核心是：过滤器链【注意：递归算法的运用】

过滤字符

当不满足条件时，则停止过滤

/**
 * @author LiuWei
 * @date 2020/10/5
 * @description
 */
public class MainDemo {
    public static void main(String[] args) {
        Msg msg = new Msg();
        msg.setMsg("我喜欢<font color='red'>体育、代码、美食、美女等</font>");
        FirstFilter firstFilter = new FirstFilter();
        SecondFilter secondFilter = new SecondFilter();
        ThirdFilter thirdFilter = new ThirdFilter();
        FourthFilter fourthFilter = new FourthFilter();
        ChainFilter chainFilter1 = new ChainFilter();
        ChainFilter chainFilter2 = new ChainFilter();
        chainFilter1.add(firstFilter).add(secondFilter);

        chainFilter2.add(thirdFilter).add(fourthFilter);
        //把过滤器链2放入过滤器链1
        chainFilter1.add(chainFilter2);
        chainFilter1.doFilter(msg);
        System.out.println(msg.getMsg());
    }
}

class Msg {

    private Integer id;

    private String msg;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

interface Filter {
    boolean doFilter(Msg msg);
}

/**
 * 过滤链
 * 亮点1：过滤器链实现Filter接口时，当两个过滤器链组合放到一个数组，执行doFilter会发生递归调用
 * 亮点2：当doFilter返回false时，停止往下执行，直接返回，这里也存在递归
 */
class ChainFilter implements Filter {
    List<Filter> filters = new ArrayList<>();

    public ChainFilter add(Filter filter) {
        filters.add(filter);
        return this;
    }

    @Override
    public boolean doFilter(Msg msg) {
        for (Filter filter : filters) {
            if (!filter.doFilter(msg)) {
                return false;
            }
        }
        return true;
    }
}

class FirstFilter implements Filter {

    @Override
    public boolean doFilter(Msg msg) {
        System.out.println(this.getClass().getSimpleName());
        msg.setMsg(msg.getMsg().replace("<", "[").replace(">", "]"));
        return true;
    }
}

class SecondFilter implements Filter {

    @Override
    public boolean doFilter(Msg msg) {
        System.out.println(this.getClass().getSimpleName());
        if (msg.getMsg().contains("编程")) {
            return false;
        }
        return true;
    }
}

class ThirdFilter implements Filter {

    @Override
    public boolean doFilter(Msg msg) {
        System.out.println(this.getClass().getSimpleName());
        msg.setMsg(msg.getMsg().replace("美女", "女神"));
        return true;
    }
}

class FourthFilter implements Filter {

    @Override
    public boolean doFilter(Msg msg) {
        System.out.println(this.getClass().getSimpleName());
        msg.setMsg(msg.getMsg().replace("体育", "运动"));
        return true;
    }
}

手写HttpServletFilter

需求：请求时按顺序先后进过FirstFilter，SecondFilter ，响应时再按顺序先后经过SecondFilter、FirstFilter，请求经过任何一个过滤器中如果不满足条件，则返回响应对象，此响应对象也会进过已经进过的过滤器

/**
 * @author LiuWei
 * @date 2020/10/5
 * @description
 */
public class mainDemo {

    public static void main(String[] args) {
        Request request = new Request();
        request.setStr("用户请求：");

        Response response = new Response();
        response.setStr("响应结果：");

        FirstFilter firstFilter = new FirstFilter();
        SecondFilter secondFilter = new SecondFilter();

        FilterChain filterChain = new FilterChain();
        filterChain.add(firstFilter).add(secondFilter);
        filterChain.doFilter(request, response);

        System.out.println(request.getStr());
        System.out.println(response.getStr());
    }
}

/**
 * 因为这里模拟了响应对象，因此doFilter方法不需要返回值，响应结果直接保存在响应对象中
 */
interface Filter {
    void doFilter(Request request, Response response, FilterChain filterChain);
}

/**
 * 责任链模式的核心是：过滤器链对递归的运用
 */
class FilterChain {

    private List<Filter> filters = new ArrayList<>();
    private Iterator<Filter> iterator;

    public FilterChain add(Filter filter) {
        filters.add(filter);
        return this;
    }

    /**
     * 请求每进入过滤器执行doFilter时，都会通过FilterChain过滤器判断是否是最后一个过滤器，
     * 如果还有过滤器，则调用下一个过滤器继续过滤请求，直到没有过滤器,直接返回。
     * 当最后一个过滤器过滤完请求，通过FilterChain判断没有过滤器了，才会开始一层一层的过滤响应
     * 一个Filter的doFilter方法的实现逻辑：过滤请求的代码--》过滤器链的代码--》过绿请求的代码
     * 过滤器链调用doFilter方法实际上是一种递归算法
     */
    public void doFilter(Request request, Response response) {
        if (iterator == null) {
            iterator = filters.iterator();
        }
        while (iterator.hasNext()) {
            Filter filter = iterator.next();
            filter.doFilter(request, response, this);
        }
    }
}

class FirstFilter implements Filter {

    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) {
        request.setStr(request.getStr() + "--request经过FirstFilter");
        if (!request.getStr().contains("用户")) {
            response.setStr(response.getStr() + "--FirstFilter没有找到相应的字符：用户");
        }
        filterChain.doFilter(request, response);
        response.setStr(response.getStr() + "--response经过FirstFilter");
    }
}

class SecondFilter implements Filter {

    @Override
    public void doFilter(Request request, Response response, FilterChain filterChain) {
        request.setStr(request.getStr() + "--request经过SecondFilter");
        if (!request.getStr().contains("请求")) {
            response.setStr(response.getStr() + "--SecondFilter没有找到相应的字符：请求");
            return;
        }
        filterChain.doFilter(request, response);
        response.setStr(response.getStr() + "--response经过SecondFilter");
    }
}

class Request {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}

class Response {
    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return JSONObject.toJSONString(this);
    }
}