对象池模式
The object pool creational design pattern is used to prepare and keep multiple instances according to the demand expectation.
实例：
package main
import (
"fmt"
"strconv"
"time"
)
type Pool chan *Object
type Object struct {
name string
}
func New(total int) *Pool {
p := make(Pool, total)
for i := 0; i < total; i++ {
p <- &Object{name:strconv.Itoa(i)}
}
return &p
}
func main() {
p := New(2)
for {
select {
case obj := <- *p:
fmt.Println(obj.name)
//time.Sleep(2*time.Second)
*p <- obj
time.Sleep(1*time.Second)
//default:
// return
}
}
}
Builder Pattern 建造者模式
Builder pattern separates the construction of a complex object from its representation so that the same construction process can create different representations.
In Go, normally a configuration struct is used to achieve the same behavior, however passing a struct to the builder method fills the code with boilerplate if cfg.Field != nil {...} checks.
实例代码：
package main
import "fmt"
// 创建speed类型
type Speed float64
const (
MPH Speed = 1
KPH = 1.60934
)
// 创建颜色类型
type Color string
const (
BlueColor Color = "blue"
GreenColor = "green"
RedColor = "red"
)
// 创建轮胎类型
type Wheels string
const (
SportsWheels Wheels = "sports"
SteelWheels = "steel"
)
// 创建car需要的工序，最后通过build创建
type Builder interface {
Color(Color) Builder
Wheels(Wheels) Builder
TopSpeed(Speed) Builder // 创建属性
Build() Interface // 创建动作
}
// 返回的接口体具备如下方法
type Interface interface {
Drive() error
Stop() error
}
type Car struct {
Name string
Wheel Wheels
Speeds Speed
Colors Color
}
// 返回一个car实例的接口
func NewBuilder() Builder {
return &Car{ // 必须是指针，因为后面的函数都是使用指针，只有指针的Car才能调用所有实现了的方法
Name: "",
Wheel: "",
Speeds: 0,
Colors: "",
}
}
// Builder接口实现
func (p *Car) Color(color Color) Builder{
p.Colors = color
return p
}
func (p *Car) Wheels(Wheel Wheels) Builder{
p.Wheel = Wheel
return p
}
func (p *Car) TopSpeed(S Speed) Builder{
p.Speeds = S
return p
}
func (p *Car) Build() Interface {
return p
}
func (p *Car) Drive() error {
fmt.Println("I'm running...",p.Speeds,p.Speeds,p.Wheel,p.Colors)
return nil
}
func (p *Car) Stop() error {
fmt.Println("I'm stopping...",p.Name,p.Speeds,p.Wheel,p.Colors)
return nil
}
func main() {
// 通过链式编程来给实例的过程赋值属性和动作，需要注意的是，这些都是通过接口的方式进行约束，所以必须实现。
car := NewBuilder().Color(BlueColor).Wheels(SportsWheels).TopSpeed(MPH).Build()
car.Drive()
}
Factory Method Pattern 工厂化方法模式
Factory method creational design pattern allows creating objects without having to specify the exact type of the object that will be created. 工厂方法创建设计模式允许创建对象，而不必指定将要创建的对象的确切类型。根据不同的情况创建不同的对象方法
代码如下：
package main
import (
"bufio"
"fmt"
"strings"
)
type StorageType int
const (
MemoryStorage StorageType = 1 << iota
TempStorage
)
type Store interface {
Open(string) (error)
}
type MemoryStorages struct {
data string
}
func newMemoryStorage(s string) *MemoryStorages {
return &MemoryStorages{data: s}
}
func (p *MemoryStorages) Open(s string) error {
sr := strings.NewReader(p.data)
r := bufio.NewReader(sr)
line, _, err := r.ReadLine()
if err != nil {
return err
}
fmt.Println(string(line))
return nil
}
type TempStorageS struct {
data string
}
func newTempStorage(s string) *TempStorageS {
return &TempStorageS{data:s}
}
func (p *TempStorageS) Open(s string) error {
sr := strings.NewReader(p.data)
r := bufio.NewReader(sr)
line, _, err := r.ReadLine()
if err != nil {
return err
}
fmt.Println(line)
return nil
}
// 根据定义的类型，传入不同的参数创建不同的对象实现方法
func NewStore(t StorageType) Store {
switch t {
case MemoryStorage:
return newMemoryStorage("Memory\n....")
case TempStorage:
return newTempStorage("openfile")
default:
return newMemoryStorage("default\n....")
}
}
func main() {
memory := NewStore(1)
memory.Open("start")
}