快收藏！最全GO语言实现设计模式下
Posted 腾讯云开发者
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了快收藏！最全GO语言实现设计模式下相关的知识，希望对你有一定的参考价值。
点个关注👆跟腾讯工程师学技术
导语| 继上篇【快收藏！最全GO语言实现设计模式】，本文继续列出GO语言实现的经典设计模式示例，每个示例都精心设计，力求符合模式结构，可作为日常编码参考，同时一些常用的设计模式融入了开发实践经验总结，帮助大家在平时工作中灵活运用。
解释器模式
（一）概念
解释器模式用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程。
（二）示例
定义一个解析特征值的语句解释器，提供是否包含特征值的终结表达式，并提供或表达式与且表达式，同时，生成南极洲特征判断表达式，及美国人特征判断表达式，最后测试程序根据对象特征值描述，通过表达式判断是否为真。
特征值解释器
package interpreter
import "strings"
// Expression 表达式接口，包含一个解释方法
type Expression interface
Interpret(context string) bool
// terminalExpression 终结符表达式，判断表达式中是否包含匹配数据
type terminalExpression struct
matchData string
func NewTerminalExpression(matchData string) *terminalExpression
return &terminalExpressionmatchData: matchData
// Interpret 判断是否包含匹配字符
func (t *terminalExpression) Interpret(context string) bool
if strings.Contains(context, t.matchData)
return true
return false
// orExpression 或表达式
type orExpression struct
left, right Expression
func NewOrExpression(left, right Expression) *orExpression
return &orExpression
left: left,
right: right,
func (o *orExpression) Interpret(context string) bool
return o.left.Interpret(context) || o.right.Interpret(context)
// andExpression 与表达式
type andExpression struct
left, right Expression
func NewAndExpression(left, right Expression) *andExpression
return &andExpression
left: left,
right: right,
func (o *andExpression) Interpret(context string) bool
return o.left.Interpret(context) && o.right.Interpret(context)
测试程序
package interpreter
import (
"fmt"
"testing"
)
func TestInterpreter(t *testing.T)
isAntarcticaExpression := generateCheckAntarcticaExpression()
// 大洲描述1
continentDescription1 := "此大洲生活着大量企鹅，全年低温，并且伴随着有暴风雪"
fmt.Printf("%s，是否是南极洲？%t\\n", continentDescription1, isAntarcticaExpression.Interpret(continentDescription1))
// 大洲描述2
continentDescription2 := "此大洲生活着狮子，全年高温多雨"
fmt.Printf("%s，是否是南极洲？%t\\n", continentDescription2, isAntarcticaExpression.Interpret(continentDescription2))
isAmericanExpression := generateCheckAmericanExpression()
peopleDescription1 := "此人生活在北美洲的黑人，说着英语，持有美国绿卡"
fmt.Printf("%s，是否是美国人？%t\\n", peopleDescription1, isAmericanExpression.Interpret(peopleDescription1))
peopleDescription2 := "此人生活在欧洲，说着英语，是欧洲议会议员"
fmt.Printf("%s，是否是南极洲？%t\\n", peopleDescription2, isAmericanExpression.Interpret(peopleDescription2))
// generateCheckAntarcticaExpression 生成校验是否是南极洲表达式
func generateCheckAntarcticaExpression() Expression
// 判断南极洲的动物，或关系
animalExpression := NewOrExpression(NewTerminalExpression("企鹅"),
NewTerminalExpression("蓝鲸"))
// 判断南极洲的天气，与关系
weatherExpression := NewAndExpression(NewTerminalExpression("低温"),
NewTerminalExpression("暴风雪"))
// 最终返回动物与天气的与关系
return NewAndExpression(animalExpression, weatherExpression)
// generateCheckAmericanExpression 生成检查美国人表达式
func generateCheckAmericanExpression() Expression
// 人种判断，或关系
raceExpression := NewOrExpression(NewTerminalExpression("白人"),
NewTerminalExpression("黑人"))
// 生活方式，与关系
lifeStyleExpression := NewAndExpression(NewTerminalExpression("英语"),
NewTerminalExpression("北美洲"))
// 身份，与关系
identityExpression := NewAndExpression(lifeStyleExpression, NewTerminalExpression("美国绿卡"))
return NewAndExpression(raceExpression, identityExpression)
运行结果
=== RUN TestInterpreter
此大洲生活着大量企鹅，全年低温，并且伴随着有暴风雪，是否是南极洲？true
此大洲生活着狮子，全年高温多雨，是否是南极洲？false
此人生活在北美洲的黑人，说着英语，持有美国绿卡，是否是美国人？true
此人生活在欧洲，说着英语，是欧洲议会议员，是否是美国人？false
--- PASS: TestInterpreter (0.00s)
PASS
适配器模式
（一）概念
适配器模式是一种结构型设计模式，它能使接口不兼容的对象能够相互合作。
适配器可担任两个对象间的封装器，它会接收对于一个对象的调用， 并将其转换为另一个对象可识别的格式和接口。
（二）示例
通过充电宝给不同充电接口的手机充电是一个非常符合适配器模式特征的生活示例；一般充电宝提供USB电源输出接口，手机充电输入接口则分为两类一是苹果手机的lightning接口，另一类是安卓手机的typeC接口，这两类接口都需要通过适配电源线连接充电宝的USB接口，这里USB接口就相当于充电宝的通用接口，lightning或typeC接口要想充电需要通过充电线适配。
手机充电插头
package adapter
import "fmt"
// HuaweiPlug 华为手机充电插槽接口
type HuaweiPlug interface
ConnectTypeC() string
// HuaweiPhone 华为系列手机
type HuaweiPhone struct
model string
// NewHuaweiPhone 华为手机创建方法
func NewHuaweiPhone(model string) *HuaweiPhone
return &HuaweiPhone
model: model,
// ConnectTypeC 华为手机TypeC充电插槽
func (h *HuaweiPhone) ConnectTypeC() string
return fmt.Sprintf("%v connect typeC plug", h.model)
// ApplePlug 苹果手机充电插槽
type ApplePlug interface
ConnectLightning() string
// IPhone 苹果系列手机
type IPhone struct
model string
// NewIPhone 苹果手机创建方法
func NewIPhone(model string) *IPhone
return &IPhone
model: model,
// ConnectLightning 苹果手机Lightning充电插槽
func (i *IPhone) ConnectLightning() string
return fmt.Sprintf("%v connect lightning plug", i.model)
充电宝适配器
package adapter
import "fmt"
// CommonPlug 通用的USB电源插槽
type CommonPlug interface
ConnectUSB() string
// HuaweiPhonePlugAdapter 华为TypeC充电插槽适配通用USB充电插槽
type HuaweiPhonePlugAdapter struct
huaweiPhone HuaweiPlug
// NewHuaweiPhonePlugAdapter 创建华为手机适配USB充电插槽适配器
func NewHuaweiPhonePlugAdapter(huaweiPhone HuaweiPlug) *HuaweiPhonePlugAdapter
return &HuaweiPhonePlugAdapter
huaweiPhone: huaweiPhone,
// ConnectUSB 链接USB
func (h *HuaweiPhonePlugAdapter) ConnectUSB() string
return fmt.Sprintf("%v adapt to usb ", h.huaweiPhone.ConnectTypeC())
// ApplePhonePlugAdapter 苹果Lightning充电插槽适配通用USB充电插槽
type ApplePhonePlugAdapter struct
iPhone ApplePlug
// NewApplePhonePlugAdapter 创建苹果手机适配USB充电插槽适配器
func NewApplePhonePlugAdapter(iPhone ApplePlug) *ApplePhonePlugAdapter
return &ApplePhonePlugAdapter
iPhone: iPhone,
// ConnectUSB 链接USB
func (a *ApplePhonePlugAdapter) ConnectUSB() string
return fmt.Sprintf("%v adapt to usb ", a.iPhone.ConnectLightning())
// PowerBank 充电宝
type PowerBank struct
brand string
// Charge 支持通用USB接口充电
func (p *PowerBank) Charge(plug CommonPlug) string
return fmt.Sprintf("%v power bank connect usb plug, start charge for %v", p.brand, plug.ConnectUSB())
测试程序
package adapter
import (
"fmt"
"testing"
)
func TestAdapter (t *testing.T)
huaweiMate40Pro := NewHuaweiPhone("华为 mate40 pro")
iphone13MaxPro := NewIPhone("苹果 iphone13 pro max")
powerBank := &PowerBank"飞利浦"
fmt.Println(powerBank.Charge(NewHuaweiPhonePlugAdapter(huaweiMate40Pro)))
fmt.Println(powerBank.Charge(NewApplePhonePlugAdapter(iphone13MaxPro)))
运行结果
=== RUN TestAdapter
飞利浦 power bank connect usb plug, start charge for 华为 mate40 pro connect typeC plug adapt to usb
飞利浦 power bank connect usb plug, start charge for 苹果 iphone13 pro max connect lightning plug adapt to usb
--- PASS: TestAdapter (0.00s)
PASS
桥接模式
（一）概念
桥接是一种结构型设计模式，可将业务逻辑或一个大类拆分为不同的层次结构， 从而能独立地进行开发。
层次结构中的第一层（通常称为抽象部分）将包含对第二层 （实现部分） 对象的引用。抽象部分将能将一些（有时是绝大部分）对自己的调用委派给实现部分的对象。所有的实现部分都有一个通用接口，因此它们能在抽象部分内部相互替换。
简单的说，一个事物存在多个维度的变化点，每一个维度都抽象出一个接口，事物引用这些接口实现整体行为逻辑，而每一个接口都可以存在多个变化的实现。
更简单的一句话：依赖接口编程。
（二）示例
对于一段经历的描述，经历就可能有多种实现，比如旅游经历，探险经历这相当于第一层次的类结构，同时描述旅游经历或探险经历又包含多个维度，比如如何到达目的地，在目的地开展了什么活动等，到达目的地有很多种方式，比如飞机、火车、汽车等；开展的活动又根据地点不同而不同，海边可以冲浪，山地可以攀岩，荒漠可以徒步穿越等；这两个维度的变化点对于描述经历来说相当于第二层次类实现，通过接口被第一层次引用。
这里对于经历描述存在三个维度的变化，
1.经历本身的两个实现：旅游经历与探险经历。
2.交通方式的两个实现：飞机和汽车。
3.开展活动的三个实现：冲浪、攀岩与徒步穿越。
如果用一个类层次去实现就需要2*2*3=12个不同的实现类，如果用桥接模式仅需要2+2+3=7个不同的类，而且两种方式的加速度也不一样，比如增加一个交通方式火车，非桥接模式需要增加2*3*3-12=6个实现类，桥接模式2+3+3-7=1个实现类；桥接模式大大增加了类之间组合的灵活性。
交通工具
package bridge
// Traffic 交通工具
type Traffic interface
Transport() string
// airplane 飞机
type airplane struct
// Transport 坐飞机
func (a *airplane) Transport() string
return "by airplane"
// car 汽车
type car struct
// Transport 坐汽车
func (t *car) Transport() string
return "by car"
目的地
package bridge
import "fmt"
// Location 地点
type Location interface
Name() string // 地点名称
PlaySports() string // 参与运动
// namedLocation 被命名的地点，统一引用此类型，声明名字字段及获取方法
type namedLocation struct
name string
// Name 获取地点名称
func (n namedLocation) Name() string
return n.name
// seaside 海边
type seaside struct
namedLocation
// NewSeaside 创建指定名字的海边，比如三亚湾
func NewSeaside(name string) *seaside
return &seaside
namedLocation: namedLocation
name: name,
,
// PlaySports 海边可以冲浪
func (s *seaside) PlaySports() string
return fmt.Sprintf("surfing")
// mountain 山
type mountain struct
namedLocation
// NewMountain 创建指定名字的山，比如泰山
func NewMountain(name string) *mountain
return &mountain
namedLocation: namedLocation
name: name,
,
// PlaySports 可以爬山
func (m *mountain) PlaySports() string
return fmt.Sprintf("climbing")
// desert 荒漠
type desert struct
namedLocation
// NewDesert 创建指定名字的荒漠，比如罗布泊
func NewDesert(name string) *desert
return &desert
namedLocation: namedLocation
name: name,
,
// PlaySports 荒漠可以徒步穿越
func (d *desert) PlaySports() string
return fmt.Sprintf("trekking")
经历描述
package bridge
import "fmt"
// Experience 经历
type Experience interface
Describe() string // 描述经历
// travelExperience 旅游经历
type travelExperience struct
subject string
traffic Traffic
location Location
// NewTravelExperience 创建旅游经历，包括主题、交通方式、地点
func NewTravelExperience(subject string, traffic Traffic, location Location) *travelExperience
return &travelExperience
subject: subject,
traffic: traffic,
location: location,
// Describe 描述旅游经历
func (t *travelExperience) Describe() string
return fmt.Sprintf("%s is to %s %s and %s", t.subject, t.location.Name(), t.traffic.Transport(), t.location.PlaySports())
// adventureExperience 探险经历
type adventureExperience struct
survivalTraining string
travelExperience
// NewAdventureExperience 创建探险经历，包括探险需要的培训，其他的与路由参数类似
func NewAdventureExperience(training string, subject string, traffic Traffic, location Location) *adventureExperience
return &adventureExperience
survivalTraining: training,
travelExperience: *NewTravelExperience(subject, traffic, location),
// Describe 描述探险经历
func (a *adventureExperience) Describe() string
return fmt.Sprintf("after %s, %s", a.survivalTraining, a.travelExperience.Describe())
测试程序
package bridge
import (
"fmt"
"testing"
)
func TestBridge(t *testing.T)
// 坐飞机去三亚度蜜月
honeymoonTravel := NewTravelExperience("honeymoon", new(airplane), NewSeaside("SanyaYalongBay"))
fmt.Println(honeymoonTravel.Describe())
// 坐车去泰山毕业旅游
graduationTrip := NewTravelExperience("graduationTrip", new(car), NewMountain("Tarzan"))
fmt.Println(graduationTrip.Describe())
// 野外生存培训后，坐车去罗布泊，徒步穿越
desertAdventure := NewAdventureExperience("wilderness survival training", "adventure", new(car), NewDesert("Lop Nor"))
fmt.Println(desertAdventure.Describe())
运行结果
=== RUN TestBridge
honeymoon is to SanyaYalongBay by airplane and surfing
graduationTrip is to Tarzan by car and climbing
after wilderness survival training, adventure is to Lop Nor by car and trekking
--- PASS: TestBridge (0.00s)
PASS
组合模式
（一）概念
组合是一种结构型设计模式，你可以使用它将对象组合成树状结构，并且能像使用独立对象一样使用它们。
对于绝大多数需要生成树状结构的问题来说，组合都是非常受欢迎的解决方案。组合最主要的功能是在整个树状结构上递归调用方法并对结果进行汇总。
（二）示例
一般来说一个地区统计人口或经济总量，总是通过行政区划一层层上报汇总得出结果，区镇是最低一级行政区划，需要落实统计人口及经济总量的工作，再上一级行政区划需要将所辖区镇的数据汇总统计，以此类推每一级行政区划都需要统计人口与经济总量，就像一个倒过来的树状结构，各级行政区划统一的组件接口是统计人口与经济总量，区镇相当于最底层的叶子节点，中间级别行政区划相当于组合节点；下面代码以苏州市为例；
组件接口
package composite
// Region 行政区，作为组合模式component接口
type Region interface
Name() string // 名称
Population() int //人口
GDP() float64 // gdp
区镇实现
package composite
// town 区镇，组合模式中相当于叶子节点
type town struct
name string
population int
gdp float64
// NewTown 创建区镇，根据名称、人口、GDP
func NewTown(name string, population int, gdp float64) *town
return &town
name: name,
population: population,
gdp: gdp,
func (c *town) Name() string
return c.name
func (c *town) Population() int
return c.population
func (c *town) GDP() float64
return c.gdp
县市地市实现
package composite
// cities 市，包括县市或者地市，组合模式中相当于composite
type cities struct
name string
regions map[string]Region
// NewCities 创建一个市
func NewCities(name string) *cities
return &cities
name: name,
regions: make(map[string]Region),
func (c *cities) Name() string
return c.name
func (c *cities) Population() int
sum := 0
for _, r := range c.regions
sum += r.Population()
return sum
func (c *cities) GDP() float64
sum := 0.0
for _, r := range c.regions
sum += r.GDP()
return sum
// Add 添加多个行政区
func (c *cities) Add(regions ...Region)
for _, r := range regions
c.regions[r.Name()] = r
// Remove 递归删除行政区
func (c *cities) Remove(name string)
for n, r := range c.regions
if n == name
delete(c.regions, name)
return
if city, ok := r.(*cities); ok
city.Remove(name)
func (c *cities) Regions() map[string]Region
return c.regions
测试程序
package composite
import (
"fmt"
"testing"
)
func TestComposite(t *testing.T)
gusu := NewTown("姑苏区", 100, 2000.00)
fmt.Println(ShowRegionInfo(gusu))
wuzhong := NewTown("吴中区", 150, 2600.00)
fmt.Println(ShowRegionInfo(wuzhong))
huqiu := NewTown("虎丘区", 80, 1800.00)
fmt.Println(ShowRegionInfo(huqiu))
kunshan := NewCities("昆山市")
kunshan.Add(NewTown("玉山镇", 60, 1200.00),
NewTown("周庄镇", 68, 1900.00),
NewTown("花桥镇", 78, 2200.00))
fmt.Println(ShowRegionInfo(kunshan))
changshu := NewCities("常熟市")
changshu.Add(NewTown("沙家浜镇", 55, 1100.00),
NewTown("古里镇", 59, 1300.00),
NewTown("辛庄镇", 68, 2100.00))
fmt.Println(ShowRegionInfo(changshu))
suzhou := NewCities("苏州市")
suzhou.Add(gusu, wuzhong, huqiu, kunshan, changshu)
fmt.Println(ShowRegionInfo(suzhou))
func ShowRegionInfo(region Region) string
return fmt.Sprintf("%s, 人口:%d万, GDP:%.2f亿", region.Name(), region.Population(), region.GDP())
运行结果
=== RUN TestComposite
姑苏区, 人口:100万, GDP:2000.00亿
吴中区, 人口:150万, GDP:2600.00亿
虎丘区, 人口:80万, GDP:1800.00亿
昆山市, 人口:206万, GDP:5300.00亿
常熟市, 人口:182万, GDP:4500.00亿
苏州市, 人口:718万, GDP:16200.00亿
--- PASS: TestComposite (0.00s)
PASS
装饰模式
（一）概念
装饰是一种结构设计模式，允许你通过将对象放入特殊封装对象中来为原对象增加新的行为。
由于目标对象和装饰器遵循同一接口，因此你可用装饰来对对象进行无限次的封装。结果对象将获得所有封装器叠加而来的行为。
（二）示例
地铁进站的过程一般情况下只需要买票，检票进站，但是如果你是带行李，就需要进行安全检查，如果是疫情时期，就需要进行疫情防护检查，比如戴口罩、测量体温等，这里买票进站相当于通用进站流程，安检及防疫检查就相当于加强的修饰行为。
修饰器实现
package decorator
import "fmt"
// Station 车站，修饰器模式统一接口
type Station interface
Enter() string // 进站
// subwayStation 地铁站
type subwayStation struct
name string
// NewSubwayStation 创建指定站名地铁站
func NewSubwayStation(name string) *subwayStation
return &subwayStation
name: name,
// Enter 进地铁站
func (s *subwayStation) Enter() string
return fmt.Sprintf("买票进入%s地铁站。", s.name)
// securityCheckDecorator 进站安检修饰器
type securityCheckDecorator struct
station Station
func NewSecurityCheckDecorator(station Station) *securityCheckDecorator
return &securityCheckDecorator
station: station,
func (s *securityCheckDecorator) Enter() string
return "行李通过安检；" + s.station.Enter()
// epidemicProtectionDecorator 进站疫情防护修饰器
type epidemicProtectionDecorator struct
station Station
func NewEpidemicProtectionDecorator(station Station) *epidemicProtectionDecorator
return &epidemicProtectionDecorator
station: station,
func (e *epidemicProtectionDecorator) Enter() string
return "测量体温，佩戴口罩；" + e.station.Enter()
测试代码
package decorator
import (
"fmt"
"testing"
)
func TestDecorator(t *testing.T)
xierqiStation := NewSubwayStation("西二旗")
fmt.Println(EnhanceEnterStationProcess(xierqiStation, false, false).Enter())
fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, false).Enter())
fmt.Println(EnhanceEnterStationProcess(xierqiStation, true, true).Enter())
// EnhanceEnterStationProcess 根据是否有行李，是否处于疫情，增加进站流程
func EnhanceEnterStationProcess(station Station, hasLuggage bool, hasEpidemic bool) Station
if hasLuggage
station = NewSecurityCheckDecorator(station)
if hasEpidemic
station = NewEpidemicProtectionDecorator(station)
return station
运行结果
=== RUN TestDecorator
买票进入西二旗地铁站。
行李通过安检；买票进入西二旗地铁站。
测量体温，佩戴口罩；行李通过安检；买票进入西二旗地铁站。
--- PASS: TestDecorator (0.00s)
PASS
外观模式
（一）概念
外观是一种结构型设计模式，能为复杂系统、程序库或框架提供一个简单 （但有限） 的接口。
尽管外观模式降低了程序的整体复杂度，但它同时也有助于将不需要的依赖移动到同一个位置。
（二）示例
用户在淘宝电商系统买商品时，只需要选好商品在结算页点击提交即可完成下单；在客户端系统仅需要一个创建订单的方法，但是整个订单的生成需要很多步骤，比如查询用户配送地址，查询商品价格，使用优惠券，扣减商品库存，支付相应价钱等。
淘宝电商系统
package facade
import "fmt"
// TaobaoFacade 淘宝网站门面，在淘宝网站下单涉及到多个系统配合调用，包括用户系统，商品系统，优惠券系统，库存系统，支付系统，最终生成订单
type TaobaoFacade struct
userService *UserService
productService *ProductService
couponService *CouponService
stockService *StockService
paymentService *PaymentService
// NewTaobaoFacade 创建淘宝网站
func NewTaobaoFacade() *TaobaoFacade
return &TaobaoFacade
userService: &UserService,
productService: &ProductService
products: map[string]float64"笔记本电脑": 6666.66,
,
couponService: &CouponService,
stockService: &StockService,
paymentService: &PaymentService,
// CreateOrder 根据用户名，商品名，商品数量生成购买订单
func (t *TaobaoFacade) CreateOrder(userName string, productName string, count int) string
// 使用优惠券
couponInfo := t.couponService.useCoupon()
// 扣减库存
stockInfo := t.stockService.decreaseFor(productName, count)
// 计算商品总价
sumPrice := t.productService.getProductPrice(productName) * float64(count)
// 支付价格
payInfo := t.paymentService.pay(sumPrice)
return fmt.Sprintf("用户%s,购买了%d件%s商品,%s,%s,%s,送货到%s", userName, count, productName, couponInfo,
stockInfo, payInfo, t.userService.getUserAddress(userName))
// UserService 用户系统
type UserService struct
func (u *UserService) getUserAddress(userName string) string
return fmt.Sprintf("%s地址是:北京市海淀区中关村大街，1号院2号楼3单元402", userName)
// ProductService 商品系统
type ProductService struct
products map[string]float64
func (p *ProductService) getProductPrice(productName string) float64
return p.products[productName]
// CouponService 优惠券系统
type CouponService struct
func (c *CouponService) useCoupon() string
return "使用满100减20优惠券"
// StockService 库存系统
type StockService struct
func (s *StockService) decreaseFor(productName string, count int) string
return fmt.Sprintf("扣减%d件%s商品库存", count, productName)
// PaymentService 支付系统
type PaymentService struct
func (p *PaymentService) pay(amount float64) string
return fmt.Sprintf("支付金额%.2f", amount)
测试程序
package facade
import (
"fmt"
"testing"
)
func TestFacade(t *testing.T)
// 通过门面模式，隐藏下单过程中，后端多个系统的复杂交互
taobao := NewTaobaoFacade()
fmt.Println(taobao.CreateOrder("张三", "笔记本电脑", 1))
运行结果
=== RUN TestFacade
用户张三,购买了1件笔记本电脑商品,使用满100减20优惠券,扣减1件笔记本电脑商品库存,支付金额6666.66,送货到张三地址是:北京市海淀区中关村大街，1号院2号楼3单元402
--- PASS: TestFacade (0.00s)
PASS
享元模式
（一）概念
享元是一种结构型设计模式，它允许你在消耗少量内存的情况下支持大量对象。
模式通过共享多个对象的部分状态来实现上述功能。换句话来说，享元会将不同对象的相同数据进行缓存以节省内存。
（二）示例
北京出租车调度系统，需要每隔一分钟记录一下全市出租车的位置信息，假设为了提高系统响应速度，近一天的数据需要存储在内存中，每个位置信息包括出租车辆信息及位置信息，位置信息在系统中就是一个(x,y)坐标，车辆信息包括车的号牌，颜色，品牌和所属公司，在调度系统存储的出租车行驶轨迹中，位置是实时在变化的，但车辆信息就可以通过享元模式共用一个对象引用，来减少内存消耗。
出租车享元对象
package flyweight
import (
"fmt"
)
// Taxi 出租车，享元对象，保存不变的内在属性信息
type Taxi struct
licensePlate string // 车牌
color string // 颜色
brand string // 汽车品牌
company string // 所属公司
// LocateFor 获取定位信息
func (t *Taxi) LocateFor(monitorMap string, x, y int) string
return fmt.Sprintf("%s,对于车牌号%s,%s,%s品牌,所属%s公司,定位(%d,%d)", monitorMap,
t.licensePlate, t.color, t.brand, t.company, x, y)
// taxiFactoryInstance 出租车工厂单例
var taxiFactoryInstance = &TaxiFactory
taxis: make(map[string]*Taxi),
// GetTaxiFactory 获取出租车工厂单例
func GetTaxiFactory() *TaxiFactory
return taxiFactoryInstance
// TaxiFactory 出租车工厂类
type TaxiFactory struct
taxis map[string]*Taxi // key为车牌号
// getTaxi 获取出租车
func (f *TaxiFactory) getTaxi(licensePlate, color, brand, company string) *Taxi
if _, ok := f.taxis[licensePlate]; !ok
f.taxis[licensePlate] = &Taxi
licensePlate: licensePlate,
color: color,
brand: brand,
company: company,
return f.taxis[licensePlate]
出租车调度系统
package flyweight
import "bytes"
// TaxiPosition 出租车位置信息 x,y为外在数据信息，taxi为内在数据信息（享元对象）
type TaxiPosition struct
x int
y int
taxi *Taxi
func NewTaxiPosition(taxi *Taxi, x, y int) *TaxiPosition
return &TaxiPosition
taxi: taxi,
x: x,
y: y,
// LocateFor 定位信息
func (p *TaxiPosition) LocateFor(monitorMap string) string
return p.taxi.LocateFor(monitorMap, p.x, p.y)
// TaxiDispatcher 出租车调度系统
type TaxiDispatcher struct
name string
traces map[string][]*TaxiPosition // 存储出租车当天轨迹信息，key为车牌号
func NewTaxiDispatcher(name string) *TaxiDispatcher
return &TaxiDispatcher
name: name,
traces: make(map[string][]*TaxiPosition),
// AddTrace 添加轨迹
func (t *TaxiDispatcher) AddTrace(licensePlate, color, brand, company string, x, y int)
taxi := GetTaxiFactory().getTaxi(licensePlate, color, brand, company)
t.traces[licensePlate] = append(t.traces[licensePlate], NewTaxiPosition(taxi, x, y))
// ShowTraces 显示轨迹
func (t *TaxiDispatcher) ShowTraces(licensePlate string) string
bytesBuf := bytes.Buffer
for _, trace := range t.traces[licensePlate]
bytesBuf.WriteString(trace.LocateFor(t.name))
bytesBuf.WriteByte('\\n')
return bytesBuf.String()
测试程序
package flyweight
import (
"fmt"
"testing"
)
func TestFlyweight(t *testing.T)
dispatcher := NewTaxiDispatcher("北京市出租车调度系统")
dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 10, 20)
dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 20, 30)
dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 30, 40)
dispatcher.AddTrace("京B.123456", "黄色", "北京现代", "北汽", 40, 50)
dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 20, 40)
dispatcher.AddTrace("京B.567890", "红色", "一汽大众", "首汽", 50, 50)
fmt.Println(dispatcher.ShowTraces("京B.123456"))
fmt.Println(dispatcher.ShowTraces("京B.567890"))
运行结果
=== RUN TestFlyweight
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(10,20)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(20,30)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(30,40)
北京市出租车调度系统,对于车牌号京B.123456,黄色,北京现代品牌,所属北汽公司,定位(40,50)
北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(20,40)
北京市出租车调度系统,对于车牌号京B.567890,红色,一汽大众品牌,所属首汽公司,定位(50,50)
--- PASS: TestFlyweight (0.00s)
PASS
代理模式
（一）概念
代理是一种结构型设计模式，让你能提供真实服务对象的替代品给客户端使用。代理接收客户端的请求并进行一些处理 （访问控制和缓存等）， 然后再将请求传递给服务对象。
代理对象拥有和服务对象相同的接口，这使得当其被传递给客户端时可与真实对象互换。
修饰与代理是非常相似的设计模式，都是基于组合设计原则，也就是说一个对象应该将部分工作委派给另一个对象。但两者之间不同点我认为是，修饰器模式总是要执行服务对象，对于执行之前或执行之后结果进行加强，服务对象基本是客户端创建好再嵌套外层的修饰对象；而代理模式不一定执行服务对象，有可能通过缓存，延迟加载等没有访问服务对象，同时服务对象什么时候创建也是由代理类决定的。
（二）示例
房屋中介代理帮助房东卖房子，这个过程就是一个代理模式的过程，中介会收集尽量多的卖房信息，并通过各种渠道发布，同时中介会随时带客户看房，并初步商讨价格，如果达成初步购买意向，才会约房东讨论房屋价格，最后签约卖房；房屋中介与房东都实现卖房接口，中介会提前坐一些前期工作，如果都没问题，才会约房东执行真正的签约卖房流程。
房屋中介卖房
package proxy
import (
"bytes"
"fmt"
)
// HouseSeller 房屋出售者
type HouseSeller interface
SellHouse(address string, buyer string) string
// houseProxy 房产中介代理
type houseProxy struct
houseSeller HouseSeller
func NewHouseProxy(houseSeller HouseSeller) *houseProxy
return &houseProxy
houseSeller: houseSeller,
// SellHouse 中介卖房，看房->初步谈价->最终和房东签协议
func (h *houseProxy) SellHouse(address string, buyer string) string
buf := bytes.Buffer
buf.WriteString(h.viewHouse(address, buyer) + "\\n")
buf.WriteString(h.preBargain(address, buyer) + "\\n")
buf.WriteString(h.houseSeller.SellHouse(address, buyer))
return buf.String()
// viewHouse 看房介绍基本情况
func (h *houseProxy) viewHouse(address string, buyer string) string
return fmt.Sprintf("带买家%s看位于%s的房屋，并介绍基本情况", buyer, address)
// preBargain 初步沟通价格
func (h *houseProxy) preBargain(address string, buyer string) string
return fmt.Sprintf("讨价还价后，初步达成购买意向")
// houseOwner 房东
type houseOwner struct
// SellHouse 房东卖房，商讨价格，签署购房协议
func (h *houseOwner) SellHouse(address string, buyer string) string
return fmt.Sprintf("最终商讨价格后，与%s签署购买地址为%s的购房协议。", buyer, address)
测试程序
package proxy
import (
"fmt"
"testing"
)
func TestProxy(t *testing.T)
proxy := NewHouseProxy(&houseOwner)
fmt.Println(proxy.SellHouse("北京市海淀区中关村大街，2号院1号楼4单元502室", "李四"))
运行结果
=== RUN TestProxy
带买家李四看位于北京市海淀区中关村大街，2号院1号楼4单元502室的房屋，并介绍基本情况
讨价还价后，初步达成购买意向
最终商讨价格后，与李四签署购买地址为北京市海淀区中关村大街，2号院1号楼4单元502室的购房协议。
--- PASS: TestProxy (0.00s)
PASS
工厂方法模式
（一）概念
工厂方法模式是一种创建型设计模式，其在父类中提供一个创建对象的方法， 允许子类决定实例化对象的类型。
（二）示例
摊煎饼的小贩需要先摊个煎饼，再卖出去，摊煎饼就可以类比为一个工厂方法，根据顾客的喜好摊出不同口味的煎饼。
接口
package factorymethod
// Pancake 煎饼
type Pancake interface
// ShowFlour 煎饼使用的面粉
ShowFlour() string
// Value 煎饼价格
Value() float32
// PancakeCook 煎饼厨师
type PancakeCook interface
// MakePancake 摊煎饼
MakePancake() Pancake
// PancakeVendor 煎饼小贩
type PancakeVendor struct
PancakeCook
// NewPancakeVendor ...
func NewPancakeVendor(cook PancakeCook) *PancakeVendor
return &PancakeVendor
PancakeCook: cook,
// SellPancake 卖煎饼，先摊煎饼，再卖
func (vendor *PancakeVendor) SellPancake() (money float32)
return vendor.MakePancake().Value()
实现
各种面的煎饼实现
package factorymethod
// cornPancake 玉米面煎饼
type cornPancake struct
// NewCornPancake ...
func NewCornPancake() *cornPancake
return &cornPancake
func (cake *cornPancake) ShowFlour() string
return "玉米面"
func (cake *cornPancake) Value() float32
return 5.0
// milletPancake 小米面煎饼
type milletPancake struct
func NewMilletPancake() *milletPancake
return &milletPancake
func (cake *milletPancake) ShowFlour() string
return "小米面"
func (cake *milletPancake) Value() float32
return 8.0
制作各种口味煎饼的工厂方法实现
package factorymethod
// cornPancakeCook 制作玉米面煎饼厨师
type cornPancakeCook struct
func NewCornPancakeCook() *cornPancakeCook
return &cornPancakeCook
func (cook *cornPancakeCook) MakePancake() Pancake
return NewCornPancake()
// milletPancakeCook 制作小米面煎饼厨师
type milletPancakeCook struct
func NewMilletPancakeCook() *milletPancakeCook
return &milletPancakeCook
func (cook *milletPancakeCook) MakePancake() Pancake
return NewMilletPancake()
运用
package factorymethod
import (
"fmt"
"testing"
)
func TestFactoryMethod(t *testing.T)
pancakeVendor := NewPancakeVendor(NewCornPancakeCook())
fmt.Printf("Corn pancake value is %v\\n", pancakeVendor.SellPancake())
pancakeVendor = NewPancakeVendor(NewMilletPancakeCook())
fmt.Printf("Millet pancake value is %v\\n", pancakeVendor.SellPancake())
输出：
=== RUN TestFactoryMethod
Corn pancake value is 5
Millet pancake value is 8
--- PASS: TestFactoryMethod (0.00s)
PASS
抽象工厂模式
（一）概念
抽象工厂是一种创建型设计模式，它能创建一系列相关的对象，而无需指定其具体类。
抽象工厂定义了用于创建不同产品的接口，但将实际的创建工作留给了具体工厂类。每个工厂类型都对应一个特定的产品变体。
在创建产品时，客户端代码调用的是工厂对象的构建方法，而不是直接调用构造函数 （ new操作符）。由于一个工厂对应一种产品变体，因此它创建的所有产品都可相互兼容。
客户端代码仅通过其抽象接口与工厂和产品进行交互。该接口允许同一客户端代码与不同产品进行交互。你只需创建一个具体工厂类并将其传递给客户端代码即可。
（二）示例
厨师准备一餐时，会分别做吃的和喝的，根据早、中、晚三餐饮食习惯，会分别制作不同的饮食，厨师就相当于抽象工厂，制作三餐的不同烹饪方式就好比不同抽象工厂的实现。
接口
package abstractfactory
// Cook 厨师接口，抽象工厂
type Cook interface
// MakeFood 制作主食
MakeFood() Food
// MakeDrink 制作饮品
MakeDrink() Drink
// Food 主食接口
type Food interface
// Eaten 被吃
Eaten() string
// Drink 饮品接口
type Drink interface
// Drunk 被喝
Drunk() string
实现
三餐不同厨师接口的实现
package abstractfactory
// breakfastCook 早餐厨师
type breakfastCook struct
func NewBreakfastCook() *breakfastCook
return &breakfastCook
func (b *breakfastCook) MakeFood() Food
return &cakeFood"切片面包"
func (b *breakfastCook) MakeDrink() Drink
return &gruelDrink"小米粥"
// lunchCook 午餐厨师
type lunchCook struct
func NewLunchCook() *lunchCook
return &lunchCook
func (l *lunchCook) MakeFood() Food
return &dishFood"烤全羊"
func (l *lunchCook) MakeDrink() Drink
return &sodaDrink"冰镇可口可乐"
// dinnerCook 晚餐厨师
type dinnerCook struct
func NewDinnerCook() *dinnerCook
return &dinnerCook
func (d *dinnerCook) MakeFood() Food
return &noodleFood"大盘鸡拌面"
func (d *dinnerCook) MakeDrink() Drink
return &soupDrink"西红柿鸡蛋汤"
不同吃的
package abstractfactory
import "fmt"
// cakeFood 蛋糕
type cakeFood struct
cakeName string
func (c *cakeFood) Eaten() string
return fmt.Sprintf("%v被吃", c.cakeName)
// dishFood 菜肴
type dishFood struct
dishName string
func (d *dishFood) Eaten() string
return fmt.Sprintf("%v被吃", d.dishName)
// noodleFood 面条
type noodleFood struct
noodleName string
func (n *noodleFood) Eaten() string
return fmt.Sprintf("%v被吃", n.noodleName)
不同喝的
package abstractfactory
import "fmt"
// gruelDrink 粥
type gruelDrink struct
gruelName string
func (g *gruelDrink) Drunk() string
return fmt.Sprintf("%v被喝", g.gruelName)
// sodaDrink 汽水
type sodaDrink struct
sodaName string
func (s *sodaDrink) Drunk() string
return fmt.Sprintf("%v被喝", s.sodaName)
// soupDrink 汤
type soupDrink struct
soupName string
func (s *soupDrink) Drunk() string
return fmt.Sprintf("%v被喝", s.soupName)
运用
package abstractfactory
import (
"fmt"
"testing"
)
func TestAbstractFactory(t *testing.T)
fmt.Printf("breakfast: %v\\n", HaveMeal(NewBreakfastCook()))
fmt.Printf("lunch: %v\\n", HaveMeal(NewLunchCook()))
fmt.Printf("dinner: %v\\n", HaveMeal(NewDinnerCook()))
// HaveMeal 吃饭
func HaveMeal(cook Cook) string
return fmt.Sprintf("%s %s", cook.MakeFood().Eaten(), cook.MakeDrink().Drunk())
输出
=== RUN TestAbstractFactory
breakfast: 切片面包被吃 小米粥被喝
lunch: 烤全羊被吃 冰镇可口可乐被喝
dinner: 大盘鸡拌面被吃 西红柿鸡蛋汤被喝
--- PASS: TestAbstractFactory (0.00s)
PASS
生成器模式
（一）概念
生成器是一种创建型设计模式，使你能够分步骤创建复杂对象。
与其他创建型模式不同，生成器不要求产品拥有通用接口。这使得用相同的创建过程生成不同的产品成为可能。
（二）示例
还是摊煎饼的例子，摊煎饼分为四个步骤，1放面糊、2放鸡蛋、3放调料、4放薄脆，通过四个创建过程，制作好一个煎饼，这个摊煎饼的过程就好比煎饼生成器接口，不同生成器的实现就相当于摊不同品类的煎饼，比如正常的煎饼，健康的煎饼（可能用的是粗粮面、柴鸡蛋、非油炸薄脆、不放酱等），生成器接口方法也可以通过参数控制煎饼的大小，比如放两勺面糊，放2个鸡蛋等。
生成器的使用者为了避免每次都调用相同的构建步骤，也可以通过包装类固定几种构建过程，生成几类常用的产品，就好像摊煎饼有几类常卖固定成品，比如普通的，加两个鸡蛋的，不要香菜的等等，这几类固定构建过程提前定制好，直接通过简单工厂方法就直接创建，如果用户再需要细粒度的定制构建，再通过生成器创建。
接口
package builder
// Quantity 分量
type Quantity int
const (
Small Quantity = 1
Middle Quantity = 5
Large Quantity = 10
)
type PancakeBuilder interface
// PutPaste 放面糊
PutPaste(quantity Quantity)
// PutEgg 放鸡蛋
PutEgg(num int)
// PutWafer 放薄脆
PutWafer()
// PutFlavour 放调料 Coriander香菜，Shallot葱 Sauce酱
PutFlavour(hasCoriander, hasShallot, hasSauce bool)
// Build 摊煎饼
Build() *Pancake
// Pancake 煎饼
type Pancake struct
pasteQuantity Quantity // 面糊分量
eggNum int // 鸡蛋数量
wafer string // 薄脆
hasCoriander bool // 是否放香菜
hasShallot bool // 是否放葱
hasSauce bool // 是否放酱
实现
正常煎饼创建器
package builder
type normalPancakeBuilder struct
pasteQuantity Quantity // 面糊量
eggNum int // 鸡蛋数量
friedWafer string // 油炸薄脆
hasCoriander bool // 是否放香菜
hasShallot bool // 是否放葱
hasHotSauce bool // 是否放辣味酱
func NewNormalPancakeBuilder() *normalPancakeBuilder
return &normalPancakeBuilder
func (n *normalPancakeBuilder) PutPaste(quantity Quantity)
n.pasteQuantity = quantity
func (n *normalPancakeBuilder) PutEgg(num int)
n.eggNum = num
func (n *normalPancakeBuilder) PutWafer()
n.friedWafer = "油炸的薄脆"
func (n *normalPancakeBuilder) PutFlavour(hasCoriander, hasShallot, hasSauce bool)
n.hasCoriander = hasCoriander
n.hasShallot = hasShallot
n.hasHotSauce = hasSauce
func (n *normalPancakeBuilder) Build() *Pancake
return &Pancake
pasteQuantity: n.pasteQuantity,
eggNum: n.eggNum,
wafer: n.friedWafer,
hasCoriander: n.hasCoriander,
hasShallot: n.hasShallot,
hasSauce: n.hasHotSauce,
健康煎饼创建器
package builder
type healthyPancakeBuilder struct
milletPasteQuantity Quantity // 小米面糊量
chaiEggNum int // 柴鸡蛋数量
nonFriedWafer string // 非油炸薄脆
hasCoriander bool // 是否放香菜
hasShallot bool // 是否放葱
func NewHealthyPancakeBuilder() *healthyPancakeBuilder
return &healthyPancakeBuilder
func (n *healthyPancakeBuilder) PutPaste(quantity Quantity)
n.milletPasteQuantity = quantity
func (n *healthyPancakeBuilder) PutEgg(num int)
n.chaiEggNum = num
func (n *healthyPancakeBuilder) PutWafer()
n.nonFriedWafer = "非油炸的薄脆"
func (n *healthyPancakeBuilder) PutFlavour(hasCoriander, hasShallot, _ bool)
n.hasCoriander = hasCoriander
n.hasShallot = hasShallot
func (n *healthyPancakeBuilder) Build() *Pancake
return &Pancake
pasteQuantity: n.milletPasteQuantity,
eggNum: n.chaiEggNum,
wafer: n.nonFriedWafer,
hasCoriander: n.hasCoriander,
hasShallot: n.hasShallot,
hasSauce: false,
煎饼生成器的封装类-厨师
package builder
// PancakeCook 摊煎饼师傅
type PancakeCook struct
builder PancakeBuilder
func NewPancakeCook(builder PancakeBuilder) *PancakeCook
return &PancakeCook
builder: builder,
// SetPancakeBuilder 重新设置煎饼构造器
func (p *PancakeCook) SetPancakeBuilder(builder PancakeBuilder)
p.builder = builder
// MakePancake 摊一个一般煎饼
func (p *PancakeCook) MakePancake() *Pancake
p.builder.PutPaste(Middle)
p.builder.PutEgg(1)
p.builder.PutWafer()
p.builder.PutFlavour(true, true, true)
return p.builder.Build()
// MakeBigPancake 摊一个巨无霸煎饼
func (p *PancakeCook) MakeBigPancake() *Pancake
p.builder.PutPaste(Large)
p.builder.PutEgg(3)
p.builder.PutWafer()
p.builder.PutFlavour(true, true, true)
return p.builder.Build()
// MakePancakeForFlavour 摊一个自选调料霸煎饼
func (p *PancakeCook) MakePancakeForFlavour(hasCoriander, hasShallot, hasSauce bool) *Pancake
p.builder.PutPaste(Large)
p.builder.PutEgg(3)
p.builder.PutWafer()
p.builder.PutFlavour(hasCoriander, hasShallot, hasSauce)
return p.builder.Build()
运用
package builder
import (
"fmt"
"testing"
)
func TestBuilder(t *testing.T)
pancakeCook := NewPancakeCook(NewNormalPancakeBuilder())
fmt.Printf("摊一个普通煎饼 %#v\\n", pancakeCook.MakePancake())
pancakeCook.SetPancakeBuilder(NewHealthyPancakeBuilder())
fmt.Printf("摊一个健康的加量煎饼 %#v\\n", pancakeCook.MakeBigPancake())
输出
=== RUN TestBuilder
摊一个普通煎饼 &builder.PancakepasteQuantity:5, eggNum:1, wafer:"油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:true
摊一个健康的加量煎饼 &builder.PancakepasteQuantity:10, eggNum:3, wafer:"非油炸的薄脆", hasCoriander:true, hasShallot:true, hasSauce:false
--- PASS: TestBuilder (0.00s)
PASS
原型模式
（一）概念
原型是一种创建型设计模式，使你能够复制对象，甚至是复杂对象，而又无需使代码依赖它们所属的类。
所有的原型类都必须有一个通用的接口， 使得即使在对象所属的具体类未知的情况下也能复制对象。原型对象可以生成自身的完整副本， 因为相同类的对象可以相互访问对方的私有成员变量。
（二）示例
纸质文件可以通过复印机轻松拷贝出多份，设置Paper接口，包含读取文件内容和克隆文件两个方法。同时声明两个类报纸（Newspaper）和简历（Resume）实现了Paper接口，通过复印机（Copier）复印出两类文件的副本，并读取文件副本内容。
接口实现
package prototype
import (
"bytes"
"fmt"
"io"
)
// Paper 纸张，包含读取内容的方法，拷贝纸张的方法，作为原型模式接口
type Paper interface
io.Reader
Clone() Paper
// Newspaper 报纸 实现原型接口
type Newspaper struct
headline string
content string
func NewNewspaper(headline string, content string) *Newspaper
return &Newspaper
headline: headline,
content: content,
func (np *Newspaper) Read(p []byte) (n int, err error)
buf := bytes.NewBufferString(fmt.Sprintf("headline:%s,content:%s", np.headline, np.content))
return buf.Read(p)
func (np *Newspaper) Clone() Paper
return &Newspaper
headline: np.headline + "_copied",
content: np.content,
// Resume 简历 实现原型接口
type Resume struct
name string
age int
experience string
func NewResume(name string, age int, experience string) *Resume
return &Resume
name: name,
age: age,
experience: experience,
func (r *Resume) Read(p []byte) (n int, err error)
buf := bytes.NewBufferString(fmt.Sprintf("name:%s,age:%d,experience:%s", r.name, r.age, r.experience))
return buf.Read(p)
func (r *Resume) Clone() Paper
return &Resume
name: r.name + "_copied",
age: r.age,
experience: r.experience,
运用
package prototype
import (
"fmt"
"reflect"
"testing"
)
func TestPrototype(t *testing.T)
copier := NewCopier("云打印机")
oneNewspaper := NewNewspaper("Go是最好的编程语言", "Go语言十大优势")
oneResume := NewResume("小明", 29, "5年码农")
otherNewspaper := copier.copy(oneNewspaper)
copyNewspaperMsg := make([]byte, 100)
byteSize, _ := otherNewspaper.Read(copyNewspaperMsg)
fmt.Println("copyNewspaperMsg:" + string(copyNewspaperMsg[:byteSize]))
otherResume := copier.copy(oneResume)
copyResumeMsg := make([]byte, 100)
byteSize, _ = otherResume.Read(copyResumeMsg)
fmt.Println("copyResumeMsg:" + string(copyResumeMsg[:byteSize]))
// Copier 复印机
type Copier struct
name string
func NewCopier(n string) *Copier
return &Copiername: n
func (c *Copier) copy(paper Paper) Paper
fmt.Printf("copier name:%v is copying:%v ", c.name, reflect.TypeOf(paper).String())
return paper.Clone()
输出
=== RUN TestPrototype
copier name:云打印机 is copying:*prototype.Newspaper copyNewspaperMsg:headline:Go是最好的编程语言_copied,content:Go语言十大优势
copier name:云打印机 is copying:*prototype.Resume copyResumeMsg:name:小明_copied,age:29,experience:5年码农
--- PASS: TestPrototype (0.00s)
PASS
单例模式
(一）概念
单例是一种创建型设计模式，让你能够保证一个类只有一个实例，并提供一个访问该实例的全局节点。
单例拥有与全局变量相同的优缺点。尽管它们非常有用，但却会破坏代码的模块化特性。
（二）示例
通过地球对象实现单例，earth不能导出，通过TheEarth方法访问全局唯一实例，并通过sync.Once实现多协程下一次加载。
接口实现
package singleton
import "sync"
var once sync.Once
// 不可导出对象
type earth struct
desc string
func (e *earth) String() string
return e.desc
// theEarth 地球单实例
var theEarth *earth
// TheEarth 获取地球单实例
func TheEarth() *earth
if theEarth == nil
once.Do(func()
theEarth = &earth
desc: "美丽的地球，孕育了生命。",
)
return theEarth
运用
package singleton
import (
"fmt"
"testing"
)
func TestSingleton(t *testing.T)
fmt.Println(TheEarth().String())
输出
=== RUN TestSingleton
美丽的地球，孕育了生命。
--- PASS: TestSingleton (0.00s)
PASS点击下方空白 ▼ 查看明日开发者黄历
summer
time
2022
/
07.23
以上是关于快收藏！最全GO语言实现设计模式下的主要内容，如果未能解决你的问题，请参考以下文章