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)、具体处理器、链的编排者(持有节点列表或首尾相连)。 - 中断条件:校验失败、权限不足、已产生响应、异常被隔离。
- 纯链:请求必须被某一个节点处理完且不再传递,类似「报销审批单必须被某一级签批」。
- 不纯链:每个节点都可以做一段横切(日志、鉴权、计时、改写请求),然后放行,最终由末端业务节点处理。
原理流程
- 请求对象构造完成,交给链首节点。
- 当前节点做前置处理;若决定中断,直接写响应返回。
- 否则调用
next把请求交给下一个节点。 - 下游返回后,当前节点可做后置处理,再向上返回。
代码或图示
纯链: 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 等函数式框架的叫法,统一表示「请求进入业务前要经过的一段处理函数」。
原理流程
- 请求进入容器 → Filter 链 → DispatcherServlet → Interceptor 链 → Controller → 返回。
- 函数式框架里没有 Filter/Interceptor 之分,全部注册为 middleware 列表,按顺序串成管道。
- 命名差异来自规范出处,不代表执行语义有本质不同。
代码或图示
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、异步异常。
原理流程
- 请求到达 Tomcat,先匹配
url-pattern走 FilterChain。 - Filter 全部放行后进入
DispatcherServlet.service。 - DispatcherServlet 找 HandlerMapping,得到
HandlerExecutionChain(包含 Interceptor 列表)。 - 依次调
preHandle,任一返回 false 即中断,不再进 Controller。 - 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()又不写响应会请求挂起。 - 共同点:注册顺序就是执行顺序,函数式、无接口、可组合。
原理流程
- 启动时把所有中间件按注册顺序塞进引擎内部切片。
- 请求进来,从切片头部开始执行当前 handler。
- handler 内部遇到
next()或c.Next(),索引加一进入下一个。 - 末端业务 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)方法,由容器构造。
原理流程
- 启动时
Program.cs按顺序调用app.Use...,构建一个嵌套的RequestDelegate。 - 请求进入时,从最外层委托开始执行。
- 遇到
await next()进入下一层;不await next()即短路。 - 内层返回后,外层继续执行
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,外层的后置代码仍然会跑(因为调用栈返回),只是看不到内层业务。
原理流程
- 注册 A → B → C → Handler。
- 请求进入:A 前置 → B 前置 → C 前置 → Handler。
- Handler 返回:C 后置 → B 后置 → A 后置。
- 任意一层不调
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。
概念解释
- 放行语义:把请求交给下一个节点,当前节点保留后置处理权。
- 短路语义:终止链的传递,直接产生响应。
- 异常短路:抛异常被全局错误处理捕获,也等价于终止后续业务节点。
原理流程
- 节点前置判断:通过则放行,不通过则直接写响应状态码并返回。
- 放行必须显式调用下游函数,否则框架不知道该继续。
- 短路后外层中间件的后置代码仍会执行,因为调用栈在逆序展开。
代码或图示
放行: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,每次调用都会从外到内走完,结果逐层叠加。 - 责任链:节点可以选择中断,请求可能根本到不了末端。
- 结构相同点:都持有一个同类型成员。
原理流程
- 看内层是否被无条件调用。
- 无条件调用、增强结果 → 装饰器。
- 可中断、决定是否继续 → 责任链。
- 实务中两者经常混合:鉴权(责任链)+ 日志(装饰器)叠在同一个管道里。
代码或图示
装饰器: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:鉴权、风控如果在链上同步查数据库,每个请求延迟被线性叠加。
原理流程
- 启动期合并相邻且职责重复的中间件。
- 节点内只做横切逻辑,业务 IO 下沉到 Service。
- 鉴权这类需要远程调用的节点加缓存与超时。
- 用 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() {},默认空实现,子类按需覆盖。 - 目的:复用「流程骨架」,把差异下沉到子类。
原理流程
- 识别流程中稳定的步骤顺序(如:读数据 → 格式化 → 写文件)。
- 在父类把这个顺序写成
final方法。 - 把可变步骤声明为抽象或钩子方法。
- 子类只覆盖步骤,不覆盖模板方法本身。
代码或图示
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也是模板方法式骨架。
原理流程
- 框架把「流程骨架」写成一个
final或protected方法。 - 差异点通过受保护方法或回调接口暴露。
- 应用开发者要么继承基类覆盖钩子,要么传入回调 lambda。
- 框架在合适时机调用回调,控制权由框架掌握。
代码或图示
// 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),把骨架做成普通函数,差异通过参数传入。
原理流程
- 定义骨架函数或结构体方法,按固定顺序调用差异步骤。
- 差异步骤要么是接口字段(调用方注入实现),要么是函数字段(注入闭包)。
- 调用方组装好差异步骤,调用骨架。
- 不需要继承层级,组合即可。
代码或图示
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 时可以选择覆盖或复用。
- 两者都用「类型系统 + 继承/实现」而非函数式字段来表达骨架。
原理流程
- TS:父类声明
abstract step(),模板方法run()按序调用。 - Rust:trait 声明
fn step(&self);与fn run(&self) { self.step(); ... },具体类型实现 trait。 - 类型系统保证骨架不被破坏(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)的口语化表达,父类在合适时机回调子类,而不是子类主动调用父类流程。
原理流程
- 先判断变化点:局部步骤 vs 整体算法。
- 局部步骤变化、骨架稳定 → 模板方法。
- 整体算法可互换、骨架不固定 → 策略。
- 框架场景下两者常配合:框架用模板方法固定生命周期,业务用策略注入算法。
代码或图示
模板方法:父类 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 优先级的实际配置案例