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

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 装饰器模式解决什么问题?包装语义怎么理解?

一句话结论

装饰器在不改变原始对象接口的前提下,把额外职责(日志、缓存、压缩、计时)包装在对象外围,多个装饰器可以按需要层层叠加;相比继承,它能在运行期灵活组合,避免子类爆炸。

概念解释

  • 四个角色:组件接口、具体组件(原始对象)、抽象装饰器(持有组件引用)、具体装饰器(叠加职责)。
  • 包装语义:装饰器与被装饰对象实现同一接口,调用方拿到的还是接口类型,不知道外面包了几层。
  • 职责叠加:每层装饰器只负责一种增强,组合出不同行为。

原理流程

  1. 定义统一组件接口。
  2. 写具体组件,只实现核心业务。
  3. 写抽象装饰器,持有一个组件引用并实现接口。
  4. 具体装饰器继承抽象装饰器,在方法内做前置/后置处理后委托内层。
  5. 调用方按需要嵌套组装。

代码或图示

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。

原理流程

  1. 创建底层数据源流。
  2. 按需要包缓冲流(减少系统调用)。
  3. 再包编码流或对象流。
  4. 统一通过最外层流接口读写。
  5. 关闭最外层会级联关闭底层流。

代码或图示

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 个装饰器类。

原理流程

  1. 识别会变化的职责(日志、加密、压缩、限流)。
  2. 每种职责写一个装饰器。
  3. 运行期按场景组合。
  4. 不需要的增强不包,避免无关对象开销。

代码或图示

继承方式:
  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 装饰器:对象级包装,同一个接口可以运行期包多层。

原理流程

  1. 定义装饰器函数,接收函数或类,返回新函数或类。
  2. 在目标函数/类上用 @decorator 语法。
  3. 解释器在定义阶段执行装饰器,替换原对象。
  4. 运行期调用的是装饰后的函数/类。

代码或图示

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:把中间件数组串成一个调用链。

原理流程

  1. 定义 handler 类型与中间件类型。
  2. 每个中间件写前置逻辑、调 await next()、写后置逻辑。
  3. 用 compose 把中间件数组串成一个 handler。
  4. 调用时按顺序执行链。

代码或图示

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。

原理流程

  1. 写中间件函数,接收 next http.Handler。
  2. 返回一个新的 http.HandlerFunc,内部做前置、调 next.ServeHTTP、做后置。
  3. 组装时 MiddlewareA(MiddlewareB(BusinessHandler))。
  4. 请求进来时按外层到内层顺序执行前置,再按内层到外层顺序执行后置。

代码或图示

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。

原理流程

  1. 写自定义 handler,继承 DelegatingHandler。
  2. 重写 SendAsync,在里面插逻辑。
  3. 把 handler 挂到 HttpClient 的 PrimaryHttpMessageHandler 链上。
  4. 请求时按链顺序执行。

代码或图示

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> 允许运行期组合不同实现。
  • 借用:装饰器持有内层引用,生命周期标注。

原理流程

  1. 定义 trait 作为组件接口。
  2. 写基础实现。
  3. 写装饰器 newtype,持有内层(值或引用)。
  4. 实现 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 装饰顺序为什么重要?顺序错了会怎样?

一句话结论

装饰链的执行顺序是「外层到内层前置,内层到外层后置」,顺序错了会导致缓存失效、鉴权绕过、日志漏记、压缩与编码乱序等问题;设计时要明确每层的职责边界。

概念解释

  • 洋葱模型:请求进入是外层到内层,响应返回是内层到外层。
  • 缓存装饰器应放在最外层(命中就不进业务)。
  • 鉴权装饰器应放在业务前面(未授权直接拒绝)。

原理流程

  1. 列出所有装饰器及其职责。
  2. 按「先做什么、后做什么」排序。
  3. 缓存最外层 → 鉴权 → 日志 → 业务。
  4. 错误的顺序:日志在缓存外面会记录缓存命中的日志,鉴权在日志后面会记录未授权请求的日志。

代码或图示

正确顺序(外→内):
  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 既是动态代理,又承载横切增强,兼具两者特征。

原理流程

  1. 看谁创建目标:装饰器的目标由调用方传入;代理可能自己创建目标(虚拟代理)。
  2. 看谁决定调用:装饰器总是调用内层;代理可以拒绝调用(保护代理)。
  3. 看包装层数:装饰器通常多层叠加;代理通常只有一层。

代码或图示

装饰器:
  调用方主动组装 → LogDecorator → CacheDecorator → Business
  目的:叠加日志、缓存能力

代理:
  调用方拿到 UserService → 实际是 RemoteProxy
  RemoteProxy 内部做网络调用,调用方不知道
  目的:控制访问(远程、懒加载、鉴权)

常见误区

  • 凭代码结构归类:结构相似不代表角色相同,必须看意图。
  • 认为代理不能多层:代理也可以嵌套,但通常一层就够。
  • 认为装饰器不能控制访问:装饰器也可以前置检查,但其核心定位是增强。

追问

  • Spring AOP 更接近哪种?答:动态代理,承载横切增强,兼具装饰器式叠加与代理式拦截特征。
  • 装饰器和责任链的区别?答:装饰器一定把请求传给内层并叠加结果;责任链可中断、不继续传递。

01.3.2.5-011 装饰链怎么调试与观测?

一句话结论

装饰链越深,调用栈越长,日志越难定位;调试时应在每个装饰器打印「进入/退出」与关键参数,用结构化日志把每层的职责标记清楚,并在异常时保留完整栈信息。

概念解释

  • 栈深:一次业务调用可能经过 4-5 层装饰器,栈帧多。
  • 日志串联:用 traceId 贯穿整条链,每层打印自己的职责名。
  • 异常透传:装饰器不应吞掉异常,要记录后继续抛出。

原理流程

  1. 每个装饰器在进入时打印「职责名 + 关键参数」。
  2. 在退出时打印「耗时 + 结果状态」。
  3. 异常时记录装饰器名与堆栈,继续抛出。
  4. 生产环境用 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 无状态装饰器为什么能复用?

一句话结论

无状态装饰器(只依赖参数与内层对象,不持有实例字段)可以安全地被多线程、多请求共享,不需要每次新建;有状态装饰器(如记录调用次数、缓存请求数据)必须按请求或按内层对象创建。

概念解释

  • 无状态装饰器:所有数据通过参数传入,装饰器本身是无副作用的函数式包装。
  • 有状态装饰器:持有字段,如缓存、计数器、请求上下文。
  • 线程安全:无状态装饰器天然线程安全;有状态装饰器需要同步或按请求隔离。

原理流程

  1. 判断装饰器是否持有可变字段。
  2. 无状态:注册为单例,所有请求共享。
  3. 有状态:按请求创建(如 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 类装饰器常用于给类加日志、注册到工厂、实现单例。

原理流程

  1. 定义类装饰器函数,接收类,返回新类或修改后的类。
  2. 在类定义上用 @decorator。
  3. 解释器在定义阶段执行装饰器。
  4. 后续 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 默认方法与装饰器的组合方式