Java23种设计模式之策略模式【普通写法以及spring中的写法】

设计模式简介

将设计者的思维融入大家的学习和工作中，更高层次的思考！
• 创建型模式：
– 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式。

• 结构型模式：
– 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

• 行为型模式：
– 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

本次文章介绍的是策略模式。

策略模式的简介

策略设计模式是一种行为型设计模式，它允许在运行时根据不同的情况选择算法或策略。
这种模式提供了一种灵活的方法来改变算法或策略，而无需修改代码。

定义一系列算法，封装每个算法，并使他们可以互换，不同的策略可以让算法独立于使用它们的客户而变化。 以上定义来自设计模式之美

这个模式主要由三个角色组成：Context（上下文）、Strategy（策略）和 ConcreteStrategy（具体策略）。

• Context（上下文）：它是包含了一个Strategy接口的引用，用来调用具体策略的方法。上下文可以根据需要改变策略。
• Strategy（策略）：它是一个接口，定义了一个算法族，这些算法可以相互替换。具体策略可以实现这个接口，这样就可以提供不同的实现方式。
• ConcreteStrategy（具体策略）：它是具体的策略实现，实现了策略接口中定义的方法。每个具体策略都实现了一种算法。

普通写法案例

假设有一个在线支付系统，支持多种支付方式，如支付宝、微信支付、银联支付等。为了方便用户选择支付方式，系统提供了一个支付方式选择页面，用户可以在该页面选择一种支付方式并进行支付。

为了实现这个功能，可以采用策略设计模式。具体实现过程如下：
1、定义支付策略接口

/**
 * 策略接口（对扩展开放）
 */
public interface PaymentStrategy {
    // 支付
    void pay(double amount);

    // 或者其他业务...
}

2、定义支付方式的具体实现类，如支付宝、微信支付和银联支付

/**
 * 支付宝支付策略
 */
public class AliPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用支付宝支付接口
        // ...
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}
/**
 * 微信支付策略
 */
public class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用微信支付接口
        // ...
        System.out.println("使用微信支付：" + amount + "元");
    }
}
/**
 * 银联卡支付策略
 */
public class UnionPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用银联支付接口
        // ...
        System.out.println("使用银联支付：" + amount + "元");
    }
}

3、接下来定义策略上下文

/**
 * 支付方式上下文
 */
public class PaymentStrategyContext {

    /**
     * 策略集合
     */
    private Map<String, PaymentStrategy> paymentStrategyMap = new HashMap<>();

	/**
	* 通过无参构造将支付所有策略进行注入
	*/
    public PaymentStrategyContext() {
        paymentStrategyMap.put("zfb", new AliPayStrategy());
        paymentStrategyMap.put("wx", new WeChatPayStrategy());
        paymentStrategyMap.put("ylk", new UnionPayStrategy());
    }

    /**
     * 返回实际处理对象
     * @param strategy 支付方式
     * @return 实际处理对象
     */
    public PaymentStrategy getStrategy(String strategy){
        return paymentStrategyMap.get(strategy);
    }

}

4、使用策略

public class TestPay {
    public static void main(String[] args) {
        // 创建支付策略上下文对象
        PaymentStrategyContext paymentPage = new PaymentStrategyContext();
        // 获取支付宝支付策略
        PaymentStrategy zfbPaymentStrategy = paymentPage.getStrategy("zfb");
        // 用户进行支付
        zfbPaymentStrategy.pay(100.0);

    }
}
// 输出：使用支付宝支付：100.0元

基于注解式改造的案例

我们还是以上面的支付案例来进行改造，通过@Component和@Autowired注解，实现我们项目中经典使用方式。

1、定义支付策略接口

/**
 * 策略接口（对扩展开放）
 */
public interface PaymentStrategy {
    // 支付
    void pay(double amount);

    // 或者其他业务...
}

2、定义支付方式的具体实现类，如支付宝、微信支付和银联支付

/**
 * 支付宝支付策略
 */
@Component("payStrategy" + "zfb")
public class AliPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用支付宝支付接口
        // ...
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

/**
 * 微信支付策略
 */
@Component("payStrategy" + "wx")
public class WeChatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用微信支付接口
        // ...
        System.out.println("使用微信支付：" + amount + "元");
    }
}

/**
 * 银联卡支付策略
 */
@Component("payStrategy" + "ylk")
public class UnionPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        // 调用银联支付接口
        // ...
        System.out.println("使用银联支付：" + amount + "元");
    }
}

3、接下来定义策略上下文改造

/**
 * 支付方式上下文
 */
@Component
public class PaymentStrategyContext {

  	 /**
     * 策略集合
     * 灵魂所在，注入实例名及对应实例
     * 实例名：即component指定名称，默认为类名首字母小写名称
     */
    @Autowired
    private Map<String, PaymentStrategy> paymentStrategyMap = new ConcurrentHashMap<>();

	/**
     * 初始化
     * @param paymentStrategyMap
     */
    public PaymentStrategyContext(Map<String, PaymentStrategy> paymentStrategyMap) {
        this.paymentStrategyMap.clear();
        paymentStrategyMap.forEach(this.paymentStrategyMap::put);
    }
    /**
     * 返回实际处理对象
     * @param strategy 支付方式
     * @return 实际处理对象
     */
    public PaymentStrategy getStrategy(String strategy){
        return paymentStrategyMap.get(strategy);
    }

}

