golang设计模式

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
}

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
}

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)
}

// 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{}
}

// 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
}

// 工厂接口和产品接口
 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{}
  }