go 常用设计模式-结构型模式

本次分享结构型模式，主要包括：

• 代理模式
• 装饰器模式
• 适配器模式
• 享元模式

1.代理模式

package proxy
 
import "fmt"
 
/*
结构型模式
 
代理，代表打理，以他人的名义代表委托人打理其本职工作之外或不所能及的事务，达成合作关系并更高效地促成事务完成的目的。
强调的是对被代理对象的控制。
*/
 
// 以光猫代理访问为例，限制小孩访问，设置相应的访问黑名单
type Modem struct {}
 
func (t Modem) Access(url string)  {
	fmt.Println("正常访问：" + url)
}
 
type Proxy struct {
	BlackList []string
	M Modem
}
 
// filter access
func (t Proxy) FilterAccess(url string)  {
	for _, v := range t.BlackList {
		if v == url {
			fmt.Println("禁止访问：" + url)
			return
		}
	}
	t.M.Access(url)
}
 

2.装饰器模式

package decorator
 
import "fmt"
 
/*
结构型模式
 
指在不改变现有对象结构的情况下，动态地给该对象增加一些额外功能的模式
 
例如：日期格式化函数，系统只提供了通用的方法。当遇到其他格式的日期的时候，
需要额外增加一些变化，使特殊日期符合一般的格式化要求。这就是对系统函数的装饰。
 
再例如：买的毛坯房，房子的主体结构我们是不允许修改的，
但是我们可以请师傅装饰内饰，使原本平平无奇的房子，变的富丽堂皇的精装修。
 
从上面举例可以看出，原始的对象（女生、毛坯房、系统函数）是不允许修改的，只能额外增加一些装饰
*/
 
// 以女生化妆为例，先定义一般接口
type Showable interface {
	Show()
}
 
// implement normal girl
type Girl struct {}
 
func (t *Girl) Show()  {
	fmt.Printf("未化妆 girl")
}
 
// Showable接口在调用的时候，传入为Showable的实现对象即可
type MakeUPDecorator struct {
	Showable
}
 
func (t *MakeUPDecorator) Show()  {
	fmt.Print("打粉底(")
	t.Showable.Show()
	fmt.Print(")")
}
 
type LipDecorator struct {
	Showable
}
 
func (t *LipDecorator) Show() {
	fmt.Print("涂口红(")
	t.Showable.Show()
	fmt.Print(")\n")
}

3.适配器模式

package adapter
 
import "fmt"
 
/*
结构型模式
 
将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
 
类似不同的移动设备 USB -> type C | Lighting | android
*/
 
type USB interface {
	Work()
}
 
// 对外接口
func Charge(usb USB)  {
	usb.Work()
}
 
// TypeC 未实现usb接口的Work方法，不可以充电
type TypeC struct {}
 
func (t TypeC) IPhone()  {
	fmt.Println("Charge IPhone")
}
 
// 通过适配器实现usb接口充电，套一层或者继承
type AdapterTypeC struct {
	TypeC
}
 
func (t AdapterTypeC) Work()  {
	t.IPhone()
}
 
type Micro struct {}
 
func (t Micro) Work()  {
	fmt.Println("Charge Android")
}

4.享元模式

package flyWeight
 
import (
	"fmt"
	"sync"
)
 
/*
结构型模式
 
对象复用
 
运用共享技术来有效地支持大量细粒度对象的复用。
它通过共享已经存在的对象来大幅度减少要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。
 
享元就是共享的概念，比如线程池、对象池、连接池等等
 
共用对象、节省内存、减少对象数量
*/
 
// define share obj
type Flyweight interface {
	Operation()
}
 
// implement interface
type ConcreteFlyweight struct {
	Key string
}
 
func (t ConcreteFlyweight) Operation()  {
	fmt.Println(t.Key)
}
 
// define obj pool, use map
type FlyweightFactory struct {
	mu sync.Mutex
	Flys map[string]Flyweight
}
 
func (t FlyweightFactory) Get(key string) Flyweight {
	t.mu.Lock()
	defer t.mu.Unlock()
 
	if f, ok := t.Flys[key]; !ok {
		f = ConcreteFlyweight{Key: key}
		t.Flys[key] = f
		return f
	} else {
		return f
	}
}
 
func (t FlyweightFactory) Len() int {
	return len(t.Flys)
}
 
func (t FlyweightFactory) Put()  {
 
}
 

5.测试

...
        fmt.Println(strings.Repeat("-", 10) + "结构型模式" + strings.Repeat("-", 10))
	// 10.proxy mode
	fmt.Println("proxy mode testing...")
	p := proxy.Proxy{
		BlackList: []string{"www.bilibili.com", "www.youku.com"},
		M: proxy.Modem{},
	}
	p.FilterAccess("www.baidu.com")
	p.FilterAccess("www.bilibili.com")
	fmt.Printf("+%s+\n", strings.Repeat("-", 50))
 
	// 11.decorator mode
	fmt.Println("decorator mode testing...")
	girl := decorator.Girl{}
	girl.Show()
	fmt.Println(" 化妆后：")
	l := decorator.LipDecorator{Showable: &decorator.MakeUPDecorator{&girl}}
	l.Show()
	fmt.Printf("+%s+\n", strings.Repeat("-", 50))
 
	// 12.adapter mode
	fmt.Println("decorator mode testing...")
	adapter.Charge(adapter.Micro{})
	adapter.Charge(adapter.AdapterTypeC{})
	fmt.Printf("+%s+\n", strings.Repeat("-", 50))
 
	// 13.flyweight mode
	fmt.Println("flyweight mode testing...")
	fly := flyWeight.FlyweightFactory{Flys: make(map[string]flyWeight.Flyweight)}
	fly.Get("A").Operation()
	fly.Get("A").Operation()
	fly.Get("B").Operation()
	fly.Get("C").Operation()
	fmt.Println("flyweight len:", fly.Len())
	fmt.Printf("+%s+\n", strings.Repeat("-", 50))
...

参考文档：

• 用Go语言实现设计模式