JAVA 二十三种设计模式大全（七）责任链模式（Chain of Responsibility Pattern）（二）

需求：

在上面的基础上，我们还希望做到
如果在责任链的某一环不符合某些条件了，则停止责任链继续向下

示意图：

代码：

设计思路：
我们实际过滤链传一个包装类，其中一部分是用户的输入，一部分是用于其他判断的参数

与（一）中的改动：

• main函数传参需要传一个request，而不只是字符串；不过不需要用户设置其他属性，仍然只需要塞一个字符串
• filter接口重载一个方法，入参出参均为request
• filterDemo都重写此方法，不符合规范的会停止过滤

下面把代码贴出来，方便大家理解：

public interface Filter {
    String doFilter(String s);

    FilterRequest doFilter(FilterRequest filterRequest);
}

public class FilterChain {


    private List<Filter> filters;


    public FilterChain() {
        filters = new ArrayList<>();
    }

    public List<Filter> getFilters() {
        return filters;
    }

    public String doFilter(String origin){
        for(Filter filter : filters){
            origin = filter.doFilter(origin);
        }
        return origin;
    }
    // 这里做方法重载，如果是request，则说明存在阻断的情况
    // 如果不是request，则说明不存在
    // 遵循只增不改的原则
    public String doFilter(FilterRequest filterRequest){
        for(Filter filter : filters){
            filterRequest = filter.doFilter(filterRequest);
        }
        return filterRequest.getS();
    }

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

    public FilterChain add(FilterChain filterChain) {
        filters.addAll(filterChain.getFilters());
        return this;
    }
}

public class FilterDemo1 implements Filter {
    @Override
    public String doFilter(String s) {
        return s.replace("abc", "ABC");
    }

    @Override
    public FilterRequest doFilter(FilterRequest filterRequest) {
        if (!filterRequest.isFlag()) {
            //    不符合规范
            return filterRequest;
        }
        if (filterRequest.getS().contains("嘿嘿")){
        //    如果字符串包含 嘿嘿，则视为不合规
        //    此时阻断后续的过滤链
            filterRequest.setFlag(false);
            filterRequest.setS(this.getClass().getName() + "不符合规范");
            return filterRequest;
        }
        // 合规
        String s = doFilter(filterRequest.getS());
        filterRequest.setS(s);
        return filterRequest;
    }
}

public class FilterDemo2 implements Filter{
    @Override
    public String doFilter(String s) {
        return s.replace("哈哈", "haha");
    }

    @Override
    public FilterRequest doFilter(FilterRequest filterRequest) {
        if (!filterRequest.isFlag()) {
            //    不符合规范
            return filterRequest;
        }
        if (filterRequest.getS().contains("嘿嘿")){
            //    如果字符串包含 嘿嘿，则视为不合规
            //    此时阻断后续的过滤链
            filterRequest.setFlag(false);
            filterRequest.setS(this.getClass().getName() + "不符合规范");
            return filterRequest;
        }
        // 合规
        String s = doFilter(filterRequest.getS());
        filterRequest.setS(s);
        return filterRequest;
    }
}

public class FilterDemo3 implements Filter {
    @Override
    public String doFilter(String s) {
        return s.replace("嘿嘿", "heihei");
    }

    @Override
    public FilterRequest doFilter(FilterRequest filterRequest) {
        if (!filterRequest.isFlag()) {
            //    不符合规范
            return filterRequest;
        }
        if (filterRequest.getS().contains("嘿嘿")){
            //    如果字符串包含 嘿嘿，则视为不合规
            //    此时阻断后续的过滤链
            filterRequest.setFlag(false);
            filterRequest.setS(this.getClass().getName() + "不符合规范");
            return filterRequest;
        }
        // 合规
        String s = doFilter(filterRequest.getS());
        filterRequest.setS(s);
        return filterRequest;
    }
}

public class FilterDemo4 implements Filter{
    @Override
    public String doFilter(String s) {
        return s.replace("呼呼", "huhu");
    }

    @Override
    public FilterRequest doFilter(FilterRequest filterRequest) {
        if (!filterRequest.isFlag()) {
            //    不符合规范
            return filterRequest;
        }
        if (filterRequest.getS().contains("嘿嘿")){
            //    如果字符串包含 嘿嘿，则视为不合规
            //    此时阻断后续的过滤链
            filterRequest.setFlag(false);
            filterRequest.setS(this.getClass().getName() + "不符合规范");
            return filterRequest;
        }
        // 合规
        String s = doFilter(filterRequest.getS());
        filterRequest.setS(s);
        return filterRequest;
    }
}

@Data
public class FilterRequest {
    private String s;
    // 代表当前是否符合规范 如果为false，则责任链都不做处理 默认合规
    private boolean flag = true;
}

public class TestChain2 {
    public static void main(String[] args) {
        String origin = "abc哈哈嘿嘿呼呼我是赵礼貌小学生";
        FilterRequest filterRequest = new FilterRequest();
        filterRequest.setS(origin);
        //    不设置flag，默认为true
        FilterChain filterChain = new FilterChain();
        filterChain.add(new FilterDemo1())
                .add(new FilterDemo2())
                .add(new FilterDemo3())
                .add(new FilterDemo4());
        String s = filterChain.doFilter(filterRequest);
        System.out.println(s);
        //    结果：
        //    chainpattern.FilterDemo1不符合规范
    }
}