设计模式之策略模式
1.意图
根据GOF的定义：定义一系列的算法或操作，并把它们一个个封装起来，并且使它们可以互换替换。以达到算法与业务独立开发的目的。
简单的说就是针对某个业务需求，抽象出解决问题的算法的一个个方法，然后实现封装不同的特定的算法(通过集成抽象类或接口)，在客户端需要使用这个算法的时候开业方便的替换就OK了，做到算法操作与业务逻辑解耦，降低了维护成本和易拓展。
2.动机
有时候对于某个问题会有多种的解决算法，但是如果在这个解决问题的类中定义多种的算法，会使这个类膨胀，拥有了一些不需要的属性和方法，这时没必要的，会使得类很难维护。
不用把所有的算法都塞进类中，只要在需要的时候替换上对应的算法类就ok了。
如果把算法实现集成到业务类中时会造成在增加新的算法的时候，需要修改此类，违背了设计原则-开闭原则，在开发中，一般是对原有代码封闭，对拓展开放的思想。
因此，通过以上的动机，策略模式就应运而生了。
3.模式结构与角色定义
策略模式的结构也比较简单。主要涉及到继承与委托两种关系，算法抽象，具体算法继承算法抽象类并实现算法，根据面向接口编程，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，这样就是静态绑定，这样的话丧失了运行时的动态性，但是效率会高一点。具体的选择应根据实际情况选择。
