Java设计模式实战：创建型与结构型模式详解

1. 设计模式核心价值与学习路径

设计模式是面向对象编程的精华所在，它记录了前辈工程师们在解决特定场景问题时的最佳实践。就像建筑大师克里斯托弗·亚历山大提出的模式语言，每个设计模式都是针对某类问题的可复用解决方案。我在实际项目中最深刻的体会是：没有最好的模式，只有最适合场景的模式选择。

初学者常陷入两个极端：要么过度设计，把简单问题复杂化；要么忽视设计，导致代码难以维护。正确的学习路径应该是：先理解23种经典模式的适用场景，再通过真实案例体会其精妙之处。比如策略模式在电商促销系统中的应用，观察者模式在消息通知场景的实现等。

重要提示：设计模式不是银弹，滥用模式比不用模式危害更大。我曾见过一个简单CRUD接口被套用7种模式的案例，这种过度设计反而让系统变得难以维护。

2. 创建型模式深度解析

2.1 单例模式的线程安全实现

单例模式看似简单，但实现起来暗藏玄机。最常见的懒汉式写法存在严重的线程安全问题：

java复制// 错误示范 - 非线程安全
public class Singleton {
    private static Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton(); // 多线程环境下可能创建多个实例
        }
        return instance;
    }
}

正确的实现方式至少有五种：

1. 饿汉式（类加载时初始化）
2. 双重检查锁（JDK5+）
3. 静态内部类（推荐方案）
4. 枚举单例（防反射攻击）
5. ThreadLocal单例（线程隔离场景）

其中静态内部类方案兼顾了懒加载和线程安全：

java复制public class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

2.2 工厂方法 vs 抽象工厂

这两个模式经常被混淆，其实本质区别在于：

• 工厂方法：创建单一产品（如不同品牌的汽车）
• 抽象工厂：创建产品族（如汽车+轮胎+座椅的组合）

在电商系统中，抽象工厂非常适合处理不同支付渠道的创建：

java复制// 抽象工厂接口
interface PaymentFactory {
    Payment createPayment();
    Refund createRefund();
    Notify createNotify();
}

// 支付宝实现
class AlipayFactory implements PaymentFactory {
    public Payment createPayment() { return new AlipayPayment(); }
    public Refund createRefund() { return new AlipayRefund(); }
    public Notify createNotify() { return new AlipayNotify(); }
}

3. 结构型模式实战技巧

3.1 装饰器模式在IO流中的应用

Java IO包是装饰器模式的经典实现。比如BufferedInputStream就是对FileInputStream的功能增强：

java复制InputStream in = new BufferedInputStream( // 缓冲功能
                    new GZIPInputStream(  // 解压功能
                        new FileInputStream("test.gz"))); // 基础文件流

这种嵌套结构的好处是：

• 各装饰器职责单一
• 可以动态组合功能
• 避免类爆炸问题

我在日志系统开发中，曾用装饰器模式实现多级日志过滤：

java复制Logger logger = new EmailLogger(          // 邮件通知
                   new ErrorLevelFilter(  // 错误级别过滤
                       new FileLogger()));// 基础文件日志

3.2 适配器模式解决接口不兼容

实际开发中经常遇到老系统改造的场景。比如我们有个老式用户查询接口：

java复制interface LegacyUserService {
    User getUser(String id);
    List<User> getAllUsers();
}

现在需要接入新的用户中心接口：

java复制interface NewUserAPI {
    UserInfo queryUser(Map<String, Object> params);
    PageResult<UserInfo> queryUsers(PageRequest request);
}

适配器模式的实现方案：

java复制class UserServiceAdapter implements LegacyUserService {
    private NewUserAPI newAPI;
    
    public User getUser(String id) {
        Map<String, Object> params = new HashMap<>();
        params.put("userId", id);
        UserInfo info = newAPI.queryUser(params);
        return convertUser(info);
    }
    
    // 其他适配方法...
}

4. 行为型模式最佳实践

4.1 观察者模式的事件驱动架构

