上一篇：【Go实现】实践GoF的23种设计模式：适配器模式
简单的分布式应用系统（示例代码工程）：https://github.com/ruanrunxue/Practice-Design-Pattern–Go-Implementation
简介
解释器模式（Interpreter Pattern）应该是 GoF 的 23 种设计模式中使用频率最少的一种了，它的应用场景较为局限。
GoF 对它的定义如下：
Given a language, define a represention for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
从定义可以看出，解释器模式主要运用于简单的语法解析场景，比如简单的领域特定语言（DSL）。举个例子，我们可以使用解析器模式来对“1+2+3-4+1”这样的文本表达式完成解析，并得到最终答案“3”。
解释器模式的整体思想是分而治之，每一个语法规则都使用一个类或者结构体（我们称之为 Rule Struct）来定义，它们相互独立，比如前一个例子中，“+” 和 “-” 都各自定义为一个 Rule Struct。因此，解释器模式的可扩展性很好。
通常，我们还能使用抽象语法树（Abstract Syntax Tree，AST）来直观地表示待解释的表达式，比如“1+2+3-4+1”可以表示成这样：
UML 结构
解释器模式通常有 4 种角色：
- Context：解释上下文，包含了解释语法需要的所有信息，它是的生命周期贯穿整个解释过程，是一个全局对象。
- AbstractExpression：声明了解释语法的方法，通常只有
Interpret(*Context)一个方法。 - TerminalExpression：实现了 AbstractExpression 接口，定义了终结表达式的解析逻辑。终结表达式在抽象语法树中作为叶子节点。
- NonterminalExpression：实现了 AbstractExpression 接口，定义了非终结表达式的解析逻辑。在抽象语法树中，除了叶子节点，其他节点都是非终结表达式。NonterminalExpression 通常会比 TerminalExpression 更复杂一些。
场景上下文
在 简单的分布式应用系统（示例代码工程）中，db 模块用来存储服务注册信息和系统监控数据，它是一个 key-value 数据库。为了更高的易用性，它支持简单的 SQL 查询功能。用户在终端控制台上可以通过 SQL 语句来查询数据库中的数据：
简单起见，我们实现的 SQL 固定为 select xxx,xxx,xxx from xxx where xxx=xxx; 的形式，为此，我们要实现 3 个 TerminalExpression，即 SelectExpression、FromExpression 和 WhereExpression，分别解释 select 语句、from 语句、where 语句；以及 1 个 NonterminalExpression，即 CompoundExpression，用来解释整个 SQL 语句。
代码实现
// demo/db/sql.go
package db
// 关键点1：定义Context结构体/类，这里是SqlContext，里面存放解析过程所需的状态和数据，以及结果数据
// SqlContext SQL解析器上下文，保存各个表达式解析的中间结果
// 当前只支持基于主键的查询SQL语句
type SqlContext struct {
tableName string
fields []string
primaryKey interface{}
}
...
// 关键点2：定义AbstractExpression接口，这里是SqlExpression，其中Interpret方法以Context作为入参
// SqlExpression Sql表达式抽象接口，每个词、符号和句子都属于表达式
type SqlExpression interface {
Interpret(ctx *SqlContext) error
}
// 关键点3：定义TerminalExpression，实现AbstractExpression接口，这里是SelectExpression、FromExpression和WhereExpression
// SelectExpression select语句解析逻辑，select关键字后面跟的为field，以,分割，比如select Id,name
type SelectExpression struct {
fields string
}
func (s *SelectExpression) Interpret(ctx *SqlContext) error {
fields := strings.Split(s.fields, ",")
if len(fields) == 0 {
return ErrSqlInvalidGrammar
}
// 关键点4：在解析过程中将状态或者结果数据存储到Context里面
ctx.SetFields(fields)
return nil
}
// FromExpression from语句解析逻辑，from关键字后面跟的为表名，比如from regionTable1
type FromExpression struct {
tableName string
}
func (f *FromExpression) Interpret(ctx *SqlContext) error {
if f.tableName == "" {
return ErrSqlInvalidGrammar
}
ctx.SetTableName(f.tableName)
return nil
}
// WhereExpression where语句解析逻辑，where关键字后面跟的是主键过滤条件，比如where id='1'
type WhereExpression struct {
condition string
}
func (w *WhereExpression) Interpret(ctx *SqlContext) error {
vals := strings.Split(w.condition, "=")
if len(vals) != 2 {
return ErrSqlInvalidGrammar
}
if strings.Contains(vals[1], "'") {
ctx.SetPrimaryKey(strings.Trim(vals[1], "'"))
return nil
}
if val, err := strconv.Atoi(vals[1]); err == nil {
ctx.SetPrimaryKey(val)
return nil
}
return ErrSqlInvalidGrammar
}
// 关键点5：实现NonterminalExpression，这里是CompoundExpression，它在解释过程中会引用到TerminalExpression，可以将TerminalExpression作为成员变量，也可以在Interpret方法中直接创建新对象。
// CompoundExpression SQL语句解释器，SQL固定为select xxx,xxx,xxx from xxx where xxx=xxx; 的固定格式
// 例子：select regionId from regionTable where regionId=1
type CompoundExpression struct {
sql string
}
func (c *CompoundExpression) Interpret(ctx *SqlContext) error {
childs := strings.Split(c.sql, " ")
if len(childs) != 6 {
return ErrSqlInvalidGrammar
}
// 关键点6：在NonterminalExpression的Interpret方法中，调用TerminalExpression的Interpret方法完成对语句的解释。
for i := 0; i < len(childs); i++ {
switch strings.ToLower(childs[i]) {
case "select":
i++
express := &SelectExpression{fields: childs[i]}
if err := express.Interpret(ctx); err != nil {
return err
}
case "from":
i++
express := &FromExpression{tableName: childs[i]}
if err := express.Interpret(ctx); err != nil {
return err
}
case "where":
i++
express := &WhereExpression{condition: childs[i]}
if err := express.Interpret(ctx); err != nil {
return err
}
default:
return ErrSqlInvalidGrammar
}
}
return nil
}
客户端这么使用：
// demo/db/memory_db.go
package db
// memoryDb 内存数据库
type memoryDb struct {
tables sync.Map // key为tableName，value为table
}
...
func (m *memoryDb) ExecSql(sql string) (*SqlResult, error) {
ctx := NewSqlContext()
express := &CompoundExpression{sql: sql}
if err := express.Interpret(ctx); err != nil {
return nil, ErrSqlInvalidGrammar
}
// 关键点7：解释成功后，从Context中获取解释结果信息
table, ok := m.tables.Load(ctx.TableName())
if !ok {
return nil, ErrTableNotExist
}
record, ok := table.(*Table).records[ctx.PrimaryKey()]
if !ok {
return nil, ErrRecordNotFound
}
result := NewSqlResult()
for _, f := range ctx.Fields() {
field := strings.ToLower(f)
if idx, ok := table.(*Table).metadata[field]; ok {
result.Add(field, record.values[idx])
}
}
return result, nil
}
总结实现解释器模式的几个关键点：
- 定义 Context 结构体/类，这里是
SqlContext，里面存放解释过程所需的状态和数据，也会存储解释结果。 - 定义 AbstractExpression 接口，这里是
SqlExpression，其中Interpret方法以 Context 作为入参。 - 定义 TerminalExpression 结构体，并实现 AbstractExpression 接口，这里是
SelectExpression、FromExpression和WhereExpression。 - 将
Interpret方法解释过程中产生的过程状态、数据存储在 Context 上，使得其他 Expression 在解释过程中能够访问。 - 实现 NonterminalExpression，这里是
CompoundExpression，它在解释过程中会引用到 TerminalExpression，可以把 TerminalExpression 作为成员变量，也可以在 Interpret 方法中直接创建新对象。 - 在 NonterminalExpression 的 Interpret 方法中，调用 TerminalExpression 的 Interpret 方法完成对语句的解释。这里是
CompoundExpression.Interpret调用SelectExpression.Interpret、FromExpression.Interpret和WhereExpression.Interpret完成对 SQL 的解释。 - 解释成功后，从 Context 中获取解释结果。
扩展
领域特定语言 DSL
在前文介绍解释器模式时有提到，它常用于对领域特定语言 DSL 的解释场景，那么什么是 DSL 呢？下面我们将简单介绍一下。
维基百科对 DSL 的定义如下：
A domain-specific language (DSL) is a computer language specialized to a particular application domain.
可见，DSL 是针对特定领域的一种计算机语言，与之相对的是 GPL，General Purpose Language，即通用编程语言。我们常用的 C/C++，Java，Go 等都属于 GPL 的范畴。
DSL 又可细分成 2 类：
-
External DSL ：此类 DSL 拥有独立的语法以及解释器，比如 CSS 用于定义 Web 网页的样式和布局、SQL 用于数据查询、XML 和 YAML 用于配置管理，它们都是典型的 External DSL。
# External DSL举例，SQL select id,name from regions where id=‘1’; -
Internal DSL：此类 DSL 构建与 GPL 之上，比如流式接口 fluent interface、单元测试中的 Mock 库，它们可以提升 GPL 的易用性和易理解性。
// Internal DSL，Java中的Mockito库
Mockito.when(mockDemo.isTrue()).thenReturn(1);
Martin Fowler 大神专门写了一本书《领域特定语言》来介绍 DSL，更多详细、专业的知识请移步这里。
典型应用场景
- 简单的语法解析。解释器模式的运用场景较为单一，主要运用于简单的语法解析场景，比如简单的领域特定语言（DSL）。
优缺点
优点
- 易于扩展。前文提到，使用解释器模式进行语法解释时，每种语法规则都会有对应的 Expression 结构体/类。因此，新增一种语法规则会非常的容易；类似地，改变一种已有的语法规则的解释方式也是很容易，单点改动即可。
缺点
- 不适用于复杂的语法解释。当语法过于复杂时，Expression 结构体/类的数量将会变得很多，从而难以维护。
与其他模式的关联
解释器模式通常与组合模式（Composite Pattern）结合在一起使用，UML 结构图中的 NonterminalExpression 和 AbstractExpression 的就是组合关系。
另外，解释器模式这种分而治之的方法，与状态模式（State Pattern）中每种状态处理各种的逻辑很是类似。
文章配图
可以在 用Keynote画出手绘风格的配图 中找到文章的绘图方法。
参考
[1] 【Go实现】实践GoF的23种设计模式：SOLID原则, 元闰子
[2] Design Patterns, Chapter 5. Behavioral Patterns, GoF
[3] Domain-Specific Languages Guide, Martin Fowler
更多文章请关注微信公众号：元闰子的邀请
