01.3.2.5 装饰器模式
所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解
覆盖范围
- 装饰器模式的包装语义与职责叠加
- Java IO 流装饰链与嵌套规则
- 装饰器与继承的取舍
- Python 函数装饰器语法糖、类装饰器与 GoF 装饰器模式的区别
- TypeScript 高阶函数与中间件
- Go
func(http.Handler) http.Handler中间件 - C#
DelegatingHandler管道 - Rust 所有权下的包装方式(返回新类型 vs 借用)
- 装饰顺序与副作用、装饰器与代理的边界
- 装饰链的调试与可观测性、无状态装饰器复用
面试题索引
| 编号 | 题目 | 难度 | 状态 | 备注 |
|---|---|---|---|---|
| 01.3.2.5-001 | 装饰器模式解决什么问题?包装语义怎么理解? | 基础 | 已完成 | 职责叠加 |
| 01.3.2.5-002 | Java IO 流装饰链怎么工作? | 进阶 | 已完成 | 经典案例 |
| 01.3.2.5-003 | 装饰器和继承怎么取舍? | 进阶 | 已完成 | 子类爆炸 |
| 01.3.2.5-004 | Python 函数装饰器语法糖和 GoF 装饰器是一回事吗? | 进阶 | 已完成 | 语法糖 vs 结构 |
| 01.3.2.5-005 | TypeScript 高阶函数怎么做中间件? | 进阶 | 已完成 | 函数式装饰 |
| 01.3.2.5-006 | Go 的 func(http.Handler) http.Handler 中间件怎么写? |
进阶 | 已完成 | 经典中间件 |
| 01.3.2.5-007 | C# DelegatingHandler 管道怎么组织? |
进阶 | 已完成 | HttpClient 管道 |
| 01.3.2.5-008 | Rust 所有权下怎么包装?返回新类型还是借用? | 高级 | 已完成 | 所有权约束 |
| 01.3.2.5-009 | 装饰顺序为什么重要?顺序错了会怎样? | 进阶 | 已完成 | 副作用叠加 |
| 01.3.2.5-010 | 装饰器和代理的区别是什么? | 基础 | 已完成 | 意图分类 |
| 01.3.2.5-011 | 装饰链怎么调试与观测? | 高级 | 已完成 | 栈深与日志 |
| 01.3.2.5-012 | 无状态装饰器为什么能复用? | 进阶 | 已完成 | 线程安全 |
| 01.3.2.5-013 | Python 类装饰器和 GoF 装饰器有什么关键区别? | 进阶 | 已完成 | 包装类 vs 包装函数 |
01.3.2.5-001 装饰器模式解决什么问题?包装语义怎么理解?
一句话结论
装饰器在不改变原始对象接口的前提下,把额外职责(日志、缓存、压缩、计时)包装在对象外围,多个装饰器可以按需要层层叠加;相比继承,它能在运行期灵活组合,避免子类爆炸。
概念解释
- 四个角色:组件接口、具体组件(原始对象)、抽象装饰器(持有组件引用)、具体装饰器(叠加职责)。
- 包装语义:装饰器与被装饰对象实现同一接口,调用方拿到的还是接口类型,不知道外面包了几层。
- 职责叠加:每层装饰器只负责一种增强,组合出不同行为。
原理流程
- 定义统一组件接口。
- 写具体组件,只实现核心业务。
- 写抽象装饰器,持有一个组件引用并实现接口。
- 具体装饰器继承抽象装饰器,在方法内做前置/后置处理后委托内层。
- 调用方按需要嵌套组装。
代码或图示
public interface Notifier {
void send(String msg);
}
public class EmailNotifier implements Notifier {
public void send(String msg) { /* 发邮件 */ }
}
public abstract class NotifierDecorator implements Notifier {
protected final Notifier inner;
protected NotifierDecorator(Notifier inner) { this.inner = inner; }
}
public class LogDecorator extends NotifierDecorator {
public LogDecorator(Notifier inner) { super(inner); }
public void send(String msg) {
System.out.println("send: " + msg);
inner.send(msg);
}
}
// 组装:邮件 + 日志 + 加密
Notifier n = new LogDecorator(new CryptoDecorator(new EmailNotifier()));
常见误区
- 装饰器继承具体组件而非实现接口:绑定具体实现,无法透明嵌套。
- 一个装饰器做多种增强:按职责拆分,日志、加密、限流各自独立。
- 装饰器不调用内层:等于替换了业务,不是装饰而是重写。
追问
- 装饰器和策略模式有什么区别?答:策略是「换算法」,装饰器是「加功能」,策略的多种实现是平级关系,装饰器是嵌套关系。
- 装饰器能改变返回值吗?答:可以,但要保证返回值仍满足组件接口,否则破坏透明性。
01.3.2.5-002 Java IO 流装饰链怎么工作?
一句话结论
Java IO 是装饰器模式最经典的工业化案例:基础流对接数据源(文件、网络、字节数组),过滤流(FilterInputStream/FilterReader)在外围叠加缓冲、编码、对象序列化等能力,按需嵌套,上层统一使用流接口。
概念解释
- 基础组件:
InputStream、OutputStream的具体子类(FileInputStream、ByteArrayInputStream)。 - 抽象装饰器:
FilterInputStream、FilterReader,持有一个同类型流引用。 - 具体装饰器:
BufferedInputStream、DataInputStream、ObjectInputStream、InputStreamReader。
原理流程
- 创建底层数据源流。
- 按需要包缓冲流(减少系统调用)。
- 再包编码流或对象流。
- 统一通过最外层流接口读写。
- 关闭最外层会级联关闭底层流。
代码或图示
try (var in = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream("a.dat")))) {
Object o = in.readObject();
} catch (IOException | ClassNotFoundException e) {
// ...
}
// 读取链:ObjectInputStream -> BufferedInputStream -> FileInputStream
// readObject() 调用:
// 反序列化 -> 从缓冲取字节 -> 缓冲不足时从文件读
常见误区
- 只关外层流:外层关闭会级联关闭内层,但必须用 try-with-resources 确保异常时也关闭。
- 缓冲流放错位置:缓冲应尽量贴近底层流,减少逐系统调用次数。
- 字符流和字节流混用:
InputStreamReader是桥接装饰器,负责字节到字符的编码转换,不能直接包在BufferedInputStream外面而不指定编码。
追问
- 为什么
BufferedInputStream继承FilterInputStream?答:它本身是装饰器,持有一个InputStream,在read()里先读缓冲,缓冲不足才从底层流读。 - NIO.2 还是装饰器吗?答:NIO 的
Channel与ByteBuffer是另一套模型,装饰器式包装不再是主流,但BufferedReader这类装饰器仍在使用。
01.3.2.5-003 装饰器和继承怎么取舍?
一句话结论
继承在编译期固定行为,会导致子类爆炸(EmailSmsNotifier、EmailLoggingSmsNotifier);装饰器在运行期组合,每种增强独立成装饰器,按需嵌套,灵活但多了一层对象间接。
概念解释
- 继承:
class LogEmailNotifier extends EmailNotifier,行为在编译期定型。 - 装饰器:
new LogDecorator(new EmailNotifier()),运行期组装。 - 组合爆炸:n 种增强,继承需要 2^n 个子类,装饰器只需 n 个装饰器类。
原理流程
- 识别会变化的职责(日志、加密、压缩、限流)。
- 每种职责写一个装饰器。
- 运行期按场景组合。
- 不需要的增强不包,避免无关对象开销。
代码或图示
继承方式:
Notifier
├─ EmailNotifier
├─ EmailLogNotifier
├─ EmailCryptoNotifier
├─ EmailLogCryptoNotifier
├─ SmsNotifier
├─ SmsLogNotifier
└─ ... 子类爆炸
装饰器方式:
Notifier
├─ EmailNotifier
├─ SmsNotifier
└─ Decorator
├─ LogDecorator
├─ CryptoDecorator
└─ CompressDecorator
运行期组合:new LogDecorator(new CryptoDecorator(new EmailNotifier()))
常见误区
- 所有增强都用装饰器:当增强组合固定且很少变化时,继承更直白,装饰器反而增加复杂度。
- 装饰器持有状态导致不可复用:无状态装饰器可以单例复用,有状态装饰器每次请求新建。
- 认为装饰器能替代继承:装饰器替代的是「为加功能而继承」,类型层次与多态仍需要继承。
追问
- Spring Boot 的 WebMvcConfigurer 是装饰器吗?答:它是配置回调,不是对象装饰器;但它内部注册的拦截器、过滤器本质是装饰链。
- 装饰器模式符合开闭原则吗?答:符合,新增装饰器不需要修改原有组件,只新增类。
01.3.2.5-004 Python 函数装饰器语法糖和 GoF 装饰器是一回事吗?
一句话结论
不是一回事。Python 的 @decorator 是语法糖,本质是「把函数或类作为参数传入另一个函数,返回替换后的函数或类」;GoF 装饰器是「对象级包装,保持接口不变」。两者思路相似,但 Python 装饰器作用于函数/类定义时,而不是运行期对象。
概念解释
- 函数装饰器:
@logger等价于func = logger(func)。 - 类装饰器:作用于类定义,返回修改后的类。
- GoF 装饰器:对象级包装,同一个接口可以运行期包多层。
原理流程
- 定义装饰器函数,接收函数或类,返回新函数或类。
- 在目标函数/类上用
@decorator语法。 - 解释器在定义阶段执行装饰器,替换原对象。
- 运行期调用的是装饰后的函数/类。
代码或图示
import time
from functools import wraps
def timing(func):
@wraps(func)
def wrapper(*args, **kwargs):
start = time.perf_counter()
try:
return func(*args, **kwargs)
finally:
print(f"{func.__name__} cost {time.perf_counter() - start:.3f}s")
return wrapper
@timing
def query_db(sql):
# ...
pass
# 等价于:query_db = timing(query_db)
常见误区
- 用
@wraps保留元信息:不写@wraps(func),装饰后函数的__name__、__doc__都会变成 wrapper,调试与反射会出问题。 - 装饰器在导入时执行:装饰器在模块加载时运行一次,不是每次调用时运行;要在调用时插逻辑,逻辑必须写在 wrapper 里。
- 认为 Python 装饰器是运行期对象代理:它是定义期替换,不是对已有对象的动态包装。
追问
- 带参数的装饰器怎么写?答:三层嵌套,最外层接收参数,中间层接收函数,最内层是 wrapper。
- 类装饰器和函数装饰器区别?答:类装饰器接收类,返回新类或修改原类;函数装饰器接收函数,返回 wrapper 函数。
01.3.2.5-005 TypeScript 高阶函数怎么做中间件?
一句话结论
TypeScript 没有接口装饰器的标准对象模型,惯用做法是高阶函数:type Middleware = (next: Handler) => Handler,每个中间件接收下一个 handler,返回包装后的 handler,运行期用 compose 串联。
概念解释
- 高阶函数:接收函数返回函数的函数。
- 中间件签名:
(ctx, next) => Promise<void>,next 是下一个中间件。 - compose:把中间件数组串成一个调用链。
原理流程
- 定义 handler 类型与中间件类型。
- 每个中间件写前置逻辑、调
await next()、写后置逻辑。 - 用
compose把中间件数组串成一个 handler。 - 调用时按顺序执行链。
代码或图示
type Handler = (ctx: Context) => Promise<void>;
type Middleware = (next: Handler) => Handler;
const logger: Middleware = (next) => async (ctx) => {
const start = Date.now();
console.log(`-> ${ctx.path}`);
await next(ctx);
console.log(`<- ${ctx.path} ${Date.now() - start}ms`);
};
const auth: Middleware = (next) => async (ctx) => {
if (!ctx.user) throw new Error("unauthorized");
await next(ctx);
};
function compose(middlewares: Middleware[]): Handler {
return middlewares.reduce(
(inner, m) => m(inner),
async () => { /* 末端 */ }
);
}
const handler = compose([logger(auth(async (ctx) => { /* 业务 */ }))]);
常见误区
- 忘记
await next():中间件不调用 next,后续中间件与业务 handler 都不会执行。 - 在 next 之后写同步代码而不 await:后置逻辑会在业务完成后异步执行,顺序错乱。
- 中间件持有请求级状态:应放在
ctx上,不要放在闭包里,否则并发请求会串数据。
追问
- Koa 的中间件和 Express 有什么区别?答:Koa 用
await next()实现洋葱模型,前后置逻辑清晰;Express 用(req, res, next)回调,后置逻辑要在next()调用后写,但容易遗漏。 - 装饰器语法在 TS 里能做什么?答:
@Decorator是实验性语法,作用于类与类成员,常用于依赖注入(如 NestJS),不是函数式中间件。
01.3.2.5-006 Go 的 func(http.Handler) http.Handler 中间件怎么写?
一句话结论
Go 的 HTTP 中间件是装饰器模式的函数式版本:每个中间件接收一个 http.Handler,返回一个新的 http.Handler,在内部做前置处理、调用 next.ServeHTTP、再做后置处理;多个中间件用嵌套或 Chain 工具串联。
概念解释
http.Handler是接口,ServeHTTP(http.ResponseWriter, *http.Request)是唯一方法。- 中间件签名:
func(http.Handler) http.Handler。 - 嵌套顺序:最外层是第一个中间件,最内层是业务 handler。
原理流程
- 写中间件函数,接收
next http.Handler。 - 返回一个新的
http.HandlerFunc,内部做前置、调next.ServeHTTP、做后置。 - 组装时
MiddlewareA(MiddlewareB(BusinessHandler))。 - 请求进来时按外层到内层顺序执行前置,再按内层到外层顺序执行后置。
代码或图示
package main
import (
"log"
"net/http"
"time"
)
func Logging(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
log.Printf("-> %s %s", r.Method, r.URL.Path)
next.ServeHTTP(w, r)
log.Printf("<- %s %s %v", r.Method, r.URL.Path, time.Since(start))
})
}
func Auth(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("X-Token") == "" {
http.Error(w, "unauthorized", http.StatusUnauthorized)
return
}
next.ServeHTTP(w, r)
})
}
func main() {
business := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("ok"))
})
handler := Logging(Auth(business))
http.Handle("/", handler)
http.ListenAndServe(":8080", nil)
}
常见误区
- 中间件不调用
next.ServeHTTP:后续中间件与业务都不执行,请求挂起。 - 后置逻辑在
next.ServeHTTP之后但在 handler 返回之前不写日志:Go 的中间件后置逻辑就是在next.ServeHTTP返回后写,天然正确。 - 把
http.ResponseWriter包成自定义类型却不实现接口:需要包装状态码时,要实现http.ResponseWriter接口或用WrapResponseWriter。
追问
- gorilla/handlers 是装饰器吗?答:是中间件库,提供 Logging、Recovery、Compress 等装饰器。
- Go 里怎么记录响应状态码?答:写一个
responseRecorder实现http.ResponseWriter,在WriteHeader时记录状态码,再传给下一个 handler。
01.3.2.5-007 C# DelegatingHandler 管道怎么组织?
一句话结论
HttpClient 的请求管道由 DelegatingHandler 组成链:每个 DelegatingHandler 持有一个 InnerHandler,重写 SendAsync 做前置处理、调用 base.SendAsync(即 InnerHandler)、再做后置处理;多个 handler 在构造 HttpClient 时按顺序挂载。
概念解释
DelegatingHandler:抽象类,有InnerHandler属性。- 链顺序:最外层 handler 先执行前置,最后执行后置。
HttpClientFactory:在 ASP.NET Core 中用AddHttpMessageHandler注册多个 handler。
原理流程
- 写自定义 handler,继承
DelegatingHandler。 - 重写
SendAsync,在里面插逻辑。 - 把 handler 挂到
HttpClient的PrimaryHttpMessageHandler链上。 - 请求时按链顺序执行。
代码或图示
public class LoggingHandler : DelegatingHandler
{
protected override async Task<HttpResponseMessage> SendAsync(
HttpRequestMessage request, CancellationToken ct)
{
Console.WriteLine($"-> {request.Method} {request.RequestUri}");
var sw = Stopwatch.StartNew();
var response = await base.SendAsync(request, ct);
Console.WriteLine($"<- {(int)response.StatusCode} {sw.ElapsedMilliseconds}ms");
return response;
}
}
// ASP.NET Core 注册
builder.Services.AddHttpClient("api")
.AddHttpMessageHandler<LoggingHandler>()
.AddHttpMessageHandler<AuthHandler>();
常见误区
- 忘记
await base.SendAsync:后续 handler 不执行,请求挂起。 - handler 顺序错乱:
AddHttpMessageHandler的顺序就是执行顺序,先加的是外层。 - 在 handler 里直接修改
HttpRequestMessage:可以,但要注意线程安全与请求复用。
追问
- DelegatingHandler 和中间件有什么区别?答:DelegatingHandler 是 HttpClient 出站管道装饰器,ASP.NET Core 中间件是入站请求装饰器,两者结构相同但方向不同。
- Polly 是装饰器吗?答:Polly 的重试、熔断、超时策略本质是
DelegatingHandler的装饰器,包在HttpClient管道里。
01.3.2.5-008 Rust 所有权下怎么包装?返回新类型还是借用?
一句话结论
Rust 的装饰器受所有权约束:无状态装饰器可以用泛型 newtype 包住内层类型,方法调用时 self.inner.method();需要持有内层可变状态时,用 &mut 借用或 Box<dyn Trait>,不能随意持有可变引用。
概念解释
- newtype 包装:
struct LogDecorator<T>(T),零开销。 - 动态分发:
Box<dyn Trait>允许运行期组合不同实现。 - 借用:装饰器持有内层引用,生命周期标注。
原理流程
- 定义 trait 作为组件接口。
- 写基础实现。
- 写装饰器 newtype,持有内层(值或引用)。
- 实现 trait,方法内做前置/后置再调
self.inner.method()。
代码或图示
trait Notifier {
fn send(&self, msg: &str);
}
struct EmailNotifier;
impl Notifier for EmailNotifier {
fn send(&self, msg: &str) { println!("email: {}", msg); }
}
struct LogDecorator<T: Notifier> {
inner: T,
}
impl<T: Notifier> Notifier for LogDecorator<T> {
fn send(&self, msg: &str) {
println!("before send: {}", msg);
self.inner.send(msg);
println!("after send");
}
}
fn main() {
let n = LogDecorator { inner: EmailNotifier };
n.send("hello");
}
常见误区
- 装饰器持有内层可变引用却不标注生命周期:编译器会拒绝,需要
struct Decorator<'a, T: Notifier> { inner: &'a T }。 - 用
Box<dyn Notifier>却不处理动态分发开销:每次方法调用走虚表,比静态分发慢。 - 装饰器里 clone 内层:所有权转移后,外层不能再使用内层。
追问
- Rust 怎么做运行期组合多个装饰器?答:用
Box<dyn Notifier>,装饰器持有Box<dyn Notifier>,可以运行期嵌套,代价是动态分发。 - Rust 的 trait object 和 Java 接口代理有什么区别?答:trait object 是编译期静态分发为主、运行期动态分发为辅;Java 代理是运行期生成类。
01.3.2.5-009 装饰顺序为什么重要?顺序错了会怎样?
一句话结论
装饰链的执行顺序是「外层到内层前置,内层到外层后置」,顺序错了会导致缓存失效、鉴权绕过、日志漏记、压缩与编码乱序等问题;设计时要明确每层的职责边界。
概念解释
- 洋葱模型:请求进入是外层到内层,响应返回是内层到外层。
- 缓存装饰器应放在最外层(命中就不进业务)。
- 鉴权装饰器应放在业务前面(未授权直接拒绝)。
原理流程
- 列出所有装饰器及其职责。
- 按「先做什么、后做什么」排序。
- 缓存最外层 → 鉴权 → 日志 → 业务。
- 错误的顺序:日志在缓存外面会记录缓存命中的日志,鉴权在日志后面会记录未授权请求的日志。
代码或图示
正确顺序(外→内):
Cache → Auth → Logger → Business
执行:
Cache 命中?→ 是:直接返回
Cache 未命中 → Auth 检查 → Logger 记录 → Business
返回:Business 结果 → Logger 完成 → Auth 放行 → Cache 写入 → 返回
错误顺序:
Logger → Cache → Auth → Business
问题:Cache 命中时 Logger 仍记录,Auth 在 Cache 后面,未授权请求可能被缓存绕过
常见误区
- 缓存放在鉴权后面:未授权请求的响应被缓存,下次授权用户拿到别人的数据。
- 日志放在最外层:缓存命中也记日志,日志量虚高。
- 压缩放在编码前面:压缩后的字节再编码会乱码。
追问
- 怎么决定装饰顺序?答:按「副作用从小到大」排列:无副作用的(日志、计时)放外层,有副作用的(鉴权、写缓存)放内层靠近业务。
- 装饰顺序错了怎么排查?答:在每个装饰器打印进入与退出日志,看调用链是否符合预期。
01.3.2.5-010 装饰器和代理的区别是什么?
一句话结论
两者结构相似(都持有被包装对象、实现同一接口),但意图不同:装饰器强调「增强能力」,由调用方主动组装多层包装;代理强调「控制访问」,代理自己决定是否、何时调用目标,调用方通常不知道代理的存在。
概念解释
- 装饰器:调用方主动
new LogDecorator(new CryptoDecorator(...)),目的是叠加功能。 - 代理:调用方拿到的就是接口,代理可能在内部懒加载、鉴权、远程调用,调用方不感知。
- 边界模糊:Spring AOP 既是动态代理,又承载横切增强,兼具两者特征。
原理流程
- 看谁创建目标:装饰器的目标由调用方传入;代理可能自己创建目标(虚拟代理)。
- 看谁决定调用:装饰器总是调用内层;代理可以拒绝调用(保护代理)。
- 看包装层数:装饰器通常多层叠加;代理通常只有一层。
代码或图示
装饰器:
调用方主动组装 → LogDecorator → CacheDecorator → Business
目的:叠加日志、缓存能力
代理:
调用方拿到 UserService → 实际是 RemoteProxy
RemoteProxy 内部做网络调用,调用方不知道
目的:控制访问(远程、懒加载、鉴权)
常见误区
- 凭代码结构归类:结构相似不代表角色相同,必须看意图。
- 认为代理不能多层:代理也可以嵌套,但通常一层就够。
- 认为装饰器不能控制访问:装饰器也可以前置检查,但其核心定位是增强。
追问
- Spring AOP 更接近哪种?答:动态代理,承载横切增强,兼具装饰器式叠加与代理式拦截特征。
- 装饰器和责任链的区别?答:装饰器一定把请求传给内层并叠加结果;责任链可中断、不继续传递。
01.3.2.5-011 装饰链怎么调试与观测?
一句话结论
装饰链越深,调用栈越长,日志越难定位;调试时应在每个装饰器打印「进入/退出」与关键参数,用结构化日志把每层的职责标记清楚,并在异常时保留完整栈信息。
概念解释
- 栈深:一次业务调用可能经过 4-5 层装饰器,栈帧多。
- 日志串联:用 traceId 贯穿整条链,每层打印自己的职责名。
- 异常透传:装饰器不应吞掉异常,要记录后继续抛出。
原理流程
- 每个装饰器在进入时打印「职责名 + 关键参数」。
- 在退出时打印「耗时 + 结果状态」。
- 异常时记录装饰器名与堆栈,继续抛出。
- 生产环境用 traceId 串联同一请求的所有装饰器日志。
代码或图示
请求进入:
[cache] miss key=user:1
[auth] check user=1 role=user
[logger] start path=/api/user/1
[business] get user id=1
[business] return user=Ann
[logger] end cost=12ms
[auth] pass
[cache] set key=user:1
常见误区
- 装饰器吞掉异常:业务异常被装饰器吃掉,调用方拿不到错误。
- 日志只打印装饰器名不打印参数:排查时不知道是哪个请求出问题。
- 生产环境关闭所有装饰器日志:出问题时无法定位是哪一层装饰器出问题。
追问
- 怎么在不修改代码的情况下看装饰链?答:用 APM 工具(如 SkyWalking、OpenTelemetry)自动采集调用链,每层装饰器作为一个 span。
- 装饰器里 panic/异常怎么处理?答:记录后重新抛出,或在最外层装饰器做兜底(如恢复中间件),但中间层不应吞异常。
01.3.2.5-012 无状态装饰器为什么能复用?
一句话结论
无状态装饰器(只依赖参数与内层对象,不持有实例字段)可以安全地被多线程、多请求共享,不需要每次新建;有状态装饰器(如记录调用次数、缓存请求数据)必须按请求或按内层对象创建。
概念解释
- 无状态装饰器:所有数据通过参数传入,装饰器本身是无副作用的函数式包装。
- 有状态装饰器:持有字段,如缓存、计数器、请求上下文。
- 线程安全:无状态装饰器天然线程安全;有状态装饰器需要同步或按请求隔离。
原理流程
- 判断装饰器是否持有可变字段。
- 无状态:注册为单例,所有请求共享。
- 有状态:按请求创建(如 ASP.NET Core 的 scoped),或用同步原语保护。
代码或图示
// 无状态装饰器:可以单例复用
public class LogDecorator implements Notifier {
private final Notifier inner;
public LogDecorator(Notifier inner) { this.inner = inner; }
public void send(String msg) {
System.out.println("send: " + msg);
inner.send(msg);
}
}
// 有状态装饰器:不能单例
public class CountingDecorator implements Notifier {
private final Notifier inner;
private int count = 0; // 可变状态
public void send(String msg) {
count++; // 多线程下会有竞争
inner.send(msg);
}
}
常见误区
- 把有状态装饰器注册为单例:多请求共享可变字段,数据串号。
- 装饰器持有内层引用却不考虑生命周期:内层对象被释放后,装饰器还持有引用,内存泄漏。
- 认为无状态装饰器零开销:每次调用仍有方法调用与日志 I/O 成本。
追问
- ASP.NET Core 中间件是单例还是 scoped?答:中间件默认单例,因此中间件必须无状态;要访问 scoped 服务,从
HttpContext.RequestServices解析。 - Go 中间件闭包里能放状态吗?答:可以,但状态在所有请求间共享,要加锁;请求级状态放
context.Context。
01.3.2.5-013 Python 类装饰器和 GoF 装饰器有什么关键区别?
一句话结论
Python 类装饰器接收一个类作为参数,在类定义阶段返回新类或修改原类,作用于「类型」;GoF 装饰器作用于「对象」,在运行期包装已有对象实例。两者思路相似但作用层级不同。
概念解释
- 类装饰器:
@decorator作用于class Foo,在类定义时执行。 - 对象装饰器:
new LogDecorator(foo_instance),在运行期包装实例。 - Python 类装饰器常用于给类加日志、注册到工厂、实现单例。
原理流程
- 定义类装饰器函数,接收类,返回新类或修改后的类。
- 在类定义上用
@decorator。 - 解释器在定义阶段执行装饰器。
- 后续
Class()创建的实例已经是装饰后的类。
代码或图示
def add_logging(cls):
original_init = cls.__init__
def new_init(self, *args, **kwargs):
print(f"init {cls.__name__}")
original_init(self, *args, **kwargs)
cls.__init__ = new_init
return cls
@add_logging
class UserService:
def __init__(self, name):
self.name = name
# 等价于:UserService = add_logging(UserService)
# 创建实例时会打印 init UserService
常见误区
- 类装饰器在定义时执行一次:不是每次创建实例时执行;要在实例创建时插逻辑,要包装
__init__。 - 类装饰器修改原类:返回新类是更安全的做法,直接修改原类会影响所有继承。
- 认为类装饰器是运行期代理:它是定义期替换,与 Java 动态代理运行期生成类不同。
追问
- Python 类装饰器和元类有什么区别?答:类装饰器在类创建后修改类,元类在类创建过程中控制类的生成;元类更强大但更复杂。
- GoF 装饰器在 Python 里怎么写?答:写一个持有内层对象的类,实现同一接口,方法里委托内层;和 Java 写法一样。
跨语言差异对照
| 语言 | 惯用实现 | 差异要点 |
|---|---|---|
| Java | 抽象装饰器类 + 具体装饰器嵌套,IO 流是经典案例 | 基于接口与继承,装饰器链在编译期定型 |
| Go | func(http.Handler) http.Handler 函数式中间件 |
无类装饰器,靠高阶函数组合,洋葱模型 |
| Python | @decorator 函数/类装饰器语法糖 |
定义期替换,不是运行期对象包装 |
| PHP | __call 魔术方法、Laravel 中间件管道 |
中间件管道是函数式装饰链,FPM 下每次请求重建 |
| C#/.NET | DelegatingHandler、IApplicationBuilder 中间件 |
HttpClient 与 ASP.NET Core 两套管道都是装饰链 |
| TypeScript/JS | 高阶函数中间件、Proxy、@Decorator 实验语法 |
函数式中间件为主,类装饰器受语法提案限制 |
| Rust | newtype + trait 实现,Box<dyn Trait> 动态组合 |
所有权约束装饰器持有方式,编译期定型为主 |
跨语言差异
- Java 是 GoF 装饰器模式最正统的实现,IO 流是教科书案例。
- Go、TypeScript、C# 把装饰器函数化,用高阶函数或中间件管道实现,比类装饰器更灵活。
- Python、PHP 的装饰器语法糖作用于定义期,与 GoF 对象装饰器不是同一层级。
- Rust 受所有权约束,装饰器要么编译期静态组合(零开销),要么动态分发(
Box<dyn Trait>)。 - 所有语言的装饰器都共享同一个本质:在不改变接口的前提下,运行期叠加职责。
- 装饰器与代理的边界在动态语言中更模糊,因为动态语言的魔术方法既能做装饰也能做代理。
待整理清单
- [ ] 补充 Kotlin 装饰器(
by委托)与 Scala 隐式类装饰器的写法 - [ ] 补充 NestJS 的装饰器与中间件管道
- [ ] 补充 Go 中间件链的
Chain/alice库实现原理 - [ ] 补充 Rust
trait默认方法与装饰器的组合方式