1
// ApplicationFilterChain.java: 行74-87
2
// 核心字段就这4个
3
private ApplicationFilterConfig[] filters = new ApplicationFilterConfig[0];  // Filter数组
4
private int pos = 0;        // 当前位置游标
5
private int n = 0;          // 有效Filter数量
6
private Servlet servlet;    // 链条终点

1
// StandardContext.java: 行378
2
private Map<String, ApplicationFilterConfig> filterConfigs = new HashMap<>();
3
// name -> config映射
4

5
// StandardContext.java: 行4455
6
private FilterMap[] array = new FilterMap[0];
7
// Filter映射规则数组

1
// StandardContext.java: 第4557-4567行
2
public boolean filterStart() {
3
    synchronized (filterConfigs) {
4
        filterConfigs.clear();
5
        for (Entry<String, FilterDef> entry : filterDefs.entrySet()) {
6
            String name = entry.getKey();
7
            // 创建Filter实例并缓存
8
            ApplicationFilterConfig config =
9
                new ApplicationFilterConfig(this, entry.getValue());
10
            filterConfigs.put(name, config);  // 存到Map
11
        }
12
    }
13
    return true;
14
}

1
// StandardWrapperValve.java: 第172-174行
2
ApplicationFilterChain filterChain =
3
    ApplicationFilterFactory.createFilterChain(request, wrapper, servlet);

1
// ApplicationFilterFactory.java: 第53-136行
2
public static ApplicationFilterChain createFilterChain(
3
        ServletRequest request, Wrapper wrapper, Servlet servlet) {
4

5
    // 1. 创建FilterChain对象
6
    ApplicationFilterChain chain = new ApplicationFilterChain();
7
    chain.setServlet(servlet);  // 设置终点
8

9
    // 2. 从Context获取所有FilterMap
10
    StandardContext context = (StandardContext) wrapper.getParent();
11
    FilterMap filterMaps[] = context.findFilterMaps();  // 行84
12

13
    // 3. 遍历FilterMap,匹配URL pattern
14
    for (FilterMap filterMap : filterMaps) {
15
        // 3.1 匹配Dispatcher类型(REQUEST/FORWARD/INCLUDE/ERROR/ASYNC)
19 collapsed lines
16
        if (!matchDispatcher(filterMap, dispatcher))
17
            continue;
18

19
        // 3.2 匹配URL pattern(如 /api/*)
20
        if (!matchFiltersURL(filterMap, requestPath))
21
            continue;
22

23
        // 3.3 根据Filter名称从Map里查找实例
24
        ApplicationFilterConfig config = (ApplicationFilterConfig)
25
            context.findFilterConfig(filterMap.getFilterName());  // 行109-110
26

27
        // 3.4 添加到FilterChain
28
        if (config != null) {
29
            chain.addFilter(config);  // 行115 - 关键!!
30
        }
31
    }
32

33
    return chain;
34
}

1
// ApplicationFilterChain.java: 第273-288行
2
void addFilter(ApplicationFilterConfig filterConfig) {
3
    // 防止重复添加
4
    for (ApplicationFilterConfig filter : filters)
5
        if (filter == filterConfig)
6
            return;
7

8
    // 数组满了就扩容(每次+10)
9
    if (n == filters.length) {
10
        ApplicationFilterConfig[] newFilters =
11
            new ApplicationFilterConfig[n + INCREMENT];  // INCREMENT=10
12
        System.arraycopy(filters, 0, newFilters, 0, n);
13
        filters = newFilters;
14
    }
15

2 collapsed lines
16
    filters[n++] = filterConfig;  // 加到尾部
17
}

