7、Java 装饰器模式从入门到实战

Java 装饰器模式从入门到实战（后端必看）

前言：装饰器模式是Java结构型设计模式中最灵活的模式之一，核心作用是"在不修改原有代码的前提下，动态增强对象功能"------就像给手机套壳，不改变手机本身，却能新增防摔、防尘、美观等功能。在后端开发中，我们经常遇到"需要给原有接口新增功能、不破坏原有代码结构、功能可灵活组合"的场景，比如接口日志打印、参数校验、缓存增强等，此时装饰器模式就能完美解决。很多开发者混淆装饰器与适配器、代理模式，面试时说不清楚核心区别，本文从入门到实战，结合真实业务场景+可运行代码+面试高频考点，带你吃透装饰器模式，看完直接能用、能说、能面试，新手也能快速上手。

一、为什么需要装饰器模式？（痛点直击）

先看一个Java后端开发中最常见的真实场景：假设你开发了一个电商系统的商品查询接口，已经上线运行，现在需要给这个接口新增两个功能------接口调用日志打印（记录请求参数和返回结果）、接口返回结果缓存（减少数据库查询压力），且要求：

• 不能修改原有商品查询接口的代码（原有代码已稳定，修改可能引入bug，且可能被其他模块依赖）；

• 日志和缓存功能可灵活组合（比如有的场景需要日志+缓存，有的场景只需要日志，有的场景不需要任何增强）；

• 新增功能后，调用方式不变（前端无需修改调用逻辑）。

如果没有装饰器模式，你可能会这么做：

• 直接修改原有接口实现类，添加日志和缓存代码------违反"开闭原则"，破坏原有稳定代码，且功能无法灵活切换；

• 新建一个接口实现类，复制原有逻辑，再添加增强功能------代码冗余，后期维护成本极高（原有逻辑修改后，所有复制的类都要同步修改）；

• 使用继承实现增强------继承关系固定，无法动态组合多个增强功能（比如日志和缓存无法灵活搭配）。

而装饰器模式的核心价值，就是在不修改原有对象代码、不改变调用方式的前提下，动态地给对象添加新功能，且多个增强功能可灵活组合，既保证原有系统稳定，又满足新需求，同时遵循开闭原则和单一职责原则。

核心结论：当系统中存在"需要增强对象功能、不破坏原有代码、功能可灵活组合"的场景时，优先使用装饰器模式。

二、装饰器模式核心概念（极简理解）

装饰器模式的核心思想："定义一个装饰器类，持有被装饰对象（原有对象）的引用，实现与被装饰对象相同的接口，在调用原有方法的基础上，新增增强逻辑，从而实现功能增强"。

简单说，装饰器就是"功能增强器"，它包裹着原有对象，不改变原有对象的核心功能，却能在原有功能的基础上，新增额外的功能，且多个装饰器可以嵌套使用，实现功能的组合增强。

装饰器模式有4个核心角色（必须掌握，面试常考，结合实战理解，无需死记硬背）：

1. Component（抽象组件）：定义被装饰对象和装饰器的共同接口/抽象类，规范核心功能（如上述场景中"商品查询接口"）；

2. ConcreteComponent（具体组件）：抽象组件的具体实现，即被装饰的原有对象，实现核心功能（如上述场景中"商品查询接口的原始实现类"）；

3. Decorator（抽象装饰器）：实现抽象组件接口，持有被装饰对象（ConcreteComponent）的引用，定义装饰器的公共行为（如"功能增强的公共逻辑"）；

4. ConcreteDecorator（具体装饰器）：抽象装饰器的具体实现，在调用被装饰对象方法的基础上，添加具体的增强功能（如"日志装饰器""缓存装饰器"）。

重点补充：装饰器模式的关键是"装饰器与被装饰对象实现相同的接口"，且装饰器持有被装饰对象的引用------这是它与适配器模式、代理模式的核心区别之一，下文会详细对比。

三、装饰器模式手写实战（必掌握）

以"商品查询接口增强"为统一场景，实现装饰器模式的完整流程，包含原始功能、日志装饰器、缓存装饰器，以及功能组合增强，代码可直接复制运行。

场景准备：定义抽象组件和具体组件（原有功能）

