浅谈golang中的工厂模式

设计模式不分语言，是一种思维层面的体现，但是不能在不同语言中使用同一套实现（每种语言有不同的特性），比如go，本身是没有继承一说，但是通过结构体的组合来实现语义上的继承。而多态也是通过接口的方式来实现的。

下方的图来自于大佬博客，贴在这里方便查看！！！

设计原则

设计模式

创建型模式

工厂模式

工厂模式在大家写项目的时候用到的地方很多，可以用于代码的解耦以及方便拓展。
在说起工厂模式之前，帮大家回忆一下golang中接口的特性：

• 类型不需要显式声明它实现了某个接口：接口被隐式地实现。多个类型可以实现同一个接口。
• 实现某个接口的类型（除了实现接口方法外）可以有其他的方法。
• 一个类型可以实现多个接口。
• 接口类型可以包含一个实例的引用， 该实例的类型实现了此接口（接口是动态类型）。
• 它本质上是一个指针，虽然不完全是一回事。
• 指向接口值的指针是非法的，它们不仅一点用也没有，还会导致代码错误。
• 接口值是nil。

简单工厂

简单工厂只需要if else 的堆叠，并返回新创建的实例即可。

import "fmt"

//简单工厂模式
//显示暴露接口
type IRuleConfigParser interface {
	Parse(data []byte)
}

//隐式隐藏实现类
type jsonRuleConfigParse struct {
}

//不需要显示实现接口，只需要函数对应上便可
func (j jsonRuleConfigParse) Parse(data []byte) {
	fmt.Println("jsonRuleConfigParse执行了")
}

type ymlRuleConfigParse struct {
}

func (y ymlRuleConfigParse) Parse(data []byte) {
	fmt.Println("ymlRuleConfigParse执行了")
}

func NewIRuleConfigParse(name string) IRuleConfigParser {
	switch name {
	case "json":
		return jsonRuleConfigParse{}
	case "yml":
		return ymlRuleConfigParse{}
	}
	return nil
}

工厂方法

当对象的创建逻辑比较复杂，不只是简单的 new 一下就可以，而是要组合其他类对象，做各种初始化操作的时候，推荐使用工厂方法模式，将复杂的创建逻辑拆分到多个工厂类中，让每个工厂类都不至于过于复杂。
实现过程可以理解为，在用户调用到创建实例之间多了一个工厂用于做特殊处理。之后使用简单工厂做抉择即可。

//暴露创建parse工厂的接口
type IRuleConfigParserFactory interface {
	CreateParse() IRuleConfigParser
}

type jsonRuleConfigParserFactory struct {
}

func (j jsonRuleConfigParserFactory) CreateParse() IRuleConfigParser {
	//这里可以对parser做特殊处理
	return jsonRuleConfigParser{}
}

type ymlRuleConfigParserFactory struct {
}

func (y ymlRuleConfigParserFactory) CreateParse() IRuleConfigParser {
	//这里可以对parser做特殊处理
	return ymlRuleConfigParser{}
}

func NewIRuleConfigParserFactory(name string) IRuleConfigParserFactory {
	switch name {
	case "json":
		return jsonRuleConfigParserFactory{}
	case "yml":
		return ymlRuleConfigParserFactory{}
	}
	return nil
}

抽象工厂

一个工厂类可以实现不同的parser接口，可以减少工厂类的数量。以下例子使用工厂方法就要使用两个工厂了。

import "fmt"
//区别于IRuleConfigParser，这是一个新的parser接口
type ISystemConfigParser interface {
	ParseSystem(data []byte)
}

type jsonSystemConfigParser struct {
}

func (j jsonSystemConfigParser) ParseSystem(data []byte) {
	fmt.Println("jsonSystemConfigParser执行了")
}

type IConfigParserFactory interface {
	CreateRuleParser() IRuleConfigParser
	CreateSystemParse() ISystemConfigParser
	//更多的parser可以在这里拓展
}

type jsonConfigParserFactory struct {
}

func (j jsonConfigParserFactory) CreateRuleParser() IRuleConfigParser {
	return jsonRuleConfigParser{}
}

func (j jsonSystemConfigParser) CreateSystemParse() ISystemConfigParser {
	return jsonSystemConfigParser{}
}