1
// ApplicationFilterChain.java: 第166-241行
2
private void internalDoFilter(ServletRequest request, ServletResponse response)
3
    throws IOException, ServletException {
4

5
    // 还有Filter没执行?
6
    if (pos < n) {
7
        ApplicationFilterConfig filterConfig = filters[pos++];  // 取当前并后移
8
        Filter filter = filterConfig.getFilter();
9

10
        // 【关键】把this(FilterChain自己)传给Filter
11
        filter.doFilter(request, response, this);
12
        return;
13
    }
14

15
    // 没Filter了?直接执行Servlet
2 collapsed lines
16
    servlet.service(request, response);
17
}

1
// ❌ 糟糕的递归设计(很多教科书这么写)
2
public void doFilter(Request req, Response res) {
3
    if (currentFilter != null) {
4
        currentFilter.doFilter(req, res, this);
5
        currentFilter = nextFilter;  // 需要维护next指针
6
        doFilter(req, res);           // 递归调用
7
    } else {
8
        servlet.service(req, res);   // 特殊情况处理!
9
    }
10
}

1
// ❌ 传统递归（每次调用都是独立栈帧）
2
void recursiveSum(int n) {
3
    if (n <= 0) return 0;
4
    return n + recursiveSum(n - 1);  // 方法调用自己
5
}
6

7
// ✅ Tomcat 的回调机制（不同方法互相调用）
8
// FilterChain.internalDoFilter()
9
filter.doFilter(request, response, this);
10
    ↓
11
// Filter.doFilter()
12
chain.doFilter(request, response);
13
    ↓
14
// FilterChain.internalDoFilter() ← 回到这里，但 pos 已经改变

1
调用栈（从下往上看）:
2

3
第1次进入 internalDoFilter()  pos=0, n=3
4
    ├─ filters[0] = AuthFilter
5
    └─ AuthFilter.doFilter(req, res, chain)  ← 进入 Filter
6
        ├─ 前置: 校验token
7
        └─ chain.doFilter(req, res)  ← Filter 调用 chain
8
            ↓
9
第2次进入 internalDoFilter()  pos=1, n=3  ← 注意: pos 已经是 1 了!
10
    ├─ filters[1] = LogFilter
11
    └─ LogFilter.doFilter(req, res, chain)
12
        ├─ 前置: 记录时间
13
        └─ chain.doFilter(req, res)
14
            ↓
15
第3次进入 internalDoFilter()  pos=2, n=3
16 collapsed lines
16
    ├─ filters[2] = CorsFilter
17
    └─ CorsFilter.doFilter(req, res, chain)
18
        ├─ 前置: 设置 CORS 头
19
        └─ chain.doFilter(req, res)
20
            ↓
21
第4次进入 internalDoFilter()  pos=3, n=3  ← pos >= n 了
22
    └─ servlet.service(req, res)  ← 执行 Servlet
23
        ↓
24
        返回 CorsFilter
25
        └─ 后置: 记录响应头
26
        ↓
27
        返回 LogFilter
28
        └─ 后置: 计算耗时
29
        ↓
30
        返回 AuthFilter
31
        └─ 后置: 记录日志

1
// Filter.doFilter() - "我要处理并决定要不要传下去"
2
void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
3

4
// FilterChain.doFilter() - "传给下一个家伙"
5
void doFilter(ServletRequest request, ServletResponse response)

1
// Filter 可以决定：要不要调用 chain.doFilter()
2

3
// 情况1: 中断链条
4
if (!isAuthenticated(request)) {
5
    response.sendError(401);
6
    return;  // 不调用 chain.doFilter(),后续 Filter 和 Servlet 都不执行
7
}
8

9
// 情况2: 继续传递
10
chain.doFilter(request, response);  // 调用它,传给下一个

1
// Filter 可以决定：传什么给下一个
2

3
// 传原始对象
4
chain.doFilter(request, response);
5

6
// 传包装后的对象（装饰器模式）
7
ResponseWrapper wrapped = new ResponseWrapper(response, encoding);
8
chain.doFilter(request, wrapped);  // 下一个 Filter 看到的是 wrapped!

1
// FilterChain.doFilter() 不需要 chain 参数
2
// 因为它自己就知道下一个是谁(内部有 filters[] 和 pos)
3

