策略模式总结，适用场景，优缺点，代码示例

相关参考博文：

博客园：

• Spring2Sun：设计模式系列

1、简介

定义了一系列的算法，把他们封装起来，他们相互之间可以替换，某个算法的调整或者新增不会影响其他的算法，是在执行期间来选择具体的算法，使用什么算法被推迟到运行时，使得系统更加灵活，复用性更高，该模式可以减少if else的数量，属于行为型。

• Context封装角色

也叫做上下文角色，起承上启下封装作用，屏蔽高层模块对策略、算法的直接访问，封装可能存在的变化。

• Strategy抽象策略角色

策略、算法家族的抽象，通常为接口，定义每个策略或算法必须具有的方法和属性。

• ConcreateStrategy

实现抽象策略中的操作，该类有具体的算法。

1.1 继承带来的扩展和复用问题

继承作为面向对象的三大要素(封装、继承、多态)之一为什么会带来问题，问题如何解决然后形成一种设计模式，head frist设计模式书中以鸭子作为例子讲解什么情况下继承的方式会带来问题。首先有各种各样的鸭子，那么自然想到各种鸭子继承自一个父类：父类为Duck，现有绿头鸭GreenHeadDuck和红头鸭RedHeadDuck：

public abstract Class Duck{
    
    
　　public void quack(){
    
    }
　　public void swin(){
    
    }
　　public abstract void display();
}
publci class GreenHeadDuck:Duck{
    
    
    public overrid void  display(){
    
    
      //外观绿头
    }
}
publci class ReadHeadDuck:Duck{
    
    
    public overrid void  display(){
    
    
      //外观红头
    }
}

父类中所有鸭子都会呱呱叫(quack)和游泳(swin)，外观却不一样所以display为抽象方法，让继承它的子类重写。现在需要新增一种鸭子，但这个鸭子是一个玩具橡皮鸭，我们按照继承的方式则橡皮鸭实现代码如下:

publci class RubberDuck:Duck{
    
    
  　public override void qucak(){
    
    
　　　　//覆盖成吱吱吱叫
　　}
    public override void  display(){
    
    
      //外观是橡皮鸭
    }
}

因为橡皮鸭是不会像其他鸭子那样叫的，所以上面代码我们需要重写qucak覆盖橡皮鸭叫的方式可。现在有一个需求，需要让鸭子飞起来，按照继承的方式我们给父类Duck添加 fly方法即可让所有鸭子飞起来。但是问题出现了，橡皮鸭是不会飞的，于是我们可以像覆盖qucak方法一样在RubberDuck中覆盖fly方法。

public abstract class Duck{
    
    
　　public void quack(){
    
    }
　　public void swin(){
    
    }
　　public abstract void display();
    public void fly(){
    
    }
}
publci class RubberDuck:Duck{
    
    
　　public override void qucak(){
    
    
　　　　//覆盖成吱吱吱叫
　　}
    public override void  display(){
    
    
      //外观是橡皮鸭
    }
    public override void fly(){
    
    
        //覆盖，什么都不做
    }
}

到这里我们已经发现了继承带来的问题：

1. 代码在多个子类中重复。
2. 很难知道所有子类的行为。
3. 运行的子类行为不容易改变。
4. 改变会牵一发动全身，引起其他子类不想要的改变。

每当有新的子类出现，就要检查是不是需要覆盖父类方法。比如再加一种木头玩具的鸭子(DecoyDuck)，那么木头鸭子不会叫也不会飞，我们是不是需要覆盖叫和飞的方法。

1.2 进一步改进，利用接口

由于quack和fly有可能变化，所以我们将quack 和fly抽象成接口，能够叫和飞行的鸭子才按需求继承接口自己实现方法。

利用接口可以解决一部分问题(不在需要重写不需要的方法)，但是却会造成代码无法复用，因为接口不具有实现，我们要在每种子类中写fly和quack。比如要在红头绿头中写"呱呱叫"，要在橡皮鸭中写"吱吱叫"。

1.3 进一步改进，策略模式

经过上面的分析可以引出设计模式的两个原则：

1. 把会变化的部分封装起来，让其他部分不会受到影响。
2. 针对接口编程，而不是针对实现。
   通过第一个设计原则我们可以取出易于变化的部分：鸭子的飞行行为(fly)和呱呱叫的行为(quack)。通过第二个设计原则我们知道需要利用接口代表每个行为，比如FlyBehavior与QuackBehavior,而行为的每个实现都将实现其中的一个接口。这样鸭子类就不会负责实现FlyBehavior与QuackBehavior，而是由行为类来专门实现，不会绑死在鸭子的子类中。