4、使用策略

/**
 * 策略设计模式Controller
 */
@RestController
@RequestMapping("/api/strategy")
public class StrategyController {

    @Autowired
    private PaymentStrategyContext paymentStrategyContext ;


    /**
     * 根据类型获取对应的策略
     */
    @GetMapping("/getByType")
    public void testStrategy(@RequestParam("type") String type) {

        try {
            PaymentStrategy zfbPaymentStrategy = paymentStrategyContext.getStrategy("payStrategy"+type);
            // 用户进行支付
       	    zfbPaymentStrategy.pay(100.0);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

然后访问 localhost:8080/api/strategy/getByType?type="zfb"

提问：那么以上的支付策略是怎么注入到上下文PaymentStrategyContext中的Map的？

• 首先我们可以注意到每个支付策略类上都有一个@Component("payStrategy" + "XX")

@Component是Spring框架中的注解之一，表示被注解的类是一个组件（Bean），会被Spring框架自动扫描并装配到Spring容器中。该注解通常用于标识Spring中需要进行依赖注入、AOP切面等操作的Java类。

使用@Component注解标注的类默认的Bean名称为类名的小写，例如类名为UserDao的Bean名称为userDao。使用@Component注解的类可以被其他注解所继承，如@Service、@Controller、@Repository等，这些注解都是@Component的派生注解，功能和@Component相同，只是为了更加明确地表明类的作用而设置的。
需要注意的是，@Component注解只是一个标记注解，不会对被注解的类进行额外的处理，如果需要使用其他注解实现更加具体的功能，可以使用派生注解或者组合注解的方式实现。

• 其次在上下文PaymentStrategyContext类中，有一个对Map自动注入的操作，这里会自动注入实例名及对应实例。
  

• 当Spring启动时，通过对上下文对象进行初始化操作时，这一步首先会对Map进行清除，然后再将名称为payStrategy开头的bean设置到Map中。
  

优缺点

• 优点

算法策略可以自由实现切换
扩展性好，加一个策略，只需要增加一个类

• 缺点

策略类数量多
需要维护一个策略枚举，让别人知道你当前具有哪些策略
(我上面是直接写的字符串，如果是在实际上面中是需要维护成一个枚举类)

策略模式的使用场景

Java中策略模式的应用场景非常广泛，以下是一些常见的例子：

• 支付方式选择：在电商平台中，用户可以选择多种支付方式，如支付宝、微信支付、银行卡支付等。这些支付方式可以看作是策略，用户选择不同的支付方式就是选择了不同的策略。
• 排序算法：在Java中，有多种排序算法可以选择，如快速排序、归并排序、冒泡排序等。这些排序算法也可以看作是策略，根据不同的需求选择不同的排序算法就是选择了不同的策略。
• 表单验证：在Web开发中，通常需要对用户输入的表单数据进行验证。不同的表单数据验证方式可以看作是策略，根据表单的不同需求选择不同的验证策略。
• 税收计算：在财务软件中，根据不同的国家和地区的税收政策，需要对税收计算方式进行不同的选择，这些税收计算方式也可以看作是策略。

以上这些例子都可以使用策略模式来实现，通过将策略封装成独立的类，可以让策略的实现与使用进行解耦，提高代码的可维护性和扩展性。

Spring框架中的使用场景

Spring框架中运用了策略模式的地方比较多，下面列举一些常见的场景：

• 验证策略（Validation Strategy）：在 Spring MVC 中，我们可以使用 @Valid 注解和 Validator 接口配合使用来进行请求参数的验证。Validator 接口中定义了一个 validate 方法，可以根据不同的策略来进行参数验证。

• 缓存策略（Caching Strategy）：Spring 框架中的缓存抽象，如 Cache 接口、CacheManager 接口和 CacheResolver 接口等，都使用了策略模式来支持不同的缓存策略，如 EhCache、Redis、Guava 等。

• 数据访问策略（Data Access Strategy）：Spring 框架中的 JdbcTemplate 使用了策略模式来支持不同的数据访问策略，如 JDBC、JPA、MyBatis 等。

• 消息队列策略（Messaging Strategy）：Spring 框架中的消息队列抽象，如 JmsTemplate 和 RabbitTemplate 等，都使用了策略模式来支持不同的消息队列策略，如 ActiveMQ、RabbitMQ 等。

以上只是几个常见的例子，实际上在 Spring 框架中运用到策略模式的地方还有很多。总的来说，策略模式可以帮助我们在应对不同的需求时，使用不同的算法或业务逻辑来达到相同的目的。这样可以使代码更加灵活、可维护和可扩展。

其实实际项目中也有很多应用，例如在线商城中有一个会员系统，商品的购买价格以及赠品等等优惠会根据用户会员等级的不同而产生不同的效果，亦或者是公司某软件对接企业微信，根据不同的审批处理请求，拿到对应的策略从而推送模板消息完成指定策略的操作等等