1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package singleton

var instance *singleton

func init() {
    instance = &singleton{}
}

type singleton struct{}

func GetInstance() *singleton {
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package singleton

var instance *singleton

type singleton struct{}

func GetInstance() *singleton {
    if instance == nil {
        instance = &singleton{}
    }
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package singleton

import "sync"

var (
    instance *singleton
    mutex    sync.Mutex
)

type singleton struct{}

func GetInstance() *singleton {
    mutex.Lock() // 如果实例存在没有必要加锁
    defer mutex.Unlock()

    if instance == nil {
        instance = &singleton{}
    }
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package singleton

import "sync"

var (
    instance *singleton
    mutex    sync.Mutex
)

type singleton struct{}

func GetInstance() *singleton {
    if instance == nil { // // 不太完美 因为这里不是完全原子的
        mutex.Lock()
        defer mutex.Unlock()

        if instance == nil {
            instance = &singleton{}
        }
    }
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

package singleton

import "sync"
import "sync/atomic"

var (
    initialized uint32
    instance *singleton
    mutex    sync.Mutex
)

type singleton struct{}

func GetInstance() *singleton {
    if atomic.LoadUInt32(&initialized) == 1 {  // 原子操作 
        return instance
    }

    mu.Lock()
    defer mu.Unlock()

    if initialized == 0 {
         instance = &singleton{}
         atomic.StoreUint32(&initialized, 1)
    }

    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package sync

import (
    "sync/atomic"
)
// Once is an object that will perform exactly one action.
//
// A Once must not be copied after first use.
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/386),
    // and fewer instructions (to calculate offset) on other architectures.
    done uint32
    m    Mutex
}

// Do calls the function f if and only if Do is being called for the
// first time for this instance of Once. In other words, given
//  var once Once
// if once.Do(f) is called multiple times, only the first call will invoke f,
// even if f has a different value in each invocation. A new instance of
// Once is required for each function to execute.
//
// Do is intended for initialization that must be run exactly once. Since f
// is niladic, it may be necessary to use a function literal to capture the
// arguments to a function to be invoked by Do:
//  config.once.Do(func() { config.init(filename) })
//
// Because no call to Do returns until the one call to f returns, if f causes
// Do to be called, it will deadlock.
//
// If f panics, Do considers it to have returned; future calls of Do return
// without calling f.
//
func (o *Once) Do(f func()) {
    // 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 atomic.LoadUint32(&o.done) == 0 {
        // Outlined slow-path to allow inlining of the fast-path.
        o.doSlow(f)
    }
}

func (o *Once) doSlow(f func()) {
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        defer atomic.StoreUint32(&o.done, 1)
        f()
    }
}

1
2
3
4
5
6

var once sync.Once

once.Do(func() {
    // 在这里执行安全的初始化
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package singleton

import (
    "sync"
)

var (
    instance *singleton
    once     sync.Once
)

type singleton struct{}

func GetInstance() *singleton {
    once.Do(func() {
        instance = &singleton{}
    })
    return instance
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package main

import "fmt"

type Product interface {
    Use()
}

type ProductA struct{}

func (p *ProductA) Use() {
    fmt.Println("Using Product A")
}

type ProductB struct{}

func (p *ProductB) Use() {
    fmt.Println("Using Product B")
}

func CreateProduct(productType string) Product {
    switch productType {
    case "A":
        return &ProductA{}
    case "B":
        return &ProductB{}
    default:
        return nil
    }
}

func main() {
    productA := CreateProduct("A")
    productA.Use()

    productB := CreateProduct("B")
    productB.Use()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main

import "fmt"

type Database interface {
    Connect() string
}

type MySQL struct{}

func (m MySQL) Connect() string {
    return "Connected to MySQL"
}

type PostgreSQL struct{}

func (p PostgreSQL) Connect() string {
    return "Connected to PostgreSQL"
}

// DatabaseFactory工厂接口
type DatabaseFactory interface {
    CreateDatabase() Database
}

type MySQLFactory struct{}

func (m MySQLFactory) CreateDatabase() Database {
    return MySQL{}
}

type PostgreSQLFactory struct{}

func (p PostgreSQLFactory) CreateDatabase() Database {
    return PostgreSQL{}
}

func UseDatabaseFactory(factory DatabaseFactory) {
    db := factory.CreateDatabase()
    fmt.Println(db.Connect())
}

func main() {
    UseDatabaseFactory(&MySQLFactory{})
    UseDatabaseFactory(&PostgreSQLFactory{})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

package main

import "fmt"

// 抽象层：数据库连接接口
type DBConnention interface {
    Connect() string
}

// 抽象层：数据库命令接口
type DBCommand interface {
    Execute(query string) string
}

// 具体产品：MySQL连接
type MySQLConnection struct{}

func (m *MySQLConnection) Connect() string {
    return "Connected to MySQL"
}

// 具体产品：MySQL命令
type MySQLCommand struct{}

func (m *MySQLCommand) Execute(query string) string {
    return fmt.Sprintf("Executed MySQL query: %s", query)
}

// 具体产品：Postgres连接
type PostgresSQLConnection struct{}

func (p *PostgresSQLConnection) Connect() string {
    return "Connected to Postgres"
}

// 具体产品：PostgresSQL命令
type PostgresSQLCommand struct{}

func (p *PostgresSQLCommand) Execute(query string) string {
    return fmt.Sprintf("Executed PostgresSQL query: %s", query)
}

// 抽象工厂接口
type DBFactory interface {
    CreateConnection() DBConnention
    CreateCommand() DBCommand
}

// 具体的MySQL工厂
type MySQLFactory struct{}

func (m *MySQLFactory) CreateConnection() DBConnention {
    return &MySQLConnection{}
}

func (m *MySQLFactory) CreateCommand() DBCommand {
    return &MySQLCommand{}
}

// 具体的PostgresSQL工厂
type PostgresSQLFactory struct{}

func (p *PostgresSQLFactory) CreateConnection() DBConnention {
    return &PostgresSQLConnection{}
}

func (p *PostgresSQLFactory) CreateCommand() DBCommand {
    return &PostgresSQLCommand{}
}

func UseDatabase(factory DBFactory) {
    connection := factory.CreateConnection()
    command := factory.CreateCommand()

    fmt.Println(connection.Connect())
    fmt.Println(command.Execute("SELECT * FROM table"))
}

// 业务逻辑
func main() {
    UseDatabase(&MySQLFactory{})
    UseDatabase(&PostgresSQLFactory{})
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package main

import "fmt"

type House struct {
    Walls   string
    Roof    string
    Windows string
    Doors   string
}

func (h *House) Show() {
    fmt.Printf("House with %s walls, %s roof, %s windows, and %s doors\n",
        h.Walls, h.Roof, h.Windows, h.Doors)
}

// 建造者接口
type HouseBuilder interface {
    BuildWalls()
    BuildRoof()
    BuildWindows()
    BuildDoors()
    GetHouse() *House
}

// 具体建造者
type ConcreateHouseBuilder struct {
    house *House
}

// 返回一个空House
func NewConcreateHouseBuilder() *ConcreateHouseBuilder {
    return &ConcreateHouseBuilder{house: &House{}}
}

func (b *ConcreateHouseBuilder) BuildWalls() {
    b.house.Walls = "concrete"
}

func (b *ConcreateHouseBuilder) BuildRoof() {
    b.house.Roof = "tile"
}

func (b *ConcreateHouseBuilder) BuildWindows() {
    b.house.Windows = "glass"
}

func (b *ConcreateHouseBuilder) BuildDoors() {
    b.house.Doors = "wooden"
}

func (b *ConcreateHouseBuilder) GetHouse() *House {
    return b.house
}

// 指挥者
type Director struct {
    builder HouseBuilder
}

func NewDirector(builder HouseBuilder) *Director {
    return &Director{builder: builder}
}

func (d *Director) Construct() {
    d.builder.BuildWalls()
    d.builder.BuildRoof()
    d.builder.BuildWindows()
    d.builder.BuildDoors()
}

// 客户端代码
func main() {
    builder := NewConcreateHouseBuilder() // 常见具体构建者
    director := NewDirector(builder)      // 创建指挥者
    director.Construct()                  // 指挥者构建产品

    house := builder.GetHouse() // 获取最终产品
    house.Show()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

package main

import "fmt"

// 原型接口
type Prototype interface {
    Clone() Prototype
}

// 具体原型
type ConcretePrototype struct {
    Name string
    Age  int
}

func (p *ConcretePrototype) Clone() Prototype {
    // 创建一个新对象 并复制当前对象的属性
    return &ConcretePrototype{
        Name: p.Name,
        Age:  p.Age,
    }
}

func (p *ConcretePrototype) String() string {
    return fmt.Sprintf("Name: %s, Age: %d", p.Name, p.Age)
}

func main() {
    // 创建原型对象
    prototype := &ConcretePrototype{
        Name: "Tom",
        Age:  18,
    }

    // 克隆原型对象
    clone := prototype.Clone().(*ConcretePrototype)

    // 修改克隆对象属性
    clone.Name = "Jerry"
    clone.Age = 20

    // 输出原型对象和克隆对象
    fmt.Println("Prototype:", prototype)
    fmt.Println("Clone:", clone)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

package main

import "fmt"

type SubSystemA struct {}

func (sa *SubSystemA) MethodA() {
    fmt.Println("子系统方法A")
}

type SubSystemB struct {}

func (sb *SubSystemB) MethodB() {
    fmt.Println("子系统方法B")
}

type SubSystemC struct {}

func (sc *SubSystemC) MethodC() {
    fmt.Println("子系统方法C")
}

type SubSystemD struct {}

func (sd *SubSystemD) MethodD() {
    fmt.Println("子系统方法D")
}

// 外观模式 提供了一个外观类 简化成一个简单的接口供使用
type Facade struct {
    a *SubSystemA
    b *SubSystemB
    c *SubSystemC
    d *SubSystemD
}

func (f *Facade) MethodOne() {
    f.a.MethodA()
    f.b.MethodB()
}


func (f *Facade) MethodTwo() {
    f.c.MethodC()
    f.d.MethodD()
}

func main() {
    // 如果不用外观模式实现MethodA() 和 MethodB()
    sa := new(SubSystemA)
    sa.MethodA()
    sb := new(SubSystemB)
    sb.MethodB()

    fmt.Println("-----------")
    // 使用外观模式
    f := Facade{
        a: new(SubSystemA),
        b: new(SubSystemB),
        c: new(SubSystemC),
        d: new(SubSystemD),
    }

    // 调用外观包裹方法
    f.MethodOne()
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112

package main

import "fmt"

// 电视机
type TV struct {}

func (t *TV) On() {
    fmt.Println("打开 电视机")
}

func (t *TV) Off() {
    fmt.Println("关闭 电视机")
}


// 音箱
type VoiceBox struct {}

func (v *VoiceBox) On() {
    fmt.Println("打开 音箱")
}

func (v *VoiceBox) Off() {
    fmt.Println("关闭 音箱")
}

// 灯光
type Light struct {}

func (l *Light) On() {
    fmt.Println("打开 灯光")
}

func (l *Light) Off() {
    fmt.Println("关闭 灯光")
}


// 游戏机
type Xbox struct {}

func (x *Xbox) On() {
    fmt.Println("打开 游戏机")
}

func (x *Xbox) Off() {
    fmt.Println("关闭 游戏机")
}


// 麦克风
type MicroPhone struct {}

func (m *MicroPhone) On() {
    fmt.Println("打开 麦克风")
}

func (m *MicroPhone) Off() {
    fmt.Println("关闭 麦克风")
}

// 投影仪
type Projector struct {}

func (p *Projector) On() {
    fmt.Println("打开 投影仪")
}

func (p *Projector) Off() {
    fmt.Println("关闭 投影仪")
}


// 家庭影院(外观)
type HomePlayerFacade struct {
    tv TV
    vb VoiceBox
    light Light
    xbox Xbox
    mp MicroPhone
    pro Projector
}


// KTV模式
func (hp *HomePlayerFacade) DoKTV() {
    fmt.Println("家庭影院进入KTV模式")
    hp.tv.On()
    hp.pro.On()
    hp.mp.On()
    hp.light.Off()
    hp.vb.On()
}

// 游戏模式
func (hp *HomePlayerFacade) DoGame() {
    fmt.Println("家庭影院进入Game模式")
    hp.tv.On()
    hp.light.On()
    hp.xbox.On()
}

func main() {
    homePlayer := new(HomePlayerFacade)

    homePlayer.DoKTV()

    fmt.Println("------------")

    homePlayer.DoGame()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main

import "fmt"

// 适配的目标
type V5 interface {
    Use5V()
}

// 业务类 依赖V5接口
type Phone struct {
    v V5
}

func NewPhone(v V5) *Phone {
    return &Phone{v}
}

func (p *Phone) Charge() {
    fmt.Println("Phone进行充电...")
    p.v.Use5V()
}

// 被适配的角色 适配者
type V220 struct{}

func (v *V220) Use220V() {
    fmt.Println("使用220V的电压")
}

// 电源适配器
type Adapter struct {
    v220 *V220
}

func (a *Adapter) Use5V() {
    fmt.Println("使用适配器进行充电")

    // 调用适配者的方法
    a.v220.Use220V()
}

func NewAdapter(v220 *V220) *Adapter {
    return &Adapter{v220}
}

// ------- 业务逻辑层 -------
func main() {
    iphone := NewPhone(NewAdapter(new(V220)))

    iphone.Charge()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

package main

import (
    "fmt"
    "time"
)

// 主题接口
type Subject interface {
    Request()
}

// 真实对象
type RealSubject struct{}

func (r *RealSubject) Request() {
    fmt.Println("RealSubject: Handling Request")
}

// 代理对象
type Proxy struct {
    realSubject *RealSubject
}

func NewProxy() *Proxy {
    return &Proxy{}
}

func (p *Proxy) Request() {
    // 延迟初始化真实对象
    if p.realSubject == nil {
        fmt.Println("Proxy: Lazy Initialzing RealSubject")
        p.realSubject = &RealSubject{}
    }

    // 访问控制
    fmt.Println("Proxy: Checking Access")
    time.Sleep(time.Second) //  模拟访问控制逻辑

    // 调用真实对象的方法
    p.realSubject.Request()

    // 日志记录
    fmt.Println("Proxy: Logging Request")
}

func main() {
    proxy := NewProxy()

    // 通过代理对象访问真实对象
    proxy.Request()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

package main

import (
    "fmt"
)

// 组件接口：文件系统节点
type FileSystemNode interface {
    Display(indent string)
}

// 叶子节点：文件
type File struct {
    name string
}

func (f *File) Display(indent string) {
    fmt.Println(indent + f.name)
}

// 组合节点：文件夹
type Folder struct {
    name     string
    children []FileSystemNode
}

func (f *Folder) Display(indent string) {
    fmt.Println(indent + f.name)
    for _, child := range f.children {
        child.Display(indent + "  ")
    }
}

func (f *Folder) Add(child FileSystemNode) {
    f.children = append(f.children, child)
}

// 客户端代码
func main() {
    // 创建文件
    file1 := &File{name: "file1.txt"}
    file2 := &File{name: "file2.txt"}
    file3 := &File{name: "file3.txt"}

    // 创建文件夹
    folder1 := &Folder{name: "Folder1"}
    folder2 := &Folder{name: "Folder2"}

    // 将文件添加到文件夹
    folder1.Add(file1)
    folder1.Add(file2)
    folder2.Add(file3)

    // 将文件夹添加到另一个文件夹
    rootFolder := &Folder{name: "Root"}
    rootFolder.Add(folder1)
    rootFolder.Add(folder2)

    // 显示文件系统结构
    rootFolder.Display("")
}

/*
输出：
Root
  Folder1
    file1.txt
    file2.txt
  Folder2
    file3.txt
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

package main

import (
    "fmt"
    "sync"
)

// 享元接口：数据库连接
type Connection interface {
    Execute(query string)
}

// 具体享元：数据库连接对象
type ConcreteConnection struct {
    id int
}

func (c *ConcreteConnection) Execute(query string) {
    fmt.Printf("Connection %d executing query: %s\n", c.id, query)
}

// 享元工厂：连接池
type ConnectionPool struct {
    connections map[int]Connection
    mutex       sync.Mutex
    nextID      int
}

func NewConnectionPool() *ConnectionPool {
    return &ConnectionPool{
        connections: make(map[int]Connection),
        nextID:      1,
    }
}

// 获取连接对象
func (p *ConnectionPool) GetConnection() Connection {
    p.mutex.Lock()
    defer p.mutex.Unlock()

    if len(p.connections) > 0 {
        for id, conn := range p.connections {
            delete(p.connections, id)
            return conn
        }
    }

    // 创建新的连接对象
    conn := &ConcreteConnection{id: p.nextID}
    p.nextID++
    return conn
}

// 将连接对象释放回连接池 以便其他客户端可以复用这个连接对象
func (p *ConnectionPool) ReleaseConnection(conn Connection) {
    p.mutex.Lock()
    defer p.mutex.Unlock()

    if c, ok := conn.(*ConcreteConnection); ok {
        p.connections[c.id] = c
    }
}

// 客户端代码
func main() {
    pool := NewConnectionPool()

    conn1 := pool.GetConnection()
    conn1.Execute("SELECT * FROM users")
    pool.ReleaseConnection(conn1)

    conn2 := pool.GetConnection()
    conn2.Execute("SELECT * FROM orders")
    pool.ReleaseConnection(conn2)
}

/*
Connection 1 executing query: SELECT * FROM users
Connection 1 executing query: SELECT * FROM orders
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

package main

import (
    "fmt"
    "time"
)

// 组件接口：请求处理器
type RequestHandler interface {
    HandleRequest(url string) string
}

type CoreRequestHandler struct{}

func (handler *CoreRequestHandler) HandleRequest(url string) string {
    time.Sleep(100 * time.Millisecond)
    return fmt.Sprintf("Response from %s", url)
}

// 装饰器: 日志记录
type LoggingDecorator struct {
    handler RequestHandler
}

func (l *LoggingDecorator) HandleRequest(url string) string {
    fmt.Printf("LoggingDecorator: Request to %s\n", url)
    response := l.handler.HandleRequest(url)
    fmt.Printf("Logging: Response for %s: %s\n", url, response)
    return response
}

// 装饰器：性能监控
type PerformanceMonitorDecorator struct {
    handler RequestHandler
}

func (p *PerformanceMonitorDecorator) HandleRequest(url string) string {
    // 记录开始时间
    start := time.Now()

    // 调用原始处理器
    response := p.handler.HandleRequest(url)

    // 记录处理时间
    duration := time.Since(start)
    fmt.Printf("Performance: Request for %s took %v\n", url, duration)
    return response
}

func main() {
    // 创建请求处理器
    handler := &CoreRequestHandler{}

    // 添加日志记录
    loggingHandler := &LoggingDecorator{handler: handler}

    // 添加性能监控
    monitorHandler := &PerformanceMonitorDecorator{handler: loggingHandler}

    // 处理请求
    fmt.Println(monitorHandler.HandleRequest("http://www.baidu.com"))
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

package main

import "fmt"

// Mac + Epson
type MacEpson struct{}

func (m *MacEpson) Print() {
    fmt.Println("Print request for mac")
    fmt.Println("Printing by a EPSON Printer")
}

// Mac + HP
type MacHp struct{}

func (m *MacHp) Print() {
    fmt.Println("Print request for mac")
    fmt.Println("Printing by a HP Printer")
}

// Windows + Epson
type WindowsEpson struct{}

func (w *WindowsEpson) Print() {
    fmt.Println("Print request for windows")
    fmt.Println("Printing by a EPSON Printer")
}

// Windows + HP
type WindowsHp struct{}

func (w *WindowsHp) Print() {
    fmt.Println("Print request for windows")
    fmt.Println("Printing by a HP Printer")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

package main

import "fmt"

// 定义Printer接口
type Printer interface {
    PrintFile()
}

// 定义Epson打印机
type Epson struct{}

func (e *Epson) PrintFile() {
    fmt.Println("Printing by Epson printer")
}

// 定义惠普打印机
type HP struct{}

func (h *HP) PrintFile() {
    fmt.Println("Printing by HP printer")
}

// 定义Computer接口
type Computer interface {
    Print()
    SetPrinter(Printer)
}

// 定义Mac计算机
type Mac struct {
    printer Printer
}

func (m *Mac) Print() {
    fmt.Println("Print request for Mac")
    m.printer.PrintFile()
}

func (m *Mac) SetPrinter(p Printer) {
    m.printer = p
}

// 定义windows计算机
type Windows struct {
    printer Printer
}

func (w *Windows) Print() {
    fmt.Println("Print request for Windows")
    w.printer.PrintFile()
}

func (w *Windows) SetPrinter(p Printer) {
    w.printer = p
}

func main() {
    // 创建打印机实例
    hpPrinter := &HP{}
    epsonPrinter := &Epson{}

    // 创建计算机实例
    macComputer := &Mac{}
    winComputer := &Windows{}

    // Mac 使用 HP 打印机
    macComputer.SetPrinter(hpPrinter)
    macComputer.Print()
    fmt.Println()

    // Mac 使用 Epson 打印机
    macComputer.SetPrinter(epsonPrinter)
    macComputer.Print()
    fmt.Println()

    // Windows 使用 HP 打印机
    winComputer.SetPrinter(hpPrinter)
    winComputer.Print()
    fmt.Println()

    // Windows 使用 Epson 打印机
    winComputer.SetPrinter(epsonPrinter)
    winComputer.Print()
    fmt.Println()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

package main

import "fmt"

// 定义中介者接口
type Mediator interface {
    SendMessage(message string, sender Colleague)
}

// 具体中介者
type ChatRoom struct {
    users []Colleague
}

func (c *ChatRoom) Register(user Colleague) {
    c.users = append(c.users, user)
}

func (c *ChatRoom) SendMessage(message string, sender Colleague) {
    for _, user := range c.users {
        if user != sender {
            user.Receive(message)
        }
    }
}

// 定义同事类接口
type Colleague interface {
    Send(message string)
    Receive(message string)
}

// 具体同事类
type User struct {
    name     string
    mediator Mediator
}

func (u *User) Send(message string) {
    fmt.Printf("%s sends: %s\n", u.name, message)
    u.mediator.SendMessage(message, u)
}

func (u *User) Receive(message string) {
    fmt.Printf("%s receives: %s\n", u.name, message)
}

func main() {
    // 创建中介者
    chatRoom := &ChatRoom{}

    // 创建用户
    alice := &User{name: "Alice", mediator: chatRoom}
    bob := &User{name: "Bob", mediator: chatRoom}
    charlie := &User{name: "Charlie", mediator: chatRoom}

    // 注册用户到聊天室
    chatRoom.Register(alice)
    chatRoom.Register(bob)
    chatRoom.Register(charlie)

    // 用户发送消息
    alice.Send("Hello, everyone!")
    bob.Send("Hi, Alice!")
    charlie.Send("Hey, Bob!")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81

package main

import "fmt"

// 定义观察者接口
type Observer interface {
    Update(temperature float64, humidity float64, pressure float64)
}

// 定义被观察者接口
type Subject interface {
    RegisterObserver(o Observer)
    RemoveObserver(o Observer)
    NotifyObservers()
}

// 具体被观察者
type WeatherData struct {
    observers   []Observer
    temperature float64
    humidity    float64
    pressure    float64
}

func (w *WeatherData) RegisterObserver(o Observer) {
    w.observers = append(w.observers, o)
}

func (w *WeatherData) RemoveObserver(o Observer) {
    for i, observer := range w.observers {
        if observer == o {
            w.observers = append(w.observers[:i], w.observers[i+1:]...)
            break
        }
    }
}

func (w *WeatherData) NotifyObservers() {
    for _, observer := range w.observers {
        observer.Update(w.temperature, w.humidity, w.pressure)
    }
}

func (w *WeatherData) SetMeasurements(temperature float64, humidity float64, pressure float64) {
    w.temperature = temperature
    w.humidity = humidity
    w.pressure = pressure
    w.NotifyObservers()
}

// 具体观察者
type DisplayDevice struct {
    name string
}

func (d *DisplayDevice) Update(temperature float64, humidity float64, pressure float64) {
    fmt.Printf("%s: Temperature=%.2f, Humidity=%.2f, Pressure=%.2f\n", d.name, temperature, humidity, pressure)
}

func main() {
    // 创建被观察者
    weatherData := &WeatherData{}

    // 创建观察者
    display1 := &DisplayDevice{name: "Display 1"}
    display2 := &DisplayDevice{name: "Display 2"}

    // 注册观察者
    weatherData.RegisterObserver(display1)
    weatherData.RegisterObserver(display2)

    // 更新天气数据并通知观察者
    weatherData.SetMeasurements(25.0, 65.0, 1013.0)
    weatherData.SetMeasurements(26.5, 70.0, 1012.5)

    // 移除一个观察者
    weatherData.RemoveObserver(display1)

    // 再次更新天气数据
    weatherData.SetMeasurements(27.0, 68.0, 1011.0)
}