先定义商品查询的核心接口（抽象组件）和原始实现类（具体组件），模拟原有系统的稳定功能。

/**
 * 1. 抽象组件（Component）：商品查询接口，定义核心功能规范
 */
public interface GoodsService {
    // 核心方法：根据商品ID查询商品信息，返回JSON字符串
    String queryGoodsById(String goodsId);
}

/**
 * 2. 具体组件（ConcreteComponent）：商品查询接口的原始实现（被装饰对象）
 * 模拟原有系统的稳定功能，不修改此类
 */
public class GoodsServiceImpl implements GoodsService {

    @Override
    public String queryGoodsById(String goodsId) {
        // 模拟数据库查询逻辑（原有核心功能）
        System.out.println("数据库查询商品，商品ID：" + goodsId);
        // 模拟返回商品信息（JSON格式）
        return "{\"goodsId\":\"" + goodsId + "\",\"goodsName\":\"Java编程思想\",\"price\":89.9,\"stock\":100}";
    }
}

步骤1：定义抽象装饰器（Decorator）

实现抽象组件接口，持有被装饰对象的引用，定义装饰器的公共逻辑，所有具体装饰器都继承此类。

/**
 * 抽象装饰器（Decorator）：实现抽象组件接口，持有被装饰对象引用
 * 定义所有具体装饰器的公共行为，可添加通用增强逻辑
 */
public abstract class GoodsDecorator implements GoodsService {

    // 持有被装饰对象（ConcreteComponent）的引用
    protected GoodsService goodsService;

    // 构造方法：注入被装饰对象
    public GoodsDecorator(GoodsService goodsService) {
        this.goodsService = goodsService;
    }

    // 实现抽象组件方法，默认调用被装饰对象的方法（可在子类中重写，添加增强逻辑）
    @Override
    public String queryGoodsById(String goodsId) {
        // 默认调用被装饰对象的核心方法，子类可重写此方法添加增强
        return goodsService.queryGoodsById(goodsId);
    }
}

步骤2：实现具体装饰器1------日志装饰器（新增日志功能）

继承抽象装饰器，重写核心方法，在调用被装饰对象方法的前后，添加日志打印逻辑（增强功能）。

/**
 * 具体装饰器1：日志装饰器（ConcreteDecorator）
 * 功能：给商品查询接口添加日志打印增强
 */
public class LogGoodsDecorator extends GoodsDecorator {

    // 构造方法：注入被装饰对象
    public LogGoodsDecorator(GoodsService goodsService) {
        super(goodsService);
    }

    // 重写核心方法，添加日志增强逻辑
    @Override
    public String queryGoodsById(String goodsId) {
        // 增强逻辑1：调用核心方法前，打印请求日志
        System.out.println("【日志装饰器】请求参数：goodsId=" + goodsId + "，请求时间：" + System.currentTimeMillis());
        
        // 调用被装饰对象的核心方法（原有功能）
        String result = super.queryGoodsById(goodsId);
        
        // 增强逻辑2：调用核心方法后，打印返回日志
        System.out.println("【日志装饰器】返回结果：" + result);
        
        // 返回增强后的结果（此处未修改结果，仅添加日志）
        return result;
    }
}

步骤3：实现具体装饰器2------缓存装饰器（新增缓存功能）

继承抽象装饰器，重写核心方法，添加缓存逻辑：先查询缓存，缓存不存在则调用原始方法，查询后存入缓存（增强功能）。

import java.util.HashMap;
import java.util.Map;

/**
 * 具体装饰器2：缓存装饰器（ConcreteDecorator）
 * 功能：给商品查询接口添加缓存增强，减少数据库查询压力
 */
public class CacheGoodsDecorator extends GoodsDecorator {

    // 模拟本地缓存（实际开发中可用Redis、Caffeine等）
    private Map<String, String> goodsCache = new HashMap<>();

    // 构造方法：注入被装饰对象
    public CacheGoodsDecorator(GoodsService goodsService) {
        super(goodsService);
    }

