在技术开发领域策略模式Strategy Pattern是一种常见且强大的设计模式它允许在运行时选择算法或行为。本文将深入探讨策略模式的第二种实现方式——隐藏在大象背后Hiding Behind the Elephant这是一种通过封装和委托来简化复杂系统设计的进阶技巧。无论你是刚接触设计模式的新手还是希望优化现有架构的资深开发者本文都将提供从基础概念到实战落地的完整指南。1. 策略模式核心概念回顾1.1 什么是策略模式策略模式属于行为型设计模式其核心思想是将一组可互换的算法封装成独立的类使得它们可以相互替换。这种模式通过定义一系列算法并将每个算法封装起来使它们可以相互替换让算法的变化独立于使用算法的客户。在实际开发中策略模式特别适用于以下场景一个系统需要动态地在几种算法中选择一种存在多种相似的行为仅在某些具体行为上有所不同需要避免使用多重条件判断语句1.2 传统策略模式的局限性传统的策略模式实现虽然解决了算法选择的问题但在复杂系统中仍存在一些局限性// 传统策略接口 public interface PaymentStrategy { void pay(int amount); } // 具体策略实现 public class CreditCardStrategy implements PaymentStrategy { public void pay(int amount) { System.out.println(使用信用卡支付 amount 元); } } public class AlipayStrategy implements PaymentStrategy { public void pay(int amount) { System.out.println(使用支付宝支付 amount 元); } } // 上下文类 public class PaymentContext { private PaymentStrategy strategy; public void setStrategy(PaymentStrategy strategy) { this.strategy strategy; } public void executePayment(int amount) { strategy.pay(amount); } }这种传统实现方式虽然清晰但在大型系统中会导致策略类数量爆炸且客户端需要显式地选择具体策略。2. 隐藏在大象背后策略详解2.1 概念解析Hiding Behind the Elephant是一种策略模式的进阶实现方式其核心思想是通过一个统一的入口点来隐藏策略选择的复杂性。这里的大象指的是一个足够强大和通用的接口或抽象类它能够容纳各种策略的实现细节。这种方式的优势在于客户端无需关心具体策略的实现策略选择逻辑被封装在内部系统扩展性更强新增策略对客户端透明降低了模块间的耦合度2.2 实现原理该策略的实现基于以下设计原则单一职责原则每个策略类只负责一种具体的算法实现开闭原则对扩展开放对修改关闭依赖倒置原则依赖于抽象而不是具体实现接口隔离原则客户端不应该依赖它不需要的接口3. 环境准备与开发配置3.1 开发环境要求为了完整实现本文的示例建议准备以下开发环境JDK版本1.8或以上版本构建工具Maven 3.6 或 Gradle 6.0IDE推荐IntelliJ IDEA、Eclipse或VS Code测试框架JUnit 4或53.2 项目结构规划创建一个标准的Maven项目结构strategy-pattern-demo/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── strategy/ │ │ │ ├── elephant/ │ │ │ │ ├── StrategyElephant.java │ │ │ │ ├── StrategyContext.java │ │ │ │ └── strategies/ │ │ │ │ ├── FastStrategy.java │ │ │ │ ├── SlowStrategy.java │ │ │ │ └── BalancedStrategy.java │ │ │ └── demo/ │ │ │ └── DemoApplication.java │ │ └── resources/ │ └── test/ │ └── java/ └── pom.xml3.3 Maven依赖配置在pom.xml中添加必要的依赖?xml version1.0 encodingUTF-8? project xmlnshttp://maven.apache.org/POM/4.0.0 xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd modelVersion4.0.0/modelVersion groupIdcom.example/groupId artifactIdstrategy-pattern-demo/artifactId version1.0.0/version properties maven.compiler.source1.8/maven.compiler.source maven.compiler.target1.8/maven.compiler.target junit.version5.7.0/junit.version /properties dependencies dependency groupIdorg.junit.jupiter/groupId artifactIdjunit-jupiter/artifactId version${junit.version}/version scopetest/scope /dependency /dependencies /project4. 核心实现代码详解4.1 定义策略接口大象首先创建核心的策略接口这是整个模式的基石// 文件路径src/main/java/com/example/strategy/elephant/StrategyElephant.java package com.example.strategy.elephant; /** * 策略模式的核心接口 - 大象 * 定义了所有策略必须实现的方法 */ public interface StrategyElephant { /** * 执行策略的核心方法 * param data 输入数据 * return 处理结果 */ String execute(String data); /** * 获取策略类型标识 * return 策略类型 */ String getStrategyType(); /** * 检查策略是否适用于当前场景 * param context 执行上下文 * return 是否适用 */ boolean isApplicable(StrategyContext context); }4.2 创建策略上下文策略上下文负责管理策略的执行环境和参数// 文件路径src/main/java/com/example/strategy/elephant/StrategyContext.java package com.example.strategy.elephant; import java.util.HashMap; import java.util.Map; /** * 策略执行上下文 * 封装了策略执行所需的环境信息和参数 */ public class StrategyContext { private MapString, Object parameters; private String environment; private int priority; public StrategyContext() { this.parameters new HashMap(); this.environment default; this.priority 1; } public StrategyContext(String environment, int priority) { this(); this.environment environment; this.priority priority; } public void setParameter(String key, Object value) { parameters.put(key, value); } public Object getParameter(String key) { return parameters.get(key); } public String getEnvironment() { return environment; } public int getPriority() { return priority; } // 其他getter和setter方法... }4.3 实现具体策略类创建三种不同的策略实现展示策略的多样性// 文件路径src/main/java/com/example/strategy/elephant/strategies/FastStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 快速处理策略 * 适用于对性能要求较高的场景 */ public class FastStrategy implements StrategyElephant { Override public String execute(String data) { // 快速处理逻辑简单转换并返回 long startTime System.currentTimeMillis(); String result FAST_ data.toUpperCase(); long endTime System.currentTimeMillis(); System.out.println(快速策略执行完成耗时 (endTime - startTime) ms); return result; } Override public String getStrategyType() { return FAST; } Override public boolean isApplicable(StrategyContext context) { // 在性能优先的环境下适用 return performance.equals(context.getEnvironment()) || context.getPriority() 5; } }// 文件路径src/main/java/com/example/strategy/elephant/strategies/SlowStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 慢速但精确的策略 * 适用于对准确性要求极高的场景 */ public class SlowStrategy implements StrategyElephant { Override public String execute(String data) { // 精确处理逻辑复杂计算和验证 long startTime System.currentTimeMillis(); try { // 模拟复杂处理 Thread.sleep(100); String result SLOW_PRECISE_ data.toLowerCase(); // 添加校验逻辑 if (result.length() 5) { result result _VALIDATED; } long endTime System.currentTimeMillis(); System.out.println(慢速策略执行完成耗时 (endTime - startTime) ms); return result; } catch (InterruptedException e) { Thread.currentThread().interrupt(); return ERROR: Processing interrupted; } } Override public String getStrategyType() { return SLOW_PRECISE; } Override public boolean isApplicable(StrategyContext context) { // 在准确性优先的环境下适用 return accuracy.equals(context.getEnvironment()) || context.getPriority() 3; } }// 文件路径src/main/java/com/example/strategy/elephant/strategies/BalancedStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 平衡策略 * 在性能和准确性之间取得平衡 */ public class BalancedStrategy implements StrategyElephant { Override public String execute(String data) { long startTime System.currentTimeMillis(); // 平衡处理逻辑适中的复杂度 String result; if (data.length() 10) { result BALANCED_SHORT_ data.substring(0, 10); } else { result BALANCED_FULL_ data; } long endTime System.currentTimeMillis(); System.out.println(平衡策略执行完成耗时 (endTime - startTime) ms); return result; } Override public String getStrategyType() { return BALANCED; } Override public boolean isApplicable(StrategyContext context) { // 在大多数环境下都适用 return !extreme.equals(context.getEnvironment()); } }4.4 策略管理器实现创建策略管理器来隐藏策略选择的复杂性// 文件路径src/main/java/com/example/strategy/elephant/StrategyManager.java package com.example.strategy.elephant; import com.example.strategy.elephant.strategies.BalancedStrategy; import com.example.strategy.elephant.strategies.FastStrategy; import com.example.strategy.elephant.strategies.SlowStrategy; import java.util.ArrayList; import java.util.List; /** * 策略管理器 - 隐藏策略选择复杂性的核心类 * 客户端只需要与这个管理器交互无需关心具体策略 */ public class StrategyManager { private ListStrategyElephant strategies; public StrategyManager() { this.strategies new ArrayList(); // 注册所有可用策略 registerStrategies(); } private void registerStrategies() { strategies.add(new FastStrategy()); strategies.add(new SlowStrategy()); strategies.add(new BalancedStrategy()); } /** * 根据上下文自动选择最合适的策略并执行 * param data 输入数据 * param context 执行上下文 * return 处理结果 */ public String executeWithOptimalStrategy(String data, StrategyContext context) { StrategyElephant optimalStrategy findOptimalStrategy(context); if (optimalStrategy null) { throw new IllegalStateException(没有找到适用的策略); } System.out.println(选择策略: optimalStrategy.getStrategyType()); return optimalStrategy.execute(data); } /** * 根据策略类型选择特定策略执行 * param data 输入数据 * param strategyType 策略类型 * return 处理结果 */ public String executeWithSpecificStrategy(String data, String strategyType) { StrategyElephant strategy strategies.stream() .filter(s - s.getStrategyType().equals(strategyType)) .findFirst() .orElseThrow(() - new IllegalArgumentException(未知的策略类型: strategyType)); StrategyContext defaultContext new StrategyContext(); return strategy.execute(data); } private StrategyElephant findOptimalStrategy(StrategyContext context) { return strategies.stream() .filter(strategy - strategy.isApplicable(context)) .findFirst() .orElse(new BalancedStrategy()); // 默认使用平衡策略 } /** * 添加新的策略实现 * param strategy 新策略 */ public void addStrategy(StrategyElephant strategy) { strategies.add(strategy); } }5. 完整实战演示5.1 创建演示应用程序编写主程序来展示策略模式的实际应用// 文件路径src/main/java/com/example/strategy/demo/DemoApplication.java package com.example.strategy.demo; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyManager; /** * 策略模式演示应用程序 */ public class DemoApplication { public static void main(String[] args) { StrategyManager manager new StrategyManager(); System.out.println( 策略模式演示开始 ); // 场景1性能优先环境 System.out.println(\n--- 场景1性能优先环境 ---); StrategyContext performanceContext new StrategyContext(performance, 8); performanceContext.setParameter(timeout, 1000); String result1 manager.executeWithOptimalStrategy(hello world, performanceContext); System.out.println(结果: result1); // 场景2准确性优先环境 System.out.println(\n--- 场景2准确性优先环境 ---); StrategyContext accuracyContext new StrategyContext(accuracy, 2); accuracyContext.setParameter(validation, strict); String result2 manager.executeWithOptimalStrategy(important data, accuracyContext); System.out.println(结果: result2); // 场景3默认环境 System.out.println(\n--- 场景3默认环境 ---); StrategyContext defaultContext new StrategyContext(); String result3 manager.executeWithOptimalStrategy(test data, defaultContext); System.out.println(结果: result3); // 场景4指定特定策略 System.out.println(\n--- 场景4指定快速策略 ---); String result4 manager.executeWithSpecificStrategy(quick processing, FAST); System.out.println(结果: result4); System.out.println(\n 策略模式演示结束 ); } }5.2 运行结果分析执行上述演示程序预期输出如下 策略模式演示开始 --- 场景1性能优先环境 --- 选择策略: FAST 快速策略执行完成耗时1ms 结果: FAST_HELLO WORLD --- 场景2准确性优先环境 --- 选择策略: SLOW_PRECISE 慢速策略执行完成耗时101ms 结果: slow_precise_important data_VALIDATED --- 场景3默认环境 --- 选择策略: BALANCED 平衡策略执行完成耗时0ms 结果: BALANCED_FULL_test data --- 场景4指定快速策略 --- 快速策略执行完成耗时0ms 结果: FAST_QUICK PROCESSING 策略模式演示结束 5.3 单元测试编写为确保代码质量编写相应的单元测试// 文件路径src/test/java/com/example/strategy/elephant/StrategyManagerTest.java package com.example.strategy.elephant; import com.example.strategy.elephant.strategies.BalancedStrategy; import com.example.strategy.elephant.strategies.FastStrategy; import com.example.strategy.elephant.strategies.SlowStrategy; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class StrategyManagerTest { private StrategyManager strategyManager; BeforeEach void setUp() { strategyManager new StrategyManager(); } Test void testPerformanceContextSelectsFastStrategy() { StrategyContext context new StrategyContext(performance, 8); String result strategyManager.executeWithOptimalStrategy(test, context); assertTrue(result.startsWith(FAST_)); } Test void testAccuracyContextSelectsSlowStrategy() { StrategyContext context new StrategyContext(accuracy, 2); String result strategyManager.executeWithOptimalStrategy(test, context); assertTrue(result.startsWith(SLOW_PRECISE_)); } Test void testSpecificStrategyExecution() { String result strategyManager.executeWithSpecificStrategy(data, BALANCED); assertTrue(result.startsWith(BALANCED_)); } Test void testAddNewStrategy() { // 创建自定义策略 StrategyElephant customStrategy new StrategyElephant() { Override public String execute(String data) { return CUSTOM_ data; } Override public String getStrategyType() { return CUSTOM; } Override public boolean isApplicable(StrategyContext context) { return true; } }; strategyManager.addStrategy(customStrategy); String result strategyManager.executeWithSpecificStrategy(test, CUSTOM); assertEquals(CUSTOM_test, result); } }6. 高级特性与优化6.1 策略优先级管理在实际项目中可能需要更复杂的策略选择逻辑// 文件路径src/main/java/com/example/strategy/elephant/PriorityStrategyManager.java package com.example.strategy.elephant; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; /** * 支持优先级管理的策略管理器 */ public class PriorityStrategyManager extends StrategyManager { /** * 根据优先级排序选择策略 */ Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { ListStrategyElephant applicableStrategies getStrategies().stream() .filter(strategy - strategy.isApplicable(context)) .sorted(Comparator.comparingInt(this::getStrategyPriority)) .collect(Collectors.toList()); return applicableStrategies.isEmpty() ? new BalancedStrategy() : applicableStrategies.get(0); } private int getStrategyPriority(StrategyElephant strategy) { // 根据策略类型返回优先级数值越小优先级越高 switch (strategy.getStrategyType()) { case FAST: return 1; case BALANCED: return 2; case SLOW_PRECISE: return 3; default: return 10; } } }6.2 策略配置化实现将策略配置外部化提高灵活性// 文件路径src/main/java/com/example/strategy/elephant/ConfigurableStrategyManager.java package com.example.strategy.elephant; import java.util.Properties; /** * 支持外部配置的策略管理器 */ public class ConfigurableStrategyManager extends StrategyManager { private Properties strategyConfig; public ConfigurableStrategyManager(Properties config) { super(); this.strategyConfig config; } Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { String configuredStrategy strategyConfig.getProperty( context.getEnvironment() .default.strategy); if (configuredStrategy ! null) { return getStrategies().stream() .filter(s - s.getStrategyType().equals(configuredStrategy)) .findFirst() .orElse(super.findOptimalStrategy(context)); } return super.findOptimalStrategy(context); } }7. 常见问题与解决方案7.1 策略选择冲突当多个策略都适用于同一上下文时可能会出现选择冲突问题现象系统在不同运行环境下选择了不同的策略导致行为不一致。解决方案明确策略优先级规则添加策略权重配置实现策略组合模式// 策略权重配置示例 public class WeightedStrategyManager extends StrategyManager { private MapString, Integer strategyWeights new HashMap(); public void setStrategyWeight(String strategyType, int weight) { strategyWeights.put(strategyType, weight); } Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { return getStrategies().stream() .filter(s - s.isApplicable(context)) .min(Comparator.comparingInt(s - strategyWeights.getOrDefault(s.getStrategyType(), 100))) .orElse(new BalancedStrategy()); } }7.2 策略性能问题策略模式可能引入的性能开销问题现象策略选择和执行过程中出现性能瓶颈。优化方案使用策略缓存预编译策略选择逻辑异步策略执行7.3 策略扩展维护随着业务发展策略数量不断增加维护挑战策略类爆炸管理复杂度增加。最佳实践使用策略工厂模式实现策略自动发现机制建立策略生命周期管理8. 生产环境最佳实践8.1 策略命名规范建立统一的策略命名规范提高代码可读性使用描述性的策略名称如HighPerformanceStrategy而非StrategyA策略类型标识符使用大写字母和下划线如FAST_PROCESSING为每个策略编写详细的文档说明8.2 配置管理建议在生产环境中策略配置应该外部化# strategy-config.properties performance.default.strategyFAST accuracy.default.strategySLOW_PRECISE development.default.strategyBALANCED # 策略权重配置 strategy.weight.FAST1 strategy.weight.BALANCED2 strategy.weight.SLOW_PRECISE38.3 监控与日志为策略执行添加完善的监控和日志public class MonitoredStrategyManager extends StrategyManager { private static final Logger logger LoggerFactory.getLogger(MonitoredStrategyManager.class); Override public String executeWithOptimalStrategy(String data, StrategyContext context) { long startTime System.currentTimeMillis(); String strategyType UNKNOWN; try { StrategyElephant strategy findOptimalStrategy(context); strategyType strategy.getStrategyType(); logger.info(执行策略: {}数据长度: {}, strategyType, data.length()); String result strategy.execute(data); long duration System.currentTimeMillis() - startTime; logger.info(策略执行完成: {}耗时: {}ms, strategyType, duration); return result; } catch (Exception e) { logger.error(策略执行失败: {}错误: {}, strategyType, e.getMessage(), e); throw e; } } }8.4 测试策略覆盖确保所有策略都有相应的测试用例为每个策略类编写单元测试测试策略选择逻辑的正确性模拟边界条件和异常情况进行集成测试验证策略组合9. 实际项目应用场景9.1 支付系统策略应用在支付系统中使用策略模式处理不同的支付方式public interface PaymentStrategy { PaymentResult process(PaymentRequest request); boolean supports(PaymentMethod method); } // 具体策略信用卡支付 public class CreditCardStrategy implements PaymentStrategy { public PaymentResult process(PaymentRequest request) { // 信用卡支付逻辑 } public boolean supports(PaymentMethod method) { return method PaymentMethod.CREDIT_CARD; } } // 支付策略管理器 public class PaymentStrategyManager { private ListPaymentStrategy strategies; public PaymentResult processPayment(PaymentRequest request) { PaymentStrategy strategy strategies.stream() .filter(s - s.supports(request.getMethod())) .findFirst() .orElseThrow(() - new UnsupportedPaymentMethodException()); return strategy.process(request); } }9.2 数据导出策略根据不同需求选择数据导出策略public interface ExportStrategy { ExportResult export(Data data, ExportConfig config); boolean supports(ExportFormat format); } // Excel导出策略 public class ExcelExportStrategy implements ExportStrategy { public ExportResult export(Data data, ExportConfig config) { // Excel导出逻辑 } public boolean supports(ExportFormat format) { return format ExportFormat.EXCEL; } }9.3 缓存策略选择根据数据特性选择合适的缓存策略public interface CacheStrategy { void cache(String key, Object value); Object get(String key); boolean isSuitable(CacheContext context); } // 内存缓存策略 public class MemoryCacheStrategy implements CacheStrategy { public void cache(String key, Object value) { // 内存缓存逻辑 } public boolean isSuitable(CacheContext context) { return context.getSize() 1000; // 小数据量适用 } }通过本文的完整讲解你应该已经掌握了策略模式中Hiding Behind the Elephant这种进阶实现方式的核心理念和实战技巧。这种设计模式能够显著提高代码的灵活性和可维护性是构建复杂系统的重要工具。在实际项目中根据具体需求选择合适的策略实现方式并遵循最佳实践将帮助您构建更加健壮和可扩展的应用程序。 策略模式进阶：隐藏在大象背后的设计模式实现详解
在技术开发领域策略模式Strategy Pattern是一种常见且强大的设计模式它允许在运行时选择算法或行为。本文将深入探讨策略模式的第二种实现方式——隐藏在大象背后Hiding Behind the Elephant这是一种通过封装和委托来简化复杂系统设计的进阶技巧。无论你是刚接触设计模式的新手还是希望优化现有架构的资深开发者本文都将提供从基础概念到实战落地的完整指南。1. 策略模式核心概念回顾1.1 什么是策略模式策略模式属于行为型设计模式其核心思想是将一组可互换的算法封装成独立的类使得它们可以相互替换。这种模式通过定义一系列算法并将每个算法封装起来使它们可以相互替换让算法的变化独立于使用算法的客户。在实际开发中策略模式特别适用于以下场景一个系统需要动态地在几种算法中选择一种存在多种相似的行为仅在某些具体行为上有所不同需要避免使用多重条件判断语句1.2 传统策略模式的局限性传统的策略模式实现虽然解决了算法选择的问题但在复杂系统中仍存在一些局限性// 传统策略接口 public interface PaymentStrategy { void pay(int amount); } // 具体策略实现 public class CreditCardStrategy implements PaymentStrategy { public void pay(int amount) { System.out.println(使用信用卡支付 amount 元); } } public class AlipayStrategy implements PaymentStrategy { public void pay(int amount) { System.out.println(使用支付宝支付 amount 元); } } // 上下文类 public class PaymentContext { private PaymentStrategy strategy; public void setStrategy(PaymentStrategy strategy) { this.strategy strategy; } public void executePayment(int amount) { strategy.pay(amount); } }这种传统实现方式虽然清晰但在大型系统中会导致策略类数量爆炸且客户端需要显式地选择具体策略。2. 隐藏在大象背后策略详解2.1 概念解析Hiding Behind the Elephant是一种策略模式的进阶实现方式其核心思想是通过一个统一的入口点来隐藏策略选择的复杂性。这里的大象指的是一个足够强大和通用的接口或抽象类它能够容纳各种策略的实现细节。这种方式的优势在于客户端无需关心具体策略的实现策略选择逻辑被封装在内部系统扩展性更强新增策略对客户端透明降低了模块间的耦合度2.2 实现原理该策略的实现基于以下设计原则单一职责原则每个策略类只负责一种具体的算法实现开闭原则对扩展开放对修改关闭依赖倒置原则依赖于抽象而不是具体实现接口隔离原则客户端不应该依赖它不需要的接口3. 环境准备与开发配置3.1 开发环境要求为了完整实现本文的示例建议准备以下开发环境JDK版本1.8或以上版本构建工具Maven 3.6 或 Gradle 6.0IDE推荐IntelliJ IDEA、Eclipse或VS Code测试框架JUnit 4或53.2 项目结构规划创建一个标准的Maven项目结构strategy-pattern-demo/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ └── com/ │ │ │ └── example/ │ │ │ └── strategy/ │ │ │ ├── elephant/ │ │ │ │ ├── StrategyElephant.java │ │ │ │ ├── StrategyContext.java │ │ │ │ └── strategies/ │ │ │ │ ├── FastStrategy.java │ │ │ │ ├── SlowStrategy.java │ │ │ │ └── BalancedStrategy.java │ │ │ └── demo/ │ │ │ └── DemoApplication.java │ │ └── resources/ │ └── test/ │ └── java/ └── pom.xml3.3 Maven依赖配置在pom.xml中添加必要的依赖?xml version1.0 encodingUTF-8? project xmlnshttp://maven.apache.org/POM/4.0.0 xmlns:xsihttp://www.w3.org/2001/XMLSchema-instance xsi:schemaLocationhttp://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd modelVersion4.0.0/modelVersion groupIdcom.example/groupId artifactIdstrategy-pattern-demo/artifactId version1.0.0/version properties maven.compiler.source1.8/maven.compiler.source maven.compiler.target1.8/maven.compiler.target junit.version5.7.0/junit.version /properties dependencies dependency groupIdorg.junit.jupiter/groupId artifactIdjunit-jupiter/artifactId version${junit.version}/version scopetest/scope /dependency /dependencies /project4. 核心实现代码详解4.1 定义策略接口大象首先创建核心的策略接口这是整个模式的基石// 文件路径src/main/java/com/example/strategy/elephant/StrategyElephant.java package com.example.strategy.elephant; /** * 策略模式的核心接口 - 大象 * 定义了所有策略必须实现的方法 */ public interface StrategyElephant { /** * 执行策略的核心方法 * param data 输入数据 * return 处理结果 */ String execute(String data); /** * 获取策略类型标识 * return 策略类型 */ String getStrategyType(); /** * 检查策略是否适用于当前场景 * param context 执行上下文 * return 是否适用 */ boolean isApplicable(StrategyContext context); }4.2 创建策略上下文策略上下文负责管理策略的执行环境和参数// 文件路径src/main/java/com/example/strategy/elephant/StrategyContext.java package com.example.strategy.elephant; import java.util.HashMap; import java.util.Map; /** * 策略执行上下文 * 封装了策略执行所需的环境信息和参数 */ public class StrategyContext { private MapString, Object parameters; private String environment; private int priority; public StrategyContext() { this.parameters new HashMap(); this.environment default; this.priority 1; } public StrategyContext(String environment, int priority) { this(); this.environment environment; this.priority priority; } public void setParameter(String key, Object value) { parameters.put(key, value); } public Object getParameter(String key) { return parameters.get(key); } public String getEnvironment() { return environment; } public int getPriority() { return priority; } // 其他getter和setter方法... }4.3 实现具体策略类创建三种不同的策略实现展示策略的多样性// 文件路径src/main/java/com/example/strategy/elephant/strategies/FastStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 快速处理策略 * 适用于对性能要求较高的场景 */ public class FastStrategy implements StrategyElephant { Override public String execute(String data) { // 快速处理逻辑简单转换并返回 long startTime System.currentTimeMillis(); String result FAST_ data.toUpperCase(); long endTime System.currentTimeMillis(); System.out.println(快速策略执行完成耗时 (endTime - startTime) ms); return result; } Override public String getStrategyType() { return FAST; } Override public boolean isApplicable(StrategyContext context) { // 在性能优先的环境下适用 return performance.equals(context.getEnvironment()) || context.getPriority() 5; } }// 文件路径src/main/java/com/example/strategy/elephant/strategies/SlowStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 慢速但精确的策略 * 适用于对准确性要求极高的场景 */ public class SlowStrategy implements StrategyElephant { Override public String execute(String data) { // 精确处理逻辑复杂计算和验证 long startTime System.currentTimeMillis(); try { // 模拟复杂处理 Thread.sleep(100); String result SLOW_PRECISE_ data.toLowerCase(); // 添加校验逻辑 if (result.length() 5) { result result _VALIDATED; } long endTime System.currentTimeMillis(); System.out.println(慢速策略执行完成耗时 (endTime - startTime) ms); return result; } catch (InterruptedException e) { Thread.currentThread().interrupt(); return ERROR: Processing interrupted; } } Override public String getStrategyType() { return SLOW_PRECISE; } Override public boolean isApplicable(StrategyContext context) { // 在准确性优先的环境下适用 return accuracy.equals(context.getEnvironment()) || context.getPriority() 3; } }// 文件路径src/main/java/com/example/strategy/elephant/strategies/BalancedStrategy.java package com.example.strategy.elephant.strategies; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyElephant; /** * 平衡策略 * 在性能和准确性之间取得平衡 */ public class BalancedStrategy implements StrategyElephant { Override public String execute(String data) { long startTime System.currentTimeMillis(); // 平衡处理逻辑适中的复杂度 String result; if (data.length() 10) { result BALANCED_SHORT_ data.substring(0, 10); } else { result BALANCED_FULL_ data; } long endTime System.currentTimeMillis(); System.out.println(平衡策略执行完成耗时 (endTime - startTime) ms); return result; } Override public String getStrategyType() { return BALANCED; } Override public boolean isApplicable(StrategyContext context) { // 在大多数环境下都适用 return !extreme.equals(context.getEnvironment()); } }4.4 策略管理器实现创建策略管理器来隐藏策略选择的复杂性// 文件路径src/main/java/com/example/strategy/elephant/StrategyManager.java package com.example.strategy.elephant; import com.example.strategy.elephant.strategies.BalancedStrategy; import com.example.strategy.elephant.strategies.FastStrategy; import com.example.strategy.elephant.strategies.SlowStrategy; import java.util.ArrayList; import java.util.List; /** * 策略管理器 - 隐藏策略选择复杂性的核心类 * 客户端只需要与这个管理器交互无需关心具体策略 */ public class StrategyManager { private ListStrategyElephant strategies; public StrategyManager() { this.strategies new ArrayList(); // 注册所有可用策略 registerStrategies(); } private void registerStrategies() { strategies.add(new FastStrategy()); strategies.add(new SlowStrategy()); strategies.add(new BalancedStrategy()); } /** * 根据上下文自动选择最合适的策略并执行 * param data 输入数据 * param context 执行上下文 * return 处理结果 */ public String executeWithOptimalStrategy(String data, StrategyContext context) { StrategyElephant optimalStrategy findOptimalStrategy(context); if (optimalStrategy null) { throw new IllegalStateException(没有找到适用的策略); } System.out.println(选择策略: optimalStrategy.getStrategyType()); return optimalStrategy.execute(data); } /** * 根据策略类型选择特定策略执行 * param data 输入数据 * param strategyType 策略类型 * return 处理结果 */ public String executeWithSpecificStrategy(String data, String strategyType) { StrategyElephant strategy strategies.stream() .filter(s - s.getStrategyType().equals(strategyType)) .findFirst() .orElseThrow(() - new IllegalArgumentException(未知的策略类型: strategyType)); StrategyContext defaultContext new StrategyContext(); return strategy.execute(data); } private StrategyElephant findOptimalStrategy(StrategyContext context) { return strategies.stream() .filter(strategy - strategy.isApplicable(context)) .findFirst() .orElse(new BalancedStrategy()); // 默认使用平衡策略 } /** * 添加新的策略实现 * param strategy 新策略 */ public void addStrategy(StrategyElephant strategy) { strategies.add(strategy); } }5. 完整实战演示5.1 创建演示应用程序编写主程序来展示策略模式的实际应用// 文件路径src/main/java/com/example/strategy/demo/DemoApplication.java package com.example.strategy.demo; import com.example.strategy.elephant.StrategyContext; import com.example.strategy.elephant.StrategyManager; /** * 策略模式演示应用程序 */ public class DemoApplication { public static void main(String[] args) { StrategyManager manager new StrategyManager(); System.out.println( 策略模式演示开始 ); // 场景1性能优先环境 System.out.println(\n--- 场景1性能优先环境 ---); StrategyContext performanceContext new StrategyContext(performance, 8); performanceContext.setParameter(timeout, 1000); String result1 manager.executeWithOptimalStrategy(hello world, performanceContext); System.out.println(结果: result1); // 场景2准确性优先环境 System.out.println(\n--- 场景2准确性优先环境 ---); StrategyContext accuracyContext new StrategyContext(accuracy, 2); accuracyContext.setParameter(validation, strict); String result2 manager.executeWithOptimalStrategy(important data, accuracyContext); System.out.println(结果: result2); // 场景3默认环境 System.out.println(\n--- 场景3默认环境 ---); StrategyContext defaultContext new StrategyContext(); String result3 manager.executeWithOptimalStrategy(test data, defaultContext); System.out.println(结果: result3); // 场景4指定特定策略 System.out.println(\n--- 场景4指定快速策略 ---); String result4 manager.executeWithSpecificStrategy(quick processing, FAST); System.out.println(结果: result4); System.out.println(\n 策略模式演示结束 ); } }5.2 运行结果分析执行上述演示程序预期输出如下 策略模式演示开始 --- 场景1性能优先环境 --- 选择策略: FAST 快速策略执行完成耗时1ms 结果: FAST_HELLO WORLD --- 场景2准确性优先环境 --- 选择策略: SLOW_PRECISE 慢速策略执行完成耗时101ms 结果: slow_precise_important data_VALIDATED --- 场景3默认环境 --- 选择策略: BALANCED 平衡策略执行完成耗时0ms 结果: BALANCED_FULL_test data --- 场景4指定快速策略 --- 快速策略执行完成耗时0ms 结果: FAST_QUICK PROCESSING 策略模式演示结束 5.3 单元测试编写为确保代码质量编写相应的单元测试// 文件路径src/test/java/com/example/strategy/elephant/StrategyManagerTest.java package com.example.strategy.elephant; import com.example.strategy.elephant.strategies.BalancedStrategy; import com.example.strategy.elephant.strategies.FastStrategy; import com.example.strategy.elephant.strategies.SlowStrategy; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.*; class StrategyManagerTest { private StrategyManager strategyManager; BeforeEach void setUp() { strategyManager new StrategyManager(); } Test void testPerformanceContextSelectsFastStrategy() { StrategyContext context new StrategyContext(performance, 8); String result strategyManager.executeWithOptimalStrategy(test, context); assertTrue(result.startsWith(FAST_)); } Test void testAccuracyContextSelectsSlowStrategy() { StrategyContext context new StrategyContext(accuracy, 2); String result strategyManager.executeWithOptimalStrategy(test, context); assertTrue(result.startsWith(SLOW_PRECISE_)); } Test void testSpecificStrategyExecution() { String result strategyManager.executeWithSpecificStrategy(data, BALANCED); assertTrue(result.startsWith(BALANCED_)); } Test void testAddNewStrategy() { // 创建自定义策略 StrategyElephant customStrategy new StrategyElephant() { Override public String execute(String data) { return CUSTOM_ data; } Override public String getStrategyType() { return CUSTOM; } Override public boolean isApplicable(StrategyContext context) { return true; } }; strategyManager.addStrategy(customStrategy); String result strategyManager.executeWithSpecificStrategy(test, CUSTOM); assertEquals(CUSTOM_test, result); } }6. 高级特性与优化6.1 策略优先级管理在实际项目中可能需要更复杂的策略选择逻辑// 文件路径src/main/java/com/example/strategy/elephant/PriorityStrategyManager.java package com.example.strategy.elephant; import java.util.Comparator; import java.util.List; import java.util.stream.Collectors; /** * 支持优先级管理的策略管理器 */ public class PriorityStrategyManager extends StrategyManager { /** * 根据优先级排序选择策略 */ Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { ListStrategyElephant applicableStrategies getStrategies().stream() .filter(strategy - strategy.isApplicable(context)) .sorted(Comparator.comparingInt(this::getStrategyPriority)) .collect(Collectors.toList()); return applicableStrategies.isEmpty() ? new BalancedStrategy() : applicableStrategies.get(0); } private int getStrategyPriority(StrategyElephant strategy) { // 根据策略类型返回优先级数值越小优先级越高 switch (strategy.getStrategyType()) { case FAST: return 1; case BALANCED: return 2; case SLOW_PRECISE: return 3; default: return 10; } } }6.2 策略配置化实现将策略配置外部化提高灵活性// 文件路径src/main/java/com/example/strategy/elephant/ConfigurableStrategyManager.java package com.example.strategy.elephant; import java.util.Properties; /** * 支持外部配置的策略管理器 */ public class ConfigurableStrategyManager extends StrategyManager { private Properties strategyConfig; public ConfigurableStrategyManager(Properties config) { super(); this.strategyConfig config; } Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { String configuredStrategy strategyConfig.getProperty( context.getEnvironment() .default.strategy); if (configuredStrategy ! null) { return getStrategies().stream() .filter(s - s.getStrategyType().equals(configuredStrategy)) .findFirst() .orElse(super.findOptimalStrategy(context)); } return super.findOptimalStrategy(context); } }7. 常见问题与解决方案7.1 策略选择冲突当多个策略都适用于同一上下文时可能会出现选择冲突问题现象系统在不同运行环境下选择了不同的策略导致行为不一致。解决方案明确策略优先级规则添加策略权重配置实现策略组合模式// 策略权重配置示例 public class WeightedStrategyManager extends StrategyManager { private MapString, Integer strategyWeights new HashMap(); public void setStrategyWeight(String strategyType, int weight) { strategyWeights.put(strategyType, weight); } Override protected StrategyElephant findOptimalStrategy(StrategyContext context) { return getStrategies().stream() .filter(s - s.isApplicable(context)) .min(Comparator.comparingInt(s - strategyWeights.getOrDefault(s.getStrategyType(), 100))) .orElse(new BalancedStrategy()); } }7.2 策略性能问题策略模式可能引入的性能开销问题现象策略选择和执行过程中出现性能瓶颈。优化方案使用策略缓存预编译策略选择逻辑异步策略执行7.3 策略扩展维护随着业务发展策略数量不断增加维护挑战策略类爆炸管理复杂度增加。最佳实践使用策略工厂模式实现策略自动发现机制建立策略生命周期管理8. 生产环境最佳实践8.1 策略命名规范建立统一的策略命名规范提高代码可读性使用描述性的策略名称如HighPerformanceStrategy而非StrategyA策略类型标识符使用大写字母和下划线如FAST_PROCESSING为每个策略编写详细的文档说明8.2 配置管理建议在生产环境中策略配置应该外部化# strategy-config.properties performance.default.strategyFAST accuracy.default.strategySLOW_PRECISE development.default.strategyBALANCED # 策略权重配置 strategy.weight.FAST1 strategy.weight.BALANCED2 strategy.weight.SLOW_PRECISE38.3 监控与日志为策略执行添加完善的监控和日志public class MonitoredStrategyManager extends StrategyManager { private static final Logger logger LoggerFactory.getLogger(MonitoredStrategyManager.class); Override public String executeWithOptimalStrategy(String data, StrategyContext context) { long startTime System.currentTimeMillis(); String strategyType UNKNOWN; try { StrategyElephant strategy findOptimalStrategy(context); strategyType strategy.getStrategyType(); logger.info(执行策略: {}数据长度: {}, strategyType, data.length()); String result strategy.execute(data); long duration System.currentTimeMillis() - startTime; logger.info(策略执行完成: {}耗时: {}ms, strategyType, duration); return result; } catch (Exception e) { logger.error(策略执行失败: {}错误: {}, strategyType, e.getMessage(), e); throw e; } } }8.4 测试策略覆盖确保所有策略都有相应的测试用例为每个策略类编写单元测试测试策略选择逻辑的正确性模拟边界条件和异常情况进行集成测试验证策略组合9. 实际项目应用场景9.1 支付系统策略应用在支付系统中使用策略模式处理不同的支付方式public interface PaymentStrategy { PaymentResult process(PaymentRequest request); boolean supports(PaymentMethod method); } // 具体策略信用卡支付 public class CreditCardStrategy implements PaymentStrategy { public PaymentResult process(PaymentRequest request) { // 信用卡支付逻辑 } public boolean supports(PaymentMethod method) { return method PaymentMethod.CREDIT_CARD; } } // 支付策略管理器 public class PaymentStrategyManager { private ListPaymentStrategy strategies; public PaymentResult processPayment(PaymentRequest request) { PaymentStrategy strategy strategies.stream() .filter(s - s.supports(request.getMethod())) .findFirst() .orElseThrow(() - new UnsupportedPaymentMethodException()); return strategy.process(request); } }9.2 数据导出策略根据不同需求选择数据导出策略public interface ExportStrategy { ExportResult export(Data data, ExportConfig config); boolean supports(ExportFormat format); } // Excel导出策略 public class ExcelExportStrategy implements ExportStrategy { public ExportResult export(Data data, ExportConfig config) { // Excel导出逻辑 } public boolean supports(ExportFormat format) { return format ExportFormat.EXCEL; } }9.3 缓存策略选择根据数据特性选择合适的缓存策略public interface CacheStrategy { void cache(String key, Object value); Object get(String key); boolean isSuitable(CacheContext context); } // 内存缓存策略 public class MemoryCacheStrategy implements CacheStrategy { public void cache(String key, Object value) { // 内存缓存逻辑 } public boolean isSuitable(CacheContext context) { return context.getSize() 1000; // 小数据量适用 } }通过本文的完整讲解你应该已经掌握了策略模式中Hiding Behind the Elephant这种进阶实现方式的核心理念和实战技巧。这种设计模式能够显著提高代码的灵活性和可维护性是构建复杂系统的重要工具。在实际项目中根据具体需求选择合适的策略实现方式并遵循最佳实践将帮助您构建更加健壮和可扩展的应用程序。