快来，这里有23种设计模式的Go语言实现

​​​​​​​​摘要：规划办法（Design Pattern）是一套被重复运用、多数人知晓的、经过分类编意图、代码规划阅历的总结，运用规划办法是为了可重产品战略用代码、让代码更简略被他人了解并且确保代码可靠性。

本文同享自华为云社区《快来，这里有23种规划办法的Go言语结束》，原文作者：元闰子 。

前语

从 1995 年 GoF 提出 23 种规划办法到现在，25 年过去嵌套查询sql句子了，规划办法依旧是软件范产品运营畴的热门话题。在当下，假定你不会一点规划办法，都不好意思说自己是一个合格产品经理的程序员。规划办法一般被界说为：

规划办法（Design Pattern）是一套被重复运用、多数人知晓的、经过分类编意图、代码规划阅历的总结，运用规划办法是为了可重用线程安全代码、让代码更简略被他人了解并且确保代码可靠性。

从界说上看，规划办法其实是一种阅历的总结，是appear针对特定问题的简练而高雅的处理方案。既然是阅历总结，那么学习规划办法最直接的长处就在于能够站在伟人的膀子上处理软件开发进程中的一些特定问题。可是，学习规划办法的最高地步是习得线程和进程的差异是什么其间处理问题所用到的思维，当你把它们的实质思appointment想吃透了，也就能做到即使现已忘掉某个规划办法的称谓和结构，也能在处理特定问题时信手拈来。

好的东西有人吹捧，当然也会招黑。apple规划办法被冲击首要因为以下两点：

1、规划办法会增加代码量，把程序逻辑变得杂乱。这一点是不行避免的，可是咱们并不能仅application仅只考虑开发阶段的本钱。最简略的程序json解析当然是一个函数从头写到尾，可是这样后期的维护本钱会变得十分大；而规划办法尽管增加了一json格局点开发本钱，可是能让人们写出可复用、可维护性高的程序。引用《软件规划的哲学》里的概念，前者便是战jsonp术编程json格局转化，后者便是战略编程，咱们应该对战术编程 Say No！jsonp

2、乱用规划办法。这是初学者最简略犯的过错，当学到一个办法时，恨不能在全部的代码都用上，然后在不该运用办法的地线程安全方故意地运用了办法，导致了程序变得反常杂乱。其实每个规划办法都有几个关键要素：适apple用场景、处理办法、优缺陷。办法并不线程撕裂者是全能药，它只需在特定的JSON问题上才华显现出效果。所以，在运用一个办法前，先json解析问问自己，当时的这个场景适用这个办法吗？

《规划办法》一书的副标题是“可复用面向方针软件的根底”，但并不意味着只需面向方针言语才华运用规划办法。办法仅仅一种处理特定问题的思维，跟言语无关。就线程的几种状况像 Go 言语一样，它并非是像 C++和 Java 一样的面向方针言语，可是规划办法approach相同适用。本系列文章将运用 Go 言语来结束 GoF 提出的 23 种规划办法，依照创立型办法（Creational Pattern）、结构型办法（Structural P线程撕裂者attern）和行为型办法（BJSONehavior线程撕裂者al Pattern）三种类别进jsonp行组织，文本首要介绍其间的创立型办法。

单例办法（Singleton Pattern）

简述

单例办法算是 23 中规划办法里最简略的一个了，它首要用于确保一个类仅有一个实例，并供给一个嵌套结构拜访它的大局拜访点。

在程序规划中，有一些方针一般咱们只需求一线程是什么意思个同享的线程池的七个参数实例，比方线程池、大局缓存、方针池等，这种场景下就适合运用单例办法。

可是，并非全部大局仅有的场景都适合运用单例办法。比方，考虑需求计算一个 API 调用的状况，有两个方针，成功调用次数和失利调用次数。这两个方针都是大局仅有的，所以有人或许会将其APP建模成两个单例 SuccessApiMetric 和 FailApiMe嵌套查询tri嵌套if函数c。依照这个思路，跟着方针数量的增多，你会发现代码里类的界说会越来越多，也越来越臃肿。这也嵌套查询sql句子是单例办法最常见的误用场景，更好的办法是将两个方针规划成一个方针 ApiMetric 下的两个实例 ApiMeticsappleuccess 和 ApiMetic faiapp是什么意思l。