    // 重写核心方法，添加缓存增强逻辑
    @Override
    public String queryGoodsById(String goodsId) {
        // 增强逻辑1：先查询缓存
        if (goodsCache.containsKey(goodsId)) {
            System.out.println("【缓存装饰器】从缓存中查询商品，商品ID：" + goodsId);
            return goodsCache.get(goodsId);
        }
        
        // 增强逻辑2：缓存不存在，调用被装饰对象的核心方法（查询数据库）
        String result = super.queryGoodsById(goodsId);
        
        // 增强逻辑3：将查询结果存入缓存，便于下次查询
        goodsCache.put(goodsId, result);
        System.out.println("【缓存装饰器】商品存入缓存，商品ID：" + goodsId);
        
        return result;
    }
}

步骤4：测试装饰器模式（功能增强+灵活组合）

测试不同的功能组合，验证装饰器的灵活性：只使用原始功能、只加日志、只加缓存、日志+缓存组合。

/**
 * 装饰器模式测试类
 * 验证：功能增强、灵活组合、不修改原有代码
 */
public class DecoratorTest {
    public static void main(String[] args) {
        // 1. 原始功能（无任何增强）
        GoodsService originalGoodsService = new GoodsServiceImpl();
        System.out.println("=== 原始功能测试 ===");
        originalGoodsService.queryGoodsById("G20260415001");
        System.out.println();

        // 2. 只添加日志增强（使用日志装饰器包裹原始对象）
        GoodsService logDecoratorService = new LogGoodsDecorator(originalGoodsService);
        System.out.println("=== 只加日志增强测试 ===");
        logDecoratorService.queryGoodsById("G20260415001");
        System.out.println();

        // 3. 只添加缓存增强（使用缓存装饰器包裹原始对象）
        GoodsService cacheDecoratorService = new CacheGoodsDecorator(originalGoodsService);
        System.out.println("=== 只加缓存增强测试 ===");
        cacheDecoratorService.queryGoodsById("G20260415001"); // 第一次查询：查数据库，存入缓存
        cacheDecoratorService.queryGoodsById("G20260415001"); // 第二次查询：查缓存
        System.out.println();

        // 4. 日志+缓存组合增强（装饰器嵌套：缓存装饰器包裹原始对象，日志装饰器包裹缓存装饰器）
        GoodsService combinationService = new LogGoodsDecorator(new CacheGoodsDecorator(originalGoodsService));
        System.out.println("=== 日志+缓存组合增强测试 ===");
        combinationService.queryGoodsById("G20260415001"); // 第一次：日志→缓存（无）→数据库→缓存
        combinationService.queryGoodsById("G20260415001"); // 第二次：日志→缓存（有）→返回
    }
}

运行结果（清晰看到增强效果）

=== 原始功能测试 ===
数据库查询商品，商品ID：G20260415001

=== 只加日志增强测试 ===
【日志装饰器】请求参数：goodsId=G20260415001，请求时间：1713187560000
数据库查询商品，商品ID：G20260415001
【日志装饰器】返回结果：{"goodsId":"G20260415001","goodsName":"Java编程思想","price":89.9,"stock":100}

=== 只加缓存增强测试 ===
数据库查询商品，商品ID：G20260415001
【缓存装饰器】商品存入缓存，商品ID：G20260415001
【缓存装饰器】从缓存中查询商品，商品ID：G20260415001

=== 日志+缓存组合增强测试 ===
【日志装饰器】请求参数：goodsId=G20260415001，请求时间：1713187560001
数据库查询商品，商品ID：G20260415001
【缓存装饰器】商品存入缓存，商品ID：G20260415001
【日志装饰器】返回结果：{"goodsId":"G20260415001","goodsName":"Java编程思想","price":89.9,"stock":100}
【日志装饰器】请求参数：goodsId=G20260415001，请求时间：1713187560002
【缓存装饰器】从缓存中查询商品，商品ID：G20260415001
【日志装饰器】返回结果：{"goodsId":"G20260415001","goodsName":"Java编程思想","price":89.9,"stock":100}

装饰器模式核心要点（避坑）

• 装饰器与被装饰对象必须实现相同的接口（或继承相同的抽象类），保证调用方式不变；

• 装饰器持有被装饰对象的引用，通过构造方法注入，而非继承，降低耦合度；

• 增强逻辑在调用被装饰对象方法的前后添加，不修改原有核心逻辑；

• 多个装饰器可嵌套使用，实现功能组合（如日志+缓存），顺序可灵活调整（如先日志后缓存、先缓存后日志）。

