策略模式在 SpringBoot 中使用

2021-08-03

springboot 设计模式

0 0

场景：当我们接收到一些数据需要对其进行处理时，由于它们来自于不同的渠道（如：腾讯，头条），不同渠道所需的处理方式不同，下面我们写一个简单Demo来实现该的场景。

解决思路

实例一：简单举例

首先构建一个 GeneralChannelRule 基础规则抽象类，定义一个抽象方法process()，不同的渠道都需要实现该抽象方法。

public abstract class GeneralChannelRule {
 public abstract void process();
}

编写一个腾讯的规则类，定义具体对于腾讯渠道数据的处理逻辑

public class TencentChannelRule extends GeneralChannelRule
   @Override
    public void process() {
        // Tencent处理逻辑
    }
}

编写一个头条的规则类，定义具体对于头条数据的处理逻辑

public class TouTiaoChannelRule extends GeneralChannelRule
   @Override
    public void process() {
        // TouTiao处理逻辑
    }
}

建立一个简单的枚举类

public enum ChannelRuleEnum {
    /**
     * 头条
     */
    TOUTIAO("TOUTIAO"),
    /**
     * 腾讯
     */
    TENCENT("TENCENT"),
    ;
  ....
}

使用规则对数据进行处理。

public static void main(String[] args) {
        //这里我们模拟接收到的数据，其渠道为为TOUTIAO，来自头条的数据
        String sign = "TOUTIAO";
        GeneralChannelRule rule;
        //根据对应渠道获取对应的具体规则实现类
        if (ChannelRuleEnum.TENCENT.code.equals(sign)) {
            rule = new TencentChannelRule();
        } else if (ChannelRuleEnum.TOUTIAO.code.equals(sign)) {
            rule = new TouTiaoChannelRule();
        } else {
            //匹配不到
        }
        //执行
        rule.process();
    }

解析：如果通过上面的方式，则存在则两个缺点。

当我们需要新增新的渠道的时候，需要对main方法中的逻辑进行修改调整。这违背了设计模式中的开放封闭规则。开放封闭原则的核心的思想是软件实体是可扩展，而不可修改的。

也就是说，对扩展是开放的，而对修改是封闭的

新增渠道后，修改代码会产生大量的if else，不太优雅。为了解决以上的两个问题，我们可以借助枚举类来巧妙优化。

新的思路

1、下面我们调整一下枚举类，增加一个GeneralChannelRule属性，并且给对应渠道构建对应的GeneralChannelRule实现类，新增一个match() 匹配方法。

public enum ChannelRuleEnum {

    /**
     * 头条
     */
    TOUTIAO("TOUTIAO",new TouTiaoChannelRule()),
    /**
     * 腾讯
     */
    TENCENT("TENCENT",new TencentChannelRule()),
    ;

    public String name;

    public GeneralChannelRule channel;

    ChannelRuleEnum(String name, GeneralChannelRule channel) {
        this.name = name;
        this.channel = channel;
    }

  //匹配
    public static ChannelRuleEnum match(String name){
        ChannelRuleEnum[] values = ChannelRuleEnum.values();
        for (ChannelRuleEnum value : values) {
            if(value.name.equals(name)){
                return value;
            }
        }
        return null;
    }
    public String getName() {
        return name;
    }

    public GeneralChannelRule getChannel() {
        return channel;
    }
}

2、改写程序

public static void main(String[] args) {
        String sign = "TOUTIAO";
        ChannelRuleEnum channelRule = ChannelRuleEnum.match(sign);
        GeneralChannelRule rule = channelRule.channel;
        rule.process(sign);
    }

解析：通过使用枚举类，在枚举中将 key 与规则具体实现进行绑定。通过改变：

可以减少if -else使得代码更加优雅如果需要新增渠道，我们只需要在编写具体规则实现类并继承GeneralChannelRule抽象类，并在枚举类中新增的枚举，而不需要改动到原先的任何代码。这符合了开发封闭原则。

最后
以上是通过枚举来巧妙干掉if-else的方案，对于减少 if-else 还有很多有趣的解决方案（如：状态设计模式等），感兴趣的朋友去查阅相关的资料。

实例二：策略模式在SpringBoot中运用

场景

关于用户订单充值（订单支付同理），我们都知道，现今的支付方式是非常的多的，例如：支付宝、微信、银联、钱包（各个APP的账户余额）等等。
查询实体Query：

/**
 * @author Howinfun
 * @desc 查询
 * @date 2019/10/22
 */
@Data
public class ChargeQuery {
    
    /** 支付方式（ALI/WX/UNION） */
    @NotBlank(message = "支付方式不能为空",groups = PayWayNotBlank.class)
    private String payWay;
    
    /** 充值金额 */
    @NotNull(message = "充值金额不能为空",groups = AmountNotNull.class)
    private Double amount;
}

Service接口：

/**
 * @author Howinfun
 * @desc 充电-充值模块
 * @date 2019/10/30
 */
public interface ChargeRechargeService {

    /**
     * 根据不用支付方式进行用户余额充值
     * @param query
     * @return
     */
    Result recharge(ChargeQuery query);

    /**
     * 充值回调
     * @param rechargeCallBack
     */
    Result rechargeCallBack(RechargeCallBack rechargeCallBack);
}

传统方式实现

就是利用if else或者switch来进行条件判断：

/**
 * @author Howinfun
 * @desc
 * @date 2019/10/30
 */
