设计模式实战：电商系统中的状态与策略模式应用

1. 设计模式实战价值解析

第一次翻开《设计模式：可复用面向对象软件的基础》（GoF经典著作）时，很多人会被23种模式的名词解释吓退。但当我参与过三个大型电商系统重构后，才真正理解这些模式不是教条，而是前辈们用代码总结出的"生存指南"。比如订单状态流转用状态模式改造后，代码量减少了40%，而促销策略组合使用策略模式后，新活动上线时间从3天缩短到2小时。

设计模式的核心价值在于：

• 标准化沟通：说"用观察者模式实现事件通知"，比画UML图更高效
• 规避陷阱：迭代器模式解决集合遍历的并发修改问题，是前人踩坑的结晶
• 架构蓝图：MVC本质是观察者+策略+组合模式的混合体

提示：不要为了用模式而用模式，当if/else超过3层或修改代码总引发连锁反应时，才是模式登场的最佳时机

2. 高频模式实战案例拆解

2.1 订单系统的状态模式改造

某跨境电商平台原有订单状态判断逻辑：

java复制if(status == "待支付"){
    if(pay()) status = "已支付";
} else if(status == "已支付"){
    if(checkStock()) status = "待发货";
} // 后续还有8个else if...

问题症状：

• 新增"预售订单"类型时需修改所有判断条件
• 状态流转规则散落在20多个Service中
• 财务对账经常漏掉特殊状态

重构方案：

mermaid复制classDiagram
    class OrderState {
        <<interface>>
        +check(): void
        +nextState(): OrderState
    }
    class UnpaidState
    class PaidState
    class ShippedState
    Order <-- OrderState

关键实现：

java复制// 状态接口
public interface OrderState {
    void check(OrderContext context);
    OrderState nextState();
}

// 具体状态
public class PaidState implements OrderState {
    @Override
    public void check(OrderContext ctx) {
        if(!inventoryService.check(ctx.getOrder())){
            throw new IllegalStateException("库存不足");
        }
    }
    
    @Override
    public OrderState nextState() {
        return new ShippedState();
    }
}

// 上下文
public class Order {
    private OrderState currentState;
    
    public void process() {
        currentState.check(this);
        currentState = currentState.nextState();
    }
}

收益对比：

2.2 策略模式在促销系统的应用

电商大促期间常见的痛点：

• 满减、折扣、赠品等10+种促销类型
• 组合促销时规则冲突（如"满300减50"与"8折"能否同享）
• 运营需要实时调整策略权重

传统写法：

java复制public BigDecimal calculatePrice(String promoType, Order order) {
    if("FULL_REDUCE".equals(promoType)){
        return fullReduceCalc(order);
    } else if("DISCOUNT".equals(promoType)){
        return discountCalc(order); 
    }
    // 更多if...
}

策略模式改造后：

java复制// 策略接口
public interface PromotionStrategy {
    boolean isApplicable(Order order);
    BigDecimal apply(Order order);
}

// 具体策略
public class DiscountStrategy implements PromotionStrategy {
    @Override
    public boolean isApplicable(Order order) {
        return order.hasDiscountCoupon();
    }
    
    @Override
    public BigDecimal apply(Order order) {
        return order.getTotal().multiply(0.8);
    }
}

// 策略上下文
public class PromotionEngine {
    private List<PromotionStrategy> strategies;
    
    public BigDecimal execute(Order order) {
        return strategies.stream()
            .filter(s -> s.isApplicable(order))
            .map(s -> s.apply(order))
            .reduce(order.getTotal(), BigDecimal::min);
    }
}

性能优化技巧：

1. 使用策略工厂预加载所有策略实例
2. 并行流处理适用策略判断
3. 为高频策略添加@Primary注解

3. 模式组合的进阶用法

3.1 订单通知的观察者+装饰器模式

典型需求：

• 订单状态变更需通知：用户、客服、物流、财务等系统
• 不同通知渠道有不同处理逻辑（短信需要内容审核，邮件要附件）
• 需要支持动态增删监听者

解决方案：

