9、（结构型设计模式）Java 装饰器模式深度学习指南

以下是为你精心撰写的 《Java 装饰器模式深度学习指南》，专为 Java 后端开发者打造，内容涵盖：定义、作用、与适配器模式的深度对比、真实业务场景、实现方式（继承 vs 组合）、Spring AOP 对应、避坑指南、最佳实践、面试高频题，所有示例均含中文注释，可直接用于项目重构、日志增强、权限校验、缓存注入、加密处理等核心场景。

---

📘 Java 装饰器模式深度学习指南

—— 从“硬编码增强”到“动态叠加功能”的架构革命

作者：Java 后端架构实战导师
适用对象：Java 后端开发者（Spring Boot / 微服务 / AOP / 日志 / 缓存 / 安全）
目标：彻底掌握“在不修改原对象的前提下，动态添加职责”的黄金模式，告别“重复代码”和“继承爆炸”
核心原则：“我不是改你，我是套你一层外衣，还能一层层套”

---

✅ 一、什么是装饰器模式？

📌 定义：

装饰器模式（Decorator Pattern） 是一种结构型设计模式，它允许你动态地将新功能附加到对象上，而无需修改原有类的代码。它通过组合而非继承来实现功能扩展。

🔍 核心思想：

• 有一个基础对象（被装饰者）
• 有一个装饰器接口，与基础对象实现相同接口
• 每个装饰器类持有一个被装饰对象的引用
• 装饰器在调用被装饰对象方法前后，添加额外行为（如日志、缓存、权限）
• 可以多层嵌套，实现功能叠加

💡 一句话记忆：
“我要一杯咖啡，加奶、加糖、加巧克力——不是做三种新咖啡，而是给原咖啡一层层加料。”

🆚 装饰器模式 vs 继承扩展

方式	继承扩展	装饰器模式
方式	子类继承父类，重写方法	包装对象，组合调用
灵活性	固定组合，编译期确定	动态组合，运行时决定
功能叠加	难以叠加多个功能	✅ 可叠加多个装饰器（A + B + C）
代码复用	产生大量子类	✅ 装饰器可复用
破坏封装	子类依赖父类实现细节	✅ 只依赖接口，不依赖实现
扩展性	新增功能需新建子类	✅ 新增功能只需新建装饰器类

✅ 经典比喻：
你去星巴克买咖啡：

• 继承方式：你得有“美式咖啡”、“加奶美式”、“加糖美式”、“加糖加奶美式”… → 类爆炸！
• 装饰器方式：你点一杯“美式咖啡”，然后说：“加奶”、“再加糖”、“再加巧克力” → 动态叠加，无限组合！

---

✅ 二、装饰器模式有什么作用？（Why Use Decorator Pattern?）

作用	说明
✅ 动态添加功能	不修改原对象，运行时决定添加哪些功能
✅ 避免继承爆炸	不用为每种组合创建子类（如：日志+缓存+加密 = 8 种组合 → 8 个子类）
✅ 符合开闭原则	新增功能只需新增装饰器，不改原有代码
✅ 功能可组合	多个装饰器可叠加使用（如：缓存 + 日志 + 权限）
✅ 透明性高	客户端感知不到装饰器存在，调用方式不变
✅ 职责分离	每个装饰器只负责一个增强功能，单一职责
✅ 支持运行时切换	可根据配置动态决定是否启用某个装饰器

💡 经典名言：
“Instead of subclassing, use composition to add behavior dynamically.”
——《Head First Design Patterns》

---

✅ 三、装饰器模式的典型使用场景（Java 后端真实案例）

