简单实现个责任链

1.GlobalFilter 接口：定义了过滤器的方法 getOrder() 和 filter(Request request)

public interface GlobalFilter {
    int getOrder();
    void filter(Request request);
}

2.AbstractNextFilter 抽象类：实现了获取下一个过滤器的方法 getNextFilter()，并且提供了一个匿名抽象类实现了抽象方法 filter(Request request)，在该方法中通过责任链的方式依次调用下一个过滤器进行处理

public abstract class AbstractNextFilter implements GlobalFilter {

    public GlobalFilter getNextFilter(List<GlobalFilter> globalFilters) {
        // 获取过滤器执行链的最小order，如果相同则排除本过滤器
        Optional<GlobalFilter> nextFilter = globalFilters.stream()
                .filter(filter -> filter.getOrder() >= this.getOrder() && filter.getClass() != this.getClass())
                .min(Comparator.comparing(GlobalFilter::getOrder));
        return nextFilter.orElse(null);
    }
}

3.Handler 接口：定义了处理请求的方法 handleRequest(Request request)

public interface Handler {
    void handleRequest(Request request);
}

4.HandlerImpl 类：实现了 Handler 接口，在 handleRequest(Request request) 方法中创建一个匿名抽象类的过滤器实例，并开始责任链的传递处理

public class HandlerImpl implements Handler {
    private final List<GlobalFilter> globalFilters;

    public HandlerImpl(Request request) {
        this.globalFilters = request.getGlobalFilters();
    }

    @Override
    public void handleRequest(Request request) {
        if (request.getGlobalFilters() != null) {
            GlobalFilter filter = new AbstractNextFilter() {
                @Override
                public int getOrder() {
                    return Integer.MIN_VALUE;
                }

                @Override
                public void filter(Request request) {
                    GlobalFilter nextFilter = getNextFilter(request.getGlobalFilters());
                    System.out.println("匿名抽象类，开始传递");
                    nextFilter.filter(request);
                }
            };
            filter.filter(request);
        }
        System.out.println("处理请求数据：" + request.getContent());
    }
}

5.OneFilter 和 TwoFilter 类：具体的过滤器实现类，分别实现了自己的过滤逻辑，并根据条件判断是否继续传递给下一个过滤器

public class OneFilter extends AbstractNextFilter {

    @Override
    public int getOrder() {
        return 1;
    }

    @Override
    public void filter(Request request) {
        GlobalFilter nextFilter = getNextFilter(request.getGlobalFilters());
        if ("不过滤OneFilter".equals(request.getContent())) {
            if (nextFilter != null) {
                // 直接放行
                nextFilter.filter(request);
            }
        } else {
            System.out.println("OneFilter 过滤器执行了");
            if (nextFilter != null) {
                nextFilter.filter(request);
            }
        }
    }
}


public class TwoFilter extends AbstractNextFilter {
    @Override
    public int getOrder() {
        return 2;
    }

    @Override
    public void filter(Request request) {
        GlobalFilter nextFilter = super.getNextFilter(request.getGlobalFilters());
        if ("不过滤TwoFilter".equals(request.getContent())) {
            if (nextFilter != null) {
                // 直接放行
                nextFilter.filter(request);
            }
        } else {
            System.out.println("TwoFilter 过滤器执行了");
            if (nextFilter != null) {
                nextFilter.filter(request);
            }
        }
    }
}

6.Request 类：封装了请求对象，包括全局过滤器列表和请求内容

public class Request {
    private List<GlobalFilter> globalFilters;
    private String content;

    public Request(List<GlobalFilter> globalFilters, String content) {
        this.globalFilters = globalFilters;
        this.content = content;
    }

    public List<GlobalFilter> getGlobalFilters() {
        return globalFilters;
    }

    public void setGlobalFilters(List<GlobalFilter> globalFilters) {
        this.globalFilters = globalFilters;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

7.测试类：当请求的数据content为不过滤OneFilter会放行到下个过滤器执行

public class TestResChain {

    public static void main(String[] args) {
        List<GlobalFilter> filterList = new ArrayList<>();
        filterList.add(new OneFilter());
        filterList.add(new TwoFilter());

        Request request = new Request(filterList, "不过滤OneFilter");
//        Request request = new Request(filterList, "不过滤TwoFilter");
//        Request request = new Request(filterList, "都过滤拦截");
        Handler handler = new HandlerImpl(request);
        handler.handleRequest(request);
    }
}