在实际的项目开发中，策略模式也比较常用。最常见的应用场景是，利用它来避免冗长的 if-else 或 switch 分支判断。它也可以像模板模式那样，提供框架的扩展点等。

1. 策略模式的定义

策略模式，英文全称是 Strategy Design Pattern。定义一族算法类，将每个算法分别封装起来，让它们可以互相替换。策略模式可以使算法的变化独立于使用它们的客户端（这里的客户端代指使用算法的代码）。

Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it.

2. 策略模式的实现

策略模能起到解耦的作用，它解耦的是策略的定义、创建、使用这三部分。

2.1 策略的定义

策略类的定义比较简单，包含一个策略接口和一组实现这个接口的策略类。因为所有的策略类都实现相同的接口，所以，客户端代码基于接口而非实现编程，可以灵活地替换不同的策略。

2.3 策略的创建

策略模式会包含一组策略，在使用它们的时候，一般会通过类型（type）来判断创建哪个策略来使用。为了封装创建逻辑，我们需要对客户端代码屏蔽创建细节。我们可以把根据 type 创建策略的逻辑抽离出来，放到工厂类中。

策略类是无状态的，不包含成员变量，只是纯粹的算法实现，这样的策略对象是可以被共享使用的，不需要在每次调用 getStrategy() 的时候，都创建一个新的策略对象。针对这种情况，事先创建好每个策略对象，缓存到工厂类中，用的时候直接返回。
如果策略类是有状态的，根据业务场景的需要，希望每次从工厂方法中，获得的都是新创建的策略对象，而不是缓存好可共享的策略对象。

2.4 策略的使用

策略模式包含一组可选策略，客户端代码一般如何确定使用哪个策略呢？最常见的是运行时动态确定使用哪种策略，这也是策略模式最典型的应用场景。“运行时动态”指的是，我们事先并不知道会使用哪个策略，而是在程序运行期间，根据配置、用户输入、计算结果等这些不确定因素，动态决定使用哪种策略。

“非运行时动态确定”，并不能发挥策略模式的优势。在这种应用场景下，策略模式实际上退化成了“面向对象的多态特性”或“基于接口而非实现编程原则”。

3. 如何利用策略模式避免分支的判断？

实际上，这得益于策略工厂类。在工厂类中们用 Map 来缓存策略，根据 type 直接从 Map 中获取对应的策略，从而避免 if-else 分支判断逻辑。状态模式来避免分支判断逻辑的时候，使用的也是同样的套路。本质上都是借助“查表法”，根据 type 查表（代码中的 strategies 就是表）替代根据 type 分支判断。

如果业务场景需要每次都创建不同的策略对象，就要用另外一种工厂类的实现方式。这种实现方式相当于把原来的 if-else 分支逻辑从使用代码转移到工厂类中了。

4. 策略模式的代码实现

type EvictionAlgo interface {
   evict(storage map[string]string)
   adjustKey(storage map[string]string, key string)
}

type LRUAlgo struct {
}

func (L *LRUAlgo) adjustKey(storage map[string]string, key string) {
   fmt.Printf("adjust key: %s by lru strategy\n", key)
}

func (L *LRUAlgo) evict(storage map[string]string) {
   fmt.Println("Evicting by lru strategy")
}

type LFUAlgo struct {
}

func (L *LFUAlgo) adjustKey(storage map[string]string, key string) {
   fmt.Printf("adjust key: %s by lfu strategy\n", key)
}

func (L *LFUAlgo) evict(storage map[string]string) {
   fmt.Println("Evicting by lfu strategy")
}

type FIFOAlgo struct {
}

func (F *FIFOAlgo) adjustKey(storage map[string]string, key string) {
   fmt.Printf("adjust key: %s by fifo strategy\n", key)
}

func (F *FIFOAlgo) evict(storage map[string]string) {
   fmt.Println("Evicting by fifo strategy")
}

type Cache struct {
   storage      map[string]string
   evictionAlgo EvictionAlgo
   size         int
   capacity     int
}

func NewCache(algo EvictionAlgo, capacity int) *Cache {
   return &Cache{
      storage:      make(map[string]string),
      evictionAlgo: algo,
      capacity:     capacity,
   }
}
func (c *Cache) SetEvictionAlgo(algo EvictionAlgo) {
   c.evictionAlgo = algo
}

func (c *Cache) Get(key string) string {
   value := c.storage[key]
   c.evictionAlgo.adjustKey(c.storage, key)
   return value
}

func (c *Cache) Add(key, value string) {
   if c.size == c.capacity {
      c.evict()
   }
   c.size++
   c.storage[key] = value
}

func (c *Cache) evict() {
   c.evictionAlgo.evict(c.storage)
   c.size--
}


// 客户端使用
func TestCache(t *testing.T) {
   lru := &LRUAlgo{}

   cache := NewCache(lru, 2)
   cache.Add("1", "1")

   cache.SetEvictionAlgo(&LFUAlgo{})
   cache.Add("2", "2")

   cache.SetEvictionAlgo(&FIFOAlgo{})
   cache.Add("3", "3")

   val := cache.Get("3")
   t.Log(val)
}

行为型 - 3. 策略模式