场景	说明	是否推荐使用装饰器模式
✅ 日志增强	在方法执行前后打印日志（如：方法名、参数、耗时）	✅ 强烈推荐
✅ 缓存注入	在数据库查询前检查缓存，命中则返回，未命中才查库	✅ 推荐
✅ 权限校验	在业务方法执行前检查用户权限	✅ 推荐
✅ 加密/解密	在数据写入前加密，读取后解密	✅ 推荐
✅ 限流/熔断	在请求处理前判断是否超限	✅ 推荐
✅ 事务管理	在方法前后自动开启/提交/回滚事务	✅ 推荐
✅ 序列化/反序列化	在对象传输前转换为 JSON/Protobuf	✅ 推荐
✅ 数据校验	在保存前校验字段合法性	✅ 推荐
✅ 性能监控	记录方法执行时间、调用次数	✅ 推荐
❌ 简单工具封装	如 StringUtils.isEmpty()	❌ 用静态方法即可
❌ 对象创建	如 new Order()	❌ 用工厂模式
❌ 接口不兼容	如微信 SDK 转成标准接口	❌ 用适配器模式

✅ 判断标准：
“我需要在不修改原类的前提下，动态添加多个可选功能？”
→ 是 → 用装饰器模式！

---

✅ 四、装饰器模式的两种实现方式详解（含中文注释）

我们从经典手写版到Spring AOP 对应版，逐步深入。

---

🔹 1. 经典装饰器模式：接口 + 装饰器类（推荐）

/**
 * 【1】抽象组件：被装饰对象的统一接口
 */
interface OutputStream {
    void write(String data); // 写入数据
}

/**
 * 【2】具体组件：真实输出流
 */
class FileOutputStream implements OutputStream {
    @Override
    public void write(String data) {
        System.out.println("💾 原始写入： " + data);
    }
}

/**
 * 【3】抽象装饰器：持有被装饰对象，实现相同接口
 */
abstract class OutputStreamDecorator implements OutputStream {
    protected OutputStream target; // 持有被装饰对象

    public OutputStreamDecorator(OutputStream target) {
        this.target = target;
    }

    // 默认行为：调用被装饰对象的方法
    @Override
    public void write(String data) {
        target.write(data);
    }
}

/**
 * 【4】具体装饰器1：日志装饰器
 */
class LoggingDecorator extends OutputStreamDecorator {
    public LoggingDecorator(OutputStream target) {
        super(target);
    }

    @Override
    public void write(String data) {
        System.out.println("📝 记录日志：即将写入 → " + data); // 增强前
        super.write(data); // 调用原行为
        System.out.println("✅ 日志记录完成"); // 增强后
    }
}

/**
 * 【5】具体装饰器2：缓存装饰器
 */
class CacheDecorator extends OutputStreamDecorator {
    private String cachedData = null;

    public CacheDecorator(OutputStream target) {
        super(target);
    }

    @Override
    public void write(String data) {
        if (cachedData == null) {
            System.out.println("⚡ 缓存数据： " + data); // 缓存
            cachedData = data;
        } else {
            System.out.println("🔄 缓存已存在，跳过缓存");
        }
        super.write(data); // 调用原行为
    }
}

/**
 * 【6】具体装饰器3：加密装饰器
 */
class EncryptDecorator extends OutputStreamDecorator {
    public EncryptDecorator(OutputStream target) {
        super(target);
    }

    @Override
    public void write(String data) {
        String encrypted = encrypt(data); // 加密
        System.out.println("🔐 加密数据： " + encrypted);
        super.write(encrypted); // 传递加密后数据
    }

    private String encrypt(String data) {
        return "ENCRYPTED_" + data; // 简化加密
    }
}

/**
 * 【7】客户端：动态组合多个装饰器
 */
public class DecoratorDemo {
    public static void main(String[] args) {
        // 创建原始对象
        OutputStream fileStream = new FileOutputStream();

        // ✅ 动态叠加多个装饰器：一层套一层
        OutputStream decorated = new LoggingDecorator(
            new CacheDecorator(
                new EncryptDecorator(fileStream)
            )
        );

        // 调用一次，触发所有增强功能
        decorated.write("用户登录成功");

        // 输出：
        // 🔐 加密数据： ENCRYPTED_用户登录成功
        // 💾 原始写入： ENCRYPTED_用户登录成功
        // ✅ 日志记录完成
        // 🚫 缓存已存在，跳过缓存
        // 📝 记录日志：即将写入 → ENCRYPTED_用户登录成功

        // ✅ 注意：装饰器顺序决定执行顺序！
        // 从内到外：Encrypt → Cache → Logging
        // 执行顺序：Logging → Cache → Encrypt → FileOutputStream
        // 也就是：**外层先执行，内层后执行**
    }
}

