Template Method in Golang

序言

随着容器云技术的不断成熟，微服务架构也变得越来越火。在微服务架构下，我们将原本单一的应用按照功能边界分解成一系列独立、专注的微服务。每个微服务对应传统应用中的一个组件，但是可以独立编译、部署和扩展。每个团队可以根据自身服务的需求和行业发展的现状，自由选择最适合的技术栈，比如编程语言和数据库。Golang语言这几年风华正茂，不仅kubernetes、 openshif和docker等容器云相关的开源项目的开发语言是Golang，而且很多对实时性要求不高的微服务团队也选择Golang作为主要开发语言。

在这个大背景下，笔者也开始了Golang之旅。Golang作为一门全新的静态类型开发语言，与既有的开发语言相比简洁、有趣却又超级强大，具备众多令人兴奋不已的新特性，其中最令笔者兴奋的两个特性分别是：

1. goroutine和channel
2. interface

如果说goroutine和channel是支撑起Golang的并发模型的基石，让Golang在如今集群化与多核化的时代成为一道极为亮丽的风景，那么interface是Golang整个类型系统的基石，让Golang在基础编程哲学的探索上达到前所未有的高度。

Golang的设计哲学之一是“少即是多”，没有万能的语言，保持简单性的方法就是只提供一种方法做事情，把事情做到极致。在这个原则的指导下，Golang对于面向对象编程的支持非常简洁而优雅：

1. 简洁之处在于，Golang并没有沿袭传统面向对象编程中的诸多概念，比如继承、虚函数、构造函数和析构函数、隐藏的this指针等
2. 优雅之处在于，Golang对面向对象编程的支持是语言类型系统中的天然组成部分，整个类型系统通过interface串联，浑然一体。多数语言都提供interface，但它们的interface都不同于Golang的interface，Golang中的interface与其他语言最大的一点区别是它的非侵入性。

笔者将要开发的用户故事涉及一系列算法步骤，即多个网络平面操作的算法框架是相同的，而具体步骤中的行为有些差异，于是就想到了一种设计模式——模板方法。与其他面向对象语言不同的是，Golang天生就是组合式设计。

本文尝试用Golang实现一下模板方法，与读者共同体验一下组合式设计的魅力。

模板方法回顾

定义

模板方法模式(Template Method Pattern)是定义一个操作中的算法的框架，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的框架就可重新定义该算法的某些特定步骤。

模板方法的通用类图如下所示：

template-method.png

虽然模板方法的通用类图非常简单，但它却是一个应用非常广泛的设计模式。

抽象模板

AbstractClass叫做抽象模板，它的方法分为两类：

1. 基本方法：也叫基本操作，是由子类实现的方法，并且在模板方法中被调用
2. 模板方法：可以有一个或几个，一般是一个算法框架，实现对基本方法的调度，完成固定的逻辑。

下面以C++代码为例：

//AbstractClass.h
struct AbstractClass
{
    virtual ~AbstractClass() = default;

    void templateMethod();

private:
    virtual void doAnyThing() = 0;
    virtual void doSomeThing() = 0;
};

//AbstractClass.cpp
void AbstractClass::templateMethod()
{
    doAnyThing();
    doSomeThing();
}

具体模板

ConcreteClass1和ConcreteClass2属于具体模板，实现父类所定义的一个或多个抽象方法，也就是父类定义的基本方法在子类中得以实现。

下面以C++代码为例：

//ConcreteClass1.h
struct ConcreteClass1 : AbstractClass
{
private:
    virtual void doAnyThing() override;
    virtual void doSomeThing() override;
};

//ConcreteClass1.cpp
void ConcreteClass1::doAnyThing()
{
    ...
}

void ConcreteClass1::doSomeThing()
{
    ...
}

注：ConcreteClass2和ConcreteClass2的代码类似，我们不再赘述。

实例化模板方法

引入问题

假设我们有两个数据库，即Mysql和Oracle，用户操作时有相同的算法框架，而算法步骤的具体行为不同，比如数据库的连接接口和关闭接口实现不同。
我们假定用户的输入是三元组（table, key, value），期望数据库有一个事务操作，核心算法的框架为：

1. 连接数据库
2. 查询用户输入的三元组对应的记录是否存在
3. 如果不存在，则插入新纪录
4. 如果存在，则更新记录
5. 关闭数据库

说明：我们同时假定数据库有数据记录的活性检测功能，当一条数据记录长期没有被引用是，就将它从数据库中删掉，所以用户不用关心记录的删除操作。

注：该问题是笔者自己杜撰的。

建模

根据Golang的interface特性建模后，模板方法的类图如下：

template-method-golang.png

下面对该图做如下说明：

1. Golang的interface只包含纯方法声明，那么模板方法不能在interface里定义，所以必须增加一个类（struct），我们记作DbTrans。DbTrans通过成员变量持有了接口Db，该成员变量在运行时动态绑定具体的数据库实例，我们用单向关联表示这种关系。图中DbTrans的Exec()方法用于实现算法框架，对应模式中的抽象模板
2. 在Golang中，一个类只要实现了一个接口要求的所有函数，我们就说这个类实现了该接口，否则就说这个类和该接口没有关系。类和接口之间没有强制的契约关系（继承），通过组合和动态绑定的方式来实现继承和多态，我们用虚线表示这种隐形的继承关系。图中MySql和Oracle分别实现了接口Db，对应模式中的具体模板

实现

Db

Db是核心要素interface，实现代码为：

type Db interface {
    Connect()
    Close()
    InsertRecord(tableName, key, value string)
    GetRecord(tableName, key string) (err error, value string)
    UpdateRecord(tableName, key, value string)
}

DbTrans

DbTrans是承载模板方法的struct，实现代码为：

type DbTrans struct {
    Inst Db
}

func (this *DbTrans) Exec(tableName, key, value string) {
    if this.Inst == nil {
        return
    }
    this.Inst.Connect()
    if err, _ := this.Inst.GetRecord(tableName, key); err != nil {
        this.Inst.InsertRecord(tableName, key, value);
    } else {
        this.Inst.UpdateRecord(tableName, key, value)
    }
    this.Inst.Close()
}

说明：该算法框架和“引入问题”一节中给出的框架完全一样

Mysql

MySql是承载具体模板方法的struct，代码实现如下：

type Mysql struct {
}

func (_ *Mysql) Connect() {
    fmt.Println("mysql connect...")
}

func (_ *Mysql) Close() {
    fmt.Println("mysql close...\n")
}

func (_ *Mysql) InsertRecord(tableName, key, value string) {
    fmt.Printf("mysql tablename-%v insert record(%v, %v) succ!\n", tableName, key, value)
}

func (_ *Mysql) GetRecord(tableName, key string) (err error, value string) {
    i := rand.Intn(5)
    if i < 2 {
        fmt.Println("mysql", tableName, "table get record by", key, "failed!")
        return errors.New("record is not existed"), "nop"
    }
    fmt.Println("mysql", tableName, "table get record by", key, "succ!")
    return nil, "nop"
}

func (_ *Mysql) UpdateRecord(tableName, key, value string) {
    fmt.Printf("mysql tablename-%v update record(%v, %v) succ!\n", tableName, key, value)
}

我们看看Mysql中的GetRecord方法实现：

1. 用[0, 5]之间的随机数是否小于2来模拟是否查找失败
2. 如果查找失败，就插入记录
3. 如果查找成功，就更新记录

Oracle

Oracle与Mysql类似，不再赘述。

Client

Client在main函数里实现，代码实现如下：

func main() {
    trans := new(DbTrans)
    trans.Inst = new(Mysql)
    trans.Exec("department", "cloudman", "a architect and be good at openstack")
    trans.Inst = new(Oracle)
    trans.Exec("department", "cloudman", "a architect and be good at openstack and like dancing")
}

显然，用户分别触发了两个数据库的事务操作，一个是mysql，一个是oracle，这两个事务的算法框架都是DbTrans。

日志

运行模板方法的Golang代码，日志如下：

mysql connect...
mysql department table get record by cloudman failed!
mysql tablename-department insert record(cloudman, a architect and be good at openstack) succ!
mysql close...

oracle connect...
oracle department table get record by cloudman succ!
oracle tablename-department update record(cloudman, a architect and be good at openstack and like dancing) succ!
oracle close...

小结

本文先回顾了模板方法的通用定义和实现，然后引入一个问题，通过建模和实现等步骤实例化了Golang版的模板方法，这对笔者即将开发的用户故事有一定的价值，也希望对读者深刻理解Golang的interface有一定的帮助。

有疑问加站长微信联系（非本文作者）