^-^
【go语言】Golang设计模式
最近更新：2024-12-06   |   字数总计：2.5k   |   阅读估时：11分钟   |   阅读量：次
  1. Golang设计模式
    1. 单例模式
      1. 懒汉模式
      2. 饿汉模式
      3. 懒汉模式-带锁
      4. Once
    2. 工厂模式
      1. 案例：产品生产
      2. 简单工厂
      3. 工厂方法模式
    3. 策略模式
      1. 案例：排序策略
      2. 案例：用户积分优惠策略
    4. 观察者模式
      1. 案例：配置热更新
    5. 适配器模式
      1. 案例：缓存适配器
    6. 代理模式
      1. 案例：缓存代理
    7. 责任链模式
      1. 案例：申报金额审批

Golang设计模式

单例模式

  • 全局只有一个实例的程序设计模式
  • 特点
    1. 全局只有一个实例
    2. 不允许外部初始化
  • 应用场景
    1. 数据库连接池
    2. 应用程序配置文件对象
  • 实例初始化模式
    1. 懒汉模式（优点：通过时间换空间，节省空间；缺点：每次使用都要判断是否已经初始化）
    2. 饿汉模式（优点：效率高，不判断是否已经初始化了；缺点：应用程序一启动就初始化了，但是会占用内存空间）
  • 应用结构
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package _case

    type Config struct {
    	name string
    }

    func (c *Config) GetName() string {
    	return c.name
    }

懒汉模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package _case

var lazyConf *Config

// 懒汉式加载，单例模式，非线程安全
// 需要通过业务场景去判断，并发到底有没有影响，假设是加载配置文件的场景下，即使是并发执行也不会有影响，可以忽略协程安全问题
func GetLazyConfig() *Config {
	if lazyConf == nil {
		lazyConf = &Config{
			name: "lazy config",
		}
	}
	return lazyConf
}

饿汉模式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package _case

var hungryConf *Config

func init() {
	hungryConf = &Config{
		name: "hungry config",
	}
}

// 饿汉式 单例模式，不存在线程安全问题
func GetHungryConfig() *Config {
	return hungryConf
}

懒汉模式-带锁

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

import "sync"

var checkLockerConf *Config

var checkLocker sync.Mutex

// 带检查锁的单例模式
func GetCheckLockerConf() *Config {
	if checkLockerConf == nil {
		checkLocker.Lock()
		defer checkLocker.Unlock()
		if checkLockerConf == nil { // 注意需要两次判断
			checkLockerConf = &Config{
				name: "check locker config",
			}
		}
	}
	return checkLockerConf
}

Once

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

import "sync"

var onceConfig *Config

var once sync.Once

func GetOnceConf() *Config {
	once.Do(func() { // 还记得吗，不管有多少个协程，多少次访问，都会只执行一次Done
		onceConfig = &Config{
			name: "once config",
		}
	})
	return onceConfig
}

工厂模式

  1. 提供创建对象的方式，而无需暴露对象的具体实现
  2. 工厂模式：简单工厂、工厂方法模式
  • 作用
    1. 将对象的创建和使用分离，降低了耦合度、使得系统更加灵活
    2. 提高系统的可维护性和扩展性，支持增加新的产品类
    3. 有助于管理对象之间的依赖关系
  • 缺点
    1. 增加了代码的复杂度和维护难度

案例：产品生产

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

type Product interface {
	GetName() string
}

type ProductA struct {
	name string
}

func (a *ProductA) GetName() string {
	return a.name
}

type ProductB struct {
	name string
}

func (b *ProductB) GetName() string {
	return b.name
}

简单工厂

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 factory

import "fmt"

type SimpleFactory struct {
}

// 简单工厂模式，假如我们要添加一种产品C，我们需要改这个工厂的代码，有一定耦合在里面
func (f *SimpleFactory) CreateProduct(productType string) Product {
	switch productType {
	case "A":
		return &ProductA{
			name: "product a",
		}
	case "B":
		return &ProductB{
			name: "product b",
		}
	}
	return nil
}

func SimpleFactoryCase() {
	factory := &SimpleFactory{}
	var product Product
	product = factory.CreateProduct("A")
	fmt.Println(product.GetName())
	product = factory.CreateProduct("B")
	fmt.Println(product.GetName())
	product = factory.CreateProduct("C")
	if product != nil {
		fmt.Println(product.GetName())
	}
}