观察者模式在分布式系统中尤为重要。以订单状态变更通知为例：

java复制// 事件发布者
class OrderService {
    private List<OrderListener> listeners = new ArrayList<>();
    
    public void addListener(OrderListener listener) {
        listeners.add(listener);
    }
    
    public void paySuccess(Order order) {
        // 处理支付逻辑...
        notifyListeners(order, "PAY_SUCCESS");
    }
    
    private void notifyListeners(Order order, String event) {
        for (OrderListener listener : listeners) {
            listener.onEvent(order, event);
        }
    }
}

// 邮件通知实现
class EmailNotifier implements OrderListener {
    public void onEvent(Order order, String event) {
        if ("PAY_SUCCESS".equals(event)) {
            sendPaymentEmail(order.getUser());
        }
    }
}

在Spring框架中，可以直接使用ApplicationEvent机制实现观察者模式：

java复制// 定义事件
class OrderEvent extends ApplicationEvent {
    private String eventType;
    public OrderEvent(Object source, String type) {
        super(source);
        this.eventType = type;
    }
}

// 发布事件
applicationContext.publishEvent(new OrderEvent(order, "PAY_SUCCESS"));

// 监听事件
@Component
class EmailListener {
    @EventListener
    public void handleOrderEvent(OrderEvent event) {
        // 处理事件
    }
}

4.2 策略模式的业务规则处理

在风控系统中，不同业务线有不同的规则校验策略：

java复制interface RiskStrategy {
    boolean check(RiskRequest request);
}

class LoanStrategy implements RiskStrategy {
    public boolean check(RiskRequest request) {
        // 贷款特有风控逻辑
    }
}

class PaymentStrategy implements RiskStrategy {
    public boolean check(RiskRequest request) {
        // 支付特有风控逻辑
    }
}

// 策略上下文
class RiskContext {
    private RiskStrategy strategy;
    
    public void setStrategy(RiskStrategy strategy) {
        this.strategy = strategy;
    }
    
    public boolean executeCheck(RiskRequest request) {
        return strategy.check(request);
    }
}

结合Spring的依赖注入可以更优雅地管理策略：

java复制@Service
class RiskService {
    @Autowired
    private Map<String, RiskStrategy> strategies; // 自动注入所有实现
    
    public boolean check(String bizType, RiskRequest request) {
        RiskStrategy strategy = strategies.get(bizType + "Strategy");
        return strategy.check(request);
    }
}

5. 设计模式综合应用案例

5.1 电商促销系统设计

一个完整的促销系统需要多种模式组合：

1. 工厂模式创建不同促销类型（满减、折扣、赠品）
2. 策略模式实现促销计算规则
3. 责任链模式处理促销叠加逻辑
4. 观察者模式通知促销结果

核心代码结构示例：

java复制// 促销工厂
interface PromotionFactory {
    Promotion createPromotion(PromotionDTO dto);
}

// 满减促销策略
class DiscountStrategy implements CalculateStrategy {
    public BigDecimal calculate(Order order) {
        // 满减计算逻辑
    }
}

// 促销责任链
class PromotionChain {
    private List<PromotionHandler> handlers;
    
    public void process(Order order) {
        for (PromotionHandler handler : handlers) {
            if (!handler.handle(order)) break;
        }
    }
}

5.2 分布式锁的多种实现方案

在不同场景下，我们需要选择适合的锁实现策略：

1. Redis分布式锁（单机Redis）

java复制public boolean tryLock(String key, long expire) {
    return redisTemplate.opsForValue()
            .setIfAbsent(key, "1", expire, TimeUnit.SECONDS);
}

2. RedLock算法（Redis集群）
3. Zookeeper临时节点
4. 数据库乐观锁

使用策略模式封装多种实现：

java复制interface DistributedLock {
    boolean tryLock(String key, long waitTime);
    void unlock(String key);
}

class LockContext {
    private DistributedLock lock;
    
    public void setLock(DistributedLock lock) {
        this.lock = lock;
    }
    
