设计模式篇之策略模式和模板模式

老铁最近面试给我一个很重要的思路，就是在项目里加上设计模式的改造，想了想，决定做设计模式的总结，第一个自当不让的是策略和模板，废话不多说

策略模式

策略模式是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理，最终可以实现解决多重if判断问题。

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

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

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

比如搭建聚合支付平台的时候，这时候需要对接很多第三方支付接口，比如支付宝、微信支付、小米支付等。

通过传统if代码判断的，后期的维护性非常差！

public  String toPayHtml2(String payCode){
   
        if(payCode.equals("ali_pay")){
   
            return  "调用支付宝接口...";
        }
        if(payCode.equals("xiaomi_pay")){
   
            return  "调用小米支付接口";
        }
        if(payCode.equals("yinlian_pay")){
   
            return  "调用银联支付接口...";
        }
        return  "未找到该接口...";
    }

这时候可以通过策略模式解决多重if判断问题。

接口PayStrategy(抽象角色)

/**
 * 抽象角色
 * 策略类
 */
public interface PayStrategy {
   
    /**
     * 共同算法实现骨架
     * @return
     */
    public String toPayHtml();
}

具体实现类

/**
 * 支付子类
 */
@Component
public class AliPayStrategy implements PayStrategy {
   
    @Override
    public String toPayHtml() {
   
        return "调用支付接口";
    }
}

/**
 * 小米实现类
 */
@Component
public class XiaoMiPayStrategy implements PayStrategy {
   
    @Override
    public String toPayHtml() {
   
        return "调用小米接口";
    }
}

创建一个得到bean对象的工具类(SpringContextUtil)

/**
 * 得到bean对象
 *
 */
@Component
public class SpringContextUtil implements ApplicationContextAware {
   
    private static ApplicationContext applicationContext;

    /**
     * 实现ApplicationContextAware接口的回调方法。设置上下文环境
     *
     * @param applicationContext
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
   
        this.applicationContext = applicationContext;
    }

    //获取applicationContext
    public static ApplicationContext getApplicationContext() {
   
        return applicationContext;
    }

    //通过name获取 Bean.
    public static Object getBean(String name){
   
        return getApplicationContext().getBean(name);
    }

    //通过class获取Bean.
    public  <T> T getBean(Class<T> clazz){
   
        return getApplicationContext().getBean(clazz);
    }

    //通过name,以及Clazz返回指定的Bean
    public  <T> T getBean(String name,Class<T> clazz){
   
        return getApplicationContext().getBean(name, clazz);
    }
}

创建一个实体类

@Data
public class PaymentChannelEntity {
   
    /** ID */
    private Integer id;
    /** 渠道名称 */
    private String channelName;
    /** 渠道ID */
    private String channelId;
    /**
     * 策略执行beanId
     */
    private String strategyBeanId;
}

创建一个上下文对象获取对应的实现类

/**
 * 上下文
 */
@Component
public class PayContextService {
   

    @Autowired
    private PaymentChannelMapper paymentChannelMapper;
    @Autowired
    private SpringContextUtil springContextUtil;

    public String toPayHtml(String payCode){
   
        //验证参数
        if(StringUtils.isBlank(payCode)){
   
            return "参数不能为空";
        }
        //使用该paycode查询，通过这种方式进行了构造的解耦
        PaymentChannelEntity paymentChannel = paymentChannelMapper.getPaymentChannel(payCode);
        if(paymentChannel==null){
   
            return  "该渠道为空...";
        }
        //获取对应的beanid
        String strategyBeanId = paymentChannel.getStrategyBeanId();
        if (strategyBeanId==null){
   
            return "beanId为空";
        }
        //得到对应的bean
        PayStrategy payStrategy = springContextUtil.getBean