工厂方法模式

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
package factory

import "fmt"

type Factory interface {
	CreateProduct() Product
}

type FactoryA struct {
}

func (f *FactoryA) CreateProduct() Product {
	return &ProductA{
		name: "product A",
	}
}

type FactoryB struct {
}

func (f *FactoryB) CreateProduct() Product {
	return &ProductB{
		name: "product B",
	}
}

func FactoryMethodCase() {
	var factory Factory
	var product Product
	factory = &FactoryA{}
	product = factory.CreateProduct()
	fmt.Println(product.GetName())
	factory = &FactoryB{}
	product = factory.CreateProduct()
	fmt.Println(product.GetName())
}

策略模式

  • 它定义一系列算法，并将每个算法分别封装，使得算法之间可以相互替换
  • 应用场景
    1. 处理不同算法，例如：多种排序，可以按需选择
    2. 实现业务规则，例如：判断用户是否满足领取优惠券的条件、计算用户积分等
    3. 避免多个if-else，可采取策略模式来处理

案例：排序策略

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
package _case

import "fmt"

// 排序策略定义
type SortStrategy interface {
	Sort(arr []int)
}

// 冒泡排序
type bubble struct{}

func (b *bubble) Sort(arr []int) {
	fmt.Println("冒泡排序")
	for i := 0; i < len(arr)-1; i++ {
		flag := false
		for j := 0; j < len(arr)-1-i; j++ {
			if arr[j] > arr[j+1] {
				arr[j], arr[j+1] = arr[j+1], arr[j]
				flag = true
			}
		}
		if flag == false {
			break
		}
	}
}

type selection struct{}

func (s *selection) Sort(arr []int) {
	fmt.Println("选择排序")
	size := len(arr)
	for i := 0; i < size; i++ {
		minIndex := i
		for j := i; j < size; j++ {
			if arr[minIndex] > arr[j] {
				minIndex = j
			}
		}
		if minIndex != i {
			arr[i], arr[minIndex] = arr[minIndex], arr[i]
		}
	}
}

type Context struct {
	sortStrategy SortStrategy
}

func (ctx *Context) SetStrategy(s SortStrategy) {
	ctx.sortStrategy = s
}

func (ctx *Context) ExecuteStrategy(arr []int) {
	ctx.sortStrategy.Sort(arr)
}

func StrategyCase() {
	arr := []int{1, 3, 10, 11, 12, 7, 9, 8}
	arr1 := []int{1, 3, 10, 11, 12, 7, 9, 8}
	ctx := &Context{}
	// 排序策略：冒泡
	ctx.SetStrategy(&bubble{})
	ctx.ExecuteStrategy(arr)
	fmt.Println(arr)
	// 排序策略：选择
	ctx.SetStrategy(&selection{})
	ctx.ExecuteStrategy(arr1)
	fmt.Println(arr1)
}

案例：用户积分优惠策略

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
package _case

import "fmt"

type User struct {
	name     string
	amount   int64 // 消费金额
	integral int64 // 积分
	coupon   bool  // 能否领取优惠券
}

type UserStrategy interface {
	Exec(user *User)
}

// 积分策略
type Integral struct{}

func (i *Integral) Exec(u *User) {
	// 消费1元，可得到1积分
	u.integral = u.amount
}

// 优惠券策略
type Coupon struct{}

func (c *Coupon) Exec(u *User) {
	// 消费金额超过100，可领取一张
	if u.amount > 100 {
		u.coupon = true
	}
}

type UserSaver struct {
	strategys []UserStrategy // 多个策略可以同时存在
}

func (us *UserSaver) AppendStrategy(s UserStrategy) {
	us.strategys = append(us.strategys, s)
}

func (us *UserSaver) ExeStrategy(u *User) {
	for _, s := range us.strategys {
		s.Exec(u)
	}
}

func UserStrategyCase() {
	u := &User{
		name:   "nn",
		amount: 110,
	}
	us := &UserSaver{}
	us.AppendStrategy(&Integral{})
	us.AppendStrategy(&Coupon{})
	us.ExeStrategy(u)
	fmt.Println(u)
}