    public void executeWithLock(String key, Runnable task) {
        if (lock.tryLock(key, 3000)) {
            try {
                task.run();
            } finally {
                lock.unlock(key);
            }
        }
    }
}

6. 设计模式常见误区与优化建议

6.1 过度设计的典型症状

1. 为不需要扩展的功能预留接口
2. 三层以上的装饰器嵌套
3. 策略模式中只有一种策略实现
4. 滥用单例导致测试困难

我曾经重构过一个"模式滥用"的典型案例：

java复制// 原始代码 - 过度设计
public class ReportService {
    private ReportStrategyFactory factory;
    private ReportDecoratorChain decorators;
    private ReportObserverManager observers;
    
    public void generate() {
        ReportStrategy strategy = factory.getStrategy(type);
        Report report = strategy.generate();
        report = decorators.decorate(report);
        observers.notify(report);
    }
}

// 优化后 - 保持简单
public class ReportService {
    public Report generateSimpleReport() {
        // 直接实现核心逻辑
    }
}

6.2 性能优化实践经验

某些设计模式需要注意性能影响：

1. 装饰器模式的多层嵌套会增加调用栈深度
2. 观察者模式的同步通知会阻塞主流程
3. 责任链模式的长链条会增加响应时间

优化方案：

• 异步观察者（使用事件总线）
• 责任链短路机制（快速失败）
• 对象池复用享元对象

例如改进后的观察者模式：

java复制// 异步事件总线
class EventBus {
    private Executor executor = Executors.newFixedThreadPool(4);
    
    public void post(Event event) {
        executor.execute(() -> {
            for (Listener listener : listeners) {
                listener.onEvent(event);
            }
        });
    }
}

7. 设计模式面试精要

7.1 高频面试题解析

1. "Spring中用了哪些设计模式？"

   • 工厂模式：BeanFactory
   • 代理模式：AOP实现
   • 模板方法：JdbcTemplate
   • 观察者：ApplicationEvent
   • 适配器：HandlerAdapter

2. "单例模式如何防止反射攻击？"

   java复制public enum Singleton {
       INSTANCE;
       
       // 枚举单例天然防反射
       public void doWork() {}
   }
   

3. "装饰器和代理模式的区别？"

   • 装饰器：增强功能
   • 代理：控制访问

7.2 架构师级设计问题

1. "如何设计一个支持多种消息协议的通知系统？"

   • 策略模式处理不同协议
   • 责任链模式实现过滤
   • 建造者模式构造复杂消息

2. "设计一个可扩展的权限系统"

   • 组合模式表示权限树
   • 访问者模式统计权限
   • 代理模式控制权限校验

3. "实现分布式事务的多种方案"

   • 命令模式：事务指令
   • 状态模式：事务状态机
   • 观察者模式：事件通知

8. 现代Java中的模式演进

8.1 Lambda表达式对模式的简化

很多行为模式可以用Lambda更简洁地实现。比如策略模式：