四、实战二：装饰器模式进阶（结合Spring，企业实战）

实际企业开发中，我们不会手动创建装饰器和被装饰对象实例，而是结合Spring框架的依赖注入（DI）、注解，将装饰器和被装饰对象交给Spring容器管理，进一步降低耦合，实现更灵活的功能增强。

场景升级：接口增强（日志+权限校验）

假设项目中所有接口都需要新增"日志打印"和"权限校验"功能，使用装饰器模式结合Spring，实现接口增强，且不修改原有接口代码，支持灵活切换增强功能。

步骤1：定义抽象组件和具体组件（原有接口）

import org.springframework.stereotype.Service;

/**
 * 抽象组件：用户接口（企业项目中通常是Service接口）
 */
public interface UserService {
    // 核心方法：根据用户ID查询用户信息
    String queryUserById(String userId);
}

/**
 * 具体组件：用户接口实现类（被装饰对象）
 * 交给Spring管理，原有功能稳定，不修改
 */
@Service
public class UserServiceImpl implements UserService {

    @Override
    public String queryUserById(String userId) {
        // 模拟数据库查询逻辑
        System.out.println("数据库查询用户，用户ID：" + userId);
        return "{\"userId\":\"" + userId + "\",\"userName\":\"张三\",\"age\":25}";
    }
}

步骤2：定义抽象装饰器和具体装饰器（结合Spring注解）

使用Spring的@Component注解将装饰器交给Spring管理，通过@Autowired注入被装饰对象，实现功能增强。

import org.springframework.stereotype.Component;

/**
 * 抽象装饰器：结合Spring，持有被装饰对象引用
 */
@Component
public abstract class UserDecorator implements UserService {

    // 注入被装饰对象（Spring自动注入UserServiceImpl实例）
    @Autowired
    protected UserService userService;

    // 默认调用被装饰对象的方法
    @Override
    public String queryUserById(String userId) {
        return userService.queryUserById(userId);
    }
}

/**
 * 具体装饰器1：日志装饰器（Spring管理）
 */
@Component
public class LogUserDecorator extends UserDecorator {

    @Override
    public String queryUserById(String userId) {
        // 增强逻辑：日志打印
        System.out.println("【用户接口日志】请求参数：userId=" + userId);
        String result = super.queryUserById(userId);
        System.out.println("【用户接口日志】返回结果：" + result);
        return result;
    }
}

/**
 * 具体装饰器2：权限校验装饰器（Spring管理）
 */
@Component
public class AuthUserDecorator extends UserDecorator {

    @Override
    public String queryUserById(String userId) {
        // 增强逻辑：权限校验（模拟，实际开发中可对接权限框架）
        if (!"admin".equals(userId)) {
            System.out.println("【权限校验】用户ID：" + userId + "，无查询权限");
            return "{\"code\":403,\"message\":\"无权限访问\"}";
        }
        // 权限通过，调用核心方法
        return super.queryUserById(userId);
    }
}

步骤3：Spring配置与客户端调用（企业实战版）

通过Spring的@Configuration配置类，实现装饰器的灵活组合，客户端直接调用装饰器实例，无需关心对象创建和依赖注入。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Spring配置类：组合装饰器，实现灵活增强
 * 可根据业务需求，配置不同的装饰器组合
 */
@Configuration
public class DecoratorConfig {

    // 配置：日志+权限校验 组合装饰器
    @Bean
    public UserService userServiceWithLogAndAuth(LogUserDecorator logDecorator, AuthUserDecorator authDecorator) {
        // 嵌套装饰：先权限校验，再日志打印（顺序可调整）
        authDecorator.userService = logDecorator;
        return authDecorator;
    }

    // 配置：只日志装饰器（单独使用）
    @Bean
    public UserService userServiceWithLog(LogUserDecorator logDecorator) {
        return logDecorator;
    }

    // 配置：只权限校验装饰器（单独使用）
    @Bean
    public UserService userServiceWithAuth(AuthUserDecorator authDecorator) {
        return authDecorator;
    }
}

/**
 * 客户端调用（企业开发常用，通过Spring容器获取实例）
 */