java复制// 观察者基础结构
public interface OrderListener {
    void onUpdate(OrderEvent event);
}

public class SmsNotifier implements OrderListener {
    @Override
    public void onUpdate(OrderEvent event) {
        // 基础短信通知
    }
}

// 装饰器增强功能
public class AuditDecorator implements OrderListener {
    private final OrderListener delegate;
    
    public AuditDecorator(OrderListener delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public void onUpdate(OrderEvent event) {
        if(contentAuditService.check(event.getMessage())){
            delegate.onUpdate(event);
        }
    }
}

// 使用示例
OrderSubject subject = new OrderSubject();
subject.addListener(new AuditDecorator(new SmsNotifier()));

3.2 工厂方法+原型模式的缓存优化

对象创建场景的痛点：

• 复杂对象构造耗时（如加载DB配置的查询引擎）
• 需要支持不同类型产品的快速切换
• 相似对象需要差异化配置

优化方案：

java复制public interface QueryEngine {
    QueryResult execute(String sql);
}

public class MysqlEngine implements QueryEngine, Cloneable {
    private ConnectionConfig config;
    
    @Override
    public QueryEngine clone() {
        MysqlEngine clone = new MysqlEngine();
        clone.config = this.config.deepCopy();
        return clone;
    }
}

public class EngineFactory {
    private static Map<String, QueryEngine> prototypes = new ConcurrentHashMap<>();
    
    static {
        prototypes.put("mysql", initMysqlEngine());
        prototypes.put("oracle", initOracleEngine());
    }
    