4
chain.doFilter(request, response);  // FilterChain 内部会找到 filters[pos++]

1
public class ApplicationFilterChain {
2
    private Filter[] filters;
3
    private int pos = 0;  // 实例字段，整个请求期间共享
4
    private int n = 0;
5
    private Servlet servlet;
6

7
    public void doFilter(ServletRequest req, ServletResponse res) {
8
        internalDoFilter(req, res);
9
    }
10

11
    private void internalDoFilter(ServletRequest req, ServletResponse res) {
12
        System.out.println("进入 internalDoFilter(), pos=" + pos + ", n=" + n);
13

14
        if (pos < n) {
15
            Filter filter = filters[pos++];  // 关键: pos 立即递增!
25 collapsed lines
16
            System.out.println("调用 Filter: " + filter.getClass().getSimpleName() + ", pos 现在=" + pos);
17

18
            filter.doFilter(req, res, this);  // 把 this 传进去
19
            // 注意: 这里会阻塞，等待 filter.doFilter() 返回
20

21
            System.out.println("Filter 返回: " + filter.getClass().getSimpleName());
22
            return;
23
        }
24

25
        System.out.println("所有 Filter 执行完毕, 调用 Servlet");
26
        servlet.service(req, res);
27
    }
28
}
29

30
// Filter 实现
31
public class LogFilter implements Filter {
32
    public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) {
33
        System.out.println("[LogFilter] 前置处理");
34

35
        chain.doFilter(req, res);  // 调用 chain（同一个对象）
36
        // 这里会阻塞，等待下一个 Filter 返回
37

38
        System.out.println("[LogFilter] 后置处理");
39
    }
40
}

1
进入 internalDoFilter(), pos=0, n=3
2
调用 Filter: AuthFilter, pos 现在=1
3
[AuthFilter] 前置处理
4
    进入 internalDoFilter(), pos=1, n=3  ← pos 已经是 1 了!
5
    调用 Filter: LogFilter, pos 现在=2
6
    [LogFilter] 前置处理
7
        进入 internalDoFilter(), pos=2, n=3
8
        调用 Filter: CorsFilter, pos 现在=3
9
        [CorsFilter] 前置处理
10
            进入 internalDoFilter(), pos=3, n=3  ← pos >= n 了
11
            所有 Filter 执行完毕, 调用 Servlet
12
            [Servlet] 处理请求
13
        [CorsFilter] 后置处理
14
        Filter 返回: CorsFilter
15
    [LogFilter] 后置处理
3 collapsed lines
16
    Filter 返回: LogFilter
17
[AuthFilter] 后置处理
18
Filter 返回: AuthFilter

1
// 糟糕的设计
2
public void doFilter(ServletRequest request, ServletResponse response) {
3
    for (int i = 0; i < n; i++) {
4
        Filter filter = filters[i].getFilter();
5
        filter.doFilter(request, response);  // 没有 chain 参数!
6
    }
7
    servlet.service(request, response);
8
}

1
// Filter 需要在调用下一个之前和之后都做处理
2
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
3
    // 【前置处理】- 面包片1
4
    long start = System.currentTimeMillis();
5
    logRequestStart(request);
6

7
    // 【调用下一个】- 夹心
8
    chain.doFilter(request, response);  // 这里会阻塞，等待下一个返回
9

10
    // 【后置处理】- 面包片2
11
    long duration = System.currentTimeMillis() - start;
12
    logRequestEnd(request, duration);
13
}

1
// ❌ for循环版本
2
for (int i = 0; i < n; i++) {
3
    Filter filter = filters[i].getFilter();
4

5
    // 前置处理
6
    filter.beforeProcess(request, response);
7

8
    // ??? 怎么在"所有后续Filter和Servlet执行完"之后做后置处理？
9
    // for循环一旦进入下一次迭代，就回不到这里了！
10

11
    // 后置处理 - 做不到!
12
    filter.afterProcess(request, response);  // 这会在下一个Filter之前执行，不是之后!
13
}

