Java设计模式之策略模式：从入门到架构级实践

策略模式不仅是一种技术实现，更体现了关注点分离和拥抱变化的架构哲学。策略服务化：独立部署的策略服务动态策略编排：可视化策略编排平台AI驱动策略：基于机器学习的智能策略建议开发者在实践中注意：保持策略实现的纯净性建立策略版本管理机制实现策略效果监控体系定期进行策略健康度评估真正的架构之美，在于让复杂系统的变化处于可控范围。策略模式正是实现这一目标的重要工具，值得每个架构师深入理解和灵活运用。

听闻风很好吃

780人浏览 · 2025-04-16 12:00:00

听闻风很好吃 · 2025-04-16 12:00:00 发布

一、策略模式的核心思想再探

1.1 模式本质解构

策略模式的本质是将变化维度封装为独立对象。在软件开发中，我们常常面临这样的场景：某个功能的实现存在多种可能的变化路径，而系统需要在运行时动态选择不同的实现方式。策略模式通过以下方式实现这一目标：

正交分解：将主业务逻辑与算法实现分离
接口契约：通过统一接口规范算法调用方式
动态委派：运行时通过对象组合切换具体实现

1.2 设计哲学启示

策略模式体现了多个重要的设计原则：

开闭原则（OCP）
新增策略类时无需修改现有代码
单一职责原则（SRP）
每个策略类只负责一个算法实现
依赖倒置原则（DIP）
高层模块依赖抽象接口而非具体实现

1.3 策略模式三要素深度解析

Context（环境类）

典型实现方式：

public class PaymentContext {
    private PaymentStrategy strategy;
    private PaymentRequest request;
    
    public PaymentContext(PaymentStrategy strategy, PaymentRequest request) {
        this.strategy = strategy;
        this.request = request;
    }
    
    public PaymentResult execute() {
        // 前置处理（如参数校验）
        validateRequest(request);
        
        // 委托策略执行
        PaymentResult result = strategy.process(request);
        
        // 后置处理（如记录日志）
        logResult(result);
        return result;
    }
}

设计要点：
- 通常包含策略执行前后的通用处理
- 可持有策略执行需要的上下文信息
- 建议实现为线程安全的无状态对象

Strategy（抽象策略）

接口设计规范：
- 方法签名要面向业务语义设计
- 参数设计要考虑扩展性
- 返回类型要足够抽象

错误示例分析：

// 反模式：参数过于具体
interface BadStrategy {
    void process(HttpServletRequest req);
}

// 正例：使用领域对象
interface GoodStrategy {
    PaymentResult process(PaymentRequest request);
}

ConcreteStrategy（具体策略）

实现注意事项：
- 保持无状态：避免使用实例变量
- 线程安全性：若必须保持状态，需同步处理
- 异常处理：在策略内部处理或声明抛出

最佳实践示例：

public class AlipayStrategy implements PaymentStrategy {
    private final AlipayClient client; // 依赖注入
    
    @Override
    public PaymentResult process(PaymentRequest request) {
        try {
            AlipayResponse response = client.pay(convert(request));
            return parse(response);
        } catch (AlipayException e) {
            throw new PaymentException("Alipay processing failed", e);
        }
    }
    
    // 私有转换方法
    private AlipayRequest convert(PaymentRequest request) {
        // 转换逻辑...
    }
}

二、策略模式工程化实践进阶

2.1 策略注册与发现机制

基于注解的自动注册

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

// 策略实现
@StrategyType("wechat")
public class WechatPayStrategy implements PaymentStrategy {
    // 实现代码...
}

// 注册中心
public class StrategyRegistry {
    private Map<String, PaymentStrategy> strategies = new ConcurrentHashMap<>();
    
    public void register(String type, PaymentStrategy strategy) {
        strategies.put(type, strategy);
    }
    
    public PaymentStrategy getStrategy(String type) {
        return strategies.get(type);
    }
    
    // 自动扫描注册
    public void autoRegister(String packageName) {
        Reflections reflections = new Reflections(packageName);
        Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(StrategyType.class);
        for (Class<?> clazz : annotated) {
            StrategyType annotation = clazz.getAnnotation(StrategyType.class);
            String type = annotation.value();
            PaymentStrategy instance = (PaymentStrategy) clazz.newInstance();
            register(type, instance);
        }
    }
}

2.2 策略组合模式

组合策略实现

public class CompositeStrategy implements DiscountStrategy {
    private List<DiscountStrategy> strategies = new ArrayList<>();
    