    public static QueryEngine create(String type) {
        return prototypes.get(type).clone();
    }
}

性能对比：

4. 设计模式反模式警示

4.1 过度设计的典型症状

1. 模式嵌套失控：

java复制// 实际遇到的"炫技"代码
AbstractFactoryBuilder.create()
    .withDecorator(
        new CacheDecorator(
            new LogDecorator(
                new ObserverDecorator(
                    new RealSubject()))))
    .build();

2. 不必要的抽象：

• 只有一种实现的策略接口
• 永远不会扩展的状态机
• 单例类继承抽象工厂

4.2 模式选择决策树

mermaid复制graph TD
    A[需求变更频繁?] -->|是| B[策略/命令模式]
    A -->|否| C[存在对象创建复杂度?]
    C -->|是| D[工厂/建造者模式]
    C -->|否| E[需要解耦调用者与实现?]
    E -->|是| F[桥接/适配器模式]
    E -->|否| G[需要统一处理多个对象?]
    G -->|是| H[组合/迭代器模式]

4.3 代码坏味道检测表

5. 现代语言中的模式演进

5.1 Java Stream对模式的简化

传统迭代器模式：

java复制Iterator<String> it = list.iterator();
while(it.hasNext()) {
    String item = it.next();
    // 处理逻辑
}

Stream实现：

java复制list.stream()
    .filter(s -> s.length() > 3)
    .map(String::toUpperCase)
    .forEach(System.out::println);

5.2 Spring框架中的模式实践

1. 依赖注入：组合模式的高级应用
2. @EventListener：观察者模式的声明式实现
3. RestTemplate：门面模式封装HTTP调用
4. @Scope("prototype")：原型模式的容器支持

5.3 函数式编程对模式的影响

策略模式的Lambda重构：

java复制// 传统实现
interface ValidationStrategy {
    boolean execute(String s);
}

class IsNumeric implements ValidationStrategy {
    public boolean execute(String s) {
        return s.matches("\\d+");
    }
}

// Lambda实现
ValidationStrategy numeric = s -> s.matches("\\d+");

6. 性能与可维护性平衡

6.1 模式带来的开销测试

测试环境：

• JMH基准测试
• 4核8G Docker容器
• Java 17

结果对比：

经验法则：在性能关键路径上，当模式导致性能下降超过30%时，应考虑裸实现

6.2 缓存优化技巧

1. 享元模式+对象池：

java复制public class ConnectionPool {
    private static Queue<Connection> pool = new ConcurrentLinkedQueue<>();
    
    static {
        IntStream.range(0,10)
            .forEach(i -> pool.add(createConnection()));
    }
    
    public static Connection get() {
        Connection conn = pool.poll();
        return conn != null ? conn : createConnection();
    }
    
    public static void release(Connection conn) {
        if(pool.size() < 20) {
            pool.offer(conn);
        }
    }
}

2. 懒加载代理：

java复制public class ImageProxy implements Image {
    private RealImage realImage;
    private String filename;
    
    public ImageProxy(String filename) {
        this.filename = filename;
    }
    
    @Override
    public void display() {
        if(realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

7. 测试中的模式应用

7.1 模板方法模式在测试框架中的应用

JUnit 5生命周期模板：

java复制public abstract class TestTemplate {
    
    @BeforeEach
    final void setupTemplate() {
        initDB();
        prepareData();
        customSetup();
    }
    
    abstract void customSetup();
    
    private void initDB() { /* 公共初始化 */ }
}

7.2 模拟对象与代理模式

Mockito核心原理示例：

java复制public class MockProxy implements InvocationHandler {
    private Map<Method, Object> stubs = new HashMap<>();
    
    public Object invoke(Object proxy, Method method, Object[] args) {
        return stubs.getOrDefault(method, 
            throw new UnsupportedOperationException());
    }
    
    public static <T> T mock(Class<T> clazz) {
        return (T) Proxy.newProxyInstance(
            clazz.getClassLoader(),
            new Class[]{clazz},
            new MockProxy());
    }
}

8. 架构级模式实践

8.1 微服务中的模式组合

1. API网关 = 门面模式 + 代理模式
2. 配置中心 = 观察者模式 + 策略模式
3. 服务发现 = 抽象工厂 + 装饰器模式

8.2 DDD中的模式映射

9. 代码重构路线图

9.1 识别重构时机

1. 代码异味检测表：

   • 单个方法超过50行
   • 类成员变量超过8个
   • 方法参数超过5个
   • if/else嵌套超过3层

2. 模式引入优先级：

   mermaid复制pie
       title 重构优先级
       "策略模式" : 35
       "观察者模式" : 25
       "工厂方法" : 20
       "装饰器模式" : 15
       "其他" : 5
   

9.2 渐进式重构步骤

以电商优惠计算为例：

阶段1：函数拆分

java复制// 原始代码
public BigDecimal calculate(Order order) {
    // 200行计算逻辑
}

// 拆分为：
public BigDecimal calculate(Order order) {
    BigDecimal base = calculateBasePrice(order);
    base = applyPromotions(base, order);
    return applyTaxes(base, order);
}

阶段2：策略模式引入

java复制interface PromotionCalculator {
    BigDecimal apply(Order order, BigDecimal current);
}

class DiscountCalculator implements PromotionCalculator {
    public BigDecimal apply(Order order, BigDecimal current) {
        return current.multiply(order.getDiscountRate());
    }
}

阶段3：配置化扩展

json复制{
  "promotionFlow": [
    {"type": "discount", "params": {"rate": 0.9}},
    {"type": "fullReduce", "params": {"threshold": 100, "minus": 10}}
  ]
}

10. 工具链推荐

10.1 模式识别工具

1. IntelliJ IDEA：

   • 右键 → Refactor → Replace With Pattern
   • 支持策略、观察者等9种模式自动重构

2. PMD：检测代码中适合模式重构的片段

   xml复制<rule ref="category/java/design.xml">
       <rule>UseSingletonPattern</rule>
       <rule>AvoidLongIfStmts</rule>
   </rule>
   

10.2 可视化工具

1. PlantUML：模式类图生成

   plantuml复制@startuml
   interface Strategy {
       +execute()
   }
   class ConcreteStrategyA
   class ConcreteStrategyB
   Strategy <|-- ConcreteStrategyA
   Strategy <|-- ConcreteStrategyB
   @enduml
   

2. JArchitect：分析项目中的模式使用情况

11. 团队协作规范

11.1 模式使用公约

1. 命名规范：

   • 策略接口后缀：Strategy
   • 工厂类前缀：XxxFactory
   • 观察者命名：XxxListener

2. 文档要求：

   java复制/**
    * 使用策略模式实现多平台支付
    * @see PaymentStrategy
    * @pattern Strategy
    */
   public class WechatPayment implements PaymentStrategy {}
   

11.2 代码审查清单

12. 常见误区辨析

12.1 单例模式的正确实现

错误示范：

java复制public class Singleton {
    private static Singleton instance;
    
    public static Singleton getInstance() {
        if(instance == null) { // 线程不安全
            instance = new Singleton();
        }
        return instance;
    }
}

推荐方案：

java复制// 方案1：枚举单例(Java最佳实践)
public enum Singleton {
    INSTANCE;
    
    public void doWork() { /* ... */ }
}

// 方案2：双重检查锁
public 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;
    }
}

12.2 工厂方法与抽象工厂的区别

本质差异：

• 工厂方法：针对单个产品等级（如不同格式的解析器）

  java复制public interface ParserFactory {
      DocumentParser createParser();
  }
  

• 抽象工厂：针对产品族（如跨平台的UI组件）

  java复制public interface UIFactory {
      Button createButton();
      TextBox createTextBox();
  }
  

13. 性能敏感场景优化

13.1 对象池模式实践

连接池实现要点：

1. 使用ThreadLocal存储连接
2. 软引用+LRU淘汰策略
3. 健康检查后台线程

基准测试对比：

13.2 享元模式在游戏开发中的应用

场景：MMORPG中渲染1000棵树

传统实现：

java复制class Tree {
    Mesh mesh;  // 每个实例独占10MB显存
    Texture texture;
    Vector3 position;
    
    void render() { /* ... */ }
}

享元优化：

java复制class TreeType {  // 享元
    Mesh mesh;
    Texture texture;
}

class Tree {
    TreeType type;  // 共享引用
    Vector3 position;
    
    void render() {
        type.render(position);
    }
}

内存对比：

14. 设计模式与SOLID原则

14.1 单一职责原则(SRP)

违反案例：

java复制class OrderProcessor {
    void process(Order order) {
        // 1. 验证订单
        // 2. 计算价格
        // 3. 扣减库存
        // 4. 生成物流单
        // 5. 发送通知
    }
}

模式改造：

java复制// 策略模式分解价格计算
// 观察者模式处理通知
// 命令模式封装库存操作

14.2 开闭原则(OCP)

模式支持度排名：

1. 策略模式（通过新增策略扩展）
2. 装饰器模式（动态添加功能）
3. 观察者模式（灵活增删监听者）

15. 前沿趋势与模式演进

15.1 响应式编程中的模式

观察者模式升级：

java复制Flux<String> flux = Flux.just("A", "B", "C");

// 订阅即观察者
flux.subscribe(
    data -> System.out.println("onNext:" + data),
    err -> System.err.println("onError:" + err),
    () -> System.out.println("onComplete")
);

15.2 云原生中的新模式

1. Sidecar模式：装饰器模式的分布式实现
2. Operator模式：模板方法在K8s中的应用
3. CQRS：命令与查询职责分离的策略模式变体

16. 个人经验总结

在金融支付系统重构中，最成功的模式应用是责任链+策略模式的组合：

java复制public interface FraudRule {
    FraudCheckResult check(Payment payment);
}

public class RuleChain implements FraudRule {
    private List<FraudRule> rules;
    
    public FraudCheckResult check(Payment payment) {
        return rules.stream()
            .map(rule -> rule.check(payment))
            .filter(FraudCheckResult::isBlock)
            .findFirst()
            .orElse(FraudCheckResult.pass());
    }
}

关键收获：

1. 规则执行耗时从320ms降至80ms（并行流优化）
2. 新增规则只需实现接口并注册，无需修改核心逻辑
3. 动态调整规则顺序满足不同风控场景

模式应用的终极目标不是代码美观，而是让系统在面对需求变更时，只需新增代码而非修改已有代码。当你的架构能达到这个标准，才是真正掌握了设计模式的精髓。