设计模式分类

创建型模式，共5种：工厂方法模式，抽象工厂模式，单利模式，建造者模式，原型模式。
结构型模式，共7种：适配模式，装饰器模式，代理模式（jdk和cglib）,外观模式，桥接模式，组合模式，享元模式。
行为型模式，共十一种：策略模式，模板方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者模式，中介者模式，解释器模式，

什么是策略模式

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

环境(Context)角色：持有一个Strategy的引用。
抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现，此角色给出所有的具体策略类所需的接口。接口或者抽象类定义具体实现交给实现类或者是子类来做
具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。
定义策略接口(抽象)->实现不同的策略类->利用多态或其他方式调用策略

策略模式的优点缺点：

1. 优点

算法可以自由切换（高层屏蔽算法，角色自由切换）
避免使用多重条件判断（如果算法过多就会出现多种相同的判断，很难维护）
扩展性好（可自由添加取消算法，而不影响整个功能）

2. 缺点

策略类数量增多
所有的策略类都需要对外暴露

策略模式应用场景

联合登录 QQ联合登录/微信联合登录/钉钉联合登录
排序算法冒泡/简单选择/堆排序等
支付方式支付宝/微信支付/银联支付/平安支付等
快递申通、圆通、京东、德邦、顺丰等
发送通知短信、微信公众号模板、钉钉通知、邮件
根据快递号码查询具体快递物流信息
代码冗余性、灵活
if(用户传递的快递号码申通)
{
// 调用申通的快递接口
}

用户选择支付方式、选择查询快递

3.支付方式支付宝/微信支付/银联支付/平安支付等

4.快递申通、圆通、京东、德邦、顺丰等

相同的事情-----支付用户选择不同支付渠道
查询快递、支付？
聚合支付平台

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

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

策略模式项目环境

工厂方式实现

maven依赖

        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.3.RELEASE</version>
    </parent>
    <dependencies>
        <!--  springboot 整合web组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.73</version>
        </dependency>
    </dependencies>

strategy

    /**
     * 共同算法实现骨架 (可以使用接口或者抽象类)
     *
     * @return
     */
    String toPayHtml();
}

@Component
public class AliPayStrategy  implements PayStrategy {
    @Override
    public String toPayHtml() {
        return "对接支付宝接口";
    }
}

@Component
public class UnionPayStrategy implements PayStrategy {
    @Override
    public String toPayHtml() {
        return "对接银联支付";
    }
}


@Component
public class WeChatPayStrategy  implements PayStrategy {
    @Override
    public String toPayHtml() {
        return "对接微信支付";
    }
}

@Component
public class UnionPayStrategy implements PayStrategy {
    @Override
    public String toPayHtml() {
        return "对接银联支付";
    }
}

factory

public class StrategyFactory {
    private  static Map<String, PayStrategy> payStrategys=new HashMap<>();
    public  StrategyFactory(){
        initStrategy();
    }

    private void initStrategy() {
        payStrategys.put("aliPayStrategy", new AliPayStrategy());
        payStrategys.put("unionPayStrategy", new UnionPayStrategy());
        payStrategys.put("weChatPayStrategy", new WeChatPayStrategy());
        log.info("<初始化支付相关策略ok,payStrategys:{}>", payStrategys);
    }
    public    PayStrategy getPayStrategy(String strategyType){
        return payStrategys.get(strategyType);
    }
}

service

public class PayContextService {
    public StrategyFactory strategyFactory=new StrategyFactory();
    @Autowired
    private PaymentChannelMapper paymentChannelMapper;
    @RequestMapping("/toPayHtml")
    public String toPayHtml(String payCode){
      if(StringUtils.isEmpty(payCode)){
          return "payCode is null";
      }
      //根据paycode名称从strategyFactory获取具体的Strategy策略
       // PayStrategy payStrategy= strategyFactory.getPayStrategy(payCode);
        //使用SpringUtils從IOC容器里获取bean对象
      //
        PaymentChannelEntity paymentChannelEntity = paymentChannelMapper.getPaymentChannel(payCode);
        if (paymentChannelEntity == null) {
            return "payCode error  or 渠道已经关闭 ";
        }
        String strategyBeanId = paymentChannelEntity.getStrategyBeanId();
        PayStrategy payStrategy= SpringUtils.getBean(strategyBeanId, PayStrategy.class);
       if(payStrategy ==null){
           return "not found payStrategy";
       }
       //获取具体的payStrategy调用toPayHtml
        return payStrategy.toPayHtml();
    }
}

SpringIOC实现
其实我们可以直接将该具体的Strategy策略注入到ioc容器中，从IOC容器中获取到具体的策略bean对象。
Springutils工具类

@Slf4j
public class SpringUtils  implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        SpringUtils.applicationContext = applicationContext;
    }

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

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

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

    //通过name,以及Clazz返回指定的Bean
    public static <T> T getBean(String name, Class<T> clazz) {
        try {
            return getApplicationContext().getBean(name, clazz);
        } catch (Exception e) {
            log.error("<e:{}>", e);
            return null;
        }
    }
}

将Strategy注入IOC容器中
优点：策略模式最终帮助我们解决在实际开发中多重if判断问题、提高扩展性、维护性增强、提高代码可读性。
缺点：后期维护不同策略类是非常多、定义类比较多、代码量增大。
优点大于缺点。