关于本系列
这个系列首先是关于Go语言实践的。在项目中实际使用Go语言也有段时间了，一个体会就是不论是官方文档、图书还是网络资料，关于Go语言惯用法（idiom）的介绍都比较少，基本只能靠看标准库源代码自己琢磨，所以我特别想在这方面有一些收集和总结。
然后这个系列也是关于设计模式的。虽然Go语言不是一门面向对象编程语言，但是很多面向对象设计模式所要解决的问题是在程序设计中客观存在的。不管用什么语言，总是要面对和解决这些问题的，只是解决的思路和途径会有所不同。所以我想就以经典的设计模式作为切入点来展开这个系列，毕竟大家对设计模式都很熟悉了，可以避免无中生有想出一些蹩脚的应用场景。
@H_404_10@@H_502_13@
@H_502_13@
GoF对组合模式的定义是，将对象组合成树形结构以表示“部分整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
对于这句话我是有异议的，这里先卖个关子，我们先从实际例子说起。
组合模式的例子大家都见得很多了，比如文件系统（文件/文件夹）、GUI窗口（Frame/Control）、菜单（菜单/菜单项）等等，我这里也举个菜单的例子，不过不是操作系统里的菜单，是真正的菜单，KFC的……
姑且把KFC里的食物认为是菜单项，一份套餐是菜单。菜单和菜单项有一些公有属性：名字、描述、价格、都能被购买等，所以正如GoF所说，我们需要一致性地使用它们。它们的层次结构体现在一个菜单里会包含多个菜单项或菜单，其价格是所有子项的和。嗯，这个例子其实不是很恰当，不能很好的体现菜单包含菜单的情况，所以我多定义了一个“超值午餐”菜单，其中包含若干个套餐。
func main() {
menu1 := NewMenu("培根鸡腿燕麦堡套餐","供应时间：09:15--22:44")
menu1.Add(NewMenuItem("主食","培根鸡腿燕麦堡1个",11.5))
menu1.Add(NewMenuItem("小吃","玉米沙拉1份",5.0))
menu1.Add(NewMenuItem("饮料","九珍果汁饮料1杯",6.5))
menu2 := NewMenu("奥尔良烤鸡腿饭套餐","供应时间：09:15--22:44")
menu2.Add(NewMenuItem("主食","新奥尔良烤鸡腿饭1份",15.0))
menu2.Add(NewMenuItem("小吃","新奥尔良烤翅2块",11.0))
menu2.Add(NewMenuItem("饮料","芙蓉荟蔬汤1份",4.5))
all := NewMenu("超值午餐","周一至周五有售")
all.Add(menu1)
all.Add(menu2)
all.Print()
}
得到的输出如下：
超值午餐,周一至周五有售,￥53.50
------------------------
培根鸡腿燕麦堡套餐,供应时间：09:15--22:44,￥23.00
------------------------
主食,￥11.50
-- 培根鸡腿燕麦堡1个
小吃,￥5.00
-- 玉米沙拉1份
饮料,￥6.50
-- 九珍果汁饮料1杯
奥尔良烤鸡腿饭套餐,￥30.50
------------------------
主食,￥15.00
-- 新奥尔良烤鸡腿饭1份
小吃,￥11.00
-- 新奥尔良烤翅2块
饮料,￥4.50
-- 芙蓉荟蔬汤1份
面向对象实现
先说明一下：Go语言不是面向对象语言，实际上只有struct而没有类或对象。但是为了说明方便，后面我会使用类这个术语来表示struct的定义，用对象这个术语来表示struct实例。
按照惯例，先使用经典的面向对象来分析。首先我们需要定义菜单和菜单项的抽象基类，这样使用者就可以只依赖于接口了，于是实现使用上的一致性。
Go语言中没有继承，所以我们把抽象基类定义为接口，后面会由菜单和菜单项实现具体功能：
type MenuComponent interface {
Name() string
Description() string
Price() float32
Print()
Add(MenuComponent)
Remove(int)
Child(int) MenuComponent
}
菜单项的实现：
type MenuItem struct {
name string
description string
price float32
}
func NewMenuItem(name,description string,price float32) MenuComponent {
return &MenuItem{
name: name,description: description,price: price,}
}
func (m *MenuItem) Name() string {
return m.name
}
func (m *MenuItem) Description() string {
return m.description
}
func (m *MenuItem) Price() float32 {
return m.price
}
func (m *MenuItem) Print() {
fmt.Printf(" %s,￥%.2f\n",m.name,m.price)
fmt.Printf(" -- %s\n",m.description)
}
func (m *MenuItem) Add(MenuComponent) {
panic("not implement")
}
func (m *MenuItem) Remove(int) {
panic("not implement")
}
func (m *MenuItem) Child(int) MenuComponent {
panic("not implement")
}
有两点请留意一下。
@H_404_10@@H_502_13@
下面是菜单的实现：
type Menu struct {
name string
description string
children []MenuComponent
}
func NewMenu(name,description string) MenuComponent {
return &Menu{
name: name,}
}
func (m *Menu) Name() string {
return m.name
}
func (m *Menu) Description() string {
return m.description
}
func (m *Menu) Price() (price float32) {
for _,v := range m.children {
price += v.Price()
}
return
}
func (m *Menu) Print() {
fmt.Printf("%s,%s,m.description,m.Price())
fmt.Println("------------------------")
for _,v := range m.children {
v.Print()
}
fmt.Println()
}
func (m *Menu) Add(c MenuComponent) {
m.children = append(m.children,c)
}
func (m *Menu) Remove(idx int) {
m.children = append(m.children[:idx],m.children[idx+1:]...)
}
func (m *Menu) Child(idx int) MenuComponent {
return m.children[idx]
}
其中Price()统计所有子项的Price后加和，Print()输出自身的信息后依次输出所有子项的信息。另注意Remove()的实现（从slice中删除一项）。
好，现在针对这份实现思考下面3个问题。
@H_404_10@MenuItem和Menu中都有name、description这两个属性和方法，重复写两遍明显冗余。如果使用其它任何面向对象语言，这两个属性和方法都应该移到基类中实现。可是Go没有继承，这可真是坑爹。@H_502_13@
MenuComponent后，依然要知道其类型后才能正确使用，假如不加判断在MenuItem使用Add()等未实现的方法就会产生panic。类似地，我们大可以把文件夹/文件都抽象成“文件系统节点”，可以读取名字，可以计算占用空间，但是一旦我们想往“文件系统节点”中添加子节点时，还是必须得判断它到底是不是文件夹。@H_502_13@
Menu和MenuItem某种本质上是（is-a）同一个事物（MenuComponent），所以可以对它们一致性访问；另一种观点：Menu和MenuItem是两个不同的事物，只是恰巧有一些相同的属性，所以可以对它们一致性访问。@H_502_13@
用组合代替继承
前面说到Go语言没有继承，本来属于基类的name和description不能放到基类中实现。其实只要转换一下思路，这个问题是很容易用组合解决的。如果我们认为Menu和MenuItem本质上是两个不同的事物，只是恰巧有（has-a）一些相同的属性，那么将相同的属性抽离出来，再分别组合进两者，问题就迎刃而解了。
先看抽离出来的属性：
type MenuDesc struct {
name string
description string
}
func (m *MenuDesc) Name() string {
return m.name
}
func (m *MenuDesc) Description() string {
return m.description
}
改写MenuItem：
type MenuItem struct {
MenuDesc
price float32
}
func NewMenuItem(name,price float32) MenuComponent {
return &MenuItem{
MenuDesc: MenuDesc{
name: name,},price: price,}
}
// ... 方法略 ...
改写Menu:
type Menu struct {
MenuDesc
children []MenuComponent
}
func NewMenu(name,description string) MenuComponent {
return &Menu{
MenuDesc: MenuDesc{
name: name,}
}
// ... 方法略 ...
Go语言中善用组合有助于表达数据结构的意图。特别是当一个比较复杂的对象同时处理几方面的事情时，将对象拆成独立的几个部分再组合到一起，会非常清晰优雅。例如上面的MenuItem就是描述+价格，Menu就是描述+子菜单。
其实对于Menu，更好的做法是把children和Add() Remove() Child()也提取封装后再进行组合，这样Menu的功能一目了然。
type MenuGroup struct {
children []MenuComponent
}
func (m *Menu) Add(c MenuComponent) {
m.children = append(m.children,m.children[idx+1:]...)
}
func (m *Menu) Child(idx int) MenuComponent {
return m.children[idx]
}
type Menu struct {
MenuDesc
MenuGroup
}
func NewMenu(name,}
}
Go语言的思维方式
以下是本文的重点。使用Go语言开发项目2个多月，最大的感触就是：学习Go语言一定要转变思维方式，转变成功则其乐无穷，不能及时转变会发现自己处处碰壁。
下面让我们用真正Go的方式来实现KFC菜单。首先请默念三遍：没有继承，没有继承，没有继承；没有基类，没有基类，没有基类；接口只是函数签名的集合，接口只是函数签名的集合，接口只是函数签名的集合；struct不依赖于接口，struct不依赖于接口，struct不依赖于接口。
好了，与之前不同，现在我们不是先定义接口再具体实现，因为struct不依赖于接口，所以我们直接实现具体功能。先是MenuDesc和MenuItem，注意现在NewMenuItem的返回值类型是*MenuItem。
type MenuDesc struct {
name string
description string
}
func (m *MenuDesc) Name() string {
return m.name
}
func (m *MenuDesc) Description() string {
return m.description
}
type MenuItem struct {
MenuDesc
price float32
}
func NewMenuItem(name,price float32) *MenuItem {
return &MenuItem{
MenuDesc: MenuDesc{
name: name,}
}
func (m *MenuItem) Price() float32 {
return m.price
}
func (m *MenuItem) Print() {
fmt.Printf(" %s,m.description)
}
接下来是MenuGroup。我们知道MenuGroup是菜单/菜单项的集合，其children的类型是不确定的，于是我们知道这里需要定义一个接口。又因为MenuGroup的逻辑是对children进行增、删、读操作，对children的属性没有任何约束和要求，所以我们这里暂时把接口定义为空接口interface{}。
type MenuComponent interface {
}
type MenuGroup struct {
children []MenuComponent
}
func (m *Menu) Add(c MenuComponent) {
m.children = append(m.children,m.children[idx+1:]...)
}
func (m *Menu) Child(idx int) MenuComponent {
return m.children[idx]
}
最后是Menu的实现：
type Menu struct {
MenuDesc
MenuGroup
}
func NewMenu(name,description string) *Menu {
return &Menu{
MenuDesc: MenuDesc{
name: name,}
}
func (m *Menu) Price() (price float32) {
for _,v := range m.children {
v.Print()
}
fmt.Println()
}
在实现Menu的过程中，我们发现Menu对其children实际上有两个约束：需要有Price()方法和Print()方法。于是对MenuComponent进行修改：
type MenuComponent interface {
Price() float32
Print()
}
最后观察MenuItem和Menu，它们都符合MenuComponent的约束，所以二者都可以成为Menu的children，组合模式大功告成！
比较与思考
前后两份代码差异其实很小：
@H_404_10@@H_502_13@
从思路上看，差异很大却也有些微妙：
@H_404_10@@H_502_13@
children中的MenuComponent是一种具体对象，这个对象具有一系列方法可以调用，只是其方法的功能会由于子类覆盖而表现不同；第二份实现则认为children中的MenuComponent可以是任意无关的对象，唯一的要求是他们“恰巧”实现了接口所指定的约束条件。@H_502_13@
注意第一份实现中，MenuComponent中有Add()、Remove()、Child()三个方法，但却不一定是可用的，能不能使用由具体对象的类型决定；第二份实现中则不存在这些不安全的方法，因为New函数返回的是具体类型，所以可以调用的方法都是安全的。
另外，从Menu中取出某个child，其可用方法只有Price()和Print()，一样可以完全安全的调用。如果想在MenuComponent是Menu的情况下往其中添加子项呢？很简单：
if m,ok := all.Child(1).(*Menu); ok {
m.Add(NewMenuItem("玩具","Hello Kitty",5.0))
}
清晰明了，如果某child是一个Menu，那么我们可以对其进行Add()操作。
更进一步，这里我们对类型的要求其实并没有那么强，并不需要它一定要是Menu，只是需要其提供组合MenuComponent的功能，所以可以提炼出这样一个接口：
type Group interface {
Add(c MenuComponent)
Remove(idx int)
Child(idx int) MenuComponent
}
if m,ok := all.Child(1).(Group); ok {
m.Add(NewMenuItem("玩具",5.0))
}
再考虑一下“购买”这个操作，面向对象的实现中，购买的类型是MenuComponent，所以购买操作同时可以应用于Menu和MenuItem。如果用Go语言的思维方式来考察，可购买对象的唯一要求是有Price()，所以购买操作的参数是这样的接口：
type Product interface {
Price() float32
}
于是购买操作不仅可应用于Menu和MenuItem，还可用于任何提供了价格的对象。我们可以任意添加产品，不论是玩具还是会员卡或者优惠券，只要有Price()方法就可以被购买。
总结
最后总结一下我的思考，欢迎各位讨论或抨击：
@H_404_10@@H_502_13@
