1
package main
2

3
import "fmt"
4

5
type Notifier interface {
6
 SendNotification(string)
7
}
8

9
type SmsNotifier struct {
10
}
11
type EmailNotifier struct {
12
}
13
type WechatNotifier struct{}
14

15
// 定义一个通知服务，使用依赖注入的方式接收通知器
16
type NotificationService struct {
17
 notifier Notifier
18
}
19

20
func (sms *SmsNotifier) SendNotification(msg string) {
21
 fmt.Println("send sms", msg)
22
}
23
func (email *EmailNotifier) SendNotification(msg string) {
24
 fmt.Println("send email", msg)
25
}
26
func (wechat *WechatNotifier) SendNotification(msg string) {
27
 fmt.Println("send wechat", msg)
28
}
29

30
func NewNotificationService(notifier *Notifier) *NotificationService {
31
 return &NotificationService{
32
  notifier: *notifier,
33
 }
34
}
35
func (ns *NotificationService) Notify() {
36
 ns.notifier.SendNotification("meowrain")
37
}
38

39
func main() {
40
 sms := &SmsNotifier{}
41
 email := &EmailNotifier{}
42
 wechat := &WechatNotifier{}
43

44
 ns1 := NewNotificationService(&sms)
45
 ns2 := NewNotificationService(&email)
46
 ns3 := NewNotificationService(&wechat)
47

48
 ns1.Notify()
49
 ns2.Notify()
50
 ns3.Notify()
51
}

1
package main
2

3
import "fmt"
4

5
// 定义用户
6
type User struct {
7
    name     string
8
    friends  []User
9
}
10

11
func (u *User) AddFriend(friend User) {
12
    u.friends = append(u.friends, friend)
13
}
14

15
func (u *User) Send(message string) {
16
    fmt.Printf("%s: 发送消息 '%s'\n", u.name, message)
17
    for _, friend := range u.friends {
18
        friend.Receive(message)
19
    }
20
}
21

22
func (u *User) Receive(message string) {
23
    fmt.Printf("%s: 收到消息 '%s'\n", u.name, message)
24
}
25

26
func NewUser(name string) *User {
27
    return &User{name: name, friends: make([]User, 0)}
28
}
29

30
func main() {
31
    alice := NewUser("Alice")
32
    bob := NewUser("Bob")
33
    charlie := NewUser("Charlie")
34

35
    alice.AddFriend(*bob)
36
    alice.AddFriend(*charlie)
37
    bob.AddFriend(*alice)
38
    bob.AddFriend(*charlie)
39
    charlie.AddFriend(*alice)
40
    charlie.AddFriend(*bob)
41

42
    alice.Send("你好，大家！")
43
    bob.Send("嗨，Alice！")
44
    charlie.Send("很高兴见到你们！")
45
}

1
package main
2

3
import "fmt"
4

5
// 定义中介者接口
6
type Mediator interface {
7
    SendMessage(message string, user User)
8
}
9

10
// 定义用户接口
11
type User interface {
12
    Send(message string)
13
    Receive(message string)
14
}
15

16
// 实现中介者
17
type ChatRoom struct{}
18

19
func (cr *ChatRoom) SendMessage(message string, user User) {
20
    fmt.Printf("消息 '%s' 发送给所有用户\n", message)
21
    for _, u := range users {
22
        if u != user {
23
            u.Receive(message)
24
        }
25
    }
26
}
27

28
var users = make([]User, 0)
29

30
func (cr *ChatRoom) AddUser(user User) {
31
    users = append(users, user)
32
}
33

34
// 实现用户
35
type UserImpl struct {
36
    name string
37
}
38

39
func (u *UserImpl) Send(message string) {
40
    fmt.Printf("%s: 发送消息 '%s'\n", u.name, message)
41
    chatRoom.SendMessage(message, u)
42
}
43

44
func (u *UserImpl) Receive(message string) {
45
    fmt.Printf("%s: 收到消息 '%s'\n", u.name, message)
46
}
47

48
func NewUser(name string) *UserImpl {
49
    return &UserImpl{name: name}
50
}
51

