// 定義一個結(jié)構(gòu)體Singleton，用于存儲單例的實例數(shù)據(jù)
type singleton struct {
 value string // 這里可以存儲單例對象的任何數(shù)據(jù)
}

// 定義一個全局變量instance，用于存儲單例的實例
var instance *singleton

// getInstance函數(shù)用于獲取單例的實例
// 如果instance為nil，則創(chuàng)建一個新的singleton實例
// 否則，返回已存在的實例
func getInstance() *singleton {
 if instance == nil {
     instance = &singleton{value: "unique instance"} // 這里初始化singleton實例
 }
 return instance // 返回單例的實例
}

func main() {
 // 獲取單例的實例
 singletonInstance := getInstance()
 fmt.Println(singletonInstance.value) // 輸出: unique instance

 // 再次獲取單例的實例，將返回相同的實例
 anotherInstance := getInstance()
 if singletonInstance == anotherInstance {
     fmt.Println("Both instances are the same") // 輸出: Both instances are the same
 }
}

// 定義一個結(jié)構(gòu)體Singleton，用于存儲單例的實例數(shù)據(jù)
type singleton struct {
    value string // 這里可以存儲單例對象的任何數(shù)據(jù)
}

// 定義一個Once對象，用于確保初始化操作只執(zhí)行一次
var once sync.Once

// 定義一個全局變量instance，用于存儲單例的實例
var instance *singleton

// 初始化函數(shù)，由Once.Do調(diào)用
func initSingleton() {
    instance = &singleton{value: "unique instance"} // 這里初始化singleton實例
}

// getInstance函數(shù)用于獲取單例的實例
func getInstance() *singleton {
    // 執(zhí)行initSingleton，確保instance只被初始化一次
    once.Do(initSingleton)
    return instance // 返回單例的實例
}

func main() {
    // 獲取單例的實例
    singletonInstance := getInstance()
    fmt.Println(singletonInstance.value) // 輸出: unique instance

    // 再次獲取單例的實例，將返回相同的實例
    anotherInstance := getInstance()
    if singletonInstance == anotherInstance {
        fmt.Println("Both instances are the same") // 輸出: Both instances are the same
    }
    
    // 測試并發(fā)環(huán)境下的單例模式
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            singletonInstance := getInstance()
            fmt.Println(singletonInstance.value)
        }()
    }
    wg.Wait()
}

// 定義一個接口Product，它聲明了所有具體產(chǎn)品對象必須實現(xiàn)的操作
type Product interface {
 operation() // 產(chǎn)品對象的操作
}

// 定義具體產(chǎn)品ConcreteProductA，實現(xiàn)了Product接口
type ConcreteProductA struct{}
func (p *ConcreteProductA) operation() {
 fmt.Println("Operation of ConcreteProductA")
}

// 定義另一個具體產(chǎn)品ConcreteProductB，也實現(xiàn)了Product接口
type ConcreteProductB struct{}
func (p *ConcreteProductB) operation() {
 fmt.Println("Operation of ConcreteProductB")
}

// 定義一個抽象工廠Creator，它聲明了工廠方法factoryMethod，用于創(chuàng)建產(chǎn)品對象
type Creator interface {
 factoryMethod() Product // 工廠方法，用于創(chuàng)建產(chǎn)品對象
}

// 定義具體工廠CreatorA，實現(xiàn)了Creator接口
type CreatorA struct{}
func (c *CreatorA) factoryMethod() Product {
 return &ConcreteProductA{} // 具體工廠CreatorA返回ConcreteProductA的實例
}

// 定義另一個具體工廠CreatorB，也實現(xiàn)了Creator接口
type CreatorB struct{}
func (c *CreatorB) factoryMethod() Product {
 return &ConcreteProductB{} // 具體工廠CreatorB返回ConcreteProductB的實例
}

func main() {
 // 創(chuàng)建具體工廠CreatorA的實例
 creatorA := &CreatorA{}
 productA := creatorA.factoryMethod()
 productA.operation() // 調(diào)用產(chǎn)品A的操作

 // 創(chuàng)建具體工廠CreatorB的實例
 creatorB := &CreatorB{}
 productB := creatorB.factoryMethod()
 productB.operation() // 調(diào)用產(chǎn)品B的操作
}

// 定義Observer接口，它聲明了觀察者需要實現(xiàn)的Update方法
type Observer interface {
 Update(string) // 當主題狀態(tài)改變時，此方法會被調(diào)用
}

// 定義Subject結(jié)構(gòu)體，它包含一個觀察者列表和方法來添加或通知觀察者
type Subject struct {
 observers []Observer // 存儲觀察者的列表
}