观察者模式

  • 即发布订阅模式，发布者发布一个主题，观察者订阅主题并接收更新通知
  • 应用场景
    1. 配置信息更新
    2. 订阅/发布系统

案例：配置热更新

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 _case

import "fmt"

type Observer interface {
	Update(data interface{})
}

type Publisher interface {
	Subscribe(observer Observer)
	UnSubscribe(observer Observer)
	NotifyObservers(data interface{})
}

type ConfigPublisher struct {
	data      map[string]string
	observers []Observer
}

func (c *ConfigPublisher) Subscribe(observer Observer) {
	c.observers = append(c.observers, observer)
}

func (c *ConfigPublisher) UnSubscribe(observer Observer) {
	for i, v := range c.observers {
		if v == observer {
			c.observers = append(c.observers[:i], c.observers[i+1:]...)
			break
		}
	}
}

func (c *ConfigPublisher) NotifyObservers(data interface{}) {
	for _, v := range c.observers {
		v.Update(data)
	}
}

type WatchConf struct {
}

func (w *WatchConf) Update(data interface{}) {
	fmt.Println("收到配置更新信息:", data)
}

func ObserverCase() {
	var ob Observer = &WatchConf{}
	var ob2 Observer = &WatchConf{}
	var ob3 Observer = &WatchConf{}
	var pb Publisher = &ConfigPublisher{data: map[string]string{"host": "local", "port": "5050"}}
	pb.Subscribe(ob)
	pb.Subscribe(ob2)
	pb.Subscribe(ob3)
	fmt.Println(pb)
	pb.UnSubscribe(ob)
	fmt.Println(pb)
	conf := pb.(*ConfigPublisher)
	conf.data = map[string]string{"host": "127", "port": "8899"}
	pb.NotifyObservers(conf.data)
	fmt.Println(pb)
}

适配器模式

  • 允许将一个类的接口转换成客户端所期望的另一种接口，通常应用于接口不兼容的情况下
  • 应用场景
    1. 日志适配器：将应用程序中的日志发送到不同的目标
    2. 数据库适配器：使得应用程序可以轻松切换数据库引擎同时保持api接口不变
    3. 缓存适配器：实现跨多个缓存服务商的一致性缓存API，比如redis和memcached

案例：缓存适配器

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
package _case

import "fmt"

type Redis struct {
	data map[string]string
}

func (r *Redis) GetStr(key string) string {
	return r.data[key]
}

func (r *Redis) SetStr(key, value string) {
	r.data[key] = value
}

type MemCache struct {
	data map[string]interface{}
}

func (m *MemCache) GetItem(key string) interface{} {
	return m.data[key]
}

func (m *MemCache) SetItem(key string, value interface{}) {
	m.data[key] = value
}

// 定义的标准的缓存
type StdCache interface {
	Get(key string) string
	Set(key, value string)
}

type RedisAdapter struct {
	redis *Redis
}

func (adapter *RedisAdapter) Get(key string) string {
	return adapter.redis.GetStr(key)
}

func (adapter *RedisAdapter) Set(key, value string) {
	adapter.redis.SetStr(key, value)
}

type MemcacheAdapter struct {
	memCache *MemCache
}

func (adapter *MemcacheAdapter) Get(key string) string {
	return adapter.memCache.GetItem(key).(string)
}

func (adapter *MemcacheAdapter) Set(key, value string) {
	adapter.memCache.SetItem(key, value)
}

func AdapterCase() {
	var cache StdCache
	redis := &Redis{data: map[string]string{}}
	cache = &RedisAdapter{redis: redis}
	cache.Set("key1", "value1")
	cache.Set("key2", "value2")
	cache.Set("key3", "value3")
	fmt.Println(cache.Get("key1"))
	fmt.Println(cache.Get("key2"))
	fmt.Println(cache.Get("key3"))

	memc := &MemCache{data: map[string]interface{}{}}
	cache = &MemcacheAdapter{memCache: memc}
	cache.Set("k1", "v1")
	cache.Set("k2", "v2")
	cache.Set("k3", "v3")
	fmt.Println(cache.Get("k1"))
	fmt.Println(cache.Get("k2"))
	fmt.Println(cache.Get("k3"))
}