java复制// 传统实现
Collections.sort(list, new Comparator<String>() {
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

// Lambda简化
Collections.sort(list, (a, b) -> b.compareTo(a));

8.2 函数式编程与设计模式

Java8引入的函数式特性让某些模式有了新实现方式：

1. 工厂模式 -> 方法引用

   java复制ProductFactory factory = Product::new;
   

2. 观察者模式 -> Stream事件流

   java复制eventStream.filter(e -> e.getType() == PAY_SUCCESS)
              .forEach(this::sendEmail);
   

3. 模板方法 -> 函数组合

   java复制Function<Request, Response> pipeline = validate
       .andThen(process)
       .andThen(logResult);
   

9. 设计模式与代码质量

9.1 可测试性设计

好的设计模式应该提升代码可测试性：

1. 依赖注入使Mock更容易
2. 策略模式方便替换测试实现
3. 工厂模式可以返回测试替身

反例：单例模式直接调用会导致测试困难

java复制// 难以测试的代码
class OrderService {
    public void createOrder() {
        // 直接调用单例
        InventoryManager.getInstance().reduce(stock);
    }
}

// 可测试的改进
class OrderService {
    private InventoryManager inventory;
    
    // 依赖注入
    public OrderService(InventoryManager inventory) {
        this.inventory = inventory;
    }
}

9.2 代码坏味道识别

当出现以下情况时，可能需要引入设计模式：

1. 大量if-else处理不同类型（策略模式）
2. 重复的样板代码（模板方法）
3. 对象创建逻辑分散（工厂模式）
4. 组件间紧耦合（观察者模式）

典型重构示例：

java复制// 重构前
public void process(String type) {
    if ("A".equals(type)) {
        // 处理逻辑A
    } else if ("B".equals(type)) {
        // 处理逻辑B
    }
}

// 重构后 - 策略模式
public void process(String type) {
    Strategy strategy = strategyMap.get(type);
    strategy.execute();
}

10. 设计模式在框架中的应用

10.1 Spring框架中的模式实现

1. 控制反转 -> 工厂模式
2. AOP -> 代理模式
3. @EventListener -> 观察者模式
4. HandlerAdapter -> 适配器模式
5. JdbcTemplate -> 模板方法模式

源码片段分析：

java复制// Spring代理工厂核心逻辑
public class ProxyFactory {
    public Object getProxy() {
        if (targetClass.isInterface()) {
            return createJdkProxy();
        }
        return createCglibProxy();
    }
}

10.2 MyBatis中的模式运用

1. SqlSessionFactory -> 工厂模式
2. Executor -> 策略模式
3. Plugin -> 责任链模式
4. MapperProxy -> 代理模式

插件系统实现示例：

java复制// 责任链方式执行插件
public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
        target = interceptor.plugin(target);
    }
    return target;
}

11. 设计模式性能调优

11.1 对象创建优化

1. 原型模式替代频繁new操作
2. 对象池管理昂贵对象
3. 享元模式共享元数据

性能对比测试：

java复制// 普通创建
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
    new HeavyObject();
}
System.out.println("Normal: " + (System.currentTimeMillis() - start));

// 原型模式
HeavyObject prototype = new HeavyObject();
start = System.currentTimeMillis();
for (int i = 0; i < 1000000; i++) {
    prototype.clone();
}
System.out.println("Prototype: " + (System.currentTimeMillis() - start));

11.2 内存占用分析

使用JProfiler分析不同模式的内存开销：

1. 装饰器模式 vs 继承
2. 享元模式的内存节省
3. 观察者模式的监听器泄漏

典型内存问题案例：

java复制// 可能导致内存泄漏的实现
class EventSource {
    static List<Listener> listeners = new ArrayList<>();
    
    void addListener(Listener l) {
        listeners.add(l);
    }
    // 缺少remove方法
}

12. 设计模式与DDD

12.1 领域模型中的模式应用

1. 聚合根 -> 组合模式
2. 领域事件 -> 观察者模式
3. 值对象 -> 享元模式
4. 仓储接口 -> 工厂模式

DDD示例代码：

java复制// 订单聚合根
class Order {
    private List<OrderItem> items; // 组合模式
    
    public void addItem(Product product, int quantity) {
        items.add(new OrderItem(product, quantity));
    }
}

// 领域事件
class OrderPaidEvent {
    private Order order;
    // 事件内容
}

12.2 战术模式与设计模式

1. 策略模式实现业务规则
2. 装饰器模式增强领域服务
3. 模板方法定义工作流骨架

支付领域示例：

java复制abstract class PaymentService {
    // 模板方法
    public final void process(PaymentRequest request) {
        validate(request);
        executePayment(request);
        recordLog(request);
    }
    
    protected abstract void executePayment(PaymentRequest request);
}

13. 微服务架构中的模式演进

13.1 服务通信模式

1. API网关 -> 门面模式
2. 服务熔断 -> 状态模式
3. 负载均衡 -> 策略模式
4. 服务发现 -> 中介者模式