// Attach方法用于將一個觀察者添加到觀察者列表中
func (s *Subject) Attach(observer Observer) {
 s.observers = append(s.observers, observer)
}

// Notify方法用于通知所有觀察者主題狀態(tài)的改變
func (s *Subject) Notify(message string) {
 for _, observer := range s.observers {
     observer.Update(message) // 調(diào)用每個觀察者的Update方法
 }
}

// 定義一個具體觀察者ConcreteObserver，它實現(xiàn)了Observer接口
type ConcreteObserverA struct {
 name string
}

// 實現(xiàn)Observer接口的Update方法
func (c *ConcreteObserverA) Update(message string) {
 fmt.Printf("%s received message: %s\n", c.name, message)
}

func main() {
 // 創(chuàng)建主題對象
 subject := &Subject{}

 // 創(chuàng)建具體觀察者對象
 observerA := &ConcreteObserverA{name: "Observer A"}

 // 將觀察者添加到主題的觀察者列表中
 subject.Attach(observerA)

 // 當主題狀態(tài)改變時，通知所有觀察者
 subject.Notify("State changed to State 1")
}

// 定義Component接口，它是所有組件和裝飾者的基類
type Component interface {
 operation() // 組件執(zhí)行的操作
}

// 定義具體組件ConcreteComponent，實現(xiàn)了Component接口
type ConcreteComponent struct{}
func (c *ConcreteComponent) operation() {
 fmt.Println("ConcreteComponent: performing basic operation")
}

// 定義Decorator抽象結(jié)構(gòu)體，它包含一個Component接口類型的字段
type Decorator struct {
 component Component // 用于組合Component接口
}

// 實現(xiàn)Decorator的operation方法，調(diào)用其Component的operation方法
func (d *Decorator) operation() {
 if d.component != nil {
     d.component.operation() // 調(diào)用被裝飾者的operation
 }
}

// 定義具體裝飾者ConcreteDecoratorA，它嵌入了Decorator結(jié)構(gòu)體
type ConcreteDecoratorA struct {
 Decorator // 繼承Decorator，實現(xiàn)裝飾功能
}

// 為ConcreteDecoratorA實現(xiàn)operation方法，添加額外的職責
func (cda *ConcreteDecoratorA) operation() {
 cda.Decorator.operation() // 首先調(diào)用被裝飾者的operation
 fmt.Println("ConcreteDecoratorA: added additional responsibilities")
}

func main() {
 // 創(chuàng)建具體組件
 component := &ConcreteComponent{}

 // 創(chuàng)建裝飾者并關聯(lián)具體組件
 decoratorA := &ConcreteDecoratorA{Decorator{component}}

 // 執(zhí)行裝飾后的組件操作
 decoratorA.operation()
}

// 定義Strategy接口，它聲明了所有具體策略必須實現(xiàn)的algorithm方法
type Strategy interface {
 algorithm() // 策略的算法方法
}

// 定義具體策略ConcreteStrategyA，實現(xiàn)了Strategy接口
type ConcreteStrategyA struct{}
func (c *ConcreteStrategyA) algorithm() {
 fmt.Println("Executing Algorithm A")
}

// 定義另一個具體策略ConcreteStrategyB，也實現(xiàn)了Strategy接口
type ConcreteStrategyB struct{}
func (c *ConcreteStrategyB) algorithm() {
 fmt.Println("Executing Algorithm B")
}

// 定義Context結(jié)構(gòu)體，它包含一個Strategy接口類型的字段
type Context struct {
 strategy Strategy // 用于存儲當前使用的策略
}

// 執(zhí)行策略的方法，通過Context中的strategy字段調(diào)用algorithm方法
func (c *Context) executeStrategy() {
 c.strategy.algorithm() // 執(zhí)行當前策略的算法
}

func main() {
 // 創(chuàng)建Context對象
 context := &Context{}

 // 創(chuàng)建具體策略對象
 strategyA := &ConcreteStrategyA{}
 strategyB := &ConcreteStrategyB{}

 // 將Context的策略設置為策略A
 context.strategy = strategyA
 context.executeStrategy() // 輸出: Executing Algorithm A

 // 更換策略為策略B
 context.strategy = strategyB
 context.executeStrategy() // 輸出: Executing Algorithm B
}

// 定義Target接口，表示客戶端使用的特定領域相關的接口
type Target interface {
 request() // 客戶端期望調(diào)用的方法
}

// 定義一個已經(jīng)存在的類Adaptee，它有自己的接口
type Adaptee struct{}
func (a *Adaptee) specificRequest() {
 fmt.Println("Adaptee performs a specific request")
}

