过滤器链：实际上就是一个责任链模式的变种实现。
基本原理：
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 链。
一、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 中，还实现了：异步调用当响应返回后的过滤器处理。
文中还有两个 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
