【设计模式】策略模式 在java中的应用

概述

在实际开发过程中，我们经常会碰到需要在不同的业务场景中采用不同算法的情况。策略模式（Strategy Pattern）正是为了解决这种情况而设计的一种行为型设计模式。它通过定义一系列的算法，将每个算法封装起来，并且使它们可以互换，从而使得算法的变化不会影响使用算法的客户端。

策略模式的定义与应用场景

定义

策略模式是一种将算法或行为封装到各自独立的类中的设计模式。它使得算法在运行时可以相互替换，使得算法的使用者无需了解具体的实现细节，只需关注算法的接口。这种设计思想让系统具备了很好的灵活性和扩展性。

应用场景

1. 算法簇：当系统需要使用多个算法变体，并且在运行时依据需求切换时，可以采用策略模式。
2. 消除条件语句：当大量条件分支代码导致逻辑复杂、维护困难时，策略模式能够将不同的分支逻辑进行解耦，用不同的策略类来实现。
3. 复用和扩展：在有些场景中，不同的策略可能会频繁变化。如果把这些算法封装到独立的策略类中，当需要修改或扩展算法时，不需要大幅度修改原有代码，只需添加或替换对应的策略实现。

举个常见的例子，比如支付方式的选择。在电子商务系统中，我们可能支持信用卡、支付宝、微信等多种支付方式。通过定义一个支付策略接口，分别为不同的支付方式设计对应的实现类，我们可以在运行时依据用户的选择动态绑定相应的支付策略，从而避免大量的if-else判断。

策略模式的核心设计思想

策略模式的核心在于“把大量的行为封装起来，让它们独立发展。主要思路包括以下几个方面：

1. 接口隔离：将具体的算法实现隔离在各自的策略类中，客户端只需要依赖策略接口，降低了算法之间的耦合性。
2. 算法家族与共性抽取：策略模式总结一系列算法的共性，通过策略接口或抽象基类规定公共操作，让具体策略各自实现差异化行为。
3. 动态替换：由于所有策略都遵循统一接口，所以策略类可以在运行时根据需求进行动态替换，从而实现功能的灵活切换。

一种常见的类比场景是快递配送方式。假设一个电商平台支持顺丰、EMS、邮政等多家快递服务。当用户下单后，系统可以根据订单特点（如时效、价格、目的地等），动态选择最合适的配送方式。此时，每一种配送方式就相当于一个策略，平台通过提供统一的接口来调用具体的配送策略。

策略模式的纯Java实现

在这一章节，我们将使用纯Java代码实现策略模式的基本步骤。这里我们以“差异计算”为例子，通过定义一个策略接口和多个具体策略类，展示策略模式如何封装不同的算法实现，并通过示例代码来理解其基本用法。

---

1. 定义策略接口（抽象基类）

首先，我们定义一个策略接口 ComputeStrategy，该接口规定了所有具体策略类必须实现的公共方法。在本例中，提供一个 compute() 方法用于不同的计算逻辑。

文件：ComputeStrategy.java

package com.example.strategy;public interface ComputeStrategy {/*** 计算差异的统一接口*/void compute();
}

---

2. 设计具体策略类

接下来，我们分别实现两个具体策略类：CoverStrategy 和 QyKgStrategy。它们分别实现 ComputeStrategy 接口，提供各自独特的差异计算算法。

文件：CoverStrategy.java