// 定義Adapter結(jié)構(gòu)體，它作為Target接口和Adaptee類之間的橋梁
type Adapter struct {
 adaptee *Adaptee // 引用Adaptee對象
}

// Adapter實現(xiàn)了Target接口的request方法
// 該方法內(nèi)部委托給Adaptee的specificRequest方法
func (a *Adapter) request() {
 if a.adaptee != nil {
     a.adaptee.specificRequest() // 委托調(diào)用Adaptee的方法
 }
}

func main() {
 // 創(chuàng)建Adaptee對象
 adaptee := &Adaptee{}

 // 創(chuàng)建Adapter對象，并注入Adaptee對象
 adapter := &Adapter{adaptee: adaptee}

 // 客戶端使用Target接口，這里通過Adapter實現(xiàn)
 var target Target = adapter
 target.request() // 通過Adapter調(diào)用Adaptee的方法
}

// 定義一個Subject接口，它聲明了真實主題和代理主題共有的接口。
type Subject interface {
 request() // 聲明一個請求方法，真實主題和代理主題都會實現(xiàn)這個方法。
}

// RealSubject 結(jié)構(gòu)體實現(xiàn)了 Subject 接口，代表真實主題。
type RealSubject struct{}

// RealSubject 的 request 方法實現(xiàn)了 Subject 接口的 request 方法，用于執(zhí)行實際的操作。
func (r *RealSubject) request() {
 fmt.Println("Real Subject") // 打印 "Real Subject" 表示真實主題正在被調(diào)用。
}

// Proxy 結(jié)構(gòu)體包含一個指向 RealSubject 的指針，它作為代理主題。
type Proxy struct {
 realSubject *RealSubject // 代理主題包含一個對真實主題的引用，初始為 nil。
}

// Proxy 的 request 方法實現(xiàn)了 Subject 接口的 request 方法。
// 這個方法首先檢查 realSubject 是否為 nil，如果是，則創(chuàng)建 RealSubject 的實例。
// 然后，調(diào)用 realSubject 的 request 方法，從而間接地實現(xiàn)了 Subject 接口的 request 方法。
func (p *Proxy) request() {
 if p.realSubject == nil { // 如果 realSubject 為 nil，說明還沒有創(chuàng)建真實主題的實例。
     p.realSubject = &RealSubject{} // 創(chuàng)建 RealSubject 的實例，并賦值給 realSubject。
 }
 p.realSubject.request() // 調(diào)用真實主題的 request 方法。
}

// 定義Command接口，它聲明了所有具體命令必須實現(xiàn)的Execute方法
type Command interface {
    Execute() // 執(zhí)行命令的方法
}

// 定義Receiver結(jié)構(gòu)體，它將執(zhí)行命令的實際請求
type Receiver struct{}
func (r *Receiver) Action() {
    fmt.Println("Receiver: Action")
}

// 定義ConcreteCommand結(jié)構(gòu)體，它實現(xiàn)了Command接口
// 每個具體命令都包含一個Receiver的引用，表示請求的接收者
type ConcreteCommand struct {
    receiver *Receiver // 命令執(zhí)行的接收者
}

// ConcreteCommand實現(xiàn)Command接口的Execute方法
// 該方法調(diào)用Receiver的Action方法來執(zhí)行請求
func (c *ConcreteCommand) Execute() {
    c.receiver.Action() // 執(zhí)行請求
}

// 定義Invoker結(jié)構(gòu)體，它負責調(diào)用命令對象的Execute方法
type Invoker struct {
    command Command // 存儲命令對象
}

// 調(diào)用命令對象的Execute方法
func (i *Invoker) Invoke() {
    i.command.Execute() // 執(zhí)行命令
}

func main() {
    // 創(chuàng)建接收者對象
    receiver := &Receiver{}

    // 創(chuàng)建具體命令對象，并注入接收者
    command := &ConcreteCommand{receiver: receiver}

    // 創(chuàng)建調(diào)用者對象，并注入具體命令對象
    invoker := &Invoker{command: command}

    // 調(diào)用者執(zhí)行命令
    invoker.Invoke() // 輸出: Receiver: Action
}

// 定義Component接口，作為組合中對象的一致性協(xié)議
type Component interface {
 Operation() // 執(zhí)行操作的方法
 Add(Component)    // 向組合中添加子節(jié)點的方法
 Remove(Component) // 從組合中移除子節(jié)點的方法
 GetChild(int) Component // 根據(jù)索引獲取子節(jié)點的方法
}

// 定義Leaf結(jié)構(gòu)體，表示組合中的葉節(jié)點
type Leaf struct {
 name string
}

// Leaf實現(xiàn)Component接口的Operation方法
func (l *Leaf) Operation() {
 fmt.Println("Leaf:", l.name)
}