    public void addStrategy(DiscountStrategy strategy) {
        strategies.add(strategy);
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        double currentPrice = originalPrice;
        for (DiscountStrategy strategy : strategies) {
            currentPrice = strategy.applyDiscount(currentPrice);
        }
        return currentPrice;
    }
}

// 使用示例
CompositeStrategy composite = new CompositeStrategy();
composite.addStrategy(new MemberDiscount());   // 会员9折
composite.addStrategy(new CouponDiscount());   // 优惠券减50
composite.addStrategy(new FestivalDiscount()); // 节日额外95折

double finalPrice = composite.applyDiscount(1000);

2.3 策略元数据管理

策略描述信息增强

public interface EnrichedStrategy extends DiscountStrategy {
    String getStrategyName();
    String getDescription();
    LocalDate getEffectiveDate();
    LocalDate getExpirationDate();
}

// 实现类示例
public class SpringFestivalDiscount implements EnrichedStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.88;
    }
    
    @Override
    public String getStrategyName() {
        return "春节特惠";
    }
    
    @Override
    public String getDescription() {
        return "春节期间所有商品88折优惠";
    }
    
    @Override
    public LocalDate getEffectiveDate() {
        return LocalDate.of(2023, 1, 20);
    }
    
    @Override
    public LocalDate getExpirationDate() {
        return LocalDate.of(2023, 2, 5);
    }
}

三、架构级深度应用案例

3.1 智能路由系统设计

动态路由策略

public interface RoutingStrategy {
    ServiceInstance select(List<ServiceInstance> instances, RequestContext context);
}

// 权重随机策略
public class WeightedRandomStrategy implements RoutingStrategy {
    @Override
    public ServiceInstance select(List<ServiceInstance> instances, RequestContext context) {
        // 实现权重计算逻辑...
    }
}

// 响应时间最优策略
public class ResponseTimeStrategy implements RoutingStrategy {
    @Override
    public ServiceInstance select(List<ServiceInstance> instances, RequestContext context) {
        // 获取性能指标数据...
    }
}

// 路由上下文
public class Router {
    private RoutingStrategy strategy;
    private LoadBalancer loadBalancer;
    
    public ServiceInstance route(Request request) {
        List<ServiceInstance> candidates = loadBalancer.getInstances(request);
        return strategy.select(candidates, createContext(request));
    }
    
    // 动态切换策略
    public void switchStrategy(String strategyType) {
        this.strategy = StrategyFactory.create(strategyType);
    }
}

3.2 金融交易风控系统

风控策略链

public class RiskControlEngine {
    private List<RiskStrategy> strategies;
    private RiskStrategy fallbackStrategy;
    
    public RiskResult evaluate(Trade trade) {
        RiskResult finalResult = RiskResult.APPROVE;
        
        for (RiskStrategy strategy : strategies) {
            RiskResult result = strategy.evaluate(trade);
            if (result.getLevel() > finalResult.getLevel()) {
                finalResult = result;
            }
            if (result.isFinalDecision()) {
                break;
            }
        }
        
        return finalResult != RiskResult.APPROVE ? finalResult : fallbackStrategy.evaluate(trade);
    }
}

// 典型风控策略示例
public class AmountLimitStrategy implements RiskStrategy {
    private static final BigDecimal DAILY_LIMIT = new BigDecimal("1000000");
    
    @Override
    public RiskResult evaluate(Trade trade) {
        BigDecimal dailyTotal = getDailyTotal(trade.getAccount());
        if (dailyTotal.add(trade.getAmount()).compareTo(DAILY_LIMIT) > 0) {
            return new RiskResult(RiskLevel.REJECT, "超过单日交易限额");
        }
        return RiskResult.APPROVE;
    }
}

3.3 电商促销引擎

策略配置化实现

public class PromotionEngine {
    private StrategyLoader loader;
    private PromotionStrategy activeStrategy;
    
    public BigDecimal calculatePrice(Order order) {
        refreshStrategy(); // 定时刷新策略
        return activeStrategy.calculate(order);
    }
    
    private void refreshStrategy() {
        StrategyConfig config = loader.loadCurrentStrategy();
        activeStrategy = StrategyFactory.create(config);
    }
}

// 策略加载器接口
public interface StrategyLoader {
    StrategyConfig loadCurrentStrategy();
}

// 数据库实现示例
public class JdbcStrategyLoader implements StrategyLoader {
    @Override
    public StrategyConfig loadCurrentStrategy() {
        // 查询数据库获取当前生效策略
    }
}

四、性能优化与生产实践

4.1 策略缓存机制

public class CachedStrategy implements DiscountStrategy {
    private final DiscountStrategy underlying;
    private final Cache<Double, Double> cache;
    