✅ 优点：

• 功能可叠加：日志 + 缓存 + 加密 可自由组合
• 无需修改原始类：FileOutputStream 不变
• 符合开闭原则：新增功能只需新增装饰器类
• 透明调用：客户端只看到 OutputStream 接口
• 运行时动态：可依据配置决定是否启用某个装饰器

⚠️ 缺点：

• 装饰器链过长时，代码可读性下降
• 需要手动维护装饰器顺序

---

🔹 2. 装饰器模式 + Java I/O 标准库（真实案例）

Java 的 java.io 包是装饰器模式的经典教科书！

import java.io.*;

public class JavaIODecoratorDemo {
    public static void main(String[] args) throws IOException {
        // 创建基础流：写入文件
        FileOutputStream fileOut = new FileOutputStream("test.txt");

        // ✅ 动态叠加多个装饰器
        BufferedOutputStream buffered = new BufferedOutputStream(fileOut); // 缓冲
        DataOutputStream dataOut = new DataOutputStream(buffered); // 支持写基本类型
        PrintWriter writer = new PrintWriter(dataOut); // 支持 println()

        // 调用一次，触发所有增强
        writer.println("用户登录成功");
        writer.flush(); // 刷新到文件

        // 本质：PrintWriter → DataOutputStream → BufferedOutputStream → FileOutputStream
        // 每一层都包装上一层，功能叠加

        writer.close();
        System.out.println("✅ 文件已写入，使用了 Java 标准装饰器链");
    }
}

✅ Java I/O 的装饰器链：

PrintWriter
    ↓
DataOutputStream
    ↓
BufferedOutputStream
    ↓
FileOutputStream

💡 为什么 Java 要这样设计？
因为它要支持任意组合：你可以有“缓冲+压缩+加密+日志”，也可以“只缓冲”，也可以“只加密”——完全解耦，自由组合！

---

🔹 3. 装饰器模式 + Spring AOP（企业级实现）

在 Spring 中，AOP（面向切面编程）是装饰器模式的终极实现！

/**
 * 【1】业务接口
 */
interface UserService {
    void createUser(String name, String email);
    void deleteUser(Long id);
}

/**
 * 【2】真实实现
 */
@Service
public class UserServiceImpl implements UserService {

    @Override
    public void createUser(String name, String email) {
        System.out.println("👤 创建用户：name=" + name + ", email=" + email);
    }

    @Override
    public void deleteUser(Long id) {
        System.out.println("🗑️ 删除用户：id=" + id);
    }
}

/**
 * 【3】AOP 切面：相当于装饰器
 */
@Aspect
@Component
@Slf4j
public class UserServiceAspect {

    // 切入点：所有 UserService 的方法
    @Pointcut("execution(* com.example.service.UserService.*(..))")
    public void userServiceMethods() {}

    // 前置增强：日志 + 权限校验
    @Before("userServiceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        Object[] args = joinPoint.getArgs();
        log.info("📝 [前置] 方法 {} 被调用，参数：{}", methodName, args);
        // 可在此做权限校验
    }

    // 后置增强：性能监控
    @AfterReturning(pointcut = "userServiceMethods()", returning = "result")
    public void logAfter(JoinPoint joinPoint, Object result) {
        String methodName = joinPoint.getSignature().getName();
        log.info("✅ [后置] 方法 {} 执行完成，结果：{}", methodName, result);
    }

    // 异常增强
    @AfterThrowing(pointcut = "userServiceMethods()", throwing = "ex")
    public void logError(JoinPoint joinPoint, Throwable ex) {
        String methodName = joinPoint.getSignature().getName();
        log.error("❌ [异常] 方法 {} 执行失败：{}", methodName, ex.getMessage());
    }
}