怎样判别一个方针APP是否应该被建模成单例？

一般，被建模成单例的方针都有“中心点”的含义，比方线程池便是处理全部线程的中心。所以，在判别一个方针是否适合单例办法时，先考线程池虑下，这个方针是一个中心点吗？

Go 结束

在对线程池创立的四种某个方针结束单例办法时，有两个点嵌套调用有必要要注意：（1）束缚调线程的几种状况用者直接实例化该方针；（2）为该appearance方针的单例供给一个大局仅有的拜访办法。

关于 C++/Java 而言，只需把类的结构函数规划成私有的，并供给一个 static 办法去拜访该类点仅有实例即可。但关于 Go 言语来说，即没有结构函数的概念，也没有 static 办法，所以需求另寻appointment出路。

咱们能够运用 Go 言语 package 的拜访规则来结束，将单例结构体规划成首字母小写，json格局就能限制其拜访规划只在当时 package 下，模拟了 C++/Java 中的私有json格局怎样翻开结构函数；再在当时 package 下结束一个首字母大写的拜访函数，就相当于 static 办法的效果了。

在实践开发中，咱们常常会遇到需求一再创json建和毁掉的方针。一再的创立和毁掉一则消耗 CPU，二则内存的运用率也不高，一般咱们都会运用方针池技app是什么意思能来进行优化。考虑咱们需求结束一个音讯方针池，因为是大局的中json心点，处理全部的 Message 实例，所以将其结束成单例，结束代码如下：

 package msgpool
...
// 音讯嵌套查询池
type messagePool struct {
pool *sync.Pool
}
// 音讯池单例
var msgPool = &messagePool{
// 假定音讯池里没有音讯，则新建线程数一个Count值产品运营为0的Message实例
pool: &am产品规划专业p;syncappearance.Pool{New: func() interface{} { return &ajson格局怎样翻开mp;Message{Count: 0} }},
}
// 拜访音讯池单例的仅有办法
func Instance() *messagePool {
return msgPool
}
// 往音讯池里添线程池的七个参数加音讯
func (m *messagePool) AddMsg(msg *Message) {
m.pool.Put(msg)
}
// 从音讯池里获取音讯
func (m *messagePool) GetMsg() *Message {
return m.po线程池ol.Gejson解析t().(*Message)
}
...

​查验代码如下json格局转化：

 package test
...
fujson格局怎样翻开nc TestMessage线程和进程的差异是什么Pool(t *testing.T) {
msg0 := msgpool.Instance().GetMsg()
if msg0.Count != 0 {
t.Errorf("expect msg countappetite %d,产品 but嵌套是什么意思 acappearancetual %d.", 0, msg0.Count)
}
msg0.Count = 1
msgpool.Instance().AddMsg(msg0)
msg1 := msgpool.Instan线程池创立的四种ce().GetMsg()
if msg1.Count != 1 {
t.Errorf("expect m产品规划sg count %d, but actual %d.", 1, ms嵌套是什么意思g1.Count)
}
}
// 作业效果
=== RUN   TestMessagePool
--- PASS: TestMessagePool (0.00s)
PASS

以上的单例办法就嵌套分类汇总是典型的“饿汉办法”，实例在系统加载的时分就现已结束了初始化。对应地，还有一种“懒汉办法”，只需比及方针被运用的时分，才会去初始化它，然后必定程度上节省了内存。众所周知，“懒汉办法”会带来线程安全问题，能够经过一般加锁，或许更高效的两层查验锁来优化。关于“懒汉嵌套是什么意思办法”，Go 言语有一个更高雅的结束办法，那便是运用sync.Once，它有一个 Do 办法，其入参是一个办法，Go 言语会线程池确保仅仅只调用一次该办法。

 // 单例办法的“懒汉办法”结束