而"针对接口编程"的意思是"针对超类型编程"。可以明确地说明变量的声明类型应该是超类，这意味着我们在Duck父类中声明的行为变量为 FlyBehavior，QuackBehavior，“针对接口编程"的关键就在于面向对象三要素之一的"多态”，由于多态我们才能在调用超类的方法时执行的是实现类或子类的方法。所以我们改造之前写的Duck类，删除Fly()和Quack()，加入FlyBehavior和QuackBehavior变量，并用另外两个方法PerFormFly()和PerFormQuack()来执行两个行为。

public abstract Class Duck{
    
    
    protected FlyBehavior flyBehavior;
    protected QuackBehavior quackBehavior;
　　public void swin(){
    
    }
　　public abstract void display()；
   public void PerFormFly(){
    
    
      flyBehavior.fly();
   }
　　public void PerFormQuack(){
    
    
      quackBehavior.quack();
   }
}

编写相关类并测试：

//封装飞行行为
    public interface FlyBehavior
    {
    
    
        public void fly();
    }
    public class FlyWithWings : FlyBehavior
    {
    
    
        public void fly()
        {
    
    
            Console.WriteLine("用翅膀飞");
        }
    }
    public class FlyNoWay : FlyBehavior
    {
    
    
        public void fly()
        {
    
    
            Console.WriteLine("不飞，什么也不做");
        }
    }
    //封装叫声行为
    public interface QuackBehavior
    {
    
    
       public void quack();
    }

    public class Quack : QuackBehavior
    {
    
    
        public void quack()
        {
    
    
            Console.WriteLine("呱呱叫");
        }
    }
    public class Squack : QuackBehavior
    {
    
    
        public void quack()
        {
    
    
            Console.WriteLine("吱吱叫");
        }
    }
    public class MuteQuack : QuackBehavior
    {
    
    
        public void quack()
        {
    
    
            Console.WriteLine("不会叫");
        }
    }
    /// <summary>
    /// 鸭子超类
    /// </summary>
    public abstract class Duck {
    
    
        protected FlyBehavior flyBehavior;
        protected QuackBehavior quackBehavior;
        public void swin() {
    
     }
        public abstract void display();
        public void PerFormFly()
        {
    
    
            flyBehavior.fly();
        }
        public void PerFormQuack()
        {
    
    
            quackBehavior.quack();
        }
    }
    /// <summary>
    /// 绿头鸭
    /// </summary>
    public class GreenHeadDuck : Duck
    {
    
    
        public GreenHeadDuck() {
    
    
            flyBehavior = new FlyWithWings();
            quackBehavior = new Quack();
        }
        public override void display()
        {
    
    
            Console.WriteLine("绿头鸭,我的头顶有一片草原(*^_^*)");
        }
    }
    /// <summary>
    /// 橡皮鸭
    /// </summary>
    public class RubberDuck : Duck
    {
    
    
        public RubberDuck()
        {
    
    
            flyBehavior = new FlyNoWay();
            quackBehavior = new Squack();
        }
        public override void display()
        {
    
    
            Console.WriteLine("橡皮鸭");
        }
    }
        static void Main(string[] args)
        {
    
    
            //绿头鸭
            Duck greenHeadDuck = new GreenHeadDuck();
            greenHeadDuck.display();
            greenHeadDuck.PerFormQuack();
            greenHeadDuck.PerFormFly();
            Console.WriteLine("--------------------------");
            //橡皮鸭
            Duck rubberDuck = new RubberDuck();
            rubberDuck.display();
            rubberDuck.PerFormQuack();
            rubberDuck.PerFormFly();
            Console.ReadKey();
        }

如上测试我们在鸭子子类中通过构造方法实例化行为类，但建立了一堆动态的功能没有用到，是否可以动态的设定行为而不是在构造函数里面实例化。所以我们还可以加入两个设置行为的方法 SetFlyBehavior和SetQuackBehavior，再次测试动态设定行为。