public class SpringDecoratorClient {
    public static void main(String[] args) {
        // 加载Spring配置，获取容器
        org.springframework.context.ApplicationContext context = new org.springframework.context.annotation.AnnotationConfigApplicationContext(DecoratorConfig.class);

        // 1. 测试：日志+权限校验组合
        System.out.println("=== 日志+权限校验组合 ===");
        UserService service1 = context.getBean("userServiceWithLogAndAuth", UserService.class);
        System.out.println(service1.queryUserById("admin")); // 有权限，正常返回
        System.out.println(service1.queryUserById("user123")); // 无权限，返回403
        System.out.println();

        // 2. 测试：只日志装饰器
        System.out.println("=== 只日志装饰器 ===");
        UserService service2 = context.getBean("userServiceWithLog", UserService.class);
        service2.queryUserById("user123"); // 无权限校验，正常返回
    }
}

进阶要点（企业开发避坑）

• 装饰器与被装饰对象都交给Spring管理，通过@Autowired注入，无需手动创建实例，降低耦合；

• 通过Spring配置类，可灵活组合不同的装饰器，无需修改代码，只需调整配置；

• 实际开发中，装饰器可用于接口日志、权限校验、缓存、事务控制、异常处理等通用增强场景；

• 若需要动态切换装饰器（如根据不同环境启用不同增强功能），可结合Spring的@Profile注解实现。

五、实战三：框架中的装饰器模式（面试必说）

装饰器模式在Java主流框架中应用极其广泛，面试时能说出1-2个具体应用，会显得你理解更深刻，不是只懂理论。

1. Java IO流（核心应用，日常开发必用）

Java IO流中的缓冲流（BufferedInputStream、BufferedOutputStream）、转换流（InputStreamReader、OutputStreamWriter）、打印流（PrintStream）等，本质都是装饰器模式的实现，核心作用是"增强IO流的功能"。

• Component（抽象组件）：InputStream、OutputStream、Reader、Writer（IO流的顶层接口）；

• ConcreteComponent（具体组件）：FileInputStream、FileOutputStream（原始IO流，被装饰对象）；

• Decorator（抽象装饰器）：FilterInputStream、FilterOutputStream（IO流的抽象装饰器，持有原始流引用）；

• ConcreteDecorator（具体装饰器）：BufferedInputStream（缓冲增强）、InputStreamReader（转换增强）。

// 示例：BufferedInputStream（缓冲装饰器，增强FileInputStream的功能）
// 原始流（被装饰对象）：FileInputStream，无缓冲，读取效率低
java.io.InputStream inputStream = new java.io.FileInputStream("test.txt");
// 装饰器：BufferedInputStream，添加缓冲功能，提高读取效率
java.io.InputStream bufferedInputStream = new java.io.BufferedInputStream(inputStream);

// 读取数据（调用方式不变，底层已被增强）
int data = bufferedInputStream.read();

核心逻辑：BufferedInputStream持有FileInputStream的引用，在read()方法中添加缓冲逻辑，增强原始流的读取效率，不改变原始流的核心功能和调用方式。

2. Spring 框架：TransactionAwareDataSourceProxy（事务装饰器）

Spring中的TransactionAwareDataSourceProxy是装饰器模式的实现，核心作用是"给数据源（DataSource）添加事务支持"。

它持有DataSource的引用（被装饰对象），实现与DataSource相同的接口，在获取连接、关闭连接等方法中，添加事务管理的增强逻辑，让普通数据源具备事务功能，无需修改原有数据源代码。

3. Spring 框架：Cacheable注解（缓存装饰器）

Spring的@Cacheable注解，底层本质也是装饰器模式的思想：通过AOP动态生成装饰器，给目标方法添加缓存增强逻辑，在不修改目标方法代码的前提下，实现缓存功能。

4. 实际项目场景：接口统一响应包装

项目中所有接口需要统一返回格式（如{"code":200,"message":"success","data":{}}），使用装饰器模式，给所有接口添加响应包装增强，无需修改每个接口的返回逻辑，实现统一规范。

六、装饰器模式面试高频考点（必背）

1. 装饰器模式的核心优势？

• 遵循开闭原则：新增增强功能时，只需新增装饰器类，无需修改原有代码，降低维护成本；

• 功能灵活组合：多个装饰器可嵌套使用，实现不同功能的组合，无需修改代码，只需调整装饰顺序；