package com.example.strategy;public class CoverStrategy implements ComputeStrategy {@Overridepublic void compute() {// 这里模拟Cover算法的差异计算逻辑System.out.println("使用Cover策略进行差异计算...");}
}

文件：QyKgStrategy.java

package com.example.strategy;public class QyKgStrategy implements ComputeStrategy {@Overridepublic void compute() {// 这里模拟QyKg算法的差异计算逻辑System.out.println("使用QyKg策略进行差异计算...");}
}

---

3. 通过示例代码理解策略模式的基本用法

为了演示如何在应用中选择并调用不同的策略，我们在一个简单的 Demo 类中使用 Map 来存储策略信息，并根据传入的标识选择相应的策略。

文件：StrategyDemo.java

package com.example.strategy;import java.util.HashMap;
import java.util.Map;public class StrategyDemo {// 使用 Map 存储策略标识与对应的策略实现private Map<String, ComputeStrategy> strategyMap = new HashMap<>();// 构造方法中初始化策略集合public StrategyDemo() {strategyMap.put("COVER", new CoverStrategy());strategyMap.put("QYKG", new QyKgStrategy());}/*** 根据策略标识选择并执行对应的策略* @param strategyKey 策略标识，如 "COVER" 或 "QYKG"*/public void executeStrategy(String strategyKey) {ComputeStrategy strategy = strategyMap.get(strategyKey);if (strategy != null) {strategy.compute();} else {System.out.println("没有找到对应的策略！");}}public static void main(String[] args) {StrategyDemo demo = new StrategyDemo();// 根据传入的标识，动态选择策略demo.executeStrategy("COVER");   // 输出：使用Cover策略进行差异计算...demo.executeStrategy("QYKG");    // 输出：使用QyKg策略进行差异计算...demo.executeStrategy("UNKNOWN"); // 输出：没有找到对应的策略！}
}

---

1. 策略接口（ComputeStrategy）定义了一个公共方法 compute()，所有策略类都实现了这一方法。
2. 具体策略类（CoverStrategy 和 QyKgStrategy）各自实现了差异计算的不同逻辑，实现了算法的封装。
3. 客户端代码（StrategyDemo）通过一个 Map 结构，动态维护和选择不同的策略，实现了策略的灵活切换，避免了大量分支判断。

策略模式的优缺点与扩展性分析

---

1. 策略模式在设计中的优势

1. 明确职责、分离变化
   策略模式将算法/行为的实现从上下文中抽离出来，使得每一种策略都有自己单一的职责。这样不但使代码结构更清晰，也便于维护和逻辑扩展。

2. 避免大量条件判断
   当系统中存在多种算法选择时，往往会出现大量if-else或switch-case语句。使用策略模式，可以通过引入不同的策略类来替换这些条件分支，大大降低代码的复杂性。

3. 动态扩展性
   策略模式使得在运行时更容易动态选择或切换具体的策略实现。新增或修改策略只需要增加新的策略实现类，并在需要的时候注入或注册到上下文中即可，无需对原有代码进行大幅修改。

4. 增强代码复用
   策略模式的每个策略类通常针对特定的算法实现，将变动部分与不变部分分离，使得复用性增强。同时，不同的策略可以在不同的上下文中重复利用，提高代码的整体复用率。

5. 降低耦合度
   上下文对象与具体策略类之间只依赖策略接口，而不依赖具体实现，这样有效降低了代码耦合，使得系统各部分更易于独立变更和测试。

---

2. 如何让策略模式具备良好的扩展性

1. 定义良好的策略接口

   • 确保接口方法足够抽象，能够满足不同策略的扩展需求，同时避免过多的固定实现。
   • 如果策略之间存在共同行为，可以在接口中提供默认方法或者通过抽象类来实现共性逻辑，将具体实现细节留给子类。

2. 利用依赖注入与工厂模式整合

   • 在Spring等框架中使用依赖注入，通过@Component、@Autowired等方式管理策略实例，方便动态扩展和替换。
   • 使用策略工厂模式，将策略的实例化逻辑进行封装，使得可以通过配置文件或者外部参数动态决定选择哪种策略。

3. 保持上下文与策略解耦

   • 上下文类只需要关心策略接口，而无需了解具体实现细节，确保添加新策略或修改现有策略时，不必影响上下文代码。
   • 尽量通过配置、反射或者注册表的方式加载策略，而不是硬编码在上下文中。

4. 支持策略组合与嵌套

   • 如果业务逻辑较复杂，可以考虑支持策略的组合（即一个策略内部可以调用另一个策略），从而实现更精细化的处理逻辑。
   • 可以引入装饰者模式、责任链模式等其他设计模式与策略模式中的组合使用，进一步提升系统的灵活性。

5. 关注策略的可测试性

   • 每个策略类应当具备良好的单一职责，这不仅便于维护和扩展，也便于独立测试，确保新增或修改策略时不引发其他问题。
   • 对于动态注册和调用的策略，可以通过单元测试验证注册逻辑和策略调用，确保实现的一致性和正确性。

---

案例实战：Spring Boot项目中的策略模式应用

---

1. 利用@Component注解注册各个策略实现

在Spring Boot项目中，我们可以直接通过@Component注解将策略实现类注册为Spring容器中的Bean。假设我们已有的策略接口定义如下：

package com.example.strategy;public interface ComputeStrategy {/*** 计算差异的方法，不同策略实现不同的算法*/void compute();
}

---

接下来，我们通过@Component注解将不同的策略实现类注册到Spring容器中。
可以通过为@Component指定一个名称，以便后续在策略上下文中明确标识各个策略。

package com.example.strategy;import org.springframework.stereotype.Component;@Component("cover")
public class CoverStrategy implements ComputeStrategy {@Overridepublic void compute() {// Cover策略的具体实现逻辑System.out.println("使用Cover策略进行差异计算...");}
}

package com.example.strategy;import org.springframework.stereotype.Component;@Component("qykg")
public class QyKgStrategy implements ComputeStrategy {@Overridepublic void compute() {// QyKg策略的具体实现逻辑System.out.println("使用QyKg策略进行差异计算...");}
}

使用@Component注解后，Spring会自动扫描这些类，并将它们注册为策略Bean。

---

2. 通过@Autowired注入策略集合的原理

Spring提供了基于依赖注入的强大能力，可以利用@Autowired直接注入同一接口下的所有实现。
一种常见用法是将所有实现注入到Map中，其键为Bean名称，值为Bean实例。这样我们就可以根据业务需求的标识，动态选择合适的策略。

package com.example.strategy;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.Map;@Component
public class StrategyContext {// 通过Map方式注入所有实现ComputeStrategy接口的Beanprivate final Map<String, ComputeStrategy> strategyMap;@Autowiredpublic StrategyContext(Map<String, ComputeStrategy> strategyMap) {this.strategyMap = strategyMap;}/*** 根据策略标识执行对应的策略** @param strategyKey 策略标识（例如："cover" 或 "qykg"）*/public void executeStrategy(String strategyKey) {ComputeStrategy strategy = strategyMap.get(strategyKey);if (strategy != null) {strategy.compute();} else {System.out.println("没有找到对应的策略：" + strategyKey);}}
}

上面的代码中，Spring会自动扫描所有实现ComputeStrategy接口的Bean，并将它们按照Bean名称注入到strategyMap中。
这样，在业务逻辑中，我们通过传入对应的策略键，就能快速定位到具体的策略实现并调用它。

---

3. 整合到Spring Boot应用中的示例

最后，我们通过一个简单的Spring Boot启动类来演示如何使用策略上下文。

文件：StrategyDemoApplication.java

package com.example;import com.example.strategy.StrategyContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;@SpringBootApplication
public class StrategyDemoApplication implements CommandLineRunner {@Autowiredprivate StrategyContext strategyContext;public static void main(String[] args) {SpringApplication.run(StrategyDemoApplication.class, args);}@Overridepublic void run(String... args) throws Exception {// 根据策略标识执行相应计算逻辑strategyContext.executeStrategy("cover");   // 输出：使用Cover策略进行差异计算...strategyContext.executeStrategy("qykg");    // 输出：使用QyKg策略进行差异计算...strategyContext.executeStrategy("unknown"); // 输出：没有找到对应的策略：unknown}
}

在这个示例中：

1. 各个策略实现使用@Component注解注册到Spring容器中，并指定了唯一的名称。
2. StrategyContext类利用@Autowired将所有ComputeStrategy接口的实现注入到一个Map中，方便以名称来动态选择策略。
3. 在StrategyDemoApplication中，通过调用StrategyContext的executeStrategy()方法，实现了策略的动态切换和执行。

---

这种设计方式使得系统具有更好的模块化、解耦和扩展性，是现代企业级应用中的常见设计实践。