// Leaf實現(xiàn)Component接口的Add方法，葉節(jié)點不能有子節(jié)點，因此這里可以不實現(xiàn)或拋出錯誤
func (l *Leaf) Add(c Component) {
 fmt.Println("Cannot add to a leaf")
}

// Leaf實現(xiàn)Component接口的Remove方法，葉節(jié)點不能有子節(jié)點，因此這里可以不實現(xiàn)或拋出錯誤
func (l *Leaf) Remove(c Component) {
 fmt.Println("Cannot remove from a leaf")
}

// Leaf實現(xiàn)Component接口的GetChild方法，葉節(jié)點沒有子節(jié)點，因此這里返回nil
func (l *Leaf) GetChild(i int) Component {
 return nil
}

// 定義Composite結(jié)構(gòu)體，表示組合中的容器節(jié)點
type Composite struct {
 name     string
 Children []Component // 存儲子節(jié)點的列表
}

// Composite實現(xiàn)Component接口的Operation方法
func (c *Composite) Operation() {
 fmt.Println("Composite:", c.name)
 for _, child := range c.Children {
     child.Operation() // 遞歸調(diào)用子節(jié)點的Operation方法
 }
}

// Composite實現(xiàn)Component接口的Add方法，向Children列表中添加子節(jié)點
func (c *Composite) Add(component Component) {
 c.Children = append(c.Children, component)
}

// Composite實現(xiàn)Component接口的Remove方法，從Children列表中移除子節(jié)點
func (c *Composite) Remove(component Component) {
 for i, child := range c.Children {
     if child == component {
         c.Children = append(c.Children[:i], c.Children[i+1:]...)
         break
     }
 }
}

// Composite實現(xiàn)Component接口的GetChild方法，根據(jù)索引獲取子節(jié)點
func (c *Composite) GetChild(i int) Component {
 if i < 0 || i >= len(c.Children) {
     return nil // 索引超出范圍，返回nil
 }
 return c.Children[i]
}

func main() {
 // 創(chuàng)建葉節(jié)點
 leafA := &Leaf{name: "Leaf A"}
 leafB := &Leaf{name: "Leaf B"}

 // 創(chuàng)建組合節(jié)點
 composite := &Composite{name: "Composite Root"}
 composite.Add(leafA) // 向組合中添加葉節(jié)點A
 composite.Add(leafB) // 向組合中添加葉節(jié)點B

 // 執(zhí)行組合節(jié)點的操作
 composite.Operation()
}

// 定義Iterator接口，它聲明了迭代器必須實現(xiàn)的Next和Current方法
type Iterator interface {
 Next() bool   // 移動到下一個元素，并返回是否成功移動
 Current() interface{} // 返回當前元素
}

// 定義ConcreteIterator結(jié)構(gòu)體，它實現(xiàn)了Iterator接口
type ConcreteIterator struct {
 items []string   // 存儲聚合對象的元素列表
 index int        // 當前迭代到的元素索引
}

// Next方法實現(xiàn)，用于移動到下一個元素
func (c *ConcreteIterator) Next() bool {
 if c.index < len(c.items) {
     c.index++ // 索引遞增
     return true
 }
 return false // 如果索引超出范圍，返回false
}

// Current方法實現(xiàn)，用于返回當前元素
func (c *ConcreteIterator) Current() interface{} {
 if c.index > 0 && c.index <= len(c.items) {
     return c.items[c.index-1] // 返回當前索引的元素
 }
 return nil // 如果索引不在范圍內(nèi)，返回nil
}

// 定義Aggregate接口，表示聚合對象，它將負責創(chuàng)建迭代器
type Aggregate interface {
 CreateIterator() Iterator // 創(chuàng)建并返回迭代器
}

// 定義ConcreteAggregate結(jié)構(gòu)體，它實現(xiàn)了Aggregate接口
type ConcreteAggregate struct {
 items []string // 聚合對象存儲的元素列表
}

// CreateIterator方法實現(xiàn)，用于創(chuàng)建并返回一個迭代器
func (a *ConcreteAggregate) CreateIterator() Iterator {
 return &ConcreteIterator{items: a.items, index: 0} // 返回一個新的迭代器實例
}

func main() {
 // 創(chuàng)建聚合對象并添加元素
 aggregate := &ConcreteAggregate{items: []string{"Item1", "Item2", "Item3"}}

 // 使用聚合對象創(chuàng)建迭代器
 iterator := aggregate.CreateIterator()

 // 使用迭代器遍歷聚合對象中的所有元素
 for iterator.Next() {
     fmt.Println(iterator.Current())
 }
}