52
func main() {
53
    chatRoom := &ChatRoom{}
54

55
    alice := NewUser("Alice")
56
    bob := NewUser("Bob")
57
    charlie := NewUser("Charlie")
58

59
    chatRoom.AddUser(alice)
60
    chatRoom.AddUser(bob)
61
    chatRoom.AddUser(charlie)
62

63
    alice.Send("你好，大家！")
64
    bob.Send("嗨，Alice！")
65
    charlie.Send("很高兴见到你们！")
66
}

1
package singleton
2

3
import "fmt"
4

5
type instance struct {
6
 name string
7
}
8

9
var ins *instance = new(instance)
10

11
func (ins *instance) Work() {
12
 fmt.Println("work")
13
}
14

15
func GetInstance(name string) *instance {
16
 ins.name = name
17
 return ins
18
}

1
package singletontest
2

3
import "singleton"
4

5
func hello() {
6
 s := singleton.GetInstance()
7
 s.Work()
8

9
}

1
package singleton
2

3
import "fmt"
4

5
type instance struct {
6
 name string
7
}
8

9
var ins *instance
10

11
func (ins *instance) Work() {
12
 fmt.Println("work")
13
}
14

15
func GetInstance(name string) *instance {
16
 if ins == nil {
17
  ins = new(instance)
18
  ins.name = name
19
  return ins
20
 }
21
 ins.name = name
22
 return ins
23
}

1
package singleton
2

3
import (
4
 "fmt"
5
 "sync"
6
)
7

8
type instance struct {
9
 name string
10
}
11
var lock sync.Mutex
12
var ins *instance
13

14
func (ins *instance) Work() {
15
 fmt.Println("work")
16
}
17

18
func GetInstance(name string) *instance {
19
 lock.Lock()
20
 defer lock.Unlock()
21
 if ins == nil {
22
  ins = new(instance)
23
  ins.name = name
24
  return ins
25
 }
26
 ins.name = name
27
 return ins
28
}

1
package singleton
2

3
import (
4
 "fmt"
5
 "sync"
6
 "sync/atomic"
7
)
8

9
type instance struct {
10
 name string
11
}
12

13
var initialized uint32
14
var lock sync.Mutex
15
var ins *instance
16

17
func (ins *instance) Work() {
18
 fmt.Println("work")
19
}
20

21
func GetInstance(name string) *instance {
22
 //如果标记为被设置，直接返回，不加锁
23
 if atomic.LoadUint32(&initialized) == 1 {
24
  ins.name = name
25
  return ins
26
 }
27
 //如果没有，则加锁申请
28
 lock.Lock()
29
 defer lock.Unlock()
30

31
 if initialized == 0 {
32
  ins = new(instance)
33
  ins.name = name
34
  //设置标记位
35
  atomic.StoreUint32(&initialized, 1)
36
 }
37
 return ins
38
}

1
func (o *Once) Do(f func()) {　　　//判断是否执行过该方法，如果执行过则不执行
2
    if atomic.LoadUint32(&o.done) == 1 {
3
        return
4
    }
5
    // Slow-path.
6
    o.m.Lock()
7
    defer o.m.Unlock()
8
    if o.done == 0 {
9
        defer atomic.StoreUint32(&o.done, 1)
10
        f()
11
    }
12
}

1
package singleton
2

3
import (
4
 "fmt"
5
 "sync"
6
)
7

8
type instance struct {
9
 name string
10
}
11

12
var once sync.Once
13
var ins *instance
14

15
func (ins *instance) Work() {
16
 fmt.Println("work")
17
}
18

19
func GetInstance(name string) *instance {
20
 once.Do(func() {
21
  ins = new(instance)
22
  ins.name = name
23
 })
24
 return ins
25
}

1
package simplefactory
2

3
import "fmt"
4

5
type Fruit struct {
6
}
7

8
func (f *Fruit) Show(name string) {
9
 if name == "apple" {
10
  fmt.Println("我是苹果")
11
 } else if name == "banana" {
12
  fmt.Println("我是香蕉")
13
 } else if name == "pear" {
14
  fmt.Println("我是梨")
15
 }
16
}
17
func NewFruit(name string) *Fruit {
18
 fruit := new(Fruit)
19

20
 if name == "apple" {
21
  //创建apple逻辑
22
 } else if name == "banana" {
23
  //创建banana逻辑
24
 } else if name == "pear" {
25
  //创建pear逻辑
26
 }
27

28
 return fruit
29
}
30
func main() {
31
 apple := NewFruit("apple")
32
 apple.Show("apple")
33

34
 banana := NewFruit("banana")
35
 banana.Show("banana")
36

37
 pear := NewFruit("pear")
38
 pear.Show("pear")
39
}

