策略模式 + 工厂模式：彻底干掉业务代码中的 if-else

问题背景：if-else 地狱

先看一个真实业务中的示例（简化版）：

public class OrderService {
    public void processOrder(String orderType) {
        if ("NORMAL".equals(orderType)) {
            // 普通订单逻辑
        } else if ("GROUP".equals(orderType)) {
            // 团购订单逻辑
        } else if ("PROMOTION".equals(orderType)) {
            // 促销订单逻辑
        } else {
            throw new IllegalArgumentException("不支持的订单类型");
        }
    }
}

这段代码初看没毛病，但随着业务扩展，订单类型越来越多，逻辑越来越复杂，最终你会发现：

• 新增一个类型，要改核心代码（违背开闭原则）
• if-else 越来越长，难以维护
• 单元测试困难
• 职责不清晰，代码耦合严重

解决方案？策略模式 + 工厂模式！

策略模式：封装变化

策略模式的核心思想是：定义一组算法，把它们一个个封装起来，并且使它们可以互相替换。

我们可以这样设计：

Step 1: 定义订单处理接口

public interface OrderStrategy {
    void processOrder();
}

Step 2: 实现不同的策略类

@Component
public class NormalOrderStrategy implements OrderStrategy {
    @Override
    public void processOrder() {
        System.out.println("处理普通订单");
    }
}

@Component
public class GroupOrderStrategy implements OrderStrategy {
    @Override
    public void processOrder() {
        System.out.println("处理团购订单");
    }
}

@Component
public class PromotionOrderStrategy implements OrderStrategy {
    @Override
    public void processOrder() {
        System.out.println("处理促销订单");
    }
}

Step 3: 使用工厂模式进行策略选择

@Component
public class OrderStrategyFactory {

    private final Map<String, OrderStrategy> strategyMap = new HashMap<>();

    @Autowired
    public OrderStrategyFactory(List<OrderStrategy> strategies) {
        for (OrderStrategy strategy : strategies) {
            String key = getKey(strategy);
            strategyMap.put(key, strategy);
        }
    }

    public OrderStrategy getStrategy(String orderType) {
        OrderStrategy strategy = strategyMap.get(orderType.toUpperCase());
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的订单类型: " + orderType);
        }
        return strategy;
    }

    private String getKey(OrderStrategy strategy) {
        // 可以用注解、类名、配置等方式生成 key
        if (strategy instanceof NormalOrderStrategy) return "NORMAL";
        if (strategy instanceof GroupOrderStrategy) return "GROUP";
        if (strategy instanceof PromotionOrderStrategy) return "PROMOTION";
        throw new IllegalArgumentException("未知策略实现类");
    }
}

优雅调用

@Service
public class OrderService {

    @Autowired
    private OrderStrategyFactory strategyFactory;

    public void processOrder(String orderType) {
        OrderStrategy strategy = strategyFactory.getStrategy(orderType);
        strategy.processOrder();
    }
}

再进一步：使用注解 + 自动注册策略

把策略类的注册交给 Spring，完全解耦：

自定义注解

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface OrderType {
    String value();
}

策略类加注解

@Component
@OrderType("NORMAL")
public class NormalOrderStrategy implements OrderStrategy {
    public void processOrder() { System.out.println("处理普通订单"); }
}

更新工厂类，自动扫描注解

@Component
public class OrderStrategyFactory {

    private final Map strategyMap = new HashMap<>();

    @Autowired
    public OrderStrategyFactory(List strategies) {
        for (OrderStrategy strategy : strategies) {
            OrderType annotation = strategy.getClass().getAnnotation(OrderType.class);
            if (annotation != null) {
                strategyMap.put(annotation.value().toUpperCase(), strategy);
            }
        }
    }

    public OrderStrategy getStrategy(String orderType) {
        OrderStrategy strategy = strategyMap.get(orderType.toUpperCase());
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的订单类型: " + orderType);
        }
        return strategy;
    }
}

优势总结

实战建议

• 业务复杂度到达一定程度（超过 3 个 if-else 分支），优先考虑策略模式
• 搭配注解 + 工厂模式，策略注册更灵活
• 如果策略类中还涉及更多依赖（比如 DAO、Service），可放心使用 Spring 注入（@Component + @Autowired）

写在最后

策略模式 + 工厂模式，是业务编排中最常用、最优雅的组合拳。
用了它，你的代码不再臃肿、不再堆叠 if-else，不再让人一行行 debug 找逻辑。

干掉 if-else，不是目的，而是让代码变得更优雅、更可维护的过程。

别让 if-else 成为你代码的“技术债”，从今天开始，用策略模式重构你的业务逻辑！