面向对象思考与 golang cobra 库实现原理

golang 不是面向对象的语言 ，在golang中函数是一类成员（First-class function）/知乎解释 。本文不打算纠结 golang 有哪些面向对象特性，仅关注面向对象的思想如何在 golang 中应用，让我们轻松一些写出类似 cobra 中 comamnd.go 这样易于使用、可扩展的程序。

本文要点：

1. 面向对象设计与编程基本概念
2. Golang 的与面向对象支持相关的知识
3. 用设计模式设计 command.go

前提条件：

1. go tour 练习完成
2. 使用 flag 包处理简单的 cli
3. 会用 cobra
4. 熟悉 C++ 或 Java

环境准备

main.go
/cmd
    root.go
    register.go
    delete.go

1、面向对象设计与编程基本概念

以 对象 作为基本 程序结构单位 的程序设计语言。纯面向对象语言：Smalltalk, Eiffel(埃菲尔)，…，Java。 其中 Java 是最成功的程序设计语言，长期排在 TIOBE 编程语言指数排行榜前二位。随着互联网发展，尽管出现了许多新的语言 Golang, Clojure, Scala，Dart 等更挣钱的语言的竞争，Java 目前稳居排行榜第一位， “存在即真理” 的背后，一定有它的道理。

什么是对象

An object is the simulation of an entity in a computer.
An object is an encapsulation of attributes, behaviors and constraints.

面向对象语言的特点

• 包装 Encapsulation
• 信息隐藏 Information Hiding
• 数据抽象 Data Abstraction
• 继承 Inheritance
• 多态 Polymorphism

通过上述技术，实现了 Reference System -> Design & Programming

面向对象的设计

设计对象、接口、对象之间的关系，用于解决问题。

设计模式

常见应用场景的涉及的对象、对象外部特征、及其之间关系，以及典型代码。例如：

• 单例（Singleton）模式
• 命令（Command） 模式
• 模板方法（Template methods）模式
• 组合（Composite）模式
• …

2、Golang 的语言知识与折中（trade off）

2.1 Go 语言的基本元素

深入理解 Nicklaus Wirth 算法+数据结构=程序 这句话永远不错。

Go的理念： 简单、简单、简单 （没考证 ！？对吗？）

• 数据就是数据，是不可变的。例如：
  • Student 作为数据就是 Student，不是 Person
  • Student 作为对象是 Person
• 函数是一种类型，值是 First-Class 的
  • 函数类型 = 函数签名 (什么是函数签名？)

Go 是静态类型化的。每个变量都有一个静态类型，也就是说，在编译的时候变量的类型就被很精确地确定下来。

2.2 Go 的包装与隐藏

import (
  flag "github.com/spf13/pflag"
)

它们的执行顺序是？ 参见 go/golang main() init()方法的调用

2.3 数据抽象

go 的方法似乎很有特色，让我们操作数据时有了“面向对象”的感觉。其实，在上世纪面向对象语言Eiffel(埃菲尔) （第二个）就有了啊。感兴趣去看一看。

• var type 语法
• eiffelThreads vs goroutine 并发
• static typing
• …

go-method 的确是值得夸赞的创新，它与接口实现了无缝对接。它通过 receiver argument 概念，让不同类型的 operator 具有了相同的函数签名。而一组函数签名相同的操作与接口一致，则实现了接口与数据类型的隐式静态绑定。

type Vertex struct {
	X, Y float64
}

func (v Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func Abs(v Vertex) float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	v := Vertex{3, 4}
	fmt.Println(v.Abs(), Abs(v))
}

在以上代码中，函数 Abs 与 方法 Abs 语义是一样的，方法可以被认为是“语法糖”。但对于编译，Vertex 类型的数据可 静态 推导到接口类型

type Abser interface {
	Abs() float64
}

构造方法

为了实现 struct 的构造，golang 提供了一些编程约定（convention），例如：

• 提供 NewVertex(v Vertex) *Vertex 这样的函数
• 提供 (v *Vertex) New() 这样的方法

接口抽象

这种静态绑定，为 go 处理多种数据带来了便利。因为任何类型数据都一个匹配到空接口 interface{}

// Println formats using the default formats for its operands and writes to standard output.
// Spaces are always added between operands and a newline is appended.
// It returns the number of bytes written and any write error encountered.
func Println(a ...interface{}) (n int, err error) {
	return Fprintln(os.Stdout, a...)
}

这样 Println 就可以打印所有类型的数据。关键是 fmt 如何从 interface{} 得到原数据和 Stringer 接口

// Stringer is implemented by any value that has a String method,
// which defines the ``native'' format for that value.
// The String method is used to print values passed as an operand
// to any format that accepts a string or to an unformatted printer
// such as Print.
type Stringer interface {
	String() string
}

它与 Go 内部实现机制，通过反射技术 Go语言中反射包的实现原理 可见一般。

阅读 go 的语言库源代码，如 fmt.Println。这是最快、最强大的学习方法！

2.4 匿名组合 pk “继承”

Golang 不支持继承，但很好的支持组合，因为“组合优于继承”知乎的一些讨论（萧萧是正确的）。但提供了类似“继承”的语法。

例如：

type Vertex struct {
	X, Y float64
}

type Circle struct {
  Vertex
  R float64
}

type Cylinder struct {
  Circle
  H float64
}

func ToCircle(u *Vertex, r *Cylinder) *Circle {
	if &r.Vertex == u {
		return &r.Circle
	}
	return nil
}

func main() {
	cy := Cylinder{Circle{}, 10}
	//cy := Cylinder{X: 3} 编译错误
	cy.X = 3
	fmt.Println(cy)
	v := cy.Vertex
	v.Y = 4
	fmt.Println(cy, v) //cy = ?
	u := &(cy.Vertex)
	u.Y = 4
	//c := Circle(u) 编译错误
	fmt.Println(cy, u) //cy = ?
	c := ToCircle(u, &cy)
	c.R = 5
	fmt.Println(cy, c, c.Vertex) //cy = ?
}

上述程序很有趣，cy 是 Cylinder 类型的数据。

• Cylinder{X: 3} 为什么错误， cy.X = 3 为什么正确，这语法玩的溜！
• v := cy.Vertex v 是值，不是指针。 似乎是 deeply clone ?
• 别指望面向对象哪种向上类型转换（UpCasting），注意用指针哦（操）！
• 别指望面向对象哪种向下类型转换（DownCasting），自己手工实现。
• c := ToCircle(u, &cy) 改为 c := ToCircle(&v, &cy) 结果是？

没有面向对象，以前系统运行时（runtime）做的一切，都需要自己亲手实现。
不过习惯静态类型就好了，唯一的麻烦就是 值与指针从变量名太难区分！

convention：用大写 P 作为变量名后缀表示指针？？

2.5 多态

// Shaper is Inteface
type Shaper interface {
	Area() float64
}

type Square struct {
	L float64
}

func (s Square) Area() float64 {
	return s.L * s.L
}

type Rect struct {
	A, B float64
}

func (s *Rect) Area() float64 {
	return s.A * s.B
}

type A4Paper struct {
	Rect
	W int
}

// A4Paper 没有实现接口

func main() {
	//we can assign the variable of Square to variable of Shaper(interface)
	sShaper := Shaper(Square{4.0})
	rShaper := Shaper(&A4Paper{Rect{4, 5}, 80})
	fmt.Println(sShaper.Area(), rShaper.Area())
}

func PrintShapes(a ...interface{}) {
	for _, iface := range a {
		//type assertion to test value implement a interface
		//type assertion is only applied on interface, so we cast the s to empty interface
		if v, ok := iface.(Shaper); ok {
			fmt.Println(v.Area())
		}
	}
}

3、设计模式应用 - 以 golang cobra 库为案例

3.1 单实例（Singleton）模式

var Args = os.Args

func init() {
	fmt.Println("init logic here...", Args)
}

var args *[]string
var mu sync.Mutex

// GetArgs *
func GetArgs() *[]string {
	if args == nil {
		mu.Lock()
		defer mu.Unlock()
		if args == nil {
			args = &os.Args
			fmt.Println("init logic here...", *args)
		}
	}
	return args
}

func init() {
	fmt.Println("use cmd.GetArgs() anywhere...", GetArgs())
}

3.2 命令（Command）模式

type Commander interface {
	Execute() error
}

3.3 模板方法（Template methods）模式

结合 cli 程序特点，命令解析分为三个步骤：定义参数、解析命令、执行命令。模板方法就用上了，详细参考：设计模式之美：Template Method（模板方法），关键在于：

• 抽象操作（Primitive Operation）(must be overridden)
• 钩子操作（Hook Operation）(may be overridden)，通常提供默认实现。

定义抽象数据

落实到 command.go 代码：

// Command .
type Command struct {
	// Use is the one-line usage message.
	Use string
	// Short is the short description shown in the 'help' output.
	Short string
	// Long is the long message shown in the 'help <this-command>' output.
	Long string
	// SetOptions:
	SetOptions func(c *Command) error
	// Parse:
	Parse func(c *Command) error
	// Run: Typically the actual work function. Most commands will only implement this.
	Run func(cmd *Command, args []string)
}

// Execute .
func (c *Command) Execute() error {
	if ok := c.SetOptions(c); ok != nil {
		fmt.Println("Error in SetOptions!")
		return ok
	}
	if ok := c.Parse(c); ok != nil {
		fmt.Println("Error in Parsing!")
		return ok
	}
	c.Run(c, Args)
	return nil
}

上述代码的要点：

• 定义了三个回调函数，也就是钩子操作。没有虚方法也是有办法的！
• 定义了模板方法 Execute()

定义实现

落实到 main.go 代码：

func main() {
	//cmd.Execute()
	var RootCmd = &cmd.Command{
		Use:   "test",
		Short: "A brief description of your application",
		Long:  "A longer description",
	}
	RootCmd.SetOptions = func(c *cmd.Command) error {
		fmt.Println("Set Options here")
		return nil
	}
	RootCmd.Parse = func(c *cmd.Command) error {
		fmt.Println("Parse here")
		return nil
	}
	RootCmd.Run = func(c *cmd.Command, a []string) {
		fmt.Println("Do comamnd")
	}
	RootCmd.Execute()
}

运行成果

go run main.go -uPan

结果是：

Set Options here
Parse here
Do comamnd

完善程序

command.go 添加方法 和 局部变量

// Flags returns the complete FlagSet that applies
// to this command (local and persistent declared here and by all parents).
func (c *Command) Flags() *flag.FlagSet {
	if c.flags == nil {
		c.flags = flag.NewFlagSet(c.Use, flag.ContinueOnError)
	}
	return c.flags
}

修改 main.go

func main() {
	//cmd.Execute()
	var RootCmd = &cmd.Command{
		Use:   "test",
		Short: "A brief description of your application",
		Long:  "A longer description",
	}
	RootCmd.SetOptions = func(c *cmd.Command) error {
		fmt.Println("Set Options here")
		c.Flags().StringP("user", "u", "Anonymous", "Help message for username")
		return nil
	}
	RootCmd.Parse = func(c *cmd.Command) error {
		fmt.Println("Parse here")
		c.Flags().Parse(cmd.Args)
		return nil
	}
	RootCmd.Run = func(c *cmd.Command, a []string) {
		fmt.Println("Do comamnd")
		username, _ := c.Flags().GetString("user")
		fmt.Println("myCommand called by " + username)
	}
	RootCmd.Execute()
}

现在你可以方便的实现简单命令了哦！！！

3.4 组合（Composite）模式

具体参考：设计模式之美：Composite（组合）

代码 实现要点 ：

• command 添加 AddCommand。参考 cobra 的实现
• Execute() 方法有 bug 。客户不写钩子函数没有处理
• 需要写一个标准的 Parse 钩子实现
  • 如果不是根命令，当前 args 是 c.args := parent.args[1:]
  • 如果没有子命令，执行 c.Flags().Parse(c.args)
  • 有子命令，没匹配上 c.args[] 显示 help
  • 匹配子命令成功，执行 c.Execute()

没有写实现，就交给你完成了。 cobra 主要功能 OK 了。

4、小结