过滤器链：实际上就是一个责任链模式的变种实现。

基本原理：
Invoker#invoke(Request) => invoke()内部调用 Filter#filter(Request, Invoker nextInvoker) => nextInvoker#invoke(Request) => ... => lastInvoker#invoke(Request)

image.png 三个基本组件：

• Invoker - 调用器接口，有两种实现类：第一种是最终的调用终结者 lastInvoker；第二种是会调用 Filter 过滤器方法的调用器。（在 SOFARPC 中，为这两种设置了不同的类 ProviderInvoker 和 FilterInvoker，具体见：SOFARPC 源码分析5 - 服务端调用链的设计与实现；而 Dubbo 的实现是使用内部类，个人感觉更为精炼，本文实现的时候参考 Dubbo 过滤器链的实现方式）
• Filter - 过滤器接口，其实现类会调用 nextInvoker 或者尾部的 lastInvoker。
• FilterChain - 过滤器链构造器：主要有两个功能，一是根据各种条件（例如 provider 端还是 consumer 端、哪些过滤器不能加载，那些可以加载等）以及各种机制（SPI机制、自动激活点机制）加载 Filter；二是根据这些 Filter 构造 Invoker 链。

代码地址：https://github.com/zhaojigang/core-filterchain

一、Invoker

/**
 * 调用器接口
 */
public interface Invoker {
    Response invoke(Request request);
}

二、Filter

/**
 * 过滤器
 */
public interface Filter {
    /**
     * 是否需要加载该 filter
     */
    boolean needToLoad();
    /**
     * 过滤
     */
    Response filter(Request request, Invoker nextInvoker);
}

三、FilterChain

/**
 * 过滤器链构造器
 */
public class FilterChain {
    public Invoker buildFilterChain(Invoker lastInvoker) {
        Invoker invokerChainHeader = lastInvoker;
        // 1. 查询出所有的过滤器
        List<Filter> filterList = selectFilterList();
        if (filterList != null && filterList.size() > 0) {
            for (int i = filterList.size() - 1; i >= 0; i--) {
                Filter filter = filterList.get(i);
                Invoker nextInvoker = invokerChainHeader;
                invokerChainHeader = request -> filter.filter(request, nextInvoker);
            }
        }
        return invokerChainHeader;
    }

    /**
     * 实际使用中，可以根据SPI机制与自动激活点机制等去获取filter链
     */
    private List<Filter> selectFilterList() {
        List<Filter> filterList = new ArrayList<>();
        ConcreteFilter1 filter1 = new ConcreteFilter1();
        ConcreteFilter2 filter2 = new ConcreteFilter2();
        if (filter1.needToLoad()) {
            filterList.add(filter1);
        }
        if (filter2.needToLoad()) {
            filterList.add(filter2);
        }
        return filterList;
    }
}

在 SOFARPC 中，还实现了：异步调用当响应返回后的过滤器处理。

• SOFARPC 源码分析5 - 服务端调用链的设计与实现

文中还有两个 RPC 框架都会有的 Request 和 Response 统一封装类（这里只做简写）。

======================= Request =====================
public class Request {
    /**
     * 请求消息
     */
    private String req;

    public Request(String req) {
        this.req = req;
    }

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

======================= Response =====================
public class Response {
    /**
     * 响应消息
     */
    private String resp;

    public Response(String resp) {
        this.resp = resp;
    }

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

四、测试

具体过滤器

======================= ConcreteFilter1 =====================
public class ConcreteFilter1 implements Filter {
    @Override
    public boolean needToLoad() {
        return true;
    }

    @Override
    public Response filter(Request request, Invoker nextInvoker) {
        System.out.println("filter1 - before " + request);
        Response response = nextInvoker.invoke(request);
        System.out.println("filter1 - after " + request);
        return response;
    }
}

======================= ConcreteFilter2 =====================
public class ConcreteFilter2 implements Filter {
    @Override
    public boolean needToLoad() {
        return true;
    }

    @Override
    public Response filter(Request request, Invoker nextInvoker) {
        System.out.println("filter2 - before " + request);
        Response response = nextInvoker.invoke(request);
        System.out.println("filter2 - after " + request);
        return response;
    }
}

过滤器链测试

public class Main {
    public static void main(String[] args) {
        FilterChain filterChain = new FilterChain();
        Invoker invoker = filterChain.buildFilterChain(request -> {
            Response resp = new Response("lastInvoker msg");
            System.out.println("trueInvoker - " + resp);
            return resp;
        });
        Response response = invoker.invoke(new Request("req msg"));
        System.out.println(response);
    }
}

输出结果如下：

filter1 - before req msg
filter2 - before req msg
trueInvoker - lastInvoker msg
filter2 - after req msg
filter1 - after req msg
lastInvoker msg