1
// 认证 Filter
2
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
3
    if (!isAuthenticated(request)) {
4
        response.sendError(401);
5
        return;  // 不调用 chain.doFilter()，链条中断
6
    }
7

8
    chain.doFilter(request, response);  // 认证通过，继续
9
}

1
// ❌ for循环版本
2
for (int i = 0; i < n; i++) {
3
    Filter filter = filters[i].getFilter();
4
    filter.doFilter(request, response);
5

6
    // ??? Filter 怎么告诉 for 循环"别继续了"？
7
    // 抛异常？太丑了，而且会破坏正常的错误处理
8
    // 返回 boolean？需要修改 Filter 接口，破坏向后兼容
9
}

1
// 字符编码 Filter
2
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
3
    // 包装 response，自动添加 charset
4
    ResponseWrapper wrapped = new ResponseWrapper(response, "UTF-8");
5

6
    // 传包装后的对象给下一个 Filter
7
    chain.doFilter(request, wrapped);  // 下一个 Filter 看到的是 wrapped
8
}

1
// ❌ for循环版本
2
ServletRequest currentRequest = request;
3
ServletResponse currentResponse = response;
4

5
for (int i = 0; i < n; i++) {
6
    Filter filter = filters[i].getFilter();
7

8
    // ??? Filter 怎么修改 currentRequest/currentResponse？
9
    // Filter 没有返回值，无法返回包装后的对象
10
    // 只能在 Filter 内部修改对象的状态，但这可能被后续代码覆盖
11

12
    filter.doFilter(currentRequest, currentResponse);
13
}

1
// ✅ Tomcat 的回调机制
2
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
3
    // 前置处理
4
    long start = System.currentTimeMillis();
5

6
    // 可以中断链条
7
    if (!isValid(request)) {
8
        response.sendError(400);
9
        return;  // 不调用 chain.doFilter()
10
    }
11

12
    // 可以包装对象
13
    ResponseWrapper wrapped = new ResponseWrapper(response, "UTF-8");
14

15
    // 调用下一个（会阻塞等待）
6 collapsed lines
16
    chain.doFilter(request, wrapped);
17

18
    // 后置处理 - 完美支持!
19
    long duration = System.currentTimeMillis() - start;
20
    log("Request took " + duration + "ms");
21
}

1
// 1. 创建 FilterChain 对象
2
ApplicationFilterChain chain = new ApplicationFilterChain();
3
chain.pos = 0;  // 初始值
4
chain.n = 0;
5
chain.filters = new Filter[0];
6

7
// 2. 添加 Filter
8
chain.addFilter(authFilter);   // n=1
9
chain.addFilter(logFilter);    // n=2
10
chain.addFilter(corsFilter);   // n=3
11

12
// 3. 开始执行
13
chain.doFilter(request, response);
14
    ↓
15
internalDoFilter() {
7 collapsed lines
16
    if (pos < n) {  // 0 < 3
17
        Filter filter = filters[pos++];  // pos=0 → pos=1
18
        filter.doFilter(req, res, this);  // 把 this 传进去
19

20
        // 注意: 这里的 this.pos 已经是 1 了!
21
    }
22
}

1
// Filter 内部
2
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) {
3
    // chain 是什么？是 ApplicationFilterChain 对象的引用
4
    // 它的 pos 字段是多少？是 1（上一次 pos++ 的结果）
5

6
    chain.doFilter(req, res);  // 调用同一个对象的 doFilter()
7

8
    // chain.doFilter() 内部再次调用 internalDoFilter()
9
    // 此时 this.pos 是 1，所以取 filters[1]
10
}

1
内存布局:
2

3
[ApplicationFilterChain对象]
4
    ├─ filters[] = [AuthFilter, LogFilter, CorsFilter]
5
    ├─ pos = 0  ← 初始状态
6
    └─ n = 3
7

