Tantan Fu

Feb 01, 2020

《消失的设计模式》系列之策略模式

设计模式是面向对象的有用工具,但是编程语言的发展和多种编程范式混合编程的可能,使很多的模式被语言特性取代,或者被其他编程范式解决。

要解决的问题

想象一下,对于某个任务,我们需要支持多种解决方案。而这多种支持就是变化点,为了封装变换点,我们可以采用策略模式。

定义

定义了一系列的算法,把它们分别封装起来,并且使它们可以相互替换。
此模式让算法的变化独立于使用算法的客户。

面向对象的方式

UML

notion image
如上图所示,
  • Strategy 接口定义了算法的行为
  • 一系列的算法 ConcreteStrategyAConcreteStrategyB 分别实现了该接口
  • 策略被包含在一个 Context 中,拥有私有的 strategy 实例,从而执行具体的算法行为
  • 通常 Context 中还会包含一个 setStrategy 方法,从而动态改变策略

代码

首先我们定义一个接口 IStrategy
interface IStrategy { calculate(a: number, b: number): number }
它要求实现一个名为 calculate 的方法,该方法接受两个 number 类型的参数,最终返回一个 number 类型的值。
class AddStrategy implements IStrategy { calculate(a: number, b: number): number { return a + b } } class SubtractStrategy implements IStrategy { calculate(a: number, b: number): number { return a - b } }
这里我们定义了两个具体的策略类 AddStrategySubtractStrategy,它们都实现了 IStrategy 接口。
最终我们来定义 Context 类:
class Context { private strategy: IStrategy constructor(strategy: IStrategy) { this.strategy = strategy } public setStrategy(strategy: IStrategy) { this.strategy = strategy } public calculate(a: number, b: number) { return this.strategy.calculate(a, b) } }
类中包含一个私有的成员属性 strategy,可以通过构造函数赋值,也可以通过 setStrategy 来动态改变。最后 calculate 方法将会代理到具体的策略类上,并执行具体的算法。
const context = new Context(new AddStrategy()) console.log(context.calculate(1, 2)) context.setStrategy(new SubtractStrategy()) console.log(context.calculate(1, 2)) context.setStrategy(new SubtractStrategy()) console.log(context.calculate(1, 2))

带上函数式的思考帽

我们再回过头来思考策略的定义方式:
interface IStrategy { calculate(a: number, b: number): number }
这里的接口表达的意思是,期望一个类,拥有 calculate 方法,同时方法的签名是 (number, number) -> number
其实真正想要的,只是里面的这个方法而已,我们大可不必将其放在类里面。可以把接口修改成如下的样子:
interface IStrategy { (a: number, b: number): number }
这里 IStrategy 表达的意思是,一个函数,类型为 (number, number) -> number。如有有些不好理解的话,我们可以将其改为 type:
type IStrategy = (a: number, b: number) => number
那么相应的策略可以修改为:
const AddStrategy: IStrategy = (a, b) => a + b const SubtractStrategy: IStrategy = (a, b) => a - b
这时,Context 就变成了:
class Context { private strategy: IStrategy constructor(strategy: IStrategy) { this.strategy = strategy } public setStrategy(strategy: IStrategy) { this.strategy = strategy } public calculate(a: number, b: number) { return this.strategy(a, b) } } const context = new Context(AddStrategy) console.log(context.calculate(1, 2)) context.setStrategy(SubtractStrategy) console.log(context.calculate(1, 2)) context.setStrategy(SubtractStrategy) console.log(context.calculate(1, 2))
只是传入一个函数而已!去掉了类的层层包裹,一个函数就可以清晰明了地解决问题。
由于场景的设定,这里我们就不去将 Context 函数式化了。 完整代码

数组的排序算法与策略模式

其实日常编码中,遇到最多的策略模式是排序算法,例如:
;[1, 5, 3, 4, 2].sort((a, b) => a - b)
在 TypeScript 中,自定义排序策略非常容易,传入一个函数就可以了,我们再来看 Java 的表现:
class CustomComparator implements Comparator<X> { public int compare(X a, x b) { return ... } } CustomComparator comparator = new CustomComparator() Arrays.sort(arr, new CustomComparator())
其中 comparator 是一个实现了 Comparator 接口的类的实例。为了满足类型,需要定义类,然后创建实例对象,非常冗余。

总结

策略模式,其目的是使不同算法族变得可控。其方法是将符合统一接口的不同行为的类的实例注入进入。但是如果能使用函数式的方式,其实传一个函数参数,就可以了。

参考

  • Head first design patterns
 

Copyright © 2022 Tantan Fu

Powered by noto.so