golang 策略模式与策略工厂模式

什么是策略模式

策略（Strategy）模式的定义：该模式定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式，它通过对算法进行封装，把使用算法的责任和算法的实现分割开来，并委派给不同的对象对这些算法进行管理。

什么是策略工厂模式

在一个使用策略模式的系统中，当存在的策略很多时，客户端管理所有策略算法将变得很复杂，如果在环境类中使用策略工厂模式来管理这些策略类将大大减少客户端的工作复杂度

代码

在下面的代码中，分别用策略模式和策略工厂模式实现了客户端通过接口来调用不同的排序方法。在实际开发中，new策略这一步一般不是直接new的，比如用spring的IoC或者通过读取配置文件来选择不同的策略，而代码是不用改动的，这是策略模式的优势。

package main

import "fmt"

func main() {

	arr := []int{1,2,3,6,4}

	//如数据排序策略有冒泡排序、选择排序、插入排序、二叉树排序等
	//策略上下文，客户端主要通过该环境类来实现不同的策略调整，而不需要改变代码，也不用加入过多的if else 判断
	sorter := new(QuickSort)
	//sorter := new(BubleSort)

	//设置不同的策略，则会用不同的策略方法，对客户端的调用来说，写法一样，因为有一个统一的接口，本例为ISort接口。
	context := new(StrategyContext)
	context.SetSort(sorter)
	//客户端通过统一的接口来进行引用
	sort := context.GetSort()
	sort.Sort(arr)


	//工厂策略模式，从工厂获取对应的策略方法接口实例
	factory := NewStrategyFactory()
	if sort2,ok := factory.GetSortStrategy("buble");ok{
		sort2.Sort(arr)
	}

}

type ISort interface {
	Sort(arr []int)
}

type QuickSort struct {
}

type BubleSort struct {
}

func (this *BubleSort) Sort(arr []int)  {
	//冒泡排序实现
	fmt.Println("通过冒泡来实现排序")
}
func (this *QuickSort) Sort(arr []int)  {
	//快速排序实现
	fmt.Println("通过快排来实现排序")
}

//策略上下文
type StrategyContext struct {
	Sorter ISort
}

func (factory *StrategyContext) GetSort() ISort {
	return factory.Sorter
}

func (factory *StrategyContext) SetSort(sorter ISort) {
	factory.Sorter = sorter
}

//策略工厂
type StrategyFactory struct {
	strategys map[string]ISort
}

func NewStrategyFactory() *StrategyFactory {
	factory := new(StrategyFactory)
	//初始化 内部的策略
	var strategys map[string]ISort = make(map[string]ISort,2)
	quickSort := new(QuickSort)
	bubbleSort := new(BubleSort)
	strategys["quick"]=quickSort
	strategys["buble"]=bubbleSort
	factory.strategys = strategys
	return factory
}
//策略工厂提供该方法，客户端通过此 来获取不同的策略。
func (factory *StrategyFactory) GetSortStrategy(name string) (ISort ISort,ok bool) {
	if v,ok := factory.strategys[name];ok{
		return v,true
	}
	return nil,false
}