目录:
- 举个栗子
- 概念介绍
- 使用场景
1.举个栗子
类图
```
@startuml
'https://plantuml.com/class-diagram
class Elephant {
String name
String getName()
}
interface Container {
List<Elephant> elephants
void add(Elephant elephants)
}
class Refrigerator {
List<Elephant> elephants;
void add(Elephant elephants);
}
class Bowl {
List<Elephant> elephants
void add(Elephant elephants)
}
class Box {
List<Elephant> elephants
void add(Elephant elephants)
}
Container <|- Refrigerator
Container <|- Bowl
Container <|- Box
class ContainerFactory {
Container getInstance(String containerType)
}
class ContainerCounter {
Container container
void countTotalNum()
}
class Main {
void main();
}
@enduml
```
2.概念介绍
创建一个中间件来分离创建对象和使用对象的逻辑
优点:
将创建对象的逻辑放在一起
扩展新的相同行为的对象无需修改使用者的逻辑
封装复杂的对象创建逻辑
缺点:
多了一个工厂类
3.使用场景
main.go
```
package main
import (
"dbTest/Builder/factory/container/containerFactory"
"dbTest/Builder/factory/containerCounter"
"dbTest/Builder/factory/elephant"
"fmt"
"time"
)
func main() {
fmt.Println("start add elephant")
elephants := elephant.Elephant{
"rampage",
}
var containerType string
containerType = "refrigerator"
Contains := containerFactory.GetInstance(containerType)
Contains.AddElephant(elephants)
containerCount := containerCounter.ContainerCounter{}
for i := 0; i < 10; i++ {
go containerCount.CounterNum(Contains)
}
time.Sleep(time.Second)
fmt.Println("we are finished, nums:",Contains.GetTotalNum())
}
```
elephat.go
```
package elephant
type Elephant struct {
Name string
}
func (e Elephant) getName() string {
return e.Name
}
```
containerCounter.go
```
package containerCounter
import (
"dbTest/Builder/factory/container/containerInterface"
"fmt"
)
type ContainerCounter struct {
}
func (rc ContainerCounter) CounterNum(container containerInterface.Container) {
fmt.Println("ContainerCounter:",container.GetTotalNum())
return
}
```
containerFactory.go
```
package containerFactory
import (
"dbTest/Builder/factory/container/bowl"
"dbTest/Builder/factory/container/box"
"dbTest/Builder/factory/container/containerInterface"
"dbTest/Builder/factory/container/refrigerator"
)
func GetInstance(containerType string) containerInterface.Container{
switch containerType {
case "bowl":
return &bowl.Bowl{}
case "box":
return &box.Box{}
case "refrigerator":
return &refrigerator.Refrigerator{}
}
return nil
}
```
container.go
```
package containerInterface
import "dbTest/Builder/factory/elephant"
type Container interface {
AddElephant(elephant elephant.Elephant)
GetTotalNum() int
}
```
refrigerator.go
```
package refrigerator
import (
"dbTest/Builder/factory/elephant"
)
// 1、设计为小写字母开头,表示只在network包内可见,限制客户端程序的实例化
type Refrigerator struct {
elephants []elephant.Elephant
}
func (r *Refrigerator) AddElephant(elephants elephant.Elephant) {
r.elephants = append(r.elephants, elephants)
}
func (r *Refrigerator) GetTotalNum() int {
return len(r.elephants)
}
```
box.go
```
package box
import "dbTest/Builder/factory/elephant"
// 1、设计为小写字母开头,表示只在network包内可见,限制客户端程序的实例化
type Box struct {
elephants []elephant.Elephant
}
func (r *Box) AddElephant(elephants elephant.Elephant) {
r.elephants = append(r.elephants, elephants)
}
func (r *Box) GetTotalNum() int {
return len(r.elephants)
}
```
bowl.go
```
package bowl
import "dbTest/Builder/factory/elephant"
// 1、设计为小写字母开头,表示只在network包内可见,限制客户端程序的实例化
type Bowl struct {
elephants []elephant.Elephant
}
func (r *Bowl) AddElephant(elephants elephant.Elephant) {
r.elephants = append(r.elephants, elephants)
}
func (r *Bowl) GetTotalNum() int {
return len(r.elephants)
}
```