创建型模式

package singleton
 
import "sync"
 
//Singleton 是单例模式类
type Singleton struct{}
 
var (
    singleton *Singleton
    once sync.Once
)
 
//GetInstance 用于获取单例模式对象
func GetInstance() *Singleton {
	once.Do(func() {
		singleton = &Singleton{}
	})
 
	return singleton
}

type Once struct {
    // done indicates whether the action has been performed.
    // It is first in the struct because it is used in the hot path.
    // The hot path is inlined at every call site.
    // Placing done first allows more compact instructions on some architectures (amd64/x86),
    // and fewer instructions (to calculate offset) on other architectures.
    done uint32    // 调用标识符，Once对象初始化时，done值默认为0，Do方法被调用后变为1
    m    Mutex     // 初始化竞态控制，在第一次调用Once.Do()方法时，会通过m加锁,
                    // 保证在第一个Do()方法中的参数f()函数还未执行完毕时,
                    // 其他此时调用Do()方法会被阻塞（不返回也不执行）
}
 
func (o *Once) Do(f func()) {
    // Do()方法的入参是一个无参数输入与返回的函数
    // Note: Here is an incorrect implementation of Do:
    //
    //  if atomic.CompareAndSwapUint32(&o.done, 0, 1) {
    //      f()
    //  }
    //
    // Do guarantees that when it returns, f has finished.
    // This implementation would not implement that guarantee:
    // given two simultaneous calls, the winner of the cas would
    // call f, and the second would return immediately, without
    // waiting for the first's call to f to complete.
    // This is why the slow path falls back to a mutex, and why
    // the atomic.StoreUint32 must be delayed until after f returns.
    // 下面这个if中原子读取o.done的值并判断，是为了保证其他调用会先阻塞，而不是直接退出
    // 如果其他调用直接退出了，但是单例还没有初始化，就会有异常了  
    if atomic.LoadUint32(&o.done) == 0 {    // 当o.done值为0时，执行doSlow()方法
        // Outlined slow-path to allow inlining of the fast-path.
        o.doSlow(f)
    }
    // 当o.done值为1则退出Do()方法
}
 
func (o *Once) doSlow(f func()) {
    o.m.Lock()  // 加锁
    defer o.m.Unlock()  // 方法退出时释放锁
    if o.done == 0 {    // 再次检查o.done值
        defer atomic.StoreUint32(&o.done, 1)    // 原子操作将o.done值置为1
        f() // 执行传入的函数
    }
}

package simplefactory
 
//NewAPI return Api instance by type
func NewAPI(t int) API {
    if t == 1 {
        return &hiAPI{}
    } else if t == 2 {
        return &helloAPI{}
    }
    return nil
}

package simplefactory
 
//API is interface
type API interface {
    Say(name string) string
}

package simplefactory
 
import "fmt"
 
//hiAPI is one of API implement
type hiAPI struct{}
 
//Say hi to name
func (*hiAPI) Say(name string) string {
    return fmt.Sprintf("Hi, %s", name)
}
 
//HelloAPI is another API implement
type helloAPI struct{}
 
//Say hello to name
func (*helloAPI) Say(name string) string {
    return fmt.Sprintf("Hello, %s", name)
}

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

package factoryMethod
 
type OperatorBase struct {
    a, b int
}
 
func (o *OperatorBase) SetA(i int) {
    o.a = i
}
 
func (o *OperatorBase) SetB(i int) {
    o.b = i
}
 
//PlusOperator Operator 的实际加法实现
type PlusOperator struct {
    *OperatorBase
}
 
//Result 获取结果
func (p PlusOperator) Result() int {
    return p.a + p.b
}
 
//MinusOperator Operator 的实际减法实现
type MinusOperator struct {
    *OperatorBase
}
 
//Result 获取结果
func (m MinusOperator) Result() int {
    return m.a - m.b
}

package factoryMethod
 
//OperatorFactory 是工厂接口
type OperatorFactory interface {
    Create() Operator
}

package factoryMethod
 
//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{},
    }
}

package abstractFactory
 
// DAOFactory DAO抽象模式工厂接口
type DAOFactory interface {
    CreateOrderMainDAO() OrderMainDAO
    CreateOrderDetailDAO() OrderDetailDAO
}

package abstractFactory
 
type RDBDAOFactory struct {
}
 
func (R *RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {
    return &RDBMainDAO{}
}
 
func (R *RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
    return &RDBDetailDAO{}
}
 
type XMLDAOFactory struct {
}
 
func (X *XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {
    return &XMLMainDAO{}
}
 
func (X *XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
    return &XMLDetailDAO{}
}

package abstractFactory
 
// OrderMainDAO 为订单主记录
type OrderMainDAO interface {
    SaveOrderMain()
}
 
// OrderDetailDAO 为订单详情纪录
type OrderDetailDAO interface {
    SaveOrderDetail()
}

package abstractFactory
 
import "fmt"
 
// RDBMainDAP 为关系型数据库的OrderMainDAO实现
type RDBMainDAO struct {
}
 
// SaveOrderMain ...
func (R *RDBMainDAO) SaveOrderMain() {
    fmt.Print("rdb main save\n")
}
 
// RDBDetailDAO 为关系型数据库的OrderDetailDAO实现
type RDBDetailDAO struct {
}
 
// SaveOrderDetail ...
func (R *RDBDetailDAO) SaveOrderDetail() {
    fmt.Print("rdb detail save\n")
}
 
// XMLMainDAO XML存储
type XMLMainDAO struct{}
 
// SaveOrderMain ...
func (*XMLMainDAO) SaveOrderMain() {
    fmt.Print("xml main save\n")
}
 
// XMLDetailDAO XML存储
type XMLDetailDAO struct{}
 
// SaveOrderDetail ...
func (*XMLDetailDAO) SaveOrderDetail() {
    fmt.Print("xml detail save")
}