package msgpool
..线程数.
var once = &sync.Once{}
// 音讯池单例，在初次调用时初始化
var msgPool *messagePool
// 大局仅有获取音讯池pool到方嵌套法
func Instance() *messagePool线程是什么意思 {
// 在匿名函数中完产品生命周期结初始化逻辑，Go言语确保只会调用一次
once.Do(func() {
msgPool = &messagePool{
// 假定音讯池里没有音讯，则新建一个Count值为0的产品规划专业Message实例
pool: &sync.Pool{New: func() interface{} { return &Message{Count: 0} }},
}
})
return msgPool
}
...

制造者办法（Builder Pattern）

简述

在程序线程和进程的差异是什么规划中，咱们会常常遇到一些杂乱的方针，其间有许多成员特点，甚至嵌套着多个杂乱的方针。这种状况下，创立这个杂乱方针就会变得很繁琐。关于 C++/Java 而言，最常见的体现便是结构函数有着长长的参数列表：

 MyObject obj = newapp是什么意思 MyObject(param1, param2, param3, param4, param5, para产品生命周期m6, ...)

而关于 Go 言语来说，最常见产品批号是生产日期吗的体现便是多层的嵌套实例化：

obj := &MyObject{
Field1appointment: &Field1 {
Param1: &Param1 {
Val: 0,
},
Param2: &Param2 {
Val: 1,
},
...
},
Field2: &Field2 {
Param3: &Param3 {
Val: 2,
},
...
},
...
}

上述的方针创立办法有两个明显的缺陷：（1）对方针运用者不友好，运用者在apple创立方针时需求知道的细节太多；（app是什么意思2）代码可读性很差。

针对这种方针成员较多，创立方针逻辑较为繁琐的场景，就适合运用制造者办法来进行优产品规划专业化。

制造产品批号是生产日期吗者办法的效果有如下几个：

1、封装杂乱方针的创立进程，使方针运用者不感知杂乱的创立json格局怎样翻开逻辑。

2、能够一步步依照次第对成员进行赋值，线程池或许创立嵌套方针，appreciate并毕竟结束方针方针的创立。

3、对多个方针复用相同的方针创立逻辑。

其间，第 1 和第 2 点比较常用，下面对制造者办法的结束也首要是针对这两点进行示例。

Go 结束

考虑如下的一个 Message 结构体，其首要有 Header 和 Body 组成：

package msg
...
type Message struct {
Header *Header
Body   *Body
}
type Header struct {
SrcAddr  string
SrcPort  uint64
DestAddr string
DestPort uint64
Items    map[string]string
}
type Body struct {
Items []string
}
...

假定依照直接的方针创立办法，创立逻辑应该是这样的：

// 多层的嵌套实例化
message := msg.Message{
Header: &amjson格局怎样翻开p;msg.Header{
SrcAddr:  "192.168.0.1",
SrcPort:  1234,
DestAddr: "192.168.0.2",
DestPort: 8080,
Items:    make(map[string]string),
},
Body:   &msg.Body{
Items: make([]string, 0),
},
}
// 需求知道方针的结束细节
message.Header.Items["contents"] = "appli产品cationappear/json"
message.Body.Items = append(message.Body.Items, "record1")
message.Bo产品运营dy.Items = append(message.Body.Items, "record2")

尽管 Message 结构体嵌套的层次不多，可是从其创立的代码来看，确实存在对方针运用者不友好和代码可读性差的缺陷。下面咱们引进制造者办法对代码进行apple重构：

