创建型：工厂模式
睡不醒的鲤鱼 2022-10-16 Golang Go 进阶
工厂模式（Factory Pattern）是面向对象编程中的常用模式。在 Go 项目开发中，可以通过使用多种不同的工厂模式，来使代码更简洁明了。
# 一、简单工厂
简单工厂模式是最常用、最简单的。它就是一个接受一些参数，然后返回对应实例的函数。适用于每个对象的创建逻辑都比较简单的时候。
package simple_factory
import "fmt"
const TypeHi = 1
const TypeHello = 2
// API 接口定义
type API interface {
Say(name string) string
}
// NewAPI 根据类型返回 API 实例
func NewAPI(t int) API {
switch t {
case TypeHi:
return &hiAPI{}
case TypeHello:
return &helloAPI{}
}
return nil
}
type hiAPI struct{}
func (h *hiAPI) Say(name string) string {
return fmt.Sprintf("Hi, %s", name)
}
type helloAPI struct{}
func (h *helloAPI) Say(name string) string {
return fmt.Sprintf("Hello, %s", name)
}
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
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
# 二、工厂方法
在简单工厂模式中，依赖于唯一的工厂对象，如果我们需要实例化一个产品，就要向工厂中传入一个参数，获取对应的对象；如果要增加一种产品，就要在工厂中修改创建产品的函数。这会导致耦合性过高，这时我们就可以使用工厂方法模式。
在工厂方法模式中，依赖工厂函数，我们可以 通过实现工厂函数来创建多种工厂，将对象创建从由一个对象负责所有具体类的实例化，变成由一群子类来负责对具体类的实例化，从而将过程解耦。
下面是工厂方法模式的一个代码实现：
package factory_method
import "fmt"
const TypeHi = 1
const TypeHello = 2
// API 接口定义
type API interface {
Say(name string) string
}
// APIFactory 工厂方法接口定义
type APIFactory interface {
CreateAPI() API
}
// NewAPIFactory 用一个简单工厂封装工厂方法
func NewAPIFactory(t int) APIFactory {
switch t {
case TypeHi:
return &hiAPIFactory{}
case TypeHello:
return &helloAPIFactory{}
}
return nil
}
type hiAPIFactory struct{}
func (h *hiAPIFactory) CreateAPI() API {
return &hiAPI{}
}
type hiAPI struct{}
func (h *hiAPI) Say(name string) string {
return fmt.Sprintf("Hi, %s", name)
}
type helloAPIFactory struct{}
func (h *helloAPIFactory) CreateAPI() API {
return &helloAPI{}
}
type helloAPI struct{}
func (h *helloAPI) Say(name string) string {
return fmt.Sprintf("Hello, %s", name)
}
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
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
# 三、抽象工厂
抽象工厂模式用于生成产品族的工厂，所生成的对象是有关联的。如下面代码中，APIFactory 既可以创建 RestAPI，也可以创建 RpcAPI。
package abstract_factory
import "fmt"
const TypeHi = 1
// RestAPI 接口定义
type RestAPI interface {
Say(name string) string
}
// RpcAPI 接口定义
type RpcAPI interface {
Say(name string) string
}
// APIFactory 工厂方法接口定义
type APIFactory interface {
CreateRestAPI() RestAPI
CreateRpcAPI() RpcAPI
}
// NewAPIFactory 用一个简单工厂封装工厂方法
func NewAPIFactory(t int) APIFactory {
switch t {
case TypeHi:
return &hiAPIFactory{}
}
return nil
}
type hiAPIFactory struct{}
func (h *hiAPIFactory) CreateRestAPI() RestAPI {
return &hiRestAPI{}
}
func (h *hiAPIFactory) CreateRpcAPI() RpcAPI {
return &hiRpcAPI{}
}
type hiRestAPI struct{}
func (h *hiRestAPI) Say(name string) string {
return fmt.Sprintf("[REST] Hi, %s", name)
}
type hiRpcAPI struct{}
func (h *hiRpcAPI) Say(name string) string {
return fmt.Sprintf("[RPC] Hi, %s", name)
}
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
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