8
第1次调用 internalDoFilter():
9
    ├─ pos < n?  0 < 3  ✅
10
    ├─ filter = filters[0]  → AuthFilter
11
    ├─ pos++ → pos = 1  ← pos 被修改了!
12
    └─ AuthFilter.doFilter(req, res, this)  ← this 指向同一个对象
13
        ↓
14
        AuthFilter 内部:
15
        ├─ chain 引用的是同一个 ApplicationFilterChain 对象
9 collapsed lines
16
        ├─ chain.pos 是多少？是 1!（不是 0）
17
        └─ chain.doFilter(req, res)  ← 调用它
18
            ↓
19
第2次调用 internalDoFilter():
20
    ├─ pos < n?  1 < 3  ✅
21
    ├─ filter = filters[1]  → LogFilter
22
    ├─ pos++ → pos = 2  ← 继续递增
23
    └─ LogFilter.doFilter(req, res, this)
24
        ...

1
// ❌ 假设 pos 会重置
2
private void internalDoFilter(ServletRequest req, ServletResponse res) {
3
    int pos = 0;  // 假设 pos 是局部变量
4

5
    if (pos < n) {
6
        Filter filter = filters[pos++];
7
        filter.doFilter(req, res, this);
8
        return;
9
    }
10
    servlet.service(req, res);
11
}
12

13
// 结果：
14
// 第1次调用: pos=0, 执行 filters[0]
15
// 第2次调用: pos=0, 又执行 filters[0]  ← 死循环!
2 collapsed lines
16
// 第3次调用: pos=0, 还是 filters[0]
17
// ...永远执行第一个 Filter

1
Filter filter = filters[pos++];  // 后置递增

1
// 使用 pos++ (后置递增)
2
Filter filter = filters[pos++];
3
// 等价于:
4
// Filter filter = filters[pos];
5
// pos = pos + 1;
6

7
// 第1次: 取 filters[0], 然后 pos 变成 1
8
// 第2次: 取 filters[1], 然后 pos 变成 2
9
// 第3次: 取 filters[2], 然后 pos 变成 3
10
// 第4次: pos=3 >= n=3, 执行 servlet

1
// 如果用 ++pos (前置递增)
2
Filter filter = filters[++pos];
3
// 等价于:
4
// pos = pos + 1;
5
// Filter filter = filters[pos];
6

7
// 第1次: pos 先变成 1, 取 filters[1]  ← 跳过了 filters[0]!
8
// 第2次: pos 先变成 2, 取 filters[2]
9
// 第3次: pos 先变成 3, 取 filters[3]  ← 数组越界!

1
FilterChain 对象（内存中只有一个）:
2
┌─────────────────────────────────┐
3
│ filters[] = [F1, F2, F3]        │
4
│ pos = 0 → 1 → 2 → 3             │  ← pos 不断递增，永不重置
5
│ n = 3                           │
6
└─────────────────────────────────┘
7
        ↓ this
8
第1次 internalDoFilter()  pos=0
9
        ↓ this
10
F1.doFilter(req, res, this)
11
        ↓ chain (就是 this)
12
第2次 internalDoFilter()  pos=1  ← 同一个对象，pos 已经变了
13
        ↓ this
14
F2.doFilter(req, res, this)
15
        ↓ chain (还是同一个 this)
7 collapsed lines
16
第3次 internalDoFilter()  pos=2
17
        ↓ this
18
F3.doFilter(req, res, this)
19
        ↓ chain
20
第4次 internalDoFilter()  pos=3 >= n
21
        ↓
22
servlet.service()

1
public void doFilter(ServletRequest request, ServletResponse response,
2
        FilterChain chain) throws IOException, ServletException {
3

4
    // 创建一个包装对象
5
    if (response instanceof HttpServletResponse) {
6
        ResponseWrapper wrapped =
7
            new ResponseWrapper((HttpServletResponse)response, encoding);
8

9
        // 把包装对象传给下一个 Filter
10
        chain.doFilter(request, wrapped);
11
    } else {
12
        chain.doFilter(request, response);
13
    }
14
}