/// <summary>
/// 鸭子超类
/// </summary>
public abstract class Duck {
    
    
    protected FlyBehavior flyBehavior;
    protected QuackBehavior quackBehavior;
    public void swin() {
    
     }
    public abstract void display();
    public void SetFlyBehavior(FlyBehavior flyBehavior) {
    
    
        this.flyBehavior = flyBehavior;
    }
    public void SetQuackBehavior(QuackBehavior quackBehavior) {
    
    
        this.quackBehavior = quackBehavior;
    }
    public void PerFormFly()
    {
    
    
        flyBehavior.fly();
    }
    public void PerFormQuack()
    {
    
    
        quackBehavior.quack();
    }
}

2、适用场景

1. 系统有很多类，但是他们的区别只是行为不同
2. 一个系统需要动态的在几个算法中选择一种
3. 多个类只有在算法或行为上稍有不同的场景
4. 算法需要自由切换的场景
5. 需要屏蔽算法规则的场景

注意事项：

• 具体策略数量超过4个，则需要考虑使用混合模式。

3、优点

1、可以减少ifelse语句
2、提高算法的保密性和安全性
3、符合开闭原则

4、缺点

1、客户端需要知道所有策略类，自己决定使用哪个策略类
2、类的数量增加

5、代码示例

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bHcVnhWC-1608389668751)(https://img.hacpai.com/file/2019/07/image-447d0de5.png?imageView2/2/w/768/format/jpg/interlace/1/q/100)]

订单策略接口

public interface OrderStrategy {
    
    
    OrderTypeEnum supportType();
    void saveOrder();
}

支付宝下单策略

public class AlipayStrategy implements OrderStrategy {
    
    
    public OrderTypeEnum supportType() {
    
    
        return OrderTypeEnum.ALIPAY;
    }
    public void saveOrder() {
    
    
        System.out.println("支付宝支付完成");
    }
}

微信下单策略

public class WxpayStrategy implements OrderStrategy{
    
    
    public OrderTypeEnum supportType() {
    
    
        return OrderTypeEnum.WXPAY;
    }
    public void saveOrder() {
    
    
        System.out.println("微信支付完成");
    }
}

空策略类

public class EmptyStrategy implements OrderStrategy {
    
    
    public OrderTypeEnum supportType() {
    
    
        return null;
    }
    public void saveOrder() {
    
    
        System.out.println("没有支付方式");
    }
}

订单类型枚举类

public enum OrderTypeEnum {
    
    
    /**
     * 支付宝、微信
     */
    ALIPAY,WXPAY
}

下单工厂类

public class OrderFactory {
    
    
    private OrderFactory(){
    
    
    }
    /** spring下通过spring来获取所有的bean */
    private static OrderStrategy[] strategies = new OrderStrategy[]{
    
    new AlipayStrategy(),new WxpayStrategy()};
    private static OrderStrategy EMPTY_STRATEGY = new EmptyStrategy();
    private static OrderStrategy getOrderStrategy(String orderType) {
    
    
        for (OrderStrategy handler : strategies) {
    
    
            if (handler.supportType().name().equals(orderType)) {
    
    
                return handler;
            }
        }
        return EMPTY_STRATEGY;
    }
    public static void saveOrder(String orderType){
    
    
        getOrderStrategy(orderType).saveOrder();
    }
}

测试类

public class StrategyTest {
    
    
    public static void main(String[] args) {
    
    
        OrderFactory.saveOrder("ALIPAY");
        OrderFactory.saveOrder("WXPAY");
        OrderFactory.saveOrder("ICBC");
    }
}

输出结果为：

支付宝支付完成
微信支付完成
没有支付方式

6、源码分析

6.1 spring中应用

Resource
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W5uzzXJg-1608389668755)(https://img.hacpai.com/file/2019/07/image-cd73df82.png?imageView2/2/w/768/format/jpg/interlace/1/q/100)]

如图，有不同的策略类，
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lNPd49Zr-1608389668756)(https://img.hacpai.com/file/2019/07/image-2ec69237.png?imageView2/2/w/768/format/jpg/interlace/1/q/100)]

InstantiationStrategy从名字上就可以看出是策略模式，
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kfYog01n-1608389668758)(https://img.hacpai.com/file/2019/07/image-66f96b08.png?imageView2/2/w/768/format/jpg/interlace/1/q/100)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-00o1uMWV-1608389668759)(https://img.hacpai.com/file/2019/07/image-57873357.png?imageView2/2/w/768/format/jpg/interlace/1/q/100)]

也可以通过set方法来进行配置。

public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy) {
    
    
   this.instantiationStrategy = instantiationStrategy;
}

7、策略模式总结、类图

策略模式：定义了算法簇，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户