策略模式详解

策略模式（Strategy Design Pattern），定义一堆算法类，并将每个算法分别封装起来，让它们可以互相替换，被封装起来的算法具有独立性外部不可改变其特性。

策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。

策略模式的应用场景

策略模式最常见的应用场景是，利用它来避免冗长的 if-else 或 switch 分支判断。不过，它的作用还不止如此。它也可以像模板模式那样，提供框架的扩展点等等。

当我们需要多个功能相似的类，并且需要它们之间可以灵活切换时，就非常适合使用策略模式。

策略模式的构成

策略类的定义比较简单，需要定义以下两种角色：

1. 抽象策略接口类：定义了策略类需要实现的方法规范。
2. 策略实现类：继承自抽象策略接口，为具体策略类。

当有多个策略时，可以通过简单工厂封装所有的策略，使调用更加易用：

1. 策略工厂类：一般来说，通过一个策略工厂，将一群功能相同的策略封装起来，调用更加方便。

通过一个文件处理的例子来说明；有一个文件处理的通用类，可以处理excel、txt、exe文件。
面对不同类型的文件，返回具体对应的文件处理类，也就是具体的策略类。

抽象策略接口类

class FileStrategy:
    @abstractmethod
    def read(self):
        pass

抽象策略接口，定义了每个具体的策略类需要实现的方法，符合基于抽象而非实现编程。

策略实现类

class ExeFileStrategy(FileStrategy):

    def read(self):
        print("--- 进行 exe 文件的读取 ---")


class ExeclFileStrategy(FileStrategy):

    def read(self):
        print("--- 进行 excel 文件的读取 ---")


class TxtFileStrategy(FileStrategy):

    def read(self):
        print("--- 进行 txt 文件的读取 ---")

上面分别实现三个不同的具体策略类来处理 exe/excel/txt 文件的读取，每个具体的策略类，要在read方法中实现自己的读取逻辑。

策略工厂类

根据策略类是否有状态，可以分为两种策略的工厂生成方式。

# 策略类无状态时，每次返回同一个策略类，主要提供逻辑的计算。
class FileStrategyFactory:
    MAP = {
        "exe": ExeFileStrategy(),
        "execl": ExeclFileStrategy(),
        "txt": TxtFileStrategy(),
    }

    def create(self, key):
        return self.MAP[key]


# 策略类有状态时，每次返回独立的策略对象，策略对象之间独立。
class FileStrategyFactory1:
    MAP = {
        "exe": ExeFileStrategy,
        "execl": ExeclFileStrategy,
        "txt": TxtFileStrategy,
    }

    def create(self, key):
        return self.MAP[key]()

上面我们实现了两种策略工厂，并且都是使用简单工厂方法，FileStrategyFactory是无状态的，每次相同的key，返回的是同一个策略对象；FileStrategyFactory1是有状态的，每次返回策略对象之间独立。

具体使用

# 无状态策略类
fac = FileStrategyFactory()
exe = fac.create("exe")
exe1 = fac.create("exe")
execl = fac.create("execl")
print(exe is exe1)  # True，每次返回同一个对象
exe.read()
execl.read()

# 有状态策略类
fac = FileStrategyFactory1()
exe = fac.create("exe")
exe1 = fac.create("exe")
execl = fac.create("execl")
print(exe is exe1)  # False，每次返回的对象不同
exe.read()
execl.read()

替代if / else

策略模式，是如何解决冗长的if / else 逻辑，以及解耦不同的策略的呢？

假设我们没有策略类，上面的文件处理类例子，我们大概会写成这样：

if file_type == "exe":
    print("--- 进行 exe 文件的读取 ---")
elif file_type == "execl":
    print("--- 进行 execl 文件的读取 ---")
elif file_type == "txt":
    print("--- 进行 txt 文件的读取 ---")

这样每个if / else 分支，都会耦合在一起，并且如果以后需求变更，需要不断新增文件类型的读取，就会导致分支逻辑越来越长。

而策略模式，通过拆分成不同的策略类，并且通过一个map做成映射，就将不同的策略解耦开来，并且消除了冗长的 if/else 代码。

优缺点

优点

1. 扩展性好，可以灵活增减策略类。
2. 基于抽象编程，策略类之间可以自由替换而不用大动代码。
3. 减少了大量的 if/else 逻辑判断。

缺点

1. 每个策略类需要单独编写，会导致类很多。
2. 封装多层，代码变得复杂，可读性变差。