Spring Cloud实现示例：

java复制// 熔断器状态机
class CircuitBreaker {
    private State state;
    
    public void execute(Runnable task) {
        state.handle(this, task);
    }
}

// 关闭状态
class ClosedState implements State {
    public void handle(CircuitBreaker breaker, Runnable task) {
        try {
            task.run();
        } catch (Exception e) {
            failureCount++;
            if (failureCount > threshold) {
                breaker.setState(new OpenState());
            }
        }
    }
}

13.2 分布式事务处理

1. Saga模式 -> 命令模式
2. TCC模式 -> 状态模式
3. 本地消息表 -> 观察者模式

Saga实现示例：

java复制class OrderSaga {
    private List<SagaStep> steps;
    
    public void execute() {
        for (SagaStep step : steps) {
            try {
                step.execute();
            } catch (Exception e) {
                compensate(step);
                break;
            }
        }
    }
}

14. 设计模式与并发编程

14.1 线程安全模式实现

1. 不可变对象 -> 享元模式
2. 线程局部存储 -> 单例模式变体
3. 并发容器 -> 迭代器模式

线程安全的单例改进：

java复制class Singleton {
    private static volatile Singleton instance;
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

14.2 并发设计模式

1. Worker Thread模式
2. Producer-Consumer模式
3. Thread Pool模式

Java并发包实现：

java复制// Worker Thread模式示例
ExecutorService executor = Executors.newFixedThreadPool(4);
List<Future> results = new ArrayList<>();

for (Task task : tasks) {
    results.add(executor.submit(task));
}

15. 设计模式与代码重构

15.1 重构到模式

常见重构场景：

1. 重复switch-case -> 策略模式
2. 多重条件判断 -> 状态模式
3. 复杂对象构造 -> 建造者模式
4. 回调地狱 -> 命令模式

重构示例：

java复制// 重构前
public void handle(String state) {
    if ("A".equals(state)) {
        // 处理A
    } else if ("B".equals(state)) {
        // 处理B
    }
}

// 重构后 - 状态模式
interface State {
    void handle();
}

class StateA implements State {
    public void handle() { /* 处理A */ }
}

15.2 反模式识别

1. God Object -> 职责链模式
2. Spaghetti Code -> 分层模式
3. Feature Envy -> 搬移方法
4. Shotgun Surgery -> 装饰器模式

重构工具推荐：

• IDEA重构功能
• SonarQube代码检测
• ArchUnit架构测试

16. 设计模式与测试驱动开发

16.1 可测试的设计模式

1. Mockable的依赖注入
2. 策略模式的测试替身
3. 模板方法的钩子函数

测试示例：

java复制// 测试策略模式
@Test
void testDiscountStrategy() {
    PricingContext context = new PricingContext();
    context.setStrategy(new DiscountStrategy());
    
    Order order = createTestOrder();
    BigDecimal result = context.calculate(order);
    
    assertEquals(new BigDecimal("90.00"), result);
}

16.2 模式驱动的测试设计

1. 工厂模式生成测试数据
2. 组合模式构造测试用例
3. 观察者模式验证回调

测试数据工厂示例：

java复制class TestDataFactory {
    public static Order createOrderWithItems(int itemCount) {
        Order order = new Order();
        for (int i = 0; i < itemCount; i++) {
            order.addItem(createProduct(i), 1);
        }
        return order;
    }
}

17. 设计模式与代码规范

17.1 模式命名约定

1. 工厂类后缀Factory
2. 策略接口后缀Strategy
3. 装饰器类后缀Decorator
4. 建造者类后缀Builder

命名示例：

java复制class PaymentStrategyFactory {
    public PaymentStrategy create(String type) {
        switch (type) {
            case "ALIPAY": return new AlipayStrategy();
            case "WECHAT": return new WechatPayStrategy();
            default: throw new IllegalArgumentException();
        }
    }
}

17.2 模式文档规范

1. 类注释说明模式类型
2. UML图展示关系
3. 示例代码演示用法

文档示例：

java复制/**
 * 实现策略模式的价格计算策略
 * @see PricingStrategy
 */
class DiscountStrategy implements PricingStrategy {
    /**
     * 应用9折优惠计算
     * @param original 原价
     * @return 折后价格
     */
    public BigDecimal calculate(BigDecimal original) {
        return original.multiply(new BigDecimal("0.9"));
    }
}

18. 设计模式与架构风格

18.1 分层架构中的模式

1. 表现层：MVC模式
2. 业务层：策略模式
3. 数据层：仓储模式
4. 基础设施：适配器模式

分层示例：

java复制// 表现层
@Controller
class OrderController {
    @Autowired
    private OrderService service; // 业务层服务
    
    @PostMapping
    public String create(OrderForm form) {
        service.createOrder(form.toCommand());
        return "success";
    }
}

// 业务层
@Service
class OrderService {
    @Autowired
    private OrderRepository repository; // 数据层仓储
    
    @Transactional
    public void createOrder(OrderCommand command) {
        // 业务逻辑
        repository.save(order);
    }
}

18.2 事件驱动架构

1. 事件源 -> 观察者模式
2. 事件处理器 -> 策略模式
3. 事件总线 -> 中介者模式

Spring实现示例：

java复制// 定义事件
class OrderEvent extends ApplicationEvent {
    private String eventType;
    public OrderEvent(Object source, String type) {
        super(source);
        this.eventType = type;
    }
}

// 发布事件
applicationContext.publishEvent(new OrderEvent(this, "CREATED"));

// 处理事件
@Component
class OrderEventHandler {
    @EventListener
    public void handleOrderCreated(OrderEvent event) {
        if ("CREATED".equals(event.getEventType())) {
            // 处理逻辑
        }
    }
}

19. 设计模式与领域特定语言

19.1 DSL中的模式应用

1. 流畅接口 -> 建造者模式
2. 表达式解析 -> 解释器模式
3. 规则引擎 -> 策略模式

流畅接口示例：

java复制public class QueryBuilder {
    public static QueryBuilder select(String... fields) {
        return new QueryBuilder().fields(fields);
    }
    
    public QueryBuilder from(String table) { /*...*/ }
    public QueryBuilder where(String condition) { /*...*/ }
}

// 使用方式
QueryBuilder.select("name", "age")
            .from("users")
            .where("age > 18");

19.2 规则引擎设计

1. 规则接口 -> 策略模式
2. 规则链 -> 责任链模式
3. 规则工厂 -> 工厂模式

核心实现：

java复制interface Rule {
    boolean evaluate(Facts facts);
    void execute(Facts facts);
}

class RuleEngine {
    private List<Rule> rules;
    
    public void fire(Facts facts) {
        for (Rule rule : rules) {
            if (rule.evaluate(facts)) {
                rule.execute(facts);
            }
        }
    }
}

20. 设计模式与云原生

20.1 容器化设计模式

1. Sidecar模式 -> 装饰器模式
2. Ambassador模式 -> 代理模式
3. Adapter模式 -> 适配器模式

Kubernetes示例：

yaml复制apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  template:
    spec:
      containers:
      - name: web
        image: nginx
      - name: sidecar  # Sidecar容器
        image: log-collector

20.2 Serverless中的模式

1. 事件处理 -> 观察者模式
2. 函数组合 -> 责任链模式
3. 状态管理 -> 状态模式

AWS Lambda示例：

java复制public class OrderHandler implements RequestHandler<OrderEvent, String> {
    private OrderService service;
    
    public String handleRequest(OrderEvent event, Context context) {
        return service.process(event);
    }
}

21. 设计模式与性能优化

21.1 缓存模式实现

1. 缓存代理 -> 代理模式
2. 多级缓存 -> 装饰器模式
3. 缓存策略 -> 策略模式

Spring缓存示例：

java复制@Service
class ProductService {
    @Cacheable("products") // 缓存代理
    public Product getProduct(String id) {
        return repository.findById(id);
    }
    
    @CacheEvict("products")
    public void updateProduct(Product product) {
        repository.save(product);
    }
}

21.2 延迟加载优化

1. 虚拟代理 -> 代理模式
2. 惰性初始化 -> 策略模式
3. 按需加载 -> 状态模式

MyBatis实现示例：

java复制class Order {
    private List<OrderItem> items; // 懒加载
    
    public List<OrderItem> getItems() {
        if (items == null) {
            items = orderItemMapper.findByOrderId(id);
        }
        return items;
    }
}

22. 设计模式与安全编程

22.1 安全设计模式

1. 权限检查 -> 代理模式
2. 输入验证 -> 装饰器模式
3. 审计日志 -> 观察者模式

Spring Security示例：

java复制@PreAuthorize("hasRole('ADMIN')") // 安全代理
public void deleteUser(String userId) {
    userRepository.deleteById(userId);
    auditLog.log("User deleted: " + userId); // 审计观察者
}

22.2 防御性编程技巧

1. Null对象模式
2. 不变性模式
3. 保护性拷贝

不变性示例：

java复制public final class ImmutableValue {
    private final String value;
    
    public ImmutableValue(String value) {
        this.value = value;
    }
    
    public String getValue() {
        return value;
    }
}

23. 设计模式与遗留系统改造

23.1 渐进式重构策略

1. 适配器模式包装老接口
2. 门面模式统一新老系统
3. 策略模式逐步替换逻辑

重构示例：

java复制// 老系统适配器
class LegacyAdapter implements NewService {
    private LegacyService legacy;
    
    public Result execute(Request request) {
        LegacyData data = convert(request);
        LegacyResult legacyResult = legacy.process(data);
        return convert(legacyResult);
    }
}

23.2 防腐层设计

1. 适配器隔离外部系统
2. 门面统一访问入口
3. 策略处理不同版本

电商系统示例：

java复制class PaymentGatewayFacade {
    private PaymentStrategy strategy;
    
    public void setVersion(String version) {
        if ("v1".equals(version)) {
            strategy = new LegacyPaymentAdapter();
        } else {
            strategy = new NewPaymentService();
        }
    }
    
    public boolean pay(Order order) {
        return strategy.process(order);
    }
}

24. 设计模式与团队协作

24.1 模式驱动的代码规范

1. 工厂方法统一对象创建
2. 策略模式封装业务规则
3. 模板方法定义流程骨架

团队规范示例：

java复制// 所有业务服务继承基础模板
abstract class BaseService<T> {
    public final Result execute(T request) {
        validate(request);
        checkPermission();
        return process(request);
    }
    
    protected abstract Result process(T request);
}

24.2 设计模式评审要点

1. 模式选择是否合理
2. 实现是否符合预期
3. 是否有过度设计
4. 性能影响评估

Code Review清单：

• [ ] 单例是否线程安全
• [ ] 策略接口是否稳定
• [ ] 观察者是否会导致内存泄漏
• [ ] 装饰器嵌套是否过深

25. 设计模式与持续交付

25.1 可部署性设计

1. 抽象工厂管理环境配置
2. 策略模式处理部署策略
3. 观察者模式监控部署状态

部署示例：

java复制interface DeploymentStrategy {
    void deploy(Application app);
}

class BlueGreenDeploy implements DeploymentStrategy {
    public void deploy(Application app) {
        // 蓝绿部署逻辑
    }
}

class DeploymentContext {
    private DeploymentStrategy strategy;
    
    public void setStrategy(DeploymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void execute(Application app) {
        strategy.deploy(app);
    }
}

25.2 特性开关实现

1. 策略模式切换功能
2. 工厂模式创建特性实例
3. 装饰器模式添加特性逻辑

Spring实现示例：

java复制@Configuration
class FeatureConfig {
    @Bean
    @ConditionalOnProperty("feature.new-checkout")
    public CheckoutService newCheckoutService() {
        return new NewCheckoutService();
    }
    
    @Bean
    @ConditionalOnMissingBean(CheckoutService.class)
    public CheckoutService defaultCheckoutService() {
        return new LegacyCheckoutService();
    }
}

26. 设计模式与监控系统

26.1 指标收集设计

1. 装饰器模式增强监控
2. 观察者模式处理告警
3. 访问者模式统计指标

监控示例：

java复制class MonitoredService implements Service {
    private Service delegate;
    private MetricRegistry metrics;
    
    public Result execute(Request req) {
        Timer.Context timer = metrics.timer("execute").time();
        try {
            return delegate.execute(req);
        } finally {
            timer.stop();
        }
    }
}

26.2 分布式追踪实现

1. 责任链模式传播上下文
2. 装饰器模式添加追踪信息
3. 观察者模式记录Span

OpenTelemetry示例：

java复制class TracedExecutor implements Executor {
    private Executor delegate;
    
    public void execute(Runnable command) {
        Span span = tracer.spanBuilder("execute").startSpan();
        try (Scope scope = span.makeCurrent()) {
            delegate.execute(command);
        } finally {
            span.end();
        }
    }
}

27. 设计模式与机器学习

27.1 特征工程中的模式

1. 策略模式处理不同特征
2. 管道模式组合处理步骤
3. 工厂模式创建特征转换器

Scikit-learn风格实现：

java复制interface FeatureTransformer {
    Dataset transform(Dataset input);
}

class Pipeline {
    private List<FeatureTransformer> steps;
    
    public Dataset transform(Dataset input) {
        Dataset result = input;
        for (FeatureTransformer step : steps) {
            result = step.transform(result);
        }
        return result;
    }
}

27.2 模型服务化设计

1. 策略模式选择模型
2. 装饰器模式添加预处理
3. 观察者模式记录预测

服务示例：

java复制class PredictionService {
    private ModelStrategy model;
    private List<PredictionListener> listeners;
    
    public Prediction predict(Input input) {
        Prediction result = model.predict(input);
        for (PredictionListener listener : listeners) {
            listener.onPrediction(result);
        }
        return result;
    }
}

28. 设计模式与区块链

28.1 智能合约设计

1. 策略模式实现合约逻辑
2. 模板方法定义交易流程
3. 状态模式管理合约状态

Solidity风格示例：

java复制abstract class SmartContract {
    // 模板方法
    final void execute() {
        validate();
        process();
        emitEvent();
    }
    
    abstract void process();
}

class TokenContract extends SmartContract {
    void process() {
        // 代币转账逻辑
    }
}

28.2 共识算法实现

1. 状态模式处理节点状态
2. 策略模式选择算法
3. 观察者模式传播消息

PBFT实现示例：

java复制class Node {
    private ConsensusState state;
    
    public void handleMessage(Message msg) {
        state.handle(this, msg);
    }
}

class PrePrepareState implements ConsensusState {
    public void handle(Node node, Message msg) {
        // 处理pre-prepare消息
        if (valid) {
            node.setState(new PrepareState());
        }
    }
}

29. 设计模式与物联网

29.1 设备管理设计

1. 命令模式控制设备
2. 观察者模式监听状态
3. 中介者模式协调设备

智能家居示例：

java复制class SmartHome {
    private Map<String, Device> devices;
    
    public void execute(String deviceId, Command command) {
        devices.get(deviceId).execute(command);
    }
}

interface Device {
    void execute(Command command);
    void addListener(DeviceListener listener);
}

29.2 边缘计算模式

1. 策略模式处理本地计算
2. 代理模式管理云通信
3. 状态模式适应网络条件

边缘节点示例：

java复制class EdgeNode {
    private ComputeStrategy strategy;
    
    public void setNetworkCondition(String condition) {
        if ("GOOD".equals(condition)) {
            strategy = new CloudCompute();
        } else {
            strategy = new LocalCompute();
        }
    }
    
    public Result process(Data data) {
        return strategy.compute(data);
    }
}

30. 设计模式