1
// 简化版
2
class ResponseWrapper extends HttpServletResponseWrapper {
3
    private String encoding;
4

5
    public ResponseWrapper(HttpServletResponse response, String encoding) {
6
        super(response);  // 装饰器模式：包装原始 response
7
        this.encoding = encoding;
8
    }
9

10
    @Override
11
    public void setContentType(String type) {
12
        // 拦截 setContentType 调用,自动加上 charset
13
        if (type != null && !type.contains("charset")) {
14
            type = type + ";charset=" + encoding;
15
        }
3 collapsed lines
16
        super.setContentType(type);
17
    }
18
}

1
HTTP请求到达
2
    ↓
3
FilterChain.doFilter(originalRequest, originalResponse)
4
    ↓
5
internalDoFilter() → pos=0, filters[0] = AddDefaultCharsetFilter
6
    ↓
7
AddDefaultCharsetFilter.doFilter(originalRequest, originalResponse, chain)
8
    ├─ ResponseWrapper wrapped = new ResponseWrapper(originalResponse, "UTF-8")
9
    └─ chain.doFilter(originalRequest, wrapped)  ← 注意：传的是 wrapped!
10
        ↓
11
internalDoFilter() → pos=1, filters[1] = 下一个Filter
12
    ↓
13
下一个Filter.doFilter(originalRequest, wrapped, chain)  ← 它收到的是 wrapped!
14
    ├─ wrapped.setContentType("text/html")  ← 调用的是包装类的方法
15
    │   └─ 内部自动改成 "text/html;charset=UTF-8"
7 collapsed lines
16
    └─ chain.doFilter(originalRequest, wrapped)
17
        ↓
18
internalDoFilter() → pos >= n
19
    ↓
20
servlet.service(originalRequest, wrapped)  ← Servlet 收到的也是 wrapped!
21
    └─ wrapped.setContentType("application/json")
22
        └─ 自动改成 "application/json;charset=UTF-8"

1
用户请求: GET /api/users
2
    ↓
3
StandardWrapperValve.invoke()  ← Tomcat入口
4
    ↓
