摘要：本文次要聚焦在结构型模式（Structural Pattern）上，其次要思维是将多个对象组装成较大的构造，并同时放弃构造的灵便和高效，从程序的构造上解决模块之间的耦合问题。
本文分享自华为云社区《快来，这里有23种设计模式的Go语言实现（二）》，原文作者：元闰子。
本文次要聚焦在结构型模式（Structural Pattern）上，其次要思维是将多个对象组装成较大的构造，并同时放弃构造的灵便和高效，从程序的构造上解决模块之间的耦合问题。
组合模式（Composite Pattern）
简述
在面向对象编程中，有两个常见的对象设计办法，组合和继承，两者都能够解决代码复用的问题，然而应用后者时容易呈现继承档次过深，对象关系过于简单的副作用，从而导致代码的可维护性变差。因而，一个经典的面向对象设计准则是：组合优于继承。
咱们都晓得，组合所示意的语义为“has-a”，也就是局部和整体的关系，最经典的组合模式形容如下：
将对象组合成树形构造以示意“局部-整体”的层次结构，使得用户对单个对象和组合对象的应用具备一致性。
Go语言人造就反对了组合模式，而且从它不反对继承关系的特点来看，Go也奉行了组合优于继承的准则，激励大家在进行程序设计时多采纳组合的办法。Go实现组合模式的形式有两种，别离是间接组合（Direct Composition）和嵌入组合（Embedding Composition），上面咱们一起探讨这两种不同的实现办法。
Go实现
间接组合（Direct Composition）的实现形式相似于Java/C++，就是将一个对象作为另一个对象的成员属性。
一个典型的实现如《应用Go实现GoF的23种设计模式（一）》中所举的例子，一个Message构造体，由Header和Body所组成。那么Message就是一个整体，而Header和Body则为音讯的组成部分。
type Message struct { Header *Header Body *Body}当初，咱们来看一个略微简单一点的例子，同样思考上一篇文章中所形容的插件架构格调的音讯解决零碎。后面咱们用形象工厂模式解决了插件加载的问题，通常，每个插件都会有一个生命周期，常见的就是启动状态和进行状态，当初咱们应用组合模式来解决插件的启动和进行问题。
首先给Plugin接口增加几个生命周期相干的办法：
package plugin...// 插件运行状态type Status uint8const ( Stopped Status = iota Started)type Plugin interface { // 启动插件 Start() // 进行插件 Stop() // 返回插件以后的运行状态 Status() Status}// Input、Filter、Output三类插件接口的定义跟上一篇文章相似// 这里应用Message构造体代替了原来的string，使得语义更清晰type Input interface { Plugin Receive() *msg.Message}type Filter interface { Plugin Process(msg *msg.Message) *msg.Message}type Output interface { Plugin Send(msg *msg.Message)}对于插件化的音讯解决零碎而言，所有皆是插件，因而咱们将Pipeine也设计成一个插件，实现Plugin接口：
package pipeline...// 一个Pipeline由input、filter、output三个Plugin组成type Pipeline struct { status plugin.Status input plugin.Input filter plugin.Filter output plugin.Output}func (p *Pipeline) Exec() { msg := p.input.Receive() msg = p.filter.Process(msg) p.output.Send(msg)}// 启动的程序 output -> filter -> inputfunc (p *Pipeline) Start() { p.output.Start() p.filter.Start() p.input.Start() p.status = plugin.Started fmt.Println("Hello input plugin started.")}// 进行的程序 input -> filter -> outputfunc (p *Pipeline) Stop() { p.input.Stop() p.filter.Stop() p.output.Stop() p.status = plugin.Stopped fmt.Println("Hello input plugin stopped.")}func (p *Pipeline) Status() plugin.Status { return p.status}一个Pipeline由Input、Filter、Output三类插件组成，造成了“局部-整体”的关系，而且它们都实现了Plugin接口，这就是一个典型的组合模式的实现。Client无需显式地启动和进行Input、Filter和Output插件，在调用Pipeline对象的Start和Stop办法时，Pipeline就曾经帮你按程序实现对应插件的启动和进行。
相比于上一篇文章，在本文中实现Input、Filter、Output三类插件时，须要多实现3个生命周期的办法。还是以上一篇文章中的HelloInput、UpperFilter和ConsoleOutput作为例子，具体实现如下：
package plugin...type HelloInput struct { status Status}func (h *HelloInput) Receive() *msg.Message { // 如果插件未启动，则返回nil if h.status != Started { fmt.Println("Hello input plugin is not running, input nothing.") return nil } return msg.Builder(). WithHeaderItem("content", "text"). WithBodyItem("Hello World"). Build()}func (h *HelloInput) Start() { h.status = Started fmt.Println("Hello input plugin started.")}func (h *HelloInput) Stop() { h.status = Stopped fmt.Println("Hello input plugin stopped.")}func (h *HelloInput) Status() Status { return h.status}package plugin...type UpperFilter struct { status Status}func (u *UpperFilter) Process(msg *msg.Message) *msg.Message { if u.status != Started { fmt.Println("Upper filter plugin is not running, filter nothing.") return msg } for i, val := range msg.Body.Items { msg.Body.Items[i] = strings.ToUpper(val) } return msg}func (u *UpperFilter) Start() { u.status = Started fmt.Println("Upper filter plugin started.")}func (u *UpperFilter) Stop() { u.status = Stopped fmt.Println("Upper filter plugin stopped.")}func (u *UpperFilter) Status() Status { return u.status}package plugin...type ConsoleOutput struct { status Status}func (c *ConsoleOutput) Send(msg *msg.Message) { if c.status != Started { fmt.Println("Console output is not running, output nothing.") return } fmt.Printf("Output:\n\tHeader:%+v, Body:%+v\n", msg.Header.Items, msg.Body.Items)}func (c *ConsoleOutput) Start() { c.status = Started fmt.Println("Console output plugin started.")}func (c *ConsoleOutput) Stop() { c.status = Stopped fmt.Println("Console output plugin stopped.")}func (c *ConsoleOutput) Status() Status { return c.status}测试代码如下：
package test...func TestPipeline(t *testing.T) { p := pipeline.Of(pipeline.DefaultConfig()) p.Start() p.Exec() p.Stop()}// 运行后果=== RUN TestPipelineConsole output plugin started.Upper filter plugin started.Hello input plugin started.Pipeline started.Output: Header:map[content:text], Body:[HELLO WORLD]Hello input plugin stopped.Upper filter plugin stopped.Console output plugin stopped.Hello input plugin stopped.--- PASS: TestPipeline (0.00s)PASS组合模式的另一种实现，嵌入组合（Embedding Composition），其实就是利用了Go语言的匿名成员个性，实质上跟间接组合是统一的。
还是以Message构造体为例，如果采纳嵌入组合，则看起来像是这样：
type Message struct { Header Body}// 应用时，Message能够援用Header和Body的成员属性，例如：msg := &Message{}msg.SrcAddr = "192.168.0.1"适配器模式（Adapter Pattern）
简述
适配器模式是最罕用的结构型模式之一，它让本来因为接口不匹配而无奈一起工作的两个对象可能一起工作。在现实生活中，适配器模式也是处处可见，比方电源插头转换器，能够让英式的插头工作在中式的插座上。适配器模式所做的就是将一个接口Adaptee，通过适配器Adapter转换成Client所冀望的另一个接口Target来应用，实现原理也很简略，就是Adapter通过实现Target接口，并在对应的办法中调用Adaptee的接口实现。
一个典型的利用场景是，零碎中一个老的接口曾经过期行将废除，但因为历史包袱没法立刻将老接口全副替换为新接口，这时能够新增一个适配器，将老的接口适配成新的接口来应用。适配器模式很好的践行了面向对象设计准则里的开闭准则（open/closed principle），新增一个接口时也无需批改老接口，只需多加一个适配层即可。
Go实现
持续思考上一节的音讯解决零碎例子，目前为止，零碎的输出都源自于HelloInput，当初假如须要给零碎新增从Kafka音讯队列中接收数据的性能，其中Kafka消费者的接口如下：
package kafka...type Records struct { Items []string}type Consumer interface { Poll() Records}因为以后Pipeline的设计是通过plugin.Input接口来进行数据接管，因而kafka.Consumer并不能间接集成到零碎中。
怎么办？应用适配器模式！
为了能让Pipeline可能应用kafka.Consumer接口，咱们须要定义一个适配器如下：
package plugin...type KafkaInput struct { status Status consumer kafka.Consumer}func (k *KafkaInput) Receive() *msg.Message { records := k.consumer.Poll() if k.status != Started { fmt.Println("Kafka input plugin is not running, input nothing.") return nil } return msg.Builder(). WithHeaderItem("content", "text"). WithBodyItems(records.Items). Build()}// 在输出插件映射关系中退出kafka，用于通过反射创立input对象func init() { inputNames["hello"] = reflect.TypeOf(HelloInput{}) inputNames["kafka"] = reflect.TypeOf(KafkaInput{})}...因为Go语言并没有构造函数，如果依照上一篇文章中的形象工厂模式来创立KafkaInput，那么失去的实例中的consumer成员因为没有被初始化而会是nil。因而，须要给Plugin接口新增一个Init办法，用于定义插件的一些初始化操作，并在工厂返回实例前调用。
package plugin...type Plugin interface { Start() Stop() Status() Status // 新增初始化办法，在插件工厂返回实例前调用 Init()}// 批改后的插件工厂实现如下func (i *InputFactory) Create(conf Config) Plugin { t, _ := inputNames[conf.Name] p := reflect.New(t).Interface().(Plugin) // 返回插件实例前调用Init函数，实现相干初始化办法 p.Init() return p}// KakkaInput的Init函数实现func (k *KafkaInput) Init() { k.consumer = &kafka.MockConsumer{}}上述代码中的kafka.MockConsumer为咱们模式Kafka消费者的一个实现，代码如下：
package kafka...type MockConsumer struct {}func (m *MockConsumer) Poll() *Records { records := &Records{} records.Items = append(records.Items, "i am mock consumer.") return records}测试代码如下：
package test...func TestKafkaInputPipeline(t *testing.T) { config := pipeline.Config{ Name: "pipeline2", Input: plugin.Config{ PluginType: plugin.InputType, Name: "kafka", }, Filter: plugin.Config{ PluginType: plugin.FilterType, Name: "upper", }, Output: plugin.Config{ PluginType: plugin.OutputType, Name: "console", }, } p := pipeline.Of(config) p.Start() p.Exec() p.Stop()}// 运行后果=== RUN TestKafkaInputPipelineConsole output plugin started.Upper filter plugin started.Kafka input plugin started.Pipeline started.Output: Header:map[content:kafka], Body:[I AM MOCK CONSUMER.]Kafka input plugin stopped.Upper filter plugin stopped.Console output plugin stopped.Pipeline stopped.--- PASS: TestKafkaInputPipeline (0.00s)PASS桥接模式（Bridge Pattern）
简述
桥接模式次要用于将形象局部和实现局部进行解耦，使得它们可能各自往独立的方向变动。它解决了在模块有多种变动方向的状况下，用继承所导致的类爆炸问题。举一个例子，一个产品有形态和色彩两个特色（变动方向），其中形态分为方形和圆形，色彩分为红色和蓝色。如果采纳继承的设计方案，那么就须要新增4个产品子类：方形红色、圆形红色、方形蓝色、圆形红色。如果形态总共有m种变动，色彩有n种变动，那么就须要新增m*n个产品子类！当初咱们应用桥接模式进行优化，将形态和色彩别离设计为一个形象接口独立进去，这样须要新增2个形态子类：方形和圆形，以及2个色彩子类：红色和蓝色。同样，如果形态总共有m种变动，色彩有n种变动，总共只须要新增m+n个子类！
上述例子中，咱们通过将形态和色彩形象为一个接口，使产品不再依赖于具体的形态和色彩细节，从而达到理解耦的目标。桥接模式实质上就是面向接口编程，能够给零碎带来很好的灵活性和可扩展性。如果一个对象存在多个变动的方向，而且每个变动方向都须要扩大，那么应用桥接模式进行设计那是再适合不过了。
Go实现
回到音讯解决零碎的例子，一个Pipeline对象次要由Input、Filter、Output三类插件组成（3个特色），因为是插件化的零碎，不可避免的就要求反对多种Input、Filter、Output的实现，并可能灵便组合（有多个变动的方向）。显然，Pipeline就非常适合应用桥接模式进行设计，实际上咱们也这么做了。咱们将Input、Filter、Output别离设计成一个形象的接口，它们依照各自的方向去扩大。Pipeline只依赖的这3个形象接口，并不感知具体实现的细节。
package plugin...type Input interface { Plugin Receive() *msg.Message}type Filter interface { Plugin Process(msg *msg.Message) *msg.Message}type Output interface { Plugin Send(msg *msg.Message)}package pipeline...// 一个Pipeline由input、filter、output三个Plugin组成type Pipeline struct { status plugin.Status input plugin.Input filter plugin.Filter output plugin.Output}// 通过形象接口来应用，看不到底层的实现细节func (p *Pipeline) Exec() { msg := p.input.Receive() msg = p.filter.Process(msg) p.output.Send(msg)}测试代码如下：
package test...func TestPipeline(t *testing.T) { p := pipeline.Of(pipeline.DefaultConfig()) p.Start() p.Exec() p.Stop()}// 运行后果=== RUN TestPipelineConsole output plugin started.Upper filter plugin started.Hello input plugin started.Pipeline started.Output: Header:map[content:text], Body:[HELLO WORLD]Hello input plugin stopped.Upper filter plugin stopped.Console output plugin stopped.Pipeline stopped.--- PASS: TestPipeline (0.00s)PASS总结
本文次要介绍了结构型模式中的组合模式、适配器模式和桥接模式。组合模式次要解决代码复用的问题，相比于继承关系，组合模式能够防止继承档次过深导致的代码简单问题，因而面向对象设计畛域流传着组合优于继承的准则，而Go语言的设计也很好实际了该准则；适配器模式能够看作是两个不兼容接口之间的桥梁，能够将一个接口转换成Client所心愿的另外一个接口，解决了模块之间因为接口不兼容而无奈一起工作的问题；桥接模式将模块的形象局部和实现局部进行拆散，让它们可能往各自的方向扩大，从而达到解耦的目标。
点击关注，第一工夫理解华为云陈腐技术~