1
package simplefactory
2

3
type Factory struct{}
4

5
func (f *Factory) CreateFruit(name string) Fruit {
6
 switch name {
7
 case "apple":
8
  return &Apple{}
9
 case "banana":
10
  return &Banana{}
11
 default:
12
  return nil
13
 }
14
}
15

16
type Fruit interface {
17
 Show()
18
}
19
type Apple struct{}
20
type Banana struct{}
21

22
func (a *Apple) Show() {
23
 println("this is apple")
24
}
25
func (b *Banana) Show() {
26
 println("this is banana")
27
}
28
func main() {
29
 var fac Factory = Factory{}
30
 apple := fac.CreateFruit("apple")
31
 apple.Show()
32
 banana := fac.CreateFruit("banana")
33
 banana.Show()
34

35
}

1
package factory
2

3
type Fruit interface {
4
 Show()
5
}
6
type Apple struct {
7
}
8
type Banana struct{}
9
type Pear struct{}
10

11
func (a *Apple) Show() {
12
 println("我是苹果")
13
}
14
func (b *Banana) Show() {
15
 println("我是香蕉")
16
}
17
func (p *Pear) Show() {
18
 println("我是梨")
19
}
20

21
type FruitFactory interface {
22
 CreateFruit() Fruit
23
}
24
type AppleFactory struct {
25
}
26
type PearFactory struct {
27
}
28
type BananaFactory struct {
29
}
30

31
func (applefac *AppleFactory) CreateFruit() Fruit {
32
 var fruit Fruit
33
 fruit = &Apple{}
34
 return fruit
35
}
36
func (pearfac *PearFactory) CreateFruit() Fruit {
37
 var fruit Fruit
38
 fruit = &Pear{}
39
 return fruit
40
}
41
func (bananafac *BananaFactory) CreateFruit() Fruit {
42
 var fruit Fruit
43
 fruit = &Banana{}
44
 return fruit
45
}
46

47
func main() {
48
 var applefactory FruitFactory
49
 applefactory = new(AppleFactory)
50
 apple := applefactory.CreateFruit()
51
 apple.Show()
52

53
 var pearfactory FruitFactory
54
 pearfactory = new(PearFactory)
55
 pear := pearfactory.CreateFruit()
56
 pear.Show()
57

58
 var bananafactory FruitFactory
59
 bananafactory = new(BananaFactory)
60
 banana := bananafactory.CreateFruit()
61
 banana.Show()
62
}

1
package factory
2

3
import "fmt"
4

5
type Fruit interface {
6
 Show()
7
}
8
type Apple struct {
9
}
10
type Banana struct{}
11
type Pear struct{}
12

13
func (a *Apple) Show() {
14
 println("我是苹果")
15
}
16
func (b *Banana) Show() {
17
 println("我是香蕉")
18
}
19
func (p *Pear) Show() {
20
 println("我是梨")
21
}
22

23
type FruitFactory interface {
24
 CreateFruit() Fruit
25
}
26
type AppleFactory struct {
27
}
28
type PearFactory struct {
29
}
30
type BananaFactory struct {
31
}
32

33
func (applefac *AppleFactory) CreateFruit() Fruit {
34
 var fruit Fruit
35
 fruit = &Apple{}
36
 return fruit
37
}
38
func (pearfac *PearFactory) CreateFruit() Fruit {
39
 var fruit Fruit
40
 fruit = &Pear{}
41
 return fruit
42
}
43
func (bananafac *BananaFactory) CreateFruit() Fruit {
44
 var fruit Fruit
45
 fruit = &Banana{}
46
 return fruit
47
}
48

49
// (+) 新增一个"日本苹果"
50
type JapanApple struct {
51
}
52
type JapanAppleFactory struct{}
53