5
ApplicationFilterFactory.createFilterChain()  ← 创建链条
6
    ├─ context.findFilterMaps()  → [FilterMap1(/api/*), FilterMap2(/*), ...]
7
    ├─ matchFiltersURL("/api/users", "/api/*")  → true
8
    ├─ context.findFilterConfig("AuthFilter")  → AuthFilterConfig实例
9
    ├─ chain.addFilter(AuthFilterConfig)  → filters[0] = AuthFilterConfig
10
    ├─ matchFiltersURL("/api/users", "/*")  → true
11
    ├─ context.findFilterConfig("LogFilter")  → LogFilterConfig实例
12
    └─ chain.addFilter(LogFilterConfig)  → filters[1] = LogFilterConfig
13
    ↓
14
filterChain.doFilter(request, response)  ← 开始执行
15
    ↓
17 collapsed lines
16
internalDoFilter()  ← pos=0, n=2
17
    ├─ filters[0].getFilter()  → AuthFilter
18
    ├─ AuthFilter.doFilter(req, res, chain)
19
    │   ├─ 前置处理: 校验token
20
    │   ├─ chain.doFilter(req, res)  → 递归回到 internalDoFilter()
21
    │   └─ 后置处理: 记录日志
22
    ↓
23
internalDoFilter()  ← pos=1, n=2
24
    ├─ filters[1].getFilter()  → LogFilter
25
    ├─ LogFilter.doFilter(req, res, chain)
26
    │   ├─ 前置处理: 记录请求时间
27
    │   ├─ chain.doFilter(req, res)  → 递归回到 internalDoFilter()
28
    │   └─ 后置处理: 计算响应时间
29
    ↓
30
internalDoFilter()  ← pos=2, n=2
31
    ├─ pos >= n 了!
32
    └─ servlet.service(req, res)  → 执行真正的业务逻辑

1
"Filter API 是个好例子。它解决了真实问题(请求处理流水线),
2
没有引入不必要的复杂度,并且把特殊情况隐藏在了数据结构里。
3

4
如果你在设计责任链,就照着这个抄。别tm自己发明轮子,
5
搞什么 if (hasNext()) 之类的垃圾。
6

7
这代码20年没大改过(自Tomcat 5.x至今),因为第一次就设计对了。
8
这就是'好品味' - 不需要不断打补丁,不需要重构,
9
因为核心设计从一开始就是简洁优雅的。"

1
"因为你个白痴，for 循环只能做'流水线'处理，
2
不能做'三明治'处理！
3

4
Filter 需要在调用下一个之前做前置处理，
5
在下一个返回后做后置处理。
6

7
for 循环做不到这个 - 它一旦进入下一次迭代，
8
就回不到上一次了。
9

10
Tomcat 的设计用了回调机制 - 每个 Filter 都在
11
等待下一个返回，所以可以完美支持前置+后置处理。
12

13
这不是递归，这是嵌套回调。如果你觉得'复杂'，
14
那是因为你没理解调用栈的工作原理。"

1
"因为 pos 是对象的状态，不是函数的局部变量！
2

3
每次调用 internalDoFilter()，操作的都是同一个
4
FilterChain 对象。pos 是这个对象的字段，
5
当然会保留上一次的修改。
6

7
如果你希望 pos 重置为 0，那就是在说
8
'我希望每次都从第一个 Filter 开始执行'，
9
这tm不是死循环吗？
10

11
pos 的生命周期是整个请求 - 从创建 FilterChain
12
到 Servlet 返回。它是用来记录'当前执行到哪了'的，
13
当然不能重置。"

1
"包装 request/response 是个聪明的设计。
2

3
它让 Filter 可以在不修改原始对象的情况下，
4
增强它的行为。后续的 Filter 和 Servlet 完全
5
不知道自己用的是包装对象，这就是好的抽象。
6

7
这是装饰器模式的正确用法 - 透明、无侵入、
8
可叠加。不像某些框架，搞一堆 Interceptor、
9
Aspect、Proxy，最后连自己都搞不清楚调用链。"

1
基础路径: D:\java\apache-maven-3.6.3\repo\org\apache\tomcat\embed\
2
          tomcat-embed-core\9.0.46\tomcat-sources\org\apache\catalina\core\

1
Filter[]  +  游标pos  +  长度n  =  责任链的全部状态

1
while (pos < n) {
2
    filters[pos++].doFilter(request, response, this);  // 递归回调
3
}
4
servlet.service(request, response);  // 链条终点

1
public interface Filter {
2
    // 初始化方法(Servlet 3.0后变为default方法)
3
    default void init(FilterConfig filterConfig) throws ServletException {}
4

5
    // 核心方法 - 处理请求
6
    void doFilter(ServletRequest request, ServletResponse response,
7
                  FilterChain chain) throws IOException, ServletException;
8

9
    // 销毁方法(Servlet 3.0后变为default方法)
10
    default void destroy() {}
11
}

1
public interface FilterChain {
2
    // 传递给下一个Filter或Servlet
3
    void doFilter(ServletRequest request, ServletResponse response)
4
        throws IOException, ServletException;
5
}

1
public class AuthenticationFilter implements Filter {
2
    @Override
3
    public void doFilter(ServletRequest request, ServletResponse response,
4
                         FilterChain chain) throws IOException, ServletException {
5
        // 前置处理
6
        if (!isAuthenticated(request)) {
7
            response.sendError(401);
8
            return;  // 中断链条
9
        }
10

11
        // 传递给下一个 Filter (或最终的 Servlet)
12
        chain.doFilter(request, response);
13

14
        // 后置处理
15
        logRequest(request);
2 collapsed lines
16
    }
17
}