对于一个逻辑相对复杂的功能应用中，难免需要做很多的逻辑判断，需要写一堆的 if/else，更糟糕的情况是里面还会嵌套在大量的 if/else，如果代码没注释，那简直就让人疯掉了。这时候可能考虑用策略模式去处理一些具有相同逻辑的代码，免除代码体中长串的 if/else

一、策略模式的介绍

可以先看一张类图，看不懂也没关系，笔者当初刚开始接触的时候也是懵的，第三小节会以人话的方式介绍如何应用到实际的问题中，所以同学们可以先有个概念。

这个模式涉及到三个角色：

　　● 环境(Context)角色：持有一个Strategy的引用。

　　● 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

　　● 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

二、策略模式的使用场景

举个最常见的场景，就是支付方式，一般有支付宝、微信、银行卡等，如果从代码上来看就是以下这样的。

//支付接口
pay(payType, orderNo) {

    if (payType == 微信支付) {
        微信支付处理
    } else if (payType == 支付宝) {
        支付宝支付处理
    } else if (payType == 银行卡) {
        银行卡支付处理
    } else {
        暂不支持的支付方式
    }

}

如果以后需要增加新的支付方式，我们还需要改这里的代码，再加一段 else if 代码。但是这样做，其实违背了面向对象的 2 个基本原则：

● 单一责任原则：一个类应该只有一个发生变化的原因

● 开闭原则：对扩展开放，对修改关闭

三、策略模式的应用

我们针对上面支付方式的场景，看看一般策略模式是如何应用到其中的。

1、入参和出参类

定义策略接口统一的入参字段和出参字段，这对于所有的支付方式都是一样的。

1）订单支付类

入参类，定义了一个支付订单可能需要的字段，这里只是简单列举了一些，其中要注意 channel 字段，这是我们在使用策略中的重点，下面会介绍。

/**
 * 订单支付
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Data
public class PayOrder {

    /**
     * 支付金额，单位元
     */
    private String mete;
    /**
     * 用户手机号
     */
    private String phone;
    /**
     * 支付渠道
     * ALIPAY：支付宝
     * WECHAT：微信
     * CARD：银行卡
     */
    private String channel;

}

2）支付结果类

出参类，定义了订单支付后所需返回的字段，这里也是简单列举了一些。

/**
 * 支付结果
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Data
public class PayResult {

    /**
     * 订单号
     */
    private String order;

    /**
     * 支付结果
     * 1：成功
     */
    private Integer code;

}

2、策略接口

对应着第一点说到的策略类图，去定义策略中所涉及到的接口，但是笔者这边在实际使用中会有些不同。

1）支付处理统一入口

这是暴露给外部业务调用的支付接口。

/**
 * 支付处理服务统一入口
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
public interface VendorPaymentService {

    /**
     * 付款
     *
     * @param payOrder
     * @return
     */
    PayResult pay(PayOrder payOrder);

}

2）支付处理服务接口

相当于策略类图中的 Strategy 策略角色。

/**
 * 支付处理服务
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
public interface PaymentHandleService {

    /**
     * 付款
     *
     * @param payOrder
     * @return
     */
    PayResult pay(PayOrder payOrder);

}

3）支付处理上下文

简单来说就是选择哪种具体策略角色来处理，可以看到这里的入参是上面说的 channel 字段，出参则是策略后所具体的策略角色接口实现。

/**
 * 支付处理上下文
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
public interface PaymentContextService {

    /**
     * 获取处理上下文
     *
     * @param channel
     * @return
     */
    PaymentHandleService getContext(String channel);

}

3、策略具体实现

下面，我们要对上面定义的接口分别写出它们的实现类。

1）支付处理服务统一入口

方法中需要持有一个上下文接口，用于根据订单的渠道，获取具体的支付处理类。

/**
 * 支付处理服务统一入口
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Service
public class VendorPaymentServiceImpl implements VendorPaymentService {

    @Resource
    PaymentContextService paymentContextService;

    @Override
    public PayResult pay(PayOrder payOrder) {
        //获取订单中的渠道
        String channel = payOrder.getChannel();
        //根据渠道，具体选择所使用的支付处理类
        PaymentHandleService handleService = paymentContextService.getContext(channel);
        //调用该支付处理类的支付方法
        return handleService.pay(payOrder);
    }

}

2）支付处理上下文

这里是策略的核心部分，根据订单的渠道值去找到对应的具体策略支付类。

/**
 * 支付处理上下文
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Service
public class PaymentContextServiceImpl implements PaymentContextService {

    /**
     * 自动注入所有具体策略实现类
     */
    @Resource
    List<PaymentHandleService> handleServiceList;

    /**
     * 额外定义一个不支持的渠道支付方式实现类
     */
    @Resource(name = "NonsupportPaymentHandleServiceImpl")
    PaymentHandleService nonsupportService;

    @Override
    public PaymentHandleService getContext(String channel) {

        if (StrUtil.isEmpty(channel)) {
            return nonsupportService;
        }
        
        //策略实现类上都会打上 Payment 注解，并定义支付方式的值，用于适配订单的渠道值
        PaymentHandleService handleService = handleServiceList.stream()
                .filter(f -> StrUtil.equals(channel, f.getClass().getAnnotation(Payment.class).value()))
                .findFirst()
                .orElse(nonsupportService);

        return handleService;
    }

}

支付方法注解类

/**
 * 支付方式注解
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface Payment {

    String value() default "";

}

不支持的渠道支付方式实现类

/**
 * 不支持的业务处理实现
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Payment("nonsupport")
@Service("NonsupportPaymentHandleServiceImpl")
public class NonsupportPaymentHandleServiceImpl implements PaymentHandleService {

    @Override
    public PayResult pay(PayOrder payOrder) {
        PayResult result = new PayResult();
        result.setCode(-1);
        return result;
    }
}

3）支付方式具体策略类

这里是列举支付宝支付的实现，其他的支付类似，可以看到这里注解 Payment 定义了这个支付的渠道字段为 alipay

/**
 * 支付宝支付处理
 *
 * @Author Liurb
 * @Date 2022/11/26
 */
@Slf4j
@Payment("alipay")
@Service
public class AlipayPaymentHandleServiceImpl implements PaymentHandleService {

    @Override
    public PayResult pay(PayOrder payOrder) {

        PayResult result = new PayResult();
        result.setOrder("alipay_202211261234567890");
        result.setCode(1);

        log.info("支付宝支付处理 订单信息:{} 支付结果:{}", payOrder, result);

        return result;
    }
}

4、策略测试

我们来写一个单元测试类，这里使用支付宝的方式来支付，看看效果。

@SpringBootTest
class SpringbootAdvanceDemoApplicationTests {

    @Resource
    VendorPaymentService vendorPaymentService;

    @Test
    void contextLoads() {

        PayOrder payOrder = new PayOrder();
        payOrder.setChannel("alipay");
        payOrder.setMete("100");
        payOrder.setPhone("123456");
        
        PayResult payResult = vendorPaymentService.pay(payOrder);
        System.out.println(payResult);
    }

}

在上下文实现类中可以看到，这里已经成功注入了我们的策略实现类。