1.简单工厂模式一：

大部分工厂类都是以"Factory"结尾，也不是必须，一般会结合语义场景来定义命名。有create开头的，有getInstance()、createInstance()、newInstance()的命名方式。以下代码根据实际情况我们可知，节省内存和创建的过程，我们可以在程序启动时候提前加载好并缓存起来，使用的时候直接拿来使用。 记忆区分：简单工厂模式，根据特定的特征，生产固定的对象模型

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


type RuleConfigSource struct {
}

func (r RuleConfigSource) Load(ruleConfigFilePath string) RuleConfig {
	var ruleConfigFileExtension string = getFileExtension(ruleConfigFilePath)
	var parser IRuleConfigParser = RuleConfigParserFactory.createParser(ruleConfigFileExtension)
	if parser == nil {
		errors.New("Rule config file format is not supported: " + ruleConfigFilePath)
	}

	var configText string = ""
	var ruleConfig RuleConfig = parser.Parser(configText)
	return ruleConfig
}

func getFileExtension(filePath string) string {
	return "json"
}

type RuleConfigParserFactory struct {
}

func createParser(configFormat string) IRuleConfigParser {
	var parser IRuleConfigParser
	if strings.Contains(configFormat, "json") {
		parser = JsonRuleConfigParser{}
	} else if strings.Contains(configFormat, "xml") {
		parser = XmlRuleConfigParser{}
	} else if strings.Contains(configFormat, "yaml") {
		parser = YamlRuleConfigParser{}
	} else if strings.Contains(configFormat, "properties") {
		parser = PropertiesRuleConfigParser{}
	}
	return parser
}

2.工厂方法模式

工厂方法的定义，从某方面来说是为了统一工厂类的动作。也是为了解耦上次代码的耦合 工厂方法模式相对简单工厂模式更加符合开闭原则

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

type IRuleConfigParserFactory interface{
	CreateParser() IRuleConfigParser
}

var _ IRuleConfigParserFactory = 

// 这里只写json的，可以通过实现IRuleConfigParserFactory接口来拓展：xml,propertiy,yaml
type JsonRuleConfigParserFactory struct{}

func (j *JsonRuleConfigParserFactory)CreateParser()IRuleConfigParser{
	return JsonRuleConfigParser{}
}

通过变换之后，我们发现，要想在RuleConfigSource类中load方法引入工厂方法模式来创建parser，并调用load方法会导致在load方法中耦合了IRuleConfigParserFactory相关的创建和调用过程。针对这个问题，我们该怎么解决规避达到这块的代码逻辑”清晰明了“。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

// 改造前
func Load(ruleConfigFilePath string) (RuleConfig,error){
	ruleConfigExtension:=getFileExtension(ruleConfigFilePath)

	var parserFactory IRuleConfigParserFactory 
	if (strings.Contains(ruleConfigFileExtension,"json")){
		parserFactory = &JsonRuleConfigParser{}
	}else if (strings.Contains(ruleConfigParser,"xml")){
		parserFactory = &XmlRuleConfigParser{}
	}else if (strings.Contains(ruleConfigParser,"yaml")){
		parserFactory = &YamlRuleConfigParser{}
	}else if (strings.Contains(ruleConfigParser,"properties")){
		parserFactory = &PropertiesRuleConfigParser{}
	}else{
		return nil,errors.New("rule config file is not support! check it")
	}

	var parser IRuleConfigParser = parserFactory.CreateParser()

	configText := ""
	var ruleConfig RuleConfig = parser.Parser(configText)
	return ruleConfig,nil
}

// 改造后
func Load(ruleConfigFilePath string) (RuleConfig,error){
	ruleConfigExtension:=getFileExtension(ruleConfigFilePath)

	var parserFactory IRuleConfigParserFactory = RuleConfigParserFactoryMap.GetParser(ruleConfigExtension)

	if parserFactory == nil{
		return nil,errors.New("rule config file is not support! please check it ")
	}

	var parser IRuleConfigParser = parserFactory.CreateParser()

	configText := ""
	var ruleConfig RuleConfig = parser.Parser(configText)
	return ruleConfig,nil
}

type RuleConfigParserFactoryMap struct{
}

var CachedFactorys map[string]IRuleConfigParserFactory

func init(){
	CachedFactorys["json"]=&JsonRuleConfigParserFactory{}
	CachedFactorys["xml"]=&XmlRuleConfigParserFactory{}
	CachedFactorys["yaml"]=&YamlRuleConfigParserFactory{}
	CachedFactorys["properties"]=&PropertiesRuleConfigParserFactory{}
}

func GetParserFactory(type string)IRuleConfigParserFactory{
	if type == ""{
		return nil
	}

	parserFactory,ok:=CachedFactorys[type]
	if !ok {
		return nil
	}

	return parserFactory
}

3.抽象工厂(Abstract Factory)

简单工厂、工厂方法，类只有一种分类方式。而抽象工厂中，类就可以多种分类方式，如下

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

type IConfigParserFactory interface{
	CreateRuleParser() IRuleConfigParser
	CreateSystemRuleParser() ISystemConfigParser
	//还可以拓展其他的解析方式
}

type JsonConfigParserFactory struct{}

func (j JsonConfigParserFactory) CreateRuleParser() IRuleConfigParser{
	return &JsonRuleConfigParser{}
}

func (j JsonConfigParserFactory)CreateSystemRuleParser() ISystemConfigParser{
	return &JsonSystemRuleConfigParser{}
}
// ....省略其他对象的实现