设计模式14 策略模式

策略模式(Strategy)定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

策略模式的优点：

1、多重条件语句不易维护，而使用策略模式可以避免使用多重条件语句。

2、策略模式提供了一系列的可供重用的算法族，恰当使用继承可以把算法族的公共代码转移到父类里面，从而避免重复的代码。

3、策略模式可以提供相同行为的不同实现，客户可以根据不同时间或空间要求选择不同的。

4、策略模式提供了对开闭原则的完美支持，可以在不修改原代码的情况下，灵活增加新算法。

5、策略模式把算法的使用放到环境类中，而算法的实现移到具体策略类中，实现了二者的分离。

 

环境类：

public class Context {
    private Strategy strategy;

    public Strategy getStrategy() {
        return strategy;
    }

    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public void strategyMethod() {
        strategy.strategyMethod();
    }
}

 

策略类：

public interface Strategy {
    public void strategyMethod();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void strategyMethod() {
        // TODO Auto-generated method stub
        System.out.println("策略A");
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void strategyMethod() {
        // TODO Auto-generated method stub
        System.out.println("策略B");
    }
}

 

调用方式：

public class Client {
    /*
     * 例子：通用类库DBHelper
     * 无论连接SQLServer/Oracel/MySql数据库
     * 不同的对象，具有相同的使用方式Context
     */
    public static void main(String[] args) {
        //多个类有相似的功能，客户将具体的类传入Context，调用Context统一的方法实现具体功能
        Strategy strategy;//扩展点
        
        //使用策略A
        strategy = new ConcreteStrategyA();
        
        //扩展点(封装了变化点)->切换策略B
        //strategy = new ConcreteStrategyB();
        
        //稳定代码
        Context context = new Context();
        context.setStrategy(strategy);
        context.strategyMethod();
    }    
}

执行结果：

 

策略模式经常用于消除多条件选择的代码，例如如下代码：

public class StrategyDemo {
    public void NoStrategyMethod(Integer type) {
        switch(type) {
            case 1:
                System.out.println("执行第一种策略");
                break;
            case 2:
                System.out.println("执行第二种策略");
                break;
            case 3:
                System.out.println("执行第三种策略");
                break;
            default:
                System.out.println("没有这种策略");
                break;
        }
    }
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer type = 1;
        StrategyDemo demo = new StrategyDemo();
        demo.NoStrategyMethod(type);        
    }
}

方法NoStrategyMethod()，中根据参数type的值，执行不同的逻辑，这种写法是典型的策略模式的应用场景。

如果程序的需求改变，需要增加新的type，例如type值可以为4、5、6……或者某些已有的type值得处理逻辑需要修改。

如何既能满足这些变化，又不需要修改StrategyDemo类的代码或者尽量减少对Strategy类的影响呢？

使用设计模式就是通过扩展而不是修改的方式来满足需求的变化，或者将这种修改转移到别类中。下面给出策略模式的解决方案。

 

首先定义以下接口和类，用于管理策略：

package com.example.uml;

public interface IType {
    public void setStrategy(Strategy strategy);
    
    public void UseStrategy();
}

class MyType implements IType{
    
    private Strategy strategy;
    
    @Override
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;        
    }
    
    @Override
    public void UseStrategy() {
        this.strategy.StrategyMethod();
    }    
}


abstract class Strategy{
    public abstract void StrategyMethod();
}

class Strategy1 extends Strategy{

    @Override
    public void StrategyMethod() {
        System.out.println("执行第一种策略");
    }
}

class Strategy2 extends Strategy{

    @Override
    public void StrategyMethod() {        
        System.out.println("执行第二种策略");
        System.out.println("第二种策略修改了");
    }
}

class Strategy3 extends Strategy{

    @Override
    public void StrategyMethod() {
        System.out.println("执行第三种策略");
    }
}

class Strategy4 extends Strategy{

    @Override
    public void StrategyMethod() {
        System.out.println("执行第四种策略");
    }
}

 

客户端调用方式发生修改：

package com.example.uml;

public class StrategyDemo {
    @Deprecated
    public void NoStrategyMethod(Integer type) {
        switch (type) {
        case 1:
            System.out.println("执行第一种策略");
            break;
        case 2:
            System.out.println("执行第二种策略");
            break;
        case 3:
            System.out.println("执行第三种策略");
            break;
        default:
            System.out.println("没有这种策略");
            break;
        }
    }

    public void UseStrategyMethod(IType type) {
        type.UseStrategy();
    }

    public static void main(String[] args) {
        StrategyDemo demo = new StrategyDemo();

        // 不使用策略模式
//        Integer type = 1;
//        demo.NoStrategyMethod(type);

//        System.out.println("-----------------------------------");

        // 使用策略模式
        IType myType = new MyType();

        // 使用新增的策略4，无需修改当前类的具体业务逻辑，只需要修改new的类即可
        Strategy strategy4 = new Strategy4();
        myType.setStrategy(strategy4);
        myType.UseStrategy();

        System.out.println("-----------------------------------");

        // 假如策略2的具体逻辑发生变化，则当前类无需改变
        Strategy strategy2 = new Strategy2();
        myType.setStrategy(strategy2);
        myType.UseStrategy();
    }
}

现在的需求发生变化，第二种策略的处理逻辑改变了(增加了一行输出)，并且增加了第四种的策略需要处理。

一种方案时修改第5行的方法，当然这可以完成这个需求，而且可以说是简单而直接。

但如果这个逻辑很复杂，而又经常变化，这种修改方式就有可能引入Bug，或者影响到原本正常的功能，。

因此可以实通过IType接口与Strategy抽象类，将变化点与客户端隔离。也就是将可能频繁变化的代码从当前类中抽离。

StrategyDemo类就是客户端，这个类中不再包含判断逻辑，也不包含策略的具体逻辑，只负责调用策略类的方法。

在main()方法中，只需要new出对应的实例，然后执行抽象的方法即可，具体的内容，都有MyType、Strategy1、Strategy2、Strategy3、Strategy4……这些类来处理。在新增策略或策略改变而必须修改代码时，对main()方法影响减少到最小。