    public CachedStrategy(DiscountStrategy strategy) {
        this.underlying = strategy;
        this.cache = Caffeine.newBuilder()
                          .expireAfterWrite(5, TimeUnit.MINUTES)
                          .maximumSize(1000)
                          .build();
    }
    
    @Override
    public double applyDiscount(double originalPrice) {
        return cache.get(originalPrice, key -> underlying.applyDiscount(key));
    }
}

4.2 并行策略执行

public class ParallelExecutor {
    public Result executeStrategies(List<Strategy> strategies, Context context) {
        List<CompletableFuture<Result>> futures = strategies.stream()
            .map(strategy -> CompletableFuture.supplyAsync(
                () -> strategy.execute(context), 
                Executors.newVirtualThreadPerTaskExecutor()))
            .toList();
        
        return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
            .thenApply(v -> futures.stream()
                .map(CompletableFuture::join)
                .reduce(new Result(), this::combineResults))
            .join();
    }
}

4.3 策略预热加载

public class StrategyPreloader {
    private final StrategyRegistry registry;
    
    @PostConstruct
    public void preloadStrategies() {
        List<Class<? extends Strategy>> strategyClasses = scanStrategyClasses();
        strategyClasses.parallelStream().forEach(clazz -> {
            try {
                Strategy strategy = clazz.getDeclaredConstructor().newInstance();
                if (strategy instanceof Warmable warmable) {
                    warmable.warmUp();
                }
                registry.register(clazz.getSimpleName(), strategy);
            } catch (Exception e) {
                // 处理异常
            }
        });
    }
}

五、避坑指南与最佳实践

5.1 典型反模式识别

1. 策略膨胀反模式

症状表现：

策略类数量超过50个
存在大量相似策略类
策略选择逻辑复杂

解决方案：

使用策略组合模式
引入策略模板方法
建立策略分类体系

2. 伪策略模式

错误示例：

// 策略接口包含业务方法
interface WrongStrategy {
    void validate();
    void process();
    void cleanup();
}

修正方案：

// 拆分到不同策略接口
interface ValidationStrategy {
    void validate();
}

interface ProcessingStrategy {
    void process();
}

interface CleanupStrategy {
    void cleanup();
}

5.2 策略模式测试策略

单元测试要点

class DiscountStrategyTest {
    @ParameterizedTest
    @MethodSource("strategyProvider")
    void testStrategies(DiscountStrategy strategy, double input, double expected) {
        assertEquals(expected, strategy.applyDiscount(input), 0.001);
    }
    
    static Stream<Arguments> strategyProvider() {
        return Stream.of(
            Arguments.of(new RegularDiscount(), 100, 90),
            Arguments.of(new VipDiscount(), 100, 70),
            Arguments.of(new BlackFridayDiscount(), 100, 50)
        );
    }
}

集成测试方案

@SpringBootTest
class PaymentStrategyIT {
    @Autowired
    private StrategyContext context;
    
    @Test
    void testAlipayIntegration() {
        context.setStrategy("alipay");
        PaymentResult result = context.execute(createTestRequest());
        assertTrue(result.isSuccess());
    }
}

六、未来演进与模式变体

6.1 响应式策略模式

public interface ReactiveStrategy {
    Mono<Result> execute(Flux<Data> input);
}

public class AsyncValidationStrategy implements ReactiveStrategy {
    @Override
    public Mono<Result> execute(Flux<Data> input) {
        return input.parallel()
                 .runOn(Schedulers.parallel())
                 .flatMap(this::validateAsync)
                 .sequential()
                 .reduce(this::combineResults);
    }
}

6.2 机器学习策略

public class MLPredictionStrategy implements DecisionStrategy {
    private final PredictionModel model;
    
    public MLPredictionStrategy(byte[] modelData) {
        this.model = loadModel(modelData);
    }
    
    @Override
    public Decision makeDecision(Context context) {
        float[] features = extractFeatures(context);
        float prediction = model.predict(features);
        return prediction > 0.5 ? Decision.APPROVE : Decision.REJECT;
    }
}

6.3 策略即服务（Strategy as a Service）

@FeignClient(name = "strategy-service")
public interface StrategyServiceClient {
    @PostMapping("/strategies/{strategyId}/execute")
    StrategyResponse executeStrategy(
        @PathVariable String strategyId,
        @RequestBody StrategyRequest request);
}

public class RemoteStrategy implements DiscountStrategy {
    private final StrategyServiceClient client;
    private final String strategyId;
    
    @Override
    public double applyDiscount(double price) {
        StrategyResponse response = client.executeStrategy(strategyId, new StrategyRequest(price));
        return response.getResult();
    }
}