/**
 * 【4】客户端：调用方式完全不变
 */
@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping("/user")
    public void createUser(@RequestParam String name, @RequestParam String email) {
        userService.createUser(name, email); // ✅ 调用方式不变，但自动增强！
    }

    @DeleteMapping("/user/{id}")
    public void deleteUser(@PathVariable Long id) {
        userService.deleteUser(id); // ✅ 自动记录日志、性能、异常
    }
}

✅ 优点：

• 零侵入：业务代码完全不改
• 功能可配置：通过 @EnableAspectJAutoProxy 开启/关闭
• 支持切面复用：一个切面可作用于多个类
• Spring 集成完美：支持事务、缓存、安全等内置切面

✅ 本质就是装饰器模式：

装饰器模式	Spring AOP
LoggingDecorator	@Before 切面
CacheDecorator	@Cacheable 注解
EncryptDecorator	@Encrypt 自定义切面
target.write()	joinPoint.proceed()

✅ 结论：
Spring AOP 是装饰器模式在企业级框架中的“终极形态”！

---

🔹 4. 装饰器模式 + 自定义注解 + AOP（高级实战）

实现一个自定义缓存装饰器，通过注解声明

/**
 * 【1】自定义注解：标记需要缓存的方法
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Cacheable {
    String key() default "";
}

/**
 * 【2】业务接口
 */
interface ProductService {
    Product getProduct(Long id);
    void updateProduct(Product product);
}

/**
 * 【3】真实实现
 */
@Service
public class ProductServiceImpl implements ProductService {

    @Override
    @Cacheable(key = "product:{id}") // ✅ 声明缓存
    public Product getProduct(Long id) {
        System.out.println("🔍 从数据库查询商品：id=" + id);
        return new Product(id, "iPhone 15", 6999.0);
    }

    @Override
    public void updateProduct(Product product) {
        System.out.println("✏️ 更新商品：id=" + product.getId());
    }
}

/**
 * 【4】缓存装饰器切面
 */
@Aspect
@Component
public class CacheAspect {

    private final Map<String, Object> cache = new ConcurrentHashMap<>();

    @Pointcut("@annotation(com.example.annotation.Cacheable)")
    public void cacheableMethod() {}

    @Around("cacheableMethod()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        // 获取方法名和参数
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getName();
        Object[] args = joinPoint.getArgs();

        // 获取 @Cacheable 注解
        Cacheable cacheable = signature.getMethod().getAnnotation(Cacheable.class);
        String key = cacheable.key()
                .replace("{id}", args[0].toString()); // 简化 key 解析

        // 1. 先查缓存
        if (cache.containsKey(key)) {
            System.out.println("⚡ 缓存命中：" + key);
            return cache.get(key);
        }

        // 2. 执行原方法
        Object result = joinPoint.proceed();

        // 3. 缓存结果
        cache.put(key, result);
        System.out.println("💾 缓存写入：" + key);

        return result;
    }
}

/**
 * 【5】客户端
 */
@RestController
public class ProductController {

    @Autowired
    private ProductService productService;

    @GetMapping("/product/{id}")
    public Product getProduct(@PathVariable Long id) {
        return productService.getProduct(id); // ✅ 第一次：查库 + 缓存
    }
}

✅ 效果：

• 第一次访问 /product/1 → 查库 + 缓存
• 第二次访问 /product/1 → 直接从缓存返回，不查库！

💡 这就是 Spring Cache 的底层原理！

---

✅ 五、装饰器模式 vs 适配器模式 对比

维度	装饰器模式	适配器模式
目的	增强功能（加功能）	转换接口（改接口）
目标	保持接口一致，增加行为	使接口兼容，不增加行为
是否改变行为	✅ 是（增强）	❌ 否（只是适配）
是否修改原对象	❌ 不修改	❌ 不修改
是否可叠加	✅ 可叠加多个装饰器	❌ 通常只包装一个
类比	给咖啡加奶、加糖	把 USB-A 转成 USB-C
典型场景	日志、缓存、权限	第三方 SDK、遗留系统

