前言
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互相替换，且算法的变换不会影响使用算法的客户。
在项目开发中，我们经常要根据不同的场景，采取不同的措施，也就是不同的策略。假设我们需要对a、b这两个整数进行计算，根据条件的不同，需要执行不同的计算方式。我们可以把所有的操作都封装在同一个函数中，然后根据if ... else ...的形式来调用不同的计算方式，这种方式称为硬编码。
在实际应用中，随着功能和体验的不断增长，我们需要经常添加/修改策略，进而需要不断修改已有代码，这不仅会让这个函数越来越难以维护，还会因为修改带来一些Bug。因此，为了解耦，我们需要使用策略模式，定义一些独立的类来封装不同的算法，每一个类封装一个具体的算法。
示例代码
策略模式的重点在于策略的设定，以及普通类Operator和策略CalStrategy的对接。通过更换实现同一接口的不同策略类。降低了Operator的维护成本，解耦算法实现。
Go
strategy.go
package strategy // CalStrategy 是一个策略类 type CalStrategy interface { do(int, int) int } // Add 为加法策略 type Add struct{} func (*Add) do(a, b int) int { return a + b } // Reduce 为减法策略 type Reduce struct{} func (*Reduce) do(a, b int) int { return a - b } // Operator 是具体的策略执行者 type Operator struct { strategy CalStrategy } // 设置策略 func (o *Operator) setStrategy(strategy CalStrategy) { o.strategy = strategy } // 调用策略中的方法 func (o *Operator) calc(a, b int) int { return o.strategy.do(a, b) }
单元测试
package strategy import "testing" func TestStrategy(t *testing.T) { operator := Operator{} operator.setStrategy(&Add{}) if operator.calc(1, 2) != 3 { t.Fatal("Add strategy error") } operator.setStrategy(&Reduce{}) if operator.calc(2, 1) != 1 { t.Fatal("Reduce strategy error") } }
Python
from abc import ABC, abstractmethod class CalStrategy(ABC): """策略类 """ @abstractmethod def do(self, a: int, b: int) -> int: pass class Add(CalStrategy): """加法策略 """ def do(self, a: int, b: int) -> int: return a + b class Reduce(CalStrategy): """减法策略 """ def do(self, a: int, b: int) -> int: return a - b class Operator: """策略执行者 """ def __init__(self): self.strategy = None def set_strategy(self, strategy: CalStrategy): """设置策略 """ self.strategy = strategy def calc(self, a: int, b: int) -> int: """调用策略中的方法 """ return self.strategy.do(a, b) if __name__ == "__main__": operator = Operator() operator.set_strategy(Add()) print(operator.calc(1, 2)) operator.set_strategy(Reduce()) print(operator.calc(4, 3))
参考
- 孔令飞 - 企业级Go项目开发实战
