摘要：本文次要聚焦在结构型模式（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 uint8
const (
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 -> input
func (p *Pipeline) Start() {
p.output.Start()
p.filter.Start()
p.input.Start()
p.status = plugin.Started
fmt.Println("Hello input plugin started.")
}
// 进行的程序 input -> filter -> output
func (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 TestPipeline
Console 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 TestKafkaInputPipeline
Console 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 TestPipeline
Console 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所心愿的另外一个接口，解决了模块之间因为接口不兼容而无奈一起工作的问题；桥接模式将模块的形象局部和实现局部进行拆散，让它们可能往各自的方向扩大，从而达到解耦的目标。
点击关注，第一工夫理解华为云陈腐技术~
发表回复