✅ 一句话区分：

• 装饰器：“我给你加点料”
• 适配器：“我让你能插进我的插座”

---

✅ 六、装饰器模式的避坑指南（Java 后端高频踩坑）

问题	原因	解决方案
❌ 用继承实现增强功能	导致类爆炸	✅ 改用装饰器模式
❌ 装饰器中写业务逻辑	装饰器应只负责增强，不负责业务	✅ 业务逻辑放在 Service 层
❌ 忘记调用 super.write()	导致原功能丢失	✅ 每个装饰器必须调用 target.method()
❌ 装饰器顺序混乱	导致缓存先于日志，日志看不到真实数据	✅ 明确顺序：日志 → 缓存 → 加密 → 原对象
❌ 在装饰器中注入 Spring Bean	导致循环依赖	✅ 优先用 AOP，避免手动创建装饰器
❌ 装饰器链过长影响性能	每层都有方法调用开销	✅ 用 AOP + 字节码增强（如 AspectJ）替代运行时包装

---

✅ 七、学习建议与进阶路径

阶段	建议
📚 第一周	为你的 UserService 写一个 LoggingDecorator，记录方法调用
📚 第二周	用 AOP 实现 @Log 注解，自动记录方法执行时间
📚 第三周	用 @Cacheable 实现商品查询缓存，对比缓存命中率
📚 第四周	阅读 Spring 源码：TransactionInterceptor 如何实现事务装饰？
📚 面试准备	准备回答：

“你项目中哪里用了装饰器模式？”
“AOP 是装饰器模式吗？”
“装饰器和适配器区别？”
“Java I/O 是怎么用装饰器的？” |

---

✅ 八、装饰器模式面试高频题（附答案）

Q1：装饰器模式解决了什么问题？

A：解决了“在不修改原有类的前提下，动态地、可叠加地为对象添加新功能”的问题，避免继承爆炸。

Q2：装饰器模式和 AOP 有什么关系？

A：Spring AOP 是装饰器模式的框架级实现，通过切面在方法前后动态插入代码，本质就是装饰器。

Q3：为什么 Java I/O 要用装饰器模式？

A：因为需要支持任意组合（缓冲+压缩+加密+日志），如果用继承，要写 2^n 个子类，无法维护。

Q4：装饰器模式和策略模式的区别？

A：

• 装饰器：增强行为（如加日志）
• 策略：替换行为（如换支付方式）
  → 一个是“加料”，一个是“换配方”

Q5：装饰器模式能用注解实现吗？

A：可以！Spring 的 @Cacheable、@Transactional、@Log 都是装饰器模式的注解化实现。

---

✅ 九、总结：装饰器模式选型决策树

graph TD
    A[需要为对象动态添加功能吗？] --> B{功能是否可叠加？}
    B -->|是| C{是否在 Spring 项目中？}
    C -->|是| D[用 @Aspect + @Before/@Around 实现 AOP]
    C -->|否| E[用对象组合实现装饰器类]
    B -->|否| F[用策略模式替换行为]

✅ 最终推荐：

• Spring 项目 → ✅ AOP + @Aspect（最优雅）
• 非 Spring、需要灵活组合 → ✅ 对象组合装饰器类（最标准）
• 绝对不要：继承扩展、在装饰器中写业务逻辑、忽略调用 target.method()

---

✅ 十、结语：真正的高手，不改代码，只加外衣

你不是在学“装饰器模式”，你是在学“如何在不破坏系统稳定性的前提下，动态增强能力”。

✅ 当你看到 @Cacheable 自动缓存方法结果，而业务代码一行没改时，你已经掌握了 Spring 的灵魂。
✅ 当你用 AOP 统一记录所有接口的访问日志、性能监控、异常追踪时，你已经是架构师了。

不要为了“用模式”而用模式，
要为了“系统可扩展、可维护、可监控”而选择它。

---