golang设计模式

1.单例模式

package singletonimport \"sync\"

//Singleton 是单例模式类type Singleton struct{}var singleton *Singletonvar once sync.Once

//GetInstance ⽤于获取单例模式对象func GetInstance() *Singleton { once.Do(func() {

singleton = &Singleton{} })

return singleton}

2.装饰模式

装饰模式⽤于动态地给⼀个对象增加⼀些额外的职责，就增加对象功 能来说，装饰模式⽐⽣成⼦类实现更为灵活。它是⼀种对象结构型模 式。

装饰模式包含四个⾓⾊：抽象构件定义了对象的接⼝，可以给这些对 象动态增加职责（⽅法）；具体构件定义了具体的构件对象，实现了 在抽象构件中声明的⽅法，装饰器可以给它增加额外的职责（⽅法）； 抽象装饰类是抽象构件类的⼦类，⽤于给具体构件增加职责，但是具 体职责在其⼦类中实现；具体装饰类是抽象装饰类的⼦类，负责向构 件添加新的职责。

使⽤装饰模式来实现扩展⽐继承更加灵活，它以对客户透明的⽅式动 态地给⼀个对象附加更多的责任。装饰模式可以在不需要创造更多⼦ 类的情况下，将对象的功能加以扩展。

装饰模式的主要优点在于可以提供⽐继承更多的灵活性，可以通过⼀种动态的 ⽅式来扩展⼀个对象的功能，并通过使⽤不同的具体装饰类以及这些装饰类的 排列组合，可以创造出很多不同⾏为的组合，⽽且具体构件类与具体装饰类可 以独⽴变化，⽤户可以根据需要增加新的具体构件类和具体装饰类；其主要缺 点在于使⽤装饰模式进⾏系统设计时将产⽣很多⼩对象，⽽且装饰模式⽐继承 更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需 要逐级排查，较为烦琐。

装饰模式适⽤情况包括：在不影响其他对象的情况下，以动态、透明的⽅式给 单个对象添加职责；需要动态地给⼀个对象增加功能，这些功能也可以动态地 被撤销；当不能采⽤继承的⽅式对系统进⾏扩充或者采⽤继承不利于系统扩展 和维护时。

3.代理模式

package proxytype Subject interface { Do() string}

type RealSubject struct{}func (RealSubject) Do() string { return \"real\"}

type Proxy struct { real RealSubject}

func (p Proxy) Do() string { var res string

// 在调⽤真实对象之前的⼯作，检查缓存，判断权限，实例化真实对象等。。 res += \"pre:\" // 调⽤真实对象 res += p.real.Do()

// 调⽤之后的操作，如缓存结果，对结果进⾏处理等。。 res += \":after\" return res}

4.观察者模式

package observer

import \"fmt\"

type Subject struct { observers []Observer context string}

func NewSubject() *Subject { return &Subject{

observers: make([]Observer, 0), }}

func (s *Subject) Attach(o Observer) { s.observers = append(s.observers, o)}

func (s *Subject) notify() {

for _, o := range s.observers { o.Update(s) }}

func (s *Subject) UpdateContext(context string) { s.context = context s.notify()}

type Observer interface { Update(*Subject)}

type Reader struct { name string}

func NewReader(name string) *Reader { return &Reader{ name: name, }}

func (r *Reader) Update(s *Subject) {

fmt.Printf(\"%s receive %s\\n\", r.name, s.context)}

5.⼯⼚模式

Simple Factory Pattern（简单⼯⼚模式）

在简单⼯⼚模式中，可以根据参数的不同返回不同类的实例。eg:

// AB interfacetype AB interface {

Say(name string) string}

// A .

type A struct{}

// Say .

func (*A) Say(name string) string {

return fmt.Sprintf(\"我是A实例, %s\", name)}

// B .

type B struct{}

// Say .

func (*B) Say(name string) string {

return fmt.Sprintf(\"我是B实例, %s\", name)}

// NewAB 根据参数不同返回不同实例func NewAB(t int) AB { if t == 1 { return &A{} }

return &B{}}

Factory Method Pattern ⼯⼚模式⽅法

在⼯⼚⽅法模式中，核⼼的⼯⼚类不再负责所有产品的创建，⽽是将具体创建⼯作交给⼦类去做。这个核⼼类仅仅负责给出具体⼯⼚必须实现的接⼝，⽽不负责产品类被实例化这种细节eg:

// Operator 是被封装的实际类接⼝type Operator interface { SetA(int) SetB(int) Result() int}

// OperatorFactory 是⼯⼚接⼝type OperatorFactory interface { Create() Operator}

// OperatorBase 是Operator 接⼝实现的基类，封装公⽤⽅法type OperatorBase struct { a, b int}

// SetA 设置 A

func (o *OperatorBase) SetA(a int) { o.a = a}

// SetB 设置 B

func (o *OperatorBase) SetB(b int) { o.b = b}

//MinusOperator Operator 的实际减法实现type MinusOperator struct { *OperatorBase}

// PlusOperator Operator 的实际加法实现type PlusOperator struct { *OperatorBase}

// PlusOperatorFactory 是 PlusOperator 的⼯⼚类type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator { return &PlusOperator{

OperatorBase: &OperatorBase{}, }}

// MinusOperatorFactory 是 MinusOperator 的⼯⼚类type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator { return &MinusOperator{

OperatorBase: &OperatorBase{}, }}

//Result 获取结果

func (o PlusOperator) Result() int { return o.a + o.b}

//Result 获取结果

func (o MinusOperator) Result() int { return o.a - o.b}

Abstract Factory 抽象⼯⼚模式

当系统所提供的⼯⼚所需⽣产的具体产品并不是⼀个简单的对象，⽽是多个位于不同产品等级结构中属于不同类型的具体产品时需要使⽤抽象⼯⼚模式。

抽象⼯⼚模式是所有形式的⼯⼚模式中最为抽象和最具⼀般性的⼀种形态。抽象⼯⼚模式与⼯⼚⽅法模式最⼤的区别在于，⼯⼚⽅法模式针对的是⼀个产品等级结构，⽽抽象⼯⼚模式则需要⾯对多个产品等级结构。

// ⼯⼚接⼝和产品接⼝

type FactoryInterface interface {

CreatePigMeatBuns() ProductInterface // 创建猪⾁馅产品

Create3SBuns() ProductInterface // 创建三鲜馅产品 }

type ProductInterface interface { Intro() }

// 实现4种产品

type GDPigMeatBuns struct { }

func (p GDPigMeatBuns) Intro() { fmt.Println(\"⼴东猪⾁馅包⼦\") } .....

// 实现⼯⼚ // 齐市包⼦铺

type QSFactory struct { }

func (qs QSFactory) CreatePigMeatBuns() ProductInterface { return QSPigMeatBuns{} }

func (qs QSFactory) Create3SBuns() ProductInterface { return QS3SBuns{} }

// ⼴东包⼦铺

type GDFactory struct { }

func (gd GDFactory) CreatePigMeatBuns() ProductInterface { return GDPigMeatBuns{} }

func (gd GDFactory) Create3SBuns() ProductInterface { return GD3SBuns{} }