@Service
@AllArgsConstructor
@Slf4j
public class ChargeRechargeServiceImpl implements ChargeRechargeService {

    private final CarUserMapper carUserMapper;
    private final IncomePaymentMapper incomePaymentMapper;
    private final RechargeRecordMapper rechargeRecordMapper;
    private final PayWayHandlerContext payWayHandlerContext;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result recharge(ChargeQuery query) {
        Result result = new Result();
        // ......
        // ......
        if (PayConstant.PAY_WAY_WX.equals(query.getPayWay())){
            // 微信
            // ......
        }else if (PayConstant.PAY_WAY_ALI.equals(query.getPayWay())){
            // 支付宝
            // ......

        }else if (PayConstant.PAY_WAY_UNION_PAY.equals(query.getPayWay())){
             // 银联
             // ......
    
        }
        return result;
    }
}

总结：我们可以看到，传统的实现方式是非常的笨重的，而且代码非常的不简洁，扩展性差。假如我们要接入新的支付方式，那么我们只能继续添加 else if。

策略模式

Talk is cheap,show me the code.
我们先看一下，如果使用策略模式，service的代码将变成啥样。

/**
 * @author Howinfun
 * @desc
 * @date 2019/10/30
 */
@Service
@AllArgsConstructor
@Slf4j
public class ChargeRechargeServiceImpl implements ChargeRechargeService {

    private final PayWayHandlerContext payWayHandlerContext;


    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result recharge(ChargeQuery query) {
        return this.payWayHandlerContext.getHandlerInstance(query.getPayWay()).handler(query);
    }
}

emmmm，确实是简单了不少。不但代码量少了，简洁了，而且不再担心因为新增支付方式而修改serviceImpl的代码了。

下面进行详细的讲解：
1、首先，我们需要自定义一个注解，来标识一个支付类型对应的一个处理器。

/**
 * @author Howinfun
 * @desc 自定义注解，标识支付类型
 * @date 2019/11/2
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface PayWayHandler {

    String value();
}

2、接着，抽象一个处理器，让每个支付方式的处理器继承此抽象处理器，实现handle方法：

/**
 * @author Howinfun
 * @desc 抽象订单类型处理器
 * @date 2019/11/2
 */
public abstract class AbstractPayWayHandler {

    /**
     *
     * @param query
     * @return
     */
    abstract public Result handler(ChargeQuery query);
}

3、实现类，例如支付宝、微信、银联：
注意：每个处理器都要加上@component，交给Spring管理。

/**
 * @author Howinfun
 * @desc 支付宝支付
 * @date 2019/11/2
 */
@Component
@PayWayHandler("ALI")
@Slf4j
@AllArgsConstructor
public class AliPayWayHandler extends AbstractPayWayHandler {
    
    // ....各种依赖

    @Override
    public Result handler(ChargeQuery query) {
        Result result = new Result();
        // ......
        return result;
    }
}

/**
 * @author Howinfun
 * @desc 微信支付
 * @date 2019/11/2
 */
@Component
@PayWayHandler("WX")
@Slf4j
@AllArgsConstructor
public class WxPayWayHandler extends AbstractPayWayHandler {
    
    // ....各种依赖

    @Override
    public Result handler(ChargeQuery query) {
        Result result = new Result();
        // ......
        return result;
    }
}

/**
 * @author Howinfun
 * @desc 银联支付
 * @date 2019/11/2
 */
@Component
@PayWayHandler("UNION")
@Slf4j
@AllArgsConstructor
public class UnionPayWayHandler extends AbstractPayWayHandler {
    
    // ....各种依赖

    @Override
    public Result handler(ChargeQuery query) {
        Result result = new Result();
        // ......
        return result;
    }
}

4、然后最重点的来了，创建一个类，实现ApplicationContextAware接口，重写setApplicationContext方法，然后扫描带有自定义注解@PayWayHandler的Bean，然后存储起来，方便Service的获取。

/**
 * @author Howinfun
 * @desc
 * @date 2019/11/2
 */
@Component
public class PayWayHandlerContext implements ApplicationContextAware {

    @Autowired ApplicationContext applicationContext;

    /** key为PayWay，value为class*/
    private static final Map<String,Class> handlerMap = new HashMap<>(10);

    public AbstractPayWayHandler getHandlerInstance(String payType){
        Class clazz = handlerMap.get(payType);
        if (clazz == null){
            throw new CustomDeniedException("暂不支持此支付方式");
        }
        return (AbstractPayWayHandler) applicationContext.getBean(clazz);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        // 遍历带有PayTypeHandler注释的类
        Map<String,Object> beans = applicationContext.getBeansWithAnnotation(PayWayHandler.class);
        if (beans != null && beans.size() > 0) {
            for (Object serviceBean : beans.values()) {
                String payType = serviceBean.getClass().getAnnotation(PayWayHandler.class).value();
                handlerMap.put(payType, serviceBean.getClass());
            }
        }
    }
}

总结：到此，ServiceImpl可根据前端传过来的payWay来选择对应的handler来处理。我利用了策略模式简化了繁杂的 if else 代码，并且扩展性得到了大大的提升，不再担心因为支付方式的新增而修改业务代码。

标题：策略模式在 SpringBoot 中使用
作者：llilei
地址：http://solo.llilei.work/articles/2021/08/03/1627950719617.html

工欲善其事

存档：