代理模式

  • 允许在不改变原始对象接口的前提下，通过引入一个代理对象来控制对原始对象的访问
  • 特点
    1. 可以隐藏真实的对象
    2. 在不改变真实对象的前提下，对其进行扩展和功能增强

案例：缓存代理

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
package _case

import "fmt"

type ICache interface {
	Get(key string) interface{}
	Set(key string, value interface{})
}

// 被代理的真实对象
type Cache struct {
	data map[string]interface{}
}

func (c *Cache) Get(key string) interface{} {
	return c.data[key]
}
func (c *Cache) Set(key string, value interface{}) {
	c.data[key] = value
}

type Proxy struct {
	cache ICache
}

func (p *Proxy) Get(key string) interface{} {
	return p.cache.Get(key)
}
func (p *Proxy) Set(key string, value interface{}) {
	p.cache.Set(key, value)
}

func NewProxy(cache ICache) *Proxy {
	return &Proxy{
		cache: cache,
	}
}

func ProxyCase() {
	var cache ICache
	cache = &Cache{data: map[string]interface{}{}}
	proxy := NewProxy(cache)
	proxy.Set("key1", "value1")
	proxy.Set("key2", "value2")
	proxy.Set("key3", "value3")
	proxy.Set("key4", "value4")
	proxy.Set("key5", "value5")
	proxy.Set("key6", "value6")
	fmt.Println(proxy.Get("key1"))
	fmt.Println(proxy.Get("key2"))
	fmt.Println(proxy.Get("key3"))
	fmt.Println(proxy.Get("key4"))
}

责任链模式

  • 用于将请求从一个对象传递到另一个对象链上，直到其中一个对象能够处理该请求
  • 应用场景
    1. 不确定请求处理对象的场景
  • 注意
    1. 标准的责任链请求一旦被处理则返回，不会再被传递和处理了
    2. 可以通过该模式的变形传递处理请求
    3. 责任链模式下有可能会产生谁都无法处理的请求

案例：申报金额审批

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
package _case

import "fmt"

type Handler interface {
	SetNext(h Handler) Handler
	Handle(user string, amount int64)
}

// 项目经理
type ProjectManager struct {
	next Handler
}

func (pm *ProjectManager) Handle(user string, amount int64) {
	if amount <= 500 {
		fmt.Printf("%s 申请聚餐费用%d元，项目经理批准通过\n", user, amount)
		return
	}
	// 项目经理没有权限审批,交给下一个处理
	pm.next.Handle(user, amount)
}
func (pm *ProjectManager) SetNext(h Handler) Handler {
	pm.next = h
	return h
}

// 部门经理
type DepartmentManager struct {
	next Handler
}

func (dm *DepartmentManager) Handle(user string, amount int64) {
	if amount > 500 && amount <= 1000 {
		fmt.Printf("%s 申请聚餐费用%d元，部门经理批准通过\n", user, amount)
		return
	} else if amount > 1000 {
		fmt.Printf("%s 申请聚餐费用%d元，部门经理批准通过\n", user, amount)
		dm.next.Handle(user, amount)
	} else {
		dm.next.Handle(user, amount)
	}
}
func (dm *DepartmentManager) SetNext(h Handler) Handler {
	dm.next = h
	return h
}

// 总经理
type GeneralManager struct {
	next Handler
}

func (gm *GeneralManager) Handle(user string, amount int64) {
	if amount > 1000 {
		fmt.Printf("%s 申请聚餐费用%d元，总经理批准通过\n", user, amount)
		return
	}
	gm.next.Handle(user, amount)
}
func (gm *GeneralManager) SetNext(h Handler) Handler {
	gm.next = h
	return h
}

func DutyCase() {
	pm := &ProjectManager{}
	dm := &DepartmentManager{}
	gm := &GeneralManager{}
	pm.SetNext(dm).SetNext(gm)
	pm.Handle("张三", 300)
	pm.Handle("李四", 800)
	pm.Handle("王五", 1580)
}

2024-12-06 该篇文章被 Cleofwine 归为分类: Go云原生

上一篇：【go工程组件】高性能RPC框架gRPC 下一篇：【go语言】Golang数据结构与算法
© 2023-2026 Cleofwine / Email / GitHub / 浙ICP备2024136127号
🌙赠我弯弯一枚月，也赠予我晚星⭐ 本站由Hexo驱动｜使用Hexo-theme-A4主题