golang设计模式

1.单例模式

package singleton

import "sync"

//Singleton 是单例模式类
type Singleton struct{}

var singleton *Singleton
var once sync.Once

//GetInstance 用于获取单例模式对象
func GetInstance() *Singleton {
    once.Do(func() {
        singleton = &Singleton{}
    })

    return singleton
}

2.装饰模式

• 装饰模式用于动态地给一个对象增加一些额外的职责，就增加对象功 能来说，装饰模式比生成子类实现更为灵活。它是一种对象结构型模 式。
• 装饰模式包含四个角色：抽象构件定义了对象的接口，可以给这些对 象动态增加职责（方法）；具体构件定义了具体的构件对象，实现了 在抽象构件中声明的方法，装饰器可以给它增加额外的职责（方法）； 抽象装饰类是抽象构件类的子类，用于给具体构件增加职责，但是具 体职责在其子类中实现；具体装饰类是抽象装饰类的子类，负责向构 件添加新的职责。
• 使用装饰模式来实现扩展比继承更加灵活，它以对客户透明的方式动 态地给一个对象附加更多的责任。装饰模式可以在不需要创造更多子 类的情况下，将对象的功能加以扩展。
• 装饰模式的主要优点在于可以提供比继承更多的灵活性，可以通过一种动态的 方式来扩展一个对象的功能，并通过使用不同的具体装饰类以及这些装饰类的 排列组合，可以创造出很多不同行为的组合，而且具体构件类与具体装饰类可 以独立变化，用户可以根据需要增加新的具体构件类和具体装饰类；其主要缺 点在于使用装饰模式进行系统设计时将产生很多小对象，而且装饰模式比继承 更加易于出错，排错也很困难，对于多次装饰的对象，调试时寻找错误可能需 要逐级排查，较为烦琐。
• 装饰模式适用情况包括：在不影响其他对象的情况下，以动态、透明的方式给 单个对象添加职责；需要动态地给一个对象增加功能，这些功能也可以动态地 被撤销；当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展 和维护时。

3.代理模式

package proxy

type 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
", r.name, s.context)
}

5.工厂模式

Simple Factory Pattern（简单工厂模式）

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

// AB interface
type 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{}
  }