设计模式之策略模式

设计模式之策略模式

image

1.意图

根据GOF的定义:定义一系列的算法或操作,并把它们一个个封装起来,并且使它们可以互换替换。以达到算法与业务独立开发的目的。

简单的说就是针对某个业务需求,抽象出解决问题的算法的一个个方法,然后实现封装不同的特定的算法(通过集成抽象类或接口),在客户端需要使用这个算法的时候开业方便的替换就OK了,做到算法操作与业务逻辑解耦,降低了维护成本和易拓展。

2.动机

有时候对于某个问题会有多种的解决算法,但是如果在这个解决问题的类中定义多种的算法,会使这个类膨胀,拥有了一些不需要的属性和方法,这时没必要的,会使得类很难维护。

不用把所有的算法都塞进类中,只要在需要的时候替换上对应的算法类就ok了。

如果把算法实现集成到业务类中时会造成在增加新的算法的时候,需要修改此类,违背了设计原则-开闭原则,在开发中,一般是对原有代码封闭,对拓展开放的思想。

因此,通过以上的动机,策略模式就应运而生了。

3.模式结构与角色定义

image

策略模式的结构也比较简单。主要涉及到继承与委托两种关系,算法抽象,具体算法继承算法抽象类并实现算法,根据面向接口编程,Strategy委托给Context上下文,客户端调用到对应算法的时候,直接把对应的算法动态的赋给Context上下文就OK了。

  • Strategy:

  • 1.算法的抽象类或接口。抽象出算法的一个个方法,主要被算法具体类继承实现。

  • ConcreteStrategyA/B/C:

  • 1.算法的具体类。继承算法抽象类,实现算法。

  • Context:

  • 1.拥有Strategy的引用,有对应的接口调用算法。

客户端在调用算法的使用,主要是借助Context(其实就是一个委托类,用来调用对应的算法的),直接调用对应的算法,把业务与算法解耦。

4.应用场景

  • 许多相关的类只是算法实现细节有异。策略提供了一种用多个算法中的一个算法来配置一个类的方法。
  • 针对某个问题有多种算法,不同时候可能使用不同的算法,要方便的替换。
  • 算法与业务逻辑解耦,不想业务逻辑或客户端程序知道过多的算法实现细节。
  • 一个类定义了多种行为,但是在某个问题上,使用了多个条件判断的方法来使用不同的行为,这时候可以用策略模式来消除多个条件判断。

5.模式的实现步骤与例子

  • 1.将算法的抽象类或接口。抽象出算法的一个个方法。
  • 2.实现算法的具体类。
  • 3.创建一个拥有Strategy引用的Context类,拥有对应调用算法的方法。

下面看例子。

算法的抽象类与算法具体类:

//Strategy.h
class CalStrategy
{
public:
    virtual ~CalStrategy() {}
    virtual void Calculate() = 0;
};

class ACalStrategy : public CalStrategy
{
public:
    ~ACalStrategy(){}

    void Calculate() override {
        cout << "ACalStrategy Calculate" << endl;
    }
};

class BCalStrategy : public CalStrategy
{
public:
    ~BCalStrategy() {}

    void Calculate() override {
        cout << "BCalStrategy Calculate" << endl;
    }
};

在这里通过工厂方法的方式来创建出对应的算法:

class CalStrategyFactory
{
public:
    virtual ~CalStrategyFactory(){}
    virtual CalStrategy* CreateCalStrategy() = 0;
};


class ACalStrategyFactory : public CalStrategyFactory
{
public:
    ~ACalStrategyFactory(){}
    CalStrategy* CreateCalStrategy() override {
        return new ACalStrategy();
    }
};

class BCalStrategyFactory : public CalStrategyFactory
{
public:
    ~BCalStrategyFactory() {}
    CalStrategy* CreateCalStrategy() override {
        return new BCalStrategy();
    }
};

Context上下文类,主要是用于算法的调用:

class Context
{
public:
    Context(CalStrategyFactory* factory){
        this->calStrategy = factory->CreateCalStrategy();
    }
    ~Context(){
        delete calStrategy;
    }

    void Calculate() {
        //...
        std::cout<<"============算法开始==========="<<std::endl;

        calStrategy->Calculate();

        std::cout<<"============算法结束==========="<<std::endl;
        //...
    }

private:
    CalStrategy * calStrategy;
};

客户端调用:

#include "strategy.h"

int main()
{
    CalStrategyFactory* factoryA = new ACalStrategyFactory();
    Context* orderA = new Context(factoryA);

    CalStrategyFactory* factoryB = new BCalStrategyFactory();
    Context* orderB = new Context(factoryB);

    orderA->Calculate();
    orderB->Calculate();

    delete factoryA;
    delete factoryB;
    
    system("pause");

    return 0;
}

运行结果:

============算法开始===========
ACalStrategy Calculate
============算法结束===========
============算法开始===========
BCalStrategy Calculate
============算法结束===========

6.小结

策略方法主要是定义系列的算法,方便在需求变化时很容易的替换对应的算法,几乎是不增加什么成本的。有助于提取出算法的公共部分抽象出抽象类或接口。但是在实际使用的时候,要注意Context的使用,如果直接在里面硬编码new一个具体类的算法,就会比较生硬,没有动态性。

  • 一般拥有一个strategy引用,是通过一个接口传入对应的算法具体类,达到动态的替换算法。
  • 另外一种方法是把Context实现为模板类,在创建的时候直接创建对应的算法的方法。比如Context<ACalStrategy> contex,这样就是静态绑定,这样的话丧失了运行时的动态性,但是效率会高一点。具体的选择应根据实际情况选择。

推荐阅读更多精彩内容