• 不破坏原有结构：不修改被装饰对象的核心代码，保证原有系统稳定，避免引入bug；

• 单一职责：每个装饰器只负责一个增强功能，逻辑清晰，便于维护和扩展。

2. 装饰器模式的三种核心角色及作用？（高频中的高频）

• 抽象组件（Component）：定义被装饰对象和装饰器的共同接口，规范核心功能；

• 具体组件（ConcreteComponent）：抽象组件的具体实现，即被装饰的原始对象，实现核心功能；

• 装饰器（Decorator+ConcreteDecorator）：持有被装饰对象引用，实现抽象组件接口，添加增强功能。

3. 装饰器模式、适配器模式、代理模式的区别？（面试易错点）

核心区别：目的不同、结构不同，记住一句话区分，面试直接说清：

• 装饰器模式：核心是"增强功能"，装饰器与被装饰对象实现相同接口，持有被装饰对象引用，不改变接口，只增强功能；

• 适配器模式：核心是"解决接口不兼容"，适配器与被适配者接口不同，通过转换接口，让不兼容的接口可以对接；

• 代理模式：核心是"控制访问"，代理类与被代理类实现相同接口，持有被代理类引用，主要用于权限控制、远程调用等，不改变核心功能。

补充：装饰器模式关注"功能增强"，适配器模式关注"接口兼容"，代理模式关注"访问控制"，三者都不修改原有代码，但目的和使用场景完全不同。

4. 装饰器模式的缺点？（避坑重点）

• 增加系统复杂度：新增装饰器类，会增加类的数量，若装饰器嵌套过多，排查问题难度较大；

• 装饰顺序影响结果：多个装饰器嵌套时，顺序错误可能导致功能异常（如先缓存后日志，日志无法打印缓存查询的请求）；

• 不适用于单一功能增强：若只需给单个对象添加简单增强，使用装饰器模式会显得繁琐（可直接使用代理模式或简单继承）。

5. 什么时候用装饰器模式？（实战判断）

• 需要给原有对象新增功能，且不允许修改原有代码（遵循开闭原则）；

• 多个增强功能需要灵活组合（如日志+缓存+权限校验）；

• 需要给多个对象统一添加相同的增强功能（如所有接口添加日志打印）；

• IO流增强、缓存增强、日志增强、权限校验等通用场景。

七、总结（实战+面试双达标）

对于Java后端开发者来说，装饰器模式是"功能增强的万能工具"，它不像工厂模式、单例模式那样频繁使用，但在接口增强、通用功能封装、框架开发等场景中，是不可或缺的设计模式，也是面试中高频考察的重点（尤其是与其他模式的区别）。

1. 基础：掌握4个核心角色，理解装饰器模式"增强不修改、灵活可组合"的核心思想，能手动实现简单装饰器；

2. 实战：重点掌握装饰器与Spring的结合，实现企业级接口增强，理解Java IO流中装饰器的应用；

3. 面试：能清晰区分装饰器、适配器、代理模式的区别，说出框架中的应用场景，掌握装饰器的优缺点；

4. 避坑：记住"功能增强用装饰器，接口兼容用适配器，访问控制用代理"，避免装饰器嵌套过多，合理设计装饰顺序。

记住一句话：装饰器模式的核心是"包裹增强，不碰核心"，通过装饰器包裹原有对象，在不改变原有功能和调用方式的前提下，动态添加新功能，实现灵活扩展。掌握它，能让你在接口增强、通用功能封装中事半功倍，面试时也能轻松应对设计模式相关提问。

补充：常见问题解决

• 问题1：装饰器嵌套过多，排查问题困难怎么办？

  解决：每个装饰器只负责一个增强功能，给装饰器命名规范（如LogXXXDecorator、CacheXXXDecorator），添加详细日志，便于定位问题；

• 问题2：装饰顺序错误导致功能异常怎么办？

  解决：明确装饰顺序的逻辑（如"权限校验→日志→缓存"），在Spring配置类中固定装饰顺序，避免随意调整；

• 问题3：如何实现装饰器的动态启用/禁用？

  解决：结合Spring的@Profile、@Conditional注解，根据环境或配置，动态启用或禁用指定装饰器。