54
func (jp *JapanApple) Show() {
55
 fmt.Println("我是日本苹果")
56
}
57
func (jpapple *JapanAppleFactory) CreateFruit() Fruit {
58
 var fruit Fruit
59
 fruit = &JapanApple{}
60
 return fruit
61
}
62
func main() {
63
 var applefactory FruitFactory
64
 applefactory = new(AppleFactory)
65
 apple := applefactory.CreateFruit()
66
 apple.Show()
67

68
 var pearfactory FruitFactory
69
 pearfactory = new(PearFactory)
70
 pear := pearfactory.CreateFruit()
71
 pear.Show()
72

73
 var bananafactory FruitFactory
74
 bananafactory = new(BananaFactory)
75
 banana := bananafactory.CreateFruit()
76
 banana.Show()
77

78
 var jpapplefactory FruitFactory
79
 jpapplefactory = new(JapanAppleFactory)
80
 jpapple := jpapplefactory.CreateFruit()
81
 jpapple.Show()
82

83
}

1
package abstractfactory
2

3
import "fmt"
4

5
type FruitFactory interface {
6
 CreateApple() Apple
7
 CreateBanana() Banana
8
 CreatePear() Pear
9
}
10
type ChinaFruitFactory struct{}
11
type JapanFruitFactory struct{}
12
type AmericaFruitFactory struct{}
13

14
func (china *ChinaFruitFactory) CreateApple() Apple {
15
 apple := new(ChinaApple)
16
 return apple
17
}
18
func (china *ChinaFruitFactory) CreateBanana() Banana {
19
 banana := new(ChinaBanana)
20
 return banana
21
}
22
func (china *ChinaFruitFactory) CreatePear() Pear {
23
 pear := new(ChinaPear)
24
 return pear
25
}
26

27
func (japan *JapanFruitFactory) CreateApple() Apple {
28
 apple := new(JapanApple)
29
 return apple
30
}
31
func (japan *JapanFruitFactory) CreateBanana() Banana {
32
 banana := new(JapanBanana)
33
 return banana
34
}
35
func (japan *JapanFruitFactory) CreatePear() Pear {
36
 pear := new(JapanPear)
37
 return pear
38
}
39

40
func (america *AmericaFruitFactory) CreateApple() Apple {
41
 apple := new(AmericaApple)
42
 return apple
43
}
44
func (america *AmericaFruitFactory) CreateBanana() Banana {
45
 banana := new(AmericaBanana)
46
 return banana
47
}
48
func (america *AmericaFruitFactory) CreatePear() Pear {
49
 pear := new(AmericaPear)
50
 return pear
51
}
52

53
type Apple interface{ ShowApple() }
54
type Banana interface{ ShowBanana() }
55
type Pear interface{ ShowPear() }
56
type ChinaApple struct{}
57
type ChinaBanana struct{}
58
type ChinaPear struct{}
59
type JapanApple struct{}
60
type JapanBanana struct{}
61
type JapanPear struct{}
62
type AmericaApple struct{}
63
type AmericaBanana struct{}
64
type AmericaPear struct{}
65

66
func (chinaApple *ChinaApple) ShowApple() {
67
 fmt.Println("我是中国苹果")
68
}
69
func (chinaBanana *ChinaBanana) ShowBanana() {
70
 fmt.Println("我是中国香蕉")
71
}
72
func (chinaPear *ChinaPear) ShowPear() {
73
 fmt.Println("我是中国梨")
74
}
75
func (japanApple *JapanApple) ShowApple() {
76
 fmt.Println("我是日本苹果")
77
}
78
func (japanBanana *JapanBanana) ShowBanana() {
79
 fmt.Println("我是日本香蕉")
80
}
81
func (japanPear *JapanPear) ShowPear() {
82
 fmt.Println("我是日本梨")
83
}
84
func (americaApple *AmericaApple) ShowApple() {
85
 fmt.Println("我是美国苹果")
86
}
87
func (americaBanana *AmericaBanana) ShowBanana() {
88
 fmt.Println("我是美国香蕉")
89
}
90
func (americaPear *AmericaPear) ShowPear() {
91
 fmt.Println("我是美国梨")
92
}
93
func main() {
94
    chinaFactory := &ChinaFruitFactory{}
95
    japanFactory := &JapanFruitFactory{}
96
    americaFactory := &AmericaFruitFactory{}
97

98
    chinaApple := chinaFactory.CreateApple()
99
    chinaApple.ShowApple()
100

101
    japanBanana := japanFactory.CreateBanana()
102
    japanBanana.ShowBanana()
103

104
    americaPear := americaFactory.CreatePear()
105
    americaPear.ShowPear()
106
}