package msg
...
// Message方针的Builder方针
type builder struct {
once *sync.Once
msg *Message
}
// 回来Builder方针
func Builder() *builder {
return &builder{
once: &sync.Once{},
msg: &Message{Header: &Header{},线程撕裂者 Body: &Body{}},
}
}
// 以下是对Message成员对构建办法
func (b *buildapp是什么意思er) WithSrcAddr(srcAddr string) *builder {
b.msg.Header.SrcAddr = srcAddr
return b
}
func (b *builder) WithSrcPort(srcPort uint64json字符串) *builder {
b.msg.Heade嵌套分类汇总r.SrcPort = srcPort
retu嵌套查询sql句子rn b
}
func (b *builder) WithDestAddr(destAddr string) *builder {
b.产品运营msg.Header.DestAddr = destAddr
return b
}
func (b *builder) WithDestPort(destPort uint64) *builder {
b.msg.Header.DestP产品规划ort =产品批号是生产日期吗 destPort
return b
}
func (b *builder) WithHeaderIt嵌套调用em(key, value str产品规划ing) *builder {
// 确保mapp是什么意思ap只初始化一次
b.once.Do(func() {
b.msg.Header.Iteappstorems = make(map[string]string)
})
b.msg.Header.Items[key] = value
return b
}
func (b *builder) WithBodyItem(record string) *builder {
b.msg.Body.Items = append(b.msg.Body.Items, record)
return嵌套结构 b
}
// 创立Message方针，在终究一步调用
func (b *builder) Build() *Mappetiteessage {
return b.msg
}

​查验代码如下：

package test
...
func TestMessageB产品规划uilder(t *testing.T) {
// 运用音讯制造者进行方针创立
messjson格局怎样翻开ag线程池e := msg.Builder().
WithSrcAddr("1嵌套查询sql句子92.168.0.1").
WithSrcPort(1234).
Wit产品介绍hDestAddr("192.168.0.2").
WithDestPort(8080).
WithHeaderItem("contents", "applicJSONation/json").
WithBodyItem("record1").
WithBodyItem("record2").
Build()
if message.appreciateHeader.SrcAddr != "19嵌套循环2.168.0.1" {
t.Errorf("expect srcjson解析 address 192.168.0.1, but actual %s线程和进程的差异是什么.", message.HeJSONader.SrcAddr)
}
i产品批号是生产日期吗f messag产品定位e.Body.Items[0] != "recor产品定位d1" {app是什么意思
t.Errojson格局怎样翻开rf("expect body item0 record1, but actuaJSONl %s.", message.嵌套分类汇总的操作步骤Body.Items[0])
}
}
// 作业效果
=== RUN   TestMessageBuilder
--- PASS: TestMessageBuilder (0.00s)
PASS

从检嵌套函数验代码appear可知，运用制造者办法来进行方针创立，运用者不再需求知道方针详细的结束细节，代码可读性也更好。

工厂办法办法（Factory Method Pattern）

简述

工厂办法办法跟上一节讨论的制造者办法类似，都是将方针创立的逻辑封装起来，为运用者供给一个简略易用的方针创立接口。两嵌套者在使用场景上稍有差异，制造者办法更常用于需求传递多个参数来进行实例化的场景。

运用工厂办法来嵌套创立方针首要有两个长处：

1、代码可读性更好。相比于运用 C++/Java嵌套循环 中的结构线程安全函数，或许 Go 中的{}来创立方针，工厂办法因为能够经过函数名来表达代码含义，然后具有更好的可读性。比方，运用工厂方线程池创立的四种法 produc线程数tA:= CreateProductA()创立一个 ProductA 方针，比直接运用 prjson解析oductA:= ProductA{}的可读性要好。

2、与运用者代码解耦。许多状况下，方针的创立往往是一个简略改动的点，经过工厂办法来封装方针的创立进程，能够在创立逻辑改动时，避免霰弹式修改。

工厂办法办法也有两种结束办法：（1）供给一个工厂方针，经过调线程池的七个参数用工厂方针的工厂办法来创立产品方针；（2）线程池创立的四种将工厂办法集成到产品方针中（C+产品+/Java 中方针的 static 办法，Go 中同一 package 下的函数）

Go 结束

考虑有一个作业方针 Event，分别有两种有用的时间类型 Start 和 En嵌套if函数d：

packajson格局ge event
...产品规划
type Type uint8
// 作业类型界说
const (
Start Type = iota
End
)
// 作业笼统接口
type Even产品运营t inte产品质量法rface {
Eve嵌套ntType() Type
Conteapplent线程() string
}
// 初步作业，结束产品战略了Event接口
type Star线程池创立的四种tEvent struc线程t{
content string
}
...
// 结束作业，结束了Eappointmentveappreciatent接口
type EndEvent struct{
content string
}
...

1、依照榜首种结束办法产品运营，为 Event 供给一个工厂方针，详细代产品经理码如下：

package event
...
// 作业工厂政嵌套策
type Factory struct{}
// 更具作业类型创立详细工apple作
func (e *Factory) Create(etype Tjson格局怎样翻开ype) Eventapproach {
switch etype {
case Start:
return &StartEvent{
content: "this is start ev线程池的七个参数ent",
}
case End:
return &EndEvent{
content: "this is end event",
}
def线程池创立的四种ault:
return ni嵌套结构l
}
}

查验代码如下：

package test
...
func TestEventFactory(t *testing.T) {
factory := event.Factory{}
e := factory.Create(event产品.Start)
if e.EventType()线程安全 != event.Start {
t.Errorf("expect event.Start, but actual %v.", e.EventTypejsonp())
}
e = factory.Create(json数据event.End)
if e.EventType() != event.End {
t.Errorf("expect event.Ejson文件是干什么的nd, but actual %v.", e.EventType())
}
}
// 作业效果
=== RUN   TestEventFactory
--- PASS: Tes嵌套是什么意思tEventFactory (0.00s)
PASS

2、依照第二种结束办法，分别给 Start 和 End 类型的 Event 单独供给一个工厂办法，代码如下：

package event
...
// Start类型Eapplicationvent的工厂办法
func OfStart() Event {
return &StartEvent{
content: "this is sjson文件是干什么的tart event",
}
}
// End类型Event的工厂办法
func OfEnd() Evejson数据nt {
return &EndEvent{
content: "this is end event",
}
}

查验代码如下：

package event
...
func Te产品定位stEvent(t *testing.T) {
e := event.Of产品介绍Start()
if e.EventTy线程池pe() !=线程 event.Start {
t.Errorf("expect event.Start, but actual %v.", e.EventTy嵌套分类汇总pe())
}
e = event.OfEnd()
if e.EventType() != event.End {
t.Errorf("expeappearcAPPt event.End, but actual %v.", e.EventType())
}
}
// 作业产品批号是生产日期吗效果
=== RUN   TestEvent
--- PASS: TestEvent嵌套分类汇总 (0.00s)
PASS

笼统工厂办法（Abstract Factjsonpory Pattern）

简approach述

在工厂办法办法中，咱们经过一个工厂方针来创立一个产品族，详细创立哪个产品，则经过 swtich-case 的办法去判别。这也意味着该产品组上，每新增一类产品方针，都有必要修改原本工厂方针的代码；并且跟着产品的不断增多，工厂方针的责任也越来越重，违反了单一责任准则。

笼统工厂办法经过给工厂类新增一个笼统层处理了该问题，如上图所示，FactoryA 和 FactoryB 都结束笼统工厂接口，分别用于创立 ProductA 和 ProductB。假定后产品续新增了 ProductC，只需新增一个 FactoryC 即可，无需修改原有的代码；因为每个工厂只负责创立一个产品，因此也遵照approach了单一责任准则。

Go 结束

考虑需产品战略求如下一个插件架构风格的音讯处理系统，pipeline 是音讯处理的管道，其间包含了 input、filter 和 output 三个插件。咱们需求结束依据装备来创立 pi嵌套分类汇总peline ，加载插件进程的结束十分适合运用工厂办法，其间 inp线程安全ut、filter 和 output 三类插件的创立运用笼统工厂办法，而 pipeline 的创立则运用工厂办法办法。

​各类插件和 pipeline 的接口界说如下：

package嵌套分类汇总的操作步骤 plugin
...
// 插件笼统接口界说
type Plugin interface {}
// 输入线程是什么意思插件，用于接收音讯
type Input interfJSONace {
Plugin
Receive() string
}
// 过滤插件，用于处嵌套结构理音讯
type Filter interface {
Plugin
Processapp是什么意思(msg string) string
}
// 输出插件，用于发送音讯
type Output inter产品经理face {
Plug线程池面试题in
Send(msg string)apple
}
package pipeline
...
// 音讯管道的界说
type Pipeline struct {
input  plugin.Input
filtjson格局怎样翻开er plugin.Filter
output plugin.Output
}
// 一个音讯的处理流程为 input -> filter -> output
func (p *Pipeline) Exec() {
msg := p.input.Receive()
msg = p.filter.Process(msg)
p.output.Send(msg)
}

接着，咱们界说 input、filter、output 三类插件接口的详细结束嵌套循环：

 package plugin
...
// input插件称谓与类型的映射联络，首要用于经过反射创立input方针
var inputNames = make(map[string]reflect.Type)
// Hello input插件，接收“Hello Wo线程rld”音讯
type Hejson字符串lloInput struct {}
​
func (h *HelloInput) Receive() string {
return "Hello World"
}
// 初始化inpuappreciatet插件映射联络表
func in嵌套调用it() {
inputNames["hello"] = reflect.TAPPypeOf(Hejson数据lloInput{})
}
package plugin
...
// filter插件称谓与类型的映射联络，首要用于经过反射创立fiappearlter方针
var filterNames = make(map[string]reflect.Type)
// Upper filter插件，将音讯悉数字母转成大写
type UpperFiltapplicationer struct {}
​
func (u *Upp嵌套erFilter)产品战略 Process(msg string) string {
return strings.ToUpper(msg)
}
// 初始化f嵌套是什么意思ilter插件映射appetite联络表
func init(json格局转化) {
filterName产品定位s["upper"] = reflect.TypeOf(UpperFilter{})
}
pack嵌套查询age plugin
...
// output插件称谓与类型的映射联络，首要用于经过反射创立output方针
var out产品生命周期putNames = make(approachmap[striappleng]reflect.Type)
// Conjsonsole output插件，将音讯输出到控制台上
type ConsoleOutput struct {产品定位}
​
func (c *ConsoleOutput) Send(msg string) {
fmt.Println(msg)
}
// 初始化output插件映射联络表
func init() {
outputNames["console"] = reflect.TypeOf(ConsoleOutput{})
}

然后，咱们界说插件笼统工厂接口，以及对应插件的工厂结束：

package plugin
...
// 插件笼统工厂接口
type Factory interface {
Create(conf Config) Plugin
}
// input插件工厂方针，结束Factory接口
type Inp产品战略utFactor产品定位y struct{}
// 读取产品规划专业装备，经过反射机制进行方针实例化
func (i *InputFactory) Create(conf Config) Plugin {
t,JSON _ := inputNames[conf.N产品运营ame]
return reflect.New(t).Interface().(Plugin)
}
// filter和output插件工厂结束类似
type FilterFactory struct{}
func (f *FilterFactory) Create(conf Cjson格局onfig) Plugin {
t, _ := filter产品规划Names[conf.Name]
return reflect.New(t).IntJSONerface()产品战略.(Plugin)
}
type OutputFactory struct{}
func (o *OutputFactory) Create线程(conf Config) PlugAPPin {
t,嵌套调用 _ := outputNames[coappointmentnf.Name]
return reflect.New(t).Interface().(Plugin)
}

终究界说 pipeline 的apple工厂办法，调用 plugi产品生命周期n.Factory 笼统工厂结束 pipelien 方针的实例化：

package pipeline
...
// 保存用于创立Plugin的工厂实例，其间map的key为插件类型，value为笼统工厂接口
var pluginFactories = make(map[plugin.Typ线程池的七个参数e]plugin.Factory)
// 依据plugin.Type回来对应P产品运营lugin类型的json是什么意思工厂实例
func factoryOf(t plugin.Type) plugijson格局怎样翻开n.Factory {
factory, _json是什么意思 := pluginFactories[产品质量法t]
return factory
}
// pipeline工厂办法，依据装备创立一个Pipeline实例
func Of(conf Config) *Pipeline {
p := &Pipeline{}
p.input = factoryOf(plugin.InputType).Create(conf.Input).(plu线程数gin.Input)
p.线程是什么意思filter =产品批号是生产日期吗 factorjson是什么意思yOf(plugin.FilterType)嵌套查询.Create(conf.Filter)产品运营.(plugin.Filter)
p.output = factoryOf(plugin.OutputType).Create(co产品生命周期nf.Output).(plugin.Output)
return p
}
// 初始化插件工厂方针
func init() {
pluginFJSONactories[plugin.InputType] = &plugin.Inp嵌套分类汇总utFactory{}
pluginFactories[plugin.FappearanceilterType] = &plugin.FilterFactory{}
pluginFactories[plugin.OutputType] = &plugin.OutputFactory{}
}

查验代码如下：

package test
...
func TestPipeline(t *testing.T) {
// 其间pipeline.DefaultConfig()的装备内容见【笼统工厂办法示例图】
// 音讯处理流程嵌套分类汇总为 HelloInput -> UpperFilter -> ConsoleOutput
p := pipe线程池line.Of(pipeline.DefaultConfig())
p.Exec()
}
// 作业效果
=== RUN   TestPipeline
HELLO WORLD
--- PASJSONS: TestPipeline (0.00s)
PASS

原型办法（Prototype Pattern）

简述

原型办法首要apple处理方针复制的问题，它的中心便是 clone()办法，回来 Prototype 方针的复制品。在程嵌套分类汇总序规划进程中，往往会遇到有一些场景需求许多相同的方针，假定不运用原型办法，那么咱们或许会这样进行方针的创立：

新创立一个相同方针的实例，然后遍历原始方针的全部成员变量，​并将成员变量值复制到新方针中。这种办法的缺陷很明显，那便是运用者有必要知道方针的结束细节，导致代码之间的耦合。别的，方针很有或许存在除了方针本身以外不行嵌套循环见的变产品战略量，这json文件是干什么的种状况下该办法就行不嵌套分类汇总通了。

关于这种状况，更好的办法便是运用原型办法，将复制逻辑委托给方针本身，这样，上述两个问题也都迎刃而解了。

Go 结束

还是以制造者办法一节中的 Message 作为比如，现在规划一个 Prototype 笼统接口：

package prototype
...
// 原型复制笼统接appstore口
ty线程池pe Prototype interface {
clone() Prototype
}
​
type Mejson格局转化ssage struct {
Header *He嵌套ader
Body   *Body
}
​
func (m *Message) clone(产品批号是生产日期吗) Prototype {
msg := *m
return &msg
}

查验代码如下：

package test
...
func Tjson格局estPrototyjson数据pe(t *testing.T) {
message := msg.Builder().
WithSrcAddrjson格局("192.168.0.1").
WithSrcPort(1234).
WithDestAddr("192.168.0.2").
WithDestPort(8080).
WithHeaderItem("contents", "application/json").
WithBodyItem("record1").
WithBojsonpdyItem("record2").
Build()
// 复制一份音讯
new线程是什么意思Message := message.Clone().(*msg.Messa嵌套查询ge)
if newMessage.Header.SrcAddr != message.Header.SrcAddr {
t.Errorf("Clone Message failed.")
}
if newMessage.Body.Ijson是什么意思tems[0] !=APP message.Body.Items[0] {
t.Errorf("Clone Message failed.")
}
}
// 作业效果
=== RUN   TestPrototype
--- PASS: TestPrototype (0.00s)
PASS

总结

本文首要介绍了 GoF 的 23 种规划办法中的 5 种创立型办法，创立型办法的意图都是供给一个简略的接口，让方针的创立进json文件是干什么的程与运用者解耦。其间，单例办法首要用于确保一个类仅有一个实例，并供给一个拜访线程数它的大局访appointment问点；制造者办法首要处理需求创立方针时需求传入多个参数，或许对初产品运营始化次第有要求的场景；工厂办法办法经过供给一个工厂方针或许工厂办法，为运用者躲APP藏了方针创立的细节；笼统工厂办法是对工厂办法办法的优化，经过为工厂方针新增一个笼统层，让工厂方针遵照单一责任准则，也避免了霰弹式修改；json格局怎样翻开原型办法则让方针复制愈加简略。

点击注重，榜首时间了解华为云新鲜技能~