罗罗编程学习记录
本页内容 展开查看

01.3.2.10 责任链与模板方法

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 责任链的结构、纯链与不纯链、中断与放行
  • Filter / Interceptor / Middleware 三种叫法在不同框架里的真实层级
  • Servlet Filter、Spring Interceptor、Gin、Express、ASP.NET Core 管道
  • 注册顺序与洋葱模型、短路与递归深度
  • 责任链与装饰器的关键区别
  • 模板方法的固定骨架、钩子方法、好莱坞原则
  • JdbcTemplate、Spring 容器刷新、Abstract 基类中的模板形态
  • Go 无继承时如何用接口 + 函数字段实现模板方法
  • TypeScript abstract 类、Rust trait 默认方法
  • 模板方法与策略模式的取舍

面试题索引

编号 题目 难度 状态 备注
01.3.2.10-001 责任链的结构与中断条件是什么?纯链和不纯链差别在哪? 基础 已完成 角色与变体
01.3.2.10-002 Filter、Interceptor、Middleware 三种叫法实际差别在哪? 进阶 已完成 框架层级
01.3.2.10-003 Servlet Filter 与 Spring Interceptor 分别工作在哪一层? 进阶 已完成 执行时机
01.3.2.10-004 Gin 与 Express 的中间件是怎么组织请求的? 进阶 已完成 函数式中间件
01.3.2.10-005 ASP.NET Core middleware 的真实形态是什么?Use / Run / Map 怎么区分? 进阶 已完成 管道构造
01.3.2.10-006 注册顺序为什么等于执行顺序?洋葱模型是什么? 进阶 已完成 顺序与逆序
01.3.2.10-007 短路与放行在代码层是怎么表达的? 进阶 已完成 doFilter / next / return
01.3.2.10-008 责任链与装饰器的关键区别是什么? 进阶 已完成 是否所有节点都执行
01.3.2.10-009 责任链的递归深度与性能要注意什么? 进阶 已完成 栈与对象开销
01.3.2.10-010 模板方法如何固定骨架?钩子方法和抽象步骤怎么分? 基础 已完成 继承式复用
01.3.2.10-011 模板方法在框架中的真实形态有哪些? 进阶 已完成 JdbcTemplate / 容器刷新
01.3.2.10-012 Go 没有继承,怎么实现模板方法? 进阶 已完成 接口 + 函数字段
01.3.2.10-013 TypeScript abstract 与 Rust trait 默认方法怎么写模板方法? 进阶 已完成 抽象成员与默认实现
01.3.2.10-014 模板方法与策略怎么取舍?什么是好莱坞原则? 进阶 已完成 继承 vs 组合

01.3.2.10-001 责任链的结构与中断条件是什么?纯链和不纯链差别在哪?

一句话结论

责任链把请求沿一组处理器依次传递,每个处理器要么处理并放行到下一个,要么直接中断返回;「纯链」要求每个节点要么自己处理、要么转发,不做半截处理,「不纯链」允许节点做完自己的事再继续往下走,Web 框架里的中间件几乎都是不纯链。

概念解释

  • 三个角色:抽象处理器(handle + next)、具体处理器、链的编排者(持有节点列表或首尾相连)。
  • 中断条件:校验失败、权限不足、已产生响应、异常被隔离。
  • 纯链:请求必须被某一个节点处理完且不再传递,类似「报销审批单必须被某一级签批」。
  • 不纯链:每个节点都可以做一段横切(日志、鉴权、计时、改写请求),然后放行,最终由末端业务节点处理。

原理流程

  1. 请求对象构造完成,交给链首节点。
  2. 当前节点做前置处理;若决定中断,直接写响应返回。
  3. 否则调用 next 把请求交给下一个节点。
  4. 下游返回后,当前节点可做后置处理,再向上返回。

代码或图示

纯链:  A ──> B ──> C ──> 末端(某一站处理后即终止,不再往后)
不纯链:A ─前置> B ─前置> C ─前置> 业务Handler ─后置> C ─后置> B ─后置> A
public interface Handler {
    void handle(Request req, Chain chain);
}

public interface Chain {
    void proceed(Request req);   // 放行到下一个节点
}

常见误区

  • 认为责任链必须「只有一个节点处理」:Web 中间件几乎都是不纯链,每个节点都动请求或响应,这是正常形态。
  • 节点里既处理业务又直接返回而不调用 next:如果是纯业务节点这是终态,但横切节点忘记 next 会让后续节点全部失效,典型事故是「加了一个 filter 后接口突然 200 空响应」。

追问

  • 纯链更适合什么场景?答:审批、风控、定价等「必须由某一站定夺」的裁决型流程。
  • 不纯链更适合什么场景?答:日志、鉴权、计时、编码、改写等横切关注点叠加。

01.3.2.10-002 Filter、Interceptor、Middleware 三种叫法实际差别在哪?

一句话结论

三者本质都是责任链,但工作层级不同:Filter 是 Web 容器层(Servlet 规范),能拿到原始请求/响应;Interceptor 是 MVC 框架层,能拿到 Handler 方法与模型;Middleware 是函数式框架的统称,通常由框架自己持有管道,调用顺序由注册顺序决定。

概念解释

  • Filter:Java Servlet 规范定义,容器级,早于 Spring MVC,能包装 request/response,拿不到 HandlerMethod。
  • Interceptor:Spring MVC 框架级,在 DispatcherServlet 内部,能拿到 Controller 方法与 ModelAndView。
  • Middleware:Gin、Express、Koa、ASP.NET Core 等函数式框架的叫法,统一表示「请求进入业务前要经过的一段处理函数」。

原理流程

  1. 请求进入容器 → Filter 链 → DispatcherServlet → Interceptor 链 → Controller → 返回。
  2. 函数式框架里没有 Filter/Interceptor 之分,全部注册为 middleware 列表,按顺序串成管道。
  3. 命名差异来自规范出处,不代表执行语义有本质不同。

代码或图示

Servlet 容器:  Request -> FilterChain -> Servlet -> DispatcherServlet
             -> Interceptor.pre -> Controller -> Interceptor.post -> View
函数式框架:  Request -> mw1 -> mw2 -> mw3 -> Handler -> mw3 -> mw2 -> mw1

常见误区

  • 认为 Filter 比 Interceptor 「更靠外」所以能做更多事:靠外意味着拿不到 MVC 上下文(Handler、模型、参数解析结果),做业务鉴权反而不如 Interceptor 方便。
  • 把 middleware 当成「拦截器」:很多函数式 middleware 默认就是放行的,不写 next() 才会中断,与「拦截器」的字面直觉相反。

追问

  • 鉴权写在 Filter 还是 Interceptor?答:需要拿到 Controller 注解、用户上下文、方法级权限时用 Interceptor;只需要解析 header、包装请求、CORS 这类容器级横切用 Filter。
  • 函数式框架里为什么没有 Interceptor?答:因为没有 MVC 分发这一层抽象,管道本身就是唯一的链,框架不需要再细分两层。

01.3.2.10-003 Servlet Filter 与 Spring Interceptor 分别工作在哪一层?

一句话结论

Servlet Filter 工作在 Servlet 容器(Tomcat/Jetty)层,在请求进入 Spring 之前;Spring Interceptor 工作在 DispatcherServlet 内部、Controller 调用前后,能拿到 HandlerMethod、模型视图与拦截器抛异常后的回调。

概念解释

  • Filter 接口:doFilter(ServletRequest, ServletResponse, FilterChain),由容器调用,调用 chain.doFilter() 才放行。
  • Interceptor 接口:preHandle / postHandle / afterCompletion,由 DispatcherServlet 在映射到 Handler 后调用。
  • 可见对象不同:Filter 只见 ServletRequest/Response;Interceptor 能见 HandlerMethod、ModelAndView、异步异常。

原理流程

  1. 请求到达 Tomcat,先匹配 url-pattern 走 FilterChain。
  2. Filter 全部放行后进入 DispatcherServlet.service。
  3. DispatcherServlet 找 HandlerMapping,得到 HandlerExecutionChain(包含 Interceptor 列表)。
  4. 依次调 preHandle,任一返回 false 即中断,不再进 Controller。
  5. Controller 执行完(正常或视图渲染后)调 postHandle,最终调 afterCompletion。

代码或图示

public class LogFilter implements Filter {
    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain)
            throws IOException, ServletException {
        long t = System.currentTimeMillis();
        chain.doFilter(req, resp);          // 必须显式放行
        System.out.println("cost=" + (System.currentTimeMillis() - t));
    }
}
public class AuthInterceptor implements HandlerInterceptor {
    public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) {
        if (handler instanceof HandlerMethod hm && !hasPermission(hm)) {
            resp.setStatus(403);
            return false;                    // 返回 false 即中断,不再进 Controller
        }
        return true;
    }
}

常见误区

  • 在 Filter 里取 HandlerMethod:拿不到,Filter 根本不知道请求会被哪个 Controller 处理。
  • 在 Interceptor 里做 request.setCharacterEncoding 这类容器级处理:太晚了,请求体可能已被读取。
  • 以为 postHandle 能改响应状态:响应体可能已提交,正确做法是在 preHandle 中断或用 ResponseBodyAdvice / Filter 包装响应。

追问

  • afterCompletion 在什么时候调用?答:preHandle 成功的那些拦截器,在请求完成(视图渲染或异常处理后)调用,用于资源清理。
  • 异步请求(Callable/DeferredResult)下 Interceptor 怎么走?答:会触发 AsyncHandlerInterceptor 的 afterConcurrentHandlingStarted,主流程的 postHandle 不会立即执行,具体回调时机以 Spring 版本文档为准。

01.3.2.10-004 Gin 与 Express 的中间件是怎么组织请求的?

一句话结论

两者都是函数式中间件:每个中间件是一个函数,内部显式调用 next() 把控制权交给下一个,不调用就短路;Gin 用 gin.HandlerFunc 切片在引擎内按组挂载,Express 用 app.use 把回调塞进 router.stack。

概念解释

  • Gin:gin.HandlerFunc 签名是 func(*gin.Context),多个 handler 组成 HandlerChain,通过 c.Next() 放行,c.Abort() 短路。
  • Express:中间件签名是 (req, res, next),next() 放行,不调用 next() 又不写响应会请求挂起。
  • 共同点:注册顺序就是执行顺序,函数式、无接口、可组合。

原理流程

  1. 启动时把所有中间件按注册顺序塞进引擎内部切片。
  2. 请求进来,从切片头部开始执行当前 handler。
  3. handler 内部遇到 next() 或 c.Next(),索引加一进入下一个。
  4. 末端业务 handler 写响应;返回后沿调用栈逆序执行中间件的后置部分。

代码或图示

r := gin.New()
r.Use(func(c *gin.Context) {
    t := time.Now()
    c.Next()                                  // 放行到下一个
    fmt.Println("cost", time.Since(t))
})
r.Use(AuthMiddleware())
r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{"msg": "pong"})
})
app.use((req, res, next) => {
  const t = Date.now();
  res.on('finish', () => console.log('cost', Date.now() - t));
  next();                                     // 不放行请求就挂起
});
app.use(authMiddleware);
app.get('/ping', (req, res) => res.json({ msg: 'pong' }));

常见误区

  • Gin 里调 c.Next() 之后还继续写响应:c.Next() 会阻塞直到下游跑完,之后写响应已提交,会抛错或无效。
  • Express 里忘记 next() 也不 res.end:请求一直挂着直到客户端超时,这是 Node 服务端最常见的事故之一。
  • 在循环里动态 app.use:Express 只在启动期收集中间件,运行期改 stack 不生效。

追问

  • Gin 的 c.Abort() 做了什么?答:把内部索引设为最大,后续 c.Next() 不再触发,常用于鉴权失败直接返回。
  • Express 错误中间件签名为什么是 4 个参数?答:(err, req, res, next),Express 靠参数个数判断这是错误处理中间件,注册顺序必须在普通中间件之后。

01.3.2.10-005 ASP.NET Core middleware 的真实形态是什么?Use / Run / Map 怎么区分?

一句话结论

ASP.NET Core middleware 是一串 RequestDelegate,通过 app.Use() 拼接:传入 HttpContext 与一个表示下游的 next 委托;Run() 是末端分支,不接收 next;Map() 按路径前缀把请求分支到另一棵子管道。

概念解释

  • Use(Func<HttpContext, RequestDelegate, Task>):典型中间件,调用 await next() 放行。
  • Run(RequestDelegate):末端,没有 next,必须自己写响应。
  • Map(path, subApp => ...):路径匹配后分支,子管道有自己的中间件序列。
  • UseMiddleware<T>():强类型中间件,约定一个 InvokeAsync(HttpContext, RequestDelegate) 方法,由容器构造。

原理流程

  1. 启动时 Program.cs 按顺序调用 app.Use...,构建一个嵌套的 RequestDelegate。
  2. 请求进入时,从最外层委托开始执行。
  3. 遇到 await next() 进入下一层;不 await next() 即短路。
  4. 内层返回后,外层继续执行 await next() 之后的代码。

代码或图示

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.Use(async (context, next) => {
    var sw = System.Diagnostics.Stopwatch.StartNew();
    await next();                              // 放行
    sw.Stop();
    Console.WriteLine($"{context.Request.Path} {sw.ElapsedMilliseconds}ms");
});

app.MapWhen(ctx => ctx.Request.Path.StartsWithSegments("/admin"), sub => {
    sub.Use(async (ctx, n) => { /* admin 专属鉴权 */ await n(); });
    sub.Run(async ctx => await ctx.Response.WriteAsync("admin"));
});

app.Run(async context => await context.Response.WriteAsync("root"));
app.Run();

常见误区

  • 以为 app.Use 里的代码会「自动」在请求前后都跑:只有写在 await next() 之前的是前置,写在之后的是后置,不写后置就只跑前置。
  • 在 UseRouting 之前做依赖路由数据的判断:路由数据由 UseRouting 产生,之前拿不到 Endpoint。
  • 把同步阻塞代码放进 middleware:async 管道里 .Result / .Wait() 会阻塞线程池并可能死锁,必须 await。

追问

  • UseMiddleware<T>() 与 app.Use(...) 匿名委托有什么区别?答:匿名委托每次请求都捕获闭包;UseMiddleware<T> 类型由容器构造且单例,方法注入更干净,适合复杂中间件。
  • 为什么 Map 是分支而不是短路?答:分支后的子管道完全独立,匹配不到的请求继续走主管道。

01.3.2.10-006 注册顺序为什么等于执行顺序?洋葱模型是什么?

一句话结论

所有函数式中间件与 Servlet Filter 都按注册顺序串成嵌套调用,先注册的在外层、后注册的在内层;请求从前置进入、从后置逆序返回,画出来像一颗洋葱,所以叫洋葱模型。

概念解释

  • 注册顺序 = 外层到内层的顺序。
  • 前置:按注册顺序执行。
  • 后置:按注册逆序执行。
  • 短路:内层不调 next,外层的后置代码仍然会跑(因为调用栈返回),只是看不到内层业务。

原理流程

  1. 注册 A → B → C → Handler。
  2. 请求进入:A 前置 → B 前置 → C 前置 → Handler。
  3. Handler 返回:C 后置 → B 后置 → A 后置。
  4. 任意一层不调 next:直接沿调用栈返回,外层后置仍然执行。

代码或图示

        ┌─── A 前置 ───┐
        │  ┌─ B 前置 ┐ │
        │  │ C 前置 │ │
请求 -> │  │ Handler│ │ -> 响应
        │  │ C 后置 │ │
        │  └ B 后置 ┘ │
        └─── A 后置 ──┘
注册顺序:use(A); use(B); use(C); get("/", H);
实际调用栈:A -> B -> C -> H -> C -> B -> A

常见误区

  • 以为「后注册的中间件先跑」:绝大多数框架都是先注册先跑,反向执行的只有后置部分。
  • 短路后外层后置不跑:错,调用栈返回就会跑外层后置,只是内层 Handler 没被执行。
  • 把全局中间件按路由组动态调整顺序:分组中间件只在组内有效,全局顺序仍按注册时间。

追问

  • Nginx 与应用服务器的关系是不是洋葱模型?答:Nginx 是更外层的反向代理,请求穿过 Nginx 再进应用,应用内部又是一颗洋葱,整体是嵌套的多层管道。
  • 怎么验证实际执行顺序?答:在每个中间件前置和后置打日志,对照请求路径看输出顺序即可。

01.3.2.10-007 短路与放行在代码层是怎么表达的?

一句话结论

放行就是「显式调用下游函数」:Servlet 用 chain.doFilter()、Spring Interceptor 用 return true、Gin 用 c.Next()、Express 用 next()、ASP.NET Core 用 await next();短路就是「不调用下游、直接写响应返回」,不同框架还提供 c.Abort() / return false 这类显式 API。

概念解释

  • 放行语义:把请求交给下一个节点,当前节点保留后置处理权。
  • 短路语义:终止链的传递,直接产生响应。
  • 异常短路:抛异常被全局错误处理捕获,也等价于终止后续业务节点。

原理流程

  1. 节点前置判断:通过则放行,不通过则直接写响应状态码并返回。
  2. 放行必须显式调用下游函数,否则框架不知道该继续。
  3. 短路后外层中间件的后置代码仍会执行,因为调用栈在逆序展开。

代码或图示

放行:chain.doFilter() / next() / c.Next() / await next() / return true
短路:resp.sendError(403) / c.Abort() / res.status(403).end() / return false / 不 await next
// Spring Interceptor 短路:return false
public boolean preHandle(...) {
    if (!auth) { resp.setStatus(403); return false; }
    return true;
}
// Gin 短路:Abort 之后不再走下游 handler
if !auth {
    c.AbortWithStatus(403)
    return
}
c.Next()

常见误区

  • 短路后忘记写响应:请求挂起直到客户端超时,Express 里尤其常见。
  • 在 Gin 里 c.JSON 之后忘记 c.Abort():后续 handler 还会继续跑,可能重复写响应。
  • 把异常抛到管道外而不捕获:异常会被全局错误中间件处理,但链上其他节点的后置行为可能与预期不同。

追问

  • 短路与异常的关系?答:异常也会终止下游业务节点,但它走的是异常路径,不会执行业务节点的后置代码,外层中间件要看是否在 catch 中包裹。
  • 怎么「软短路」只记录不中断?答:把短路判断做成配置开关,命中时记录日志仍调用 next,便于灰度。

01.3.2.10-008 责任链与装饰器的关键区别是什么?

一句话结论

装饰器要求内层对象一定被调用,只是在外层加行为;责任链允许任意节点决定不调用下游。两者结构相似(都是持有下一个对象),区别在于「是否必须继续传递」。

概念解释

  • 装饰器:LoggingDecorator wraps CacheDecorator wraps Target,每次调用都会从外到内走完,结果逐层叠加。
  • 责任链:节点可以选择中断,请求可能根本到不了末端。
  • 结构相同点:都持有一个同类型成员。

原理流程

  1. 看内层是否被无条件调用。
  2. 无条件调用、增强结果 → 装饰器。
  3. 可中断、决定是否继续 → 责任链。
  4. 实务中两者经常混合:鉴权(责任链)+ 日志(装饰器)叠在同一个管道里。

代码或图示

装饰器:Logging -> Cache -> Service(每一层都一定执行下一层)
责任链:Auth   -> Risk  -> Service(Auth 失败就不进 Risk 和 Service)
// 装饰器:一定调用内层
public class LoggingRepo implements UserRepo {
    private final UserRepo inner;
    public User find(Long id) {
        var t = System.currentTimeMillis();
        User u = inner.find(id);           // 必须调用
        log("cost", System.currentTimeMillis() - t);
        return u;
    }
}

常见误区

  • 在装饰器里加 if (!auth) return null:这是把装饰器写成了责任链,破坏了「透明包裹」的约定,调用方拿到的不再是内层语义。
  • 在责任链节点里偷偷调用两次下游:会让下游业务逻辑跑两遍,典型事故。

追问

  • Spring 的 BeanPostProcessor 是哪种?答:偏装饰器,它在 Bean 外层包代理,业务方法仍会被调用,只是增强。
  • MyBatis Interceptor 是哪种?答:装饰器变体,它包住 Executor 并决定是否调用 invocation.proceed(),可短路也可增强。

01.3.2.10-009 责任链的递归深度与性能要注意什么?

一句话结论

函数式中间件本质是嵌套函数调用,链越深调用栈越长、闭包捕获越多;性能上要避免在节点里做重 IO、大对象分配与同步阻塞,热点链路要按压测评估。

概念解释

  • 调用栈深度:每个中间件一层栈帧,函数式写法尤其明显。
  • 闭包捕获:匿名函数每次请求都捕获变量,GC 压力上升。
  • 重 IO:鉴权、风控如果在链上同步查数据库,每个请求延迟被线性叠加。

原理流程

  1. 启动期合并相邻且职责重复的中间件。
  2. 节点内只做横切逻辑,业务 IO 下沉到 Service。
  3. 鉴权这类需要远程调用的节点加缓存与超时。
  4. 用 APM 看每个中间件耗时,而不是整段接口耗时。

代码或图示

链过长的代价:
- 调用栈:每节点一帧,深度过深会放大栈大小与调试栈跟踪
- 对象分配:匿名函数闭包、Context 包装、包装后的 Request/Response
- 同步阻塞:任一节点同步查远程服务,整段 RT 累加
// 反例:在中间件里同步查用户表
r.Use(func(c *gin.Context) {
    uid := c.GetHeader("X-UID")
    u := db.First(&User{}, uid)         // 每请求一次同步查询
    c.Set("user", u)
    c.Next()
})

常见误区

  • 以为「加中间件很便宜」:每个中间件都是一次函数调用与可能的对象包装,几十个中间件叠起来 RT 显著上升。
  • 在 Filter 里包 HttpServletRequestWrapper 又在 Interceptor 里再包一层:请求对象被多层包装,调试时看字段要层层解包。
  • 把审批规则做成无限长的责任链:规则多到几十条时应改用规则引擎或配置化决策表。

追问

  • 链太长怎么重构?答:把横切关注点按职责分组(日志、安全、监控各一组),业务规则抽到策略或规则表,中间件只做编排。
  • 责任链会爆栈吗?答:每节点只是一次普通函数调用,深度到几十层远不会到栈上限;真正爆栈的是递归式 next 写错成死循环自调用。

01.3.2.10-010 模板方法如何固定骨架?钩子方法和抽象步骤怎么分?

一句话结论

模板方法在父类里定义一个 final 方法,按固定顺序调用一组步骤;步骤要么是抽象方法(子类必须实现),要么是钩子方法(父类给默认空实现,子类按需覆盖),从而保证骨架不变、步骤可定制。

概念解释

  • 模板方法:public final void run(),定义步骤顺序,不允许子类改顺序。
  • 抽象步骤:protected abstract void step(),子类必须实现。
  • 钩子方法:protected void hook() {},默认空实现,子类按需覆盖。
  • 目的:复用「流程骨架」,把差异下沉到子类。

原理流程

  1. 识别流程中稳定的步骤顺序(如:读数据 → 格式化 → 写文件)。
  2. 在父类把这个顺序写成 final 方法。
  3. 把可变步骤声明为抽象或钩子方法。
  4. 子类只覆盖步骤,不覆盖模板方法本身。

代码或图示

public abstract class AbstractExporter {
    public final void export() {          // 模板方法:骨架固定
        readData();
        format();
        if (needWriteFile()) {            // 钩子控制
            writeFile();
        }
    }
    protected abstract void readData();
    protected abstract void format();
    protected void writeFile() { /* 默认落盘 */ }
    protected boolean needWriteFile() { return true; }   // 钩子
}

常见误区

  • 模板方法不加 final:子类覆盖它改变步骤顺序,等于破坏模板的约定。
  • 钩子方法里写大量默认逻辑:钩子应保持「可选」语义,复杂默认实现应放在普通方法里。
  • 父类调用子类实现的抽象方法时假设子类状态:子类构造顺序与父类字段初始化顺序容易出错,模板方法应在对象完全构造后由外部调用。

追问

  • 抽象步骤和钩子怎么选?答:子类必须提供的步骤用抽象;有合理默认、子类可能想改的用钩子。
  • 模板方法能在运行期换步骤吗?答:不能,骨架在编译期固定;要运行期换整体流程就改用策略模式。

01.3.2.10-011 模板方法在框架中的真实形态有哪些?

一句话结论

JdbcTemplate 把「获取连接、预编译、执行、释放连接」的骨架固定,把「SQL、参数、结果映射」留给回调;Spring 的 AbstractApplicationContext.refresh() 把容器启动流程固定,子类只重写 postProcess 等钩子;各类 Abstract* 基类都是模板方法的变体。

概念解释

  • JdbcTemplate:骨架是「连接 → Statement → ResultSet → 关闭」,差异点是 SQL 与 RowMapper。
  • 容器刷新:prepareRefresh → obtainFreshBeanFactory → registerBeanPostProcessors → onRefresh → finishRefresh,步骤顺序由父类固定。
  • Spring MVC 的 HttpServletBean / FrameworkServlet 也是模板方法式骨架。

原理流程

  1. 框架把「流程骨架」写成一个 final 或 protected 方法。
  2. 差异点通过受保护方法或回调接口暴露。
  3. 应用开发者要么继承基类覆盖钩子,要么传入回调 lambda。
  4. 框架在合适时机调用回调,控制权由框架掌握。

代码或图示

// JdbcTemplate:骨架固定,差异通过 RowMapper 回调
List<User> users = jdbcTemplate.query(
    "select id, name from user where dept = ?",
    ps -> ps.setString(1, dept),
    (rs, rowNum) -> new User(rs.getLong("id"), rs.getString("name"))
);
AbstractApplicationContext.refresh() 骨架:
prepareRefresh()
obtainFreshBeanFactory()
postProcessBeanFactory(beanFactory)      <- 钩子
invokeBeanFactoryPostProcessors(beanFactory)
registerBeanPostProcessors(beanFactory)
onRefresh()                              <- 钩子(子类)
finishRefresh()

常见误区

  • 把模板方法理解成「必须继承」:JdbcTemplate 用回调函数同样是模板方法,骨架固定、差异通过回调注入,这是模板方法的现代化形态。
  • 在子类覆盖 refresh() 整个方法:破坏了 Spring 容器启动约定,会导致 Bean 生命周期错乱。

追问

  • 为什么框架都爱用模板方法?答:流程骨架属于框架(稳定且不可改),差异属于应用(易变),模板方法正好把两者分离。
  • 回调式与继承式模板方法怎么选?答:语言支持 lambda 时优先回调式(Go/Rust/TS),需要多层钩子与状态时才继承(Java)。

01.3.2.10-012 Go 没有继承,怎么实现模板方法?

一句话结论

Go 没有类继承,常用两种替代:一是用结构体嵌入实现「组合式继承」,父结构体定义骨架方法、子结构体嵌入父并覆盖受保护步骤;二是把差异步骤定义为函数字段或接口,骨架方法持有这些函数并按顺序调用,更符合 Go 的组合哲学。

概念解释

  • 结构体嵌入:type MySQLExporter struct { *BaseExporter },覆盖父结构体的步骤方法。
  • 函数字段:type Pipeline struct { Read func() []Data; Format func([]Data) []byte },骨架方法 Run() 依次调用字段。
  • 回调式模板:func Run(pipeline Pipeline),把骨架做成普通函数,差异通过参数传入。

原理流程

  1. 定义骨架函数或结构体方法,按固定顺序调用差异步骤。
  2. 差异步骤要么是接口字段(调用方注入实现),要么是函数字段(注入闭包)。
  3. 调用方组装好差异步骤,调用骨架。
  4. 不需要继承层级,组合即可。

代码或图示

type Pipeline struct {
    Read   func() []Data
    Format func([]Data) []byte
    Write  func([]byte) error
}

// Run 是模板方法:骨架固定,步骤通过字段注入
func (p Pipeline) Run() error {
    rows := p.Read()
    body := p.Format(rows)
    return p.Write(body)
}

// 使用:
p := Pipeline{
    Read:   readFromDB,
    Format: formatCSV,
    Write:  writeToFile,
}
_ = p.Run()

常见误区

  • 强行模仿 Java 建抽象基类再嵌入:Go 的嵌入没有「父类模板方法强制子类覆盖」语义,未覆盖的字段会是 nil,运行期 panic。
  • 在骨架方法里直接 panic 表示「必须由子类实现」:应在 Run 开头显式校验字段非 nil 并返回明确错误。

追问

  • Go 的 http.HandlerFunc 是不是模板方法?答:偏函数式接口,不是模板方法;但 http.Server 的 Serve 流程是模板骨架,差异通过 Handler 接口注入。
  • 函数字段模板怎么测试?答:字段是函数,测试时直接传入 mock 函数,无需构造继承体系,这正是 Go 模板方法比 Java 模板方法更易测的原因。

01.3.2.10-013 TypeScript abstract 与 Rust trait 默认方法怎么写模板方法?

一句话结论

TypeScript 用 abstract class 定义 abstract 步骤方法,模板方法写成普通方法且不声明 abstract;Rust 用 trait 定义骨架方法并给默认实现,差异步骤用无默认方法的 trait 方法,类型必须自行实现。

概念解释

  • TS abstract:编译期约束,子类必须实现抽象成员,运行时与普通类一致。
  • Rust trait 默认方法:trait 可以提供方法实现,类型实现 trait 时可以选择覆盖或复用。
  • 两者都用「类型系统 + 继承/实现」而非函数式字段来表达骨架。

原理流程

  1. TS:父类声明 abstract step(),模板方法 run() 按序调用。
  2. Rust:trait 声明 fn step(&self); 与 fn run(&self) { self.step(); ... },具体类型实现 trait。
  3. 类型系统保证骨架不被破坏(TS 子类必须实现抽象方法;Rust 类型必须实现无默认方法)。

代码或图示

abstract class Exporter {
    run(): void {                  // 模板方法
        this.read();
        this.format();
        this.write();
    }
    protected abstract read(): void;
    protected abstract format(): void;
    protected write(): void { /* 默认落盘 */ }
}

class CSVExporter extends Exporter {
    protected read() { /* ... */ }
    protected format() { /* ... */ }
}
trait Exporter {
    fn read(&self) -> Vec<u8>;
    fn format(&self, data: Vec<u8>) -> Vec<u8>;

    fn run(&self) {                // 默认实现即模板方法
        let data = self.read();
        let body = self.format(data);
        self.write(body);
    }
    fn write(&self, body: Vec<u8>) { /* 默认落盘 */ }
}

常见误区

  • TS 把模板方法也声明 abstract:骨架就没有实现了,等于失去模板意义。
  • Rust 给骨架方法写默认实现后又在类型里整个覆盖:覆盖骨架就破坏了模板约定,应只覆盖差异步骤。
  • 把 abstract 当运行时保护:TS 的 abstract 仅编译期有效,转译后可被绕过。

追问

  • Rust trait 默认方法和 Go 函数字段哪个更贴近模板方法?答:Rust trait 更贴近传统模板方法(类型系统强制实现步骤),Go 字段更贴近「策略注入」。
  • TS 的 abstract 在打包后还在吗?答:类型信息被擦除,只在编译期校验。

01.3.2.10-014 模板方法与策略怎么取舍?什么是好莱坞原则?

一句话结论

模板方法用继承固定骨架、替换个别步骤;策略用组合整体替换算法;当流程骨架稳定、只换局部步骤时用模板方法,当整个算法族可互换、步骤顺序不固定时用策略。好莱坞原则「Don't call us, we'll call you」描述的正是模板方法与框架反转:父类/框架控制流程,子类只提供步骤。

概念解释

  • 模板方法:变化点在「步骤内部」,骨架由父类控制。
  • 策略:变化点在「整个算法」,上下文持有策略对象,运行期可换。
  • 好莱坞原则:控制反转(IoC)的口语化表达,父类在合适时机回调子类,而不是子类主动调用父类流程。

原理流程

  1. 先判断变化点:局部步骤 vs 整体算法。
  2. 局部步骤变化、骨架稳定 → 模板方法。
  3. 整体算法可互换、骨架不固定 → 策略。
  4. 框架场景下两者常配合:框架用模板方法固定生命周期,业务用策略注入算法。

代码或图示

模板方法:父类 run() { a(); b(); c(); },子类只覆盖 b()
策略:    Context.strategy = new XxxStrategy(); strategy.execute(); 整体替换
好莱坞:  子类不调父类,父类在 run() 里调子类实现的 step()

常见误区

  • 用模板方法承载「完全不同的两套流程」:步骤顺序都不一样时继承体系会膨胀,应改策略。
  • 用策略时复制公共流程:公共流程应上移到上下文或抽象策略类,避免重复。
  • 把好莱坞原则当成「不要调用任何上层」:它指的是控制流由框架持有,业务只提供回调,不是禁止调用。

追问

  • Spring 是模板方法还是策略?答:两者都有。容器启动生命周期是模板方法(骨架固定),Bean 的创建、AOP 代理、消息转换器是策略(可替换实现)。
  • 什么时候模板方法应该重构为策略?答:继承层级超过两三层、子类开始覆盖多个步骤、骨架本身也在变的时候。

跨语言差异对照

语言 责任链惯用形态 模板方法惯用形态
Java Servlet Filter、Spring Interceptor、Handler 链 abstract class + final 模板方法;JdbcTemplate 回调
Go gin.HandlerFunc 切片、net/http Handler 嵌套 结构体嵌入 + 函数字段;普通函数编排差异步骤
Python WSGI 中间件、装饰器函数叠加 基类 + 子类覆盖;abc.ABC + 抽象方法
PHP Laravel Pipeline、Middleware 管道 抽象基类(Abstract*),钩子方法
C#/.NET UseMiddleware、RequestDelegate 管道 抽象基类 + protected virtual 钩子;TemplateMethod 基类
TypeScript Express/Koa (req, res, next) 函数链 abstract class + abstract 成员
Rust Tower Service / Layer 栈 trait 默认方法;组合结构体注入闭包

跨语言差异

  • Java 与 C# 是「继承式模板方法」的原生土壤,final / virtual 关键字直接约束骨架。
  • Go 与 Rust 没有类继承,模板方法要么靠结构体嵌入,要么靠 trait 默认方法或函数字段,本质是组合。
  • Python 与 PHP 的中间件多以函数/闭包形式叠加,责任链接近装饰器,差异点靠运行时判断。
  • TypeScript 的 abstract 仅编译期有效,运行时需靠测试或接口约束。
  • 所有语言的 Web 框架最终都收敛到「函数式管道 + next 调用」这一形态,说明责任链在函数式世界比 GoF 类图更通用。
  • 模板方法的现代化形态不是继承,而是「骨架函数 + 回调参数」,JdbcTemplate、RedisTemplate 都是这种。

待整理清单

  • [ ] 补充 Netty ChannelPipeline 入站/出站事件的责任链细节
  • [ ] 补充 Spring Cloud Gateway GlobalFilter 与 GatewayFilter 的顺序约定
  • [ ] 补充 Rust tower-rs Service/Layer 的完整示例
  • [ ] 补充 Laravel Pipeline 与 Middleware 优先级的实际配置案例