Golang 状态机设计模式

本文介绍了Golang状态机模式的一个实现示例，通过该模式，可以解耦调用链，有助于实现测试友好的代码，提高代码质量。原文: Go State Machine Patterns

alt
导言

在我们开发的许多项目中，都需要依赖某种运行状态从而实现连续操作。

这方面的例子包括：

  • 解析配置语言、编程语言等
  • 在系统、路由器、集群上执行操作...
  • ETL（Extract Transform Load，提取转换加载）

很久以前，Rob Pike 有一个关于 Go 中词法扫描[1]的演讲，内容很讲座，我看了好几遍才真正理解。但演讲中介绍的最基本知识之一就是某个版本的 Go 状态机。

该状态机利用了 Go 的能力，即从函数中创建类型并将函数赋值给变量。

他在演讲中介绍的状态机功能强大，打破了让函数执行 if/else 并调用下一个所需函数的逻辑。取而代之的是，每个状态都会返回下一个需要调用的函数。

这样就能将调用链分成更容易测试的部分。

调用链

下面是一个用简单的调用链来完成任务的例子：

func Caller(args Args) {
  callA(args)
  callB(args)
}

或

func Caller(args Args) {
  callA(args)
}

func callA(args Args) {
  callB(args)
}

func callB(args Args) {
  return
}

两种方法都表示调用链，其中 Caller() 调用 callA()，并最终调用 callB()，从中可以看到这一系列调用是如何执行的。

当然，这种设计没有任何问题，但当调用者远程调用其他系统时，必须对这些远程调用进行模拟/打桩，以提供密封测试。

你可能还想实现条件调用链，即根据某些参数或状态，在特定条件下通过 if/else 调用不同函数。

这就意味着，要对 Caller() 进行密封测试，可能需要处理整个调用链中的桩函数。如果有 50 个调用层级，则可能需要对被测函数下面每个层级的所有函数进行模拟/打桩。

这正是 Pike 的状态机设计大显身手的地方。

状态机模式

首先定义状态:

type State[T any] func(ctx context.Context, args T) (T, State[T], error)

状态表示为函数/方法，接收一组参数（任意类型 T），并返回下一个状态及其参数或错误信息。

如果返回的状态为 nil，那么状态机将停止运行。如果设置了 error，状态机也将停止运行。因为返回的是下一个要运行的状态，所以根据不同的条件，会有不同的下一个状态。

这个版本与 Pike 的状态机的不同之处在于这里包含了泛型并返回 T。这样我们就可以创建纯粹的函数式状态机（如果需要的话），可以返回某个类型，并将其传递给下一个状态。Pike 最初实现状态机设计时还没有使用泛型。

为了实现这一目标，需要一个状态驱动程序：

func Run[T any](ctx context.Context, args T, start State[T]) (T, error) {
  var err error
  current := start
  for {
    if ctx.Err() != nil {
      return args, ctx.Err()
    }
    args, current, err = current(ctx, args)
    if err != nil {
      return args, err
    }
    if current == nil {
      return args, nil
    }
  }
}

寥寥几行代码，我们就有了一个功能强大的状态驱动程序。

下面来看一个例子，在这个例子中，我们为集群中的服务关闭操作编写了状态机：

package remove

...

// storageClient provides the methods on a storage service
// that must be provided to use Remove().
type storageClient interface {
  RemoveBackups(ctx context.Context, service string, mustKeep int) error
  RemoveContainer(ctx context.Context, service string) error
}

// serviceClient provides methods to do operations for services 
// within a cluster.
type servicesClient interface {
  Drain(ctx context.Context, service string) error
  Remove(ctx context.Context, service string) error
  List(ctx context.Context) ([]string, error)
  HasStorage(ctx context.Context, service string) (bool, error)
}

这里定义了几个需要客户实现的私有接口，以便从集群中移除服务。

我们定义了私有接口，以防止他人使用我们的定义，但会通过公有变量公开这些接口。这样，我们就能与客户保持松耦合，保证只使用我们需要的方法。

// Args are arguments to Service().
type Args struct {
  // Name is the name of the service.
  Name string
  
  // Storage is a client that can remove storage backups and storage
  // containers for a service.
  Storage storageClient
  // Services is a client that allows the draining and removal of
  // a service from the cluster.
  Services servicesClient
}

func (a Args) validate(ctx context.Context) error {
  if a.Name == "" {
    return fmt.Errorf("Name cannot be an empty string")
  }

  if a.Storage == nil {
    return fmt.Errorf("Storage cannot be nil")
  }
  if a.Services == nil {
    return fmt.Errorf("Services cannot be nil")
  }
  return nil
}

这里设置了要通过状态传递的参数，可以将在一个状态中设置并传递到另一个状态的私有字段包括在内。

请注意，Args 并非指针。

由于我们修改了 Args 并将其传递给每个状态，因此不需要给垃圾回收器增加负担。对于像这样操作来说，这点节约微不足道，但在工作量大的 ETL 管道中，节约的时间可能就很明显了。

实现中包含 validate() 方法，用于测试参数是否满足使用的最低基本要求。

// Service removes a service from a cluster and associated storage.
// The last 3 storage backups are retained for whatever the storage retainment
// period is.
func Service(ctx context.Context, args Args) error {
  if err := args.validate(); err != nil {
    return err
  }
  
  start := drainService
  _, err := Run[Args](ctx, args, start)
  if err != nil {
    return fmt.Errorf("problem removing service %q: %w", args.Name, err)
  }
  return nil
}

用户只需调用 Service()，传入 Args，如果出错就会收到错误信息。用户不需要看到状态机模式，也不需要理解状态机模式就能执行操作。

我们只需验证 Args 是否正确，将状态机的起始状态设置为名为 drainService 的函数，然后调用上面定义的 Run() 函数即可。

func drainService(ctx context.Context, args Args) (Args, State[Args], error) {
  l, err := args.Services.List(ctx)
  if err != nil {
    return args, nil, err
  }

  found := false
  for _, entry := range l {
    if entry == args.Name {
      found = true
      break
    }
  }
  if !found {
    return args, nil, fmt.Errorf("the service was not found")
  }

  if err := args.Services.Drain(ctx, args.Name); err != nil {
    return args, nil, fmt.Errorf("problem draining the service: %w", err)
  }

  return args, removeService, nil
}

我们的第一个状态叫做 drainService()，实现了上面定义的状态类型。

它使用 Args 中定义的 Services 客户端列出集群中的所有服务，如果找不到服务，就会返回错误并结束状态机。

如果找到服务，就会对服务执行关闭。一旦完成，就进入下一个状态，即 removeService()。

func removeService(ctx context.Context, args Args) (Args, State[Args], error) {
  if err := args.Services.Remove(ctx, args.Name); err != nil {
    return args, nil, fmt.Errorf("could not remove the service: %w", err)
  }

  hasStorage, err := args.Services.HasStorage(ctx, args.Name)
  if err != nil {
    return args, nil, fmt.Errorf("HasStorage() failed: %w", err)
  }
  if hasStorage{
    return args, removeBackups, nil
  }

  return args, nil, nil
}

removeService() 使用我们的 Services 客户端将服务从群集中移除。

调用 HasStorage() 方法确定是否有存储，如果有，就会进入 removeBackups() 状态，否则就会返回 args, nil, nil，这将导致状态机在无错误的情况下退出。

这个示例说明如何根据 Args 中的信息或代码中的远程调用在状态机中创建分支。

其他状态调用由你自行决定。我们看看这种设计如何更适合测试此类操作。

测试优势

这种模式首先鼓励的是小块的可测试代码，模块变得很容易分割，这样当代码块变得太大时，只需创建新的状态来隔离代码块。

但更大的优势在于无需进行大规模端到端测试。由于操作流程中的每个阶段都需要调用下一阶段，因此会出现以下情况：

  • 顶层调用者按一定顺序调用所有子函数
  • 每个调用者都会调用下一个函数
  • 两者的某种混合

两者都会导致某种类型的端到端测试，而这种测试本不需要。

如果我们对顶层调用者方法进行编码，可能看起来像这样：

func Service(ctx context.Context, args Args) error {
  ...
  if err := drainService(ctx, args); err != nil {
    return err
  }

  if err := removeService(ctx, args); err != nil {
    return err
  }

  hasStorage, err := args.Services.HasStorage(ctx, args.Name)
  if err != nil {
    return err
  }

  if hasStorage{
    if err := removeBackups(ctx, args); err != nil {
      return err
    }
    if err := removeStorage(ctx, args); err != nil {
      return err
    }
  }
  return nil
} 

如你所见，可以为所有子函数编写单独的测试，但要测试 Service()，现在必须对调用的所有客户端或方法打桩。这看起来就像是端到端测试，而对于这类代码来说，通常不是好主意。

如果转到功能调用链，情况也不会好到哪里去：

func Service(ctx context.Context, args Args) error {
  ...
  return drainService(ctx, args)
}

func drainService(ctx context.Context, args Args) (Args, error) {
  ...
  return removeService(ctx, args)
}

func removeService(ctx context.Context, args Args) (Args, error) {
  ...
  hasStorage, err := args.Services.HasStorage(ctx, args.Name)
  if err != nil {
    return args, fmt.Errorf("HasStorage() failed: %w", err)
  }
  
  if hasStorage{
    return removeBackups(ctx, args)
  }

  return nil
}
...

当我们测试时，越接近调用链的顶端，测试的实现就变得越困难。在 Service() 中，必须测试 drainService()、removeService() 以及下面所有调用。

有几种方法可以做到，但都不太好。

如果使用状态机，只需测试每个阶段是否按要求运行，并返回想要的下一阶段。

顶层调用者甚至不需要测试，它只是调用 validate() 方法，并调用应该能够被测试的 Run() 函数。

我们为 drainService() 编写一个表驱动测试，这里会拷贝一份 drainService() 代码，这样就不用返回到前面看代码了。

func drainService(ctx context.Context, args Args) (Args, State[Args], error) {
  l, err := args.Services.List(ctx)
  if err != nil {
    return args, nil, err
  }

  found := false
  for _, entry := range l {
    if entry == args.Name {
      found = true
      break
    }
  }
  if !found {
    return args, nil, fmt.Errorf("the service was not found")
  }

  if err := args.Services.Drain(ctx, args.Name); err != nil {
    return args, nil, fmt.Errorf("problem draining the service: %w", err)
  }

  return args, removeService, nil
}

func TestDrainSerivce(t *testing.T) {
  t.Parallel()

  tests := []struct {
    name      string
    args      Args
    wantErr   bool
    wantState State[Args]
  }{
    {
      name: "Error: Services.List() returns an error",
      args: Args{
        Services: &fakeServices{
          list: fmt.Errorf("error"),
        },
      },
      wantErr: true,
    },
    {
      name: "Error: Services.List() didn't contain our service name",
      args: Args{
        Name: "myService",
        Services: &fakeServices{
          list: []string{"nope", "this", "isn't", "it"},
        },
      },
      wantErr: true,
    },
    {
      name: "Error: Services.Drain() returned an error",
      args: Args{
        Name: "myService",
        Services: &fakeServices{
          list:  []string{"yes", "mySerivce", "is", "here"},
          drain: fmt.Errorf("error"),
        },
      },
      wantErr: true,
    },
    {
      name: "Success",
      args: Args{
        Name: "myService",
        Services: &fakeServices{
          list:  []string{"yes", "myService", "is", "here"},
          drain: nil,
        },
      },
      wantState: removeService,
    },
  }

  for _, test := range tests {
    _, nextState, err := drainService(context.Background(), test.args)
    switch {
    case err == nil && test.wantErr:
      t.Errorf("TestDrainService(%s): got err == nil, want err != nil", test.name)
      continue
    case err != nil && !test.wantErr:
      t.Errorf("TestDrainService(%s): got err == %s, want err == nil", test.name, err)
      continue
    case err != nil:
      continue
    }
  
    gotState := methodName(nextState)
    wantState := methodName(test.wantState)
    if gotState != wantState {
      t.Errorf("TestDrainService(%s): got next state %s, want %s", test.name, gotState, wantState)
    }
  }
}

可以在 Go Playground玩一下。

如你所见，这避免了测试整个调用链，同时还能确保测试调用链中的下一个函数。

这些测试很容易划分，维护人员也很容易遵循。

其他可能性

这种模式也有变种，即根据 Args 中设置的字段确定状态，并跟踪状态的执行以防止循环。

在第一种情况下，状态机软件包可能是这样的:

type State[T any] func(ctx context.Context, args T) (T, State[T], error)

type Args[T] struct {
  Data T

  Next State
}


func Run[T any](ctx context.Context, args Args[T], start State[T]) (T, error) {
  var err error
  current := start
  for {
    if ctx.Err() != nil {
      return args, ctx.Err()
    }
    args, current, err = current(ctx, args)
    if err != nil {
      return args, err
    }
    current = args.Next // Set our next stage
    args.Next = nil // Clear this so to prevent infinite loops

    if current == nil {
      return args, nil
    }
  }
}

可以很容易的将分布式跟踪或日志记录集成到这种设计中。

如果希望推送大量数据并利用并发优势，不妨试试 stagedpipe 软件包，其内置了大量高级功能，可以看视频和 README 学习如何使用。

希望这篇文章能让你充分了解 Go 状态机设计模式，现在你的工具箱里多了一个强大的新工具。

你好，我是俞凡，在Motorola做过研发，现在在Mavenir做技术工作，对通信、网络、后端架构、云原生、DevOps、CICD、区块链、AI等技术始终保持着浓厚的兴趣，平时喜欢阅读、思考，相信持续学习、终身成长，欢迎一起交流学习。为了方便大家以后能第一时间看到文章，请朋友们关注公众号"DeepNoMind"，并设个星标吧，如果能一键三连(转发、点赞、在看)，则能给我带来更多的支持和动力，激励我持续写下去，和大家共同成长进步！

参考资料
[1]

Rob Pike关于词法扫描的演讲: https://www.youtube.com/watch?v=HxaD_trXwRE,

本文由 mdnice 多平台发布

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/537613.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

LeetCode-62. 不同路径【数学 动态规划 组合数学】

LeetCode-62. 不同路径【数学 动态规划 组合数学】

LeetCode-62. 不同路径【数学 动态规划 组合数学】 题目描述：解题思路一：动态规划，动规五部曲解题思路二：动态规划（版本二）解题思路三：数论 题目描述： 一个机器人位于一个 m x n 网…
阅读更多...
麦肯锡问题分析七步法

麦肯锡问题分析七步法

麦肯锡七步分析法又称“七步分析法”是麦肯锡公司根据他们做过的大量案例，总结出的一套对商业机遇的分析方法。它是一种在实际运用中，对新创公司及成熟公司都很重要的思维、工作方法。麦肯锡问题分析7步法为企业提供了一个结构化的问题解决框架&#xff…
阅读更多...
分类算法（数据挖掘）

分类算法（数据挖掘）

目录 1. 逻辑回归（Logistic Regression） 2. 支持向量机（Support Vector Machine, SVM） 3. 决策树（Decision Tree） 4. 随机森林（Random Forest） 5. K近邻（K-Nearest …
阅读更多...
Mongodb入门--头歌实验MongoDB 复制集 分片

Mongodb入门--头歌实验MongoDB 复制集 分片

一、MongoDB之副本集配置 1.1MongoDB主从复制 主从复制是MongoDB最早使用的复制方式， 该复制方式易于配置，并且可以支持任意数量的从节点服务器，与使用单节点模式相比有如下优点： 在从服务器上存储数据副本，提高了数…
阅读更多...
【已解决】VMware Horizon Client: 无法建立安全加密链路连接

【已解决】VMware Horizon Client: 无法建立安全加密链路连接

文章目录 问题原因解决方法方法1：在HTTPS拦截中添加VMware忽略列表 (推荐)方法2： 只拦截 浏览器进程的请求 / 取消 HTTPS 拦截（如果没有拦截HTTPS的必要 / 只针对浏览器请求，可以使用此方法） 当前使用mac 编辑&#xf…
阅读更多...
淘宝扭蛋机小程序：扭出惊喜，乐享购物新体验

淘宝扭蛋机小程序：扭出惊喜，乐享购物新体验

在快节奏的现代生活中，人们总是在寻找新鲜、有趣的娱乐方式。淘宝扭蛋机小程序应运而生，为您带来前所未有的购物与娱乐结合新体验。在这里，每一次的扭动都充满惊喜，每一次的点击都带来乐趣，让您在购物的同时&#xff0…
阅读更多...
OpenResty，Nginx实现接口验签与黑名单控制

OpenResty，Nginx实现接口验签与黑名单控制

介绍 nginx与openresty是两种优秀知名的7层负载均衡软件，nginx以其出色的性能和稳定性成为首选，而openresty则是在Nginx基础上构建的，支持嵌入Lua语言，大幅提升了开发效率。 安装OpenResty 版本 openresty-1.25.3.1-win64下载地…
阅读更多...
D. Solve The Maze Codeforces Round 648 (Div. 2)

D. Solve The Maze Codeforces Round 648 (Div. 2)

题目链接： Problem - 1365D - CodeforcesCodeforces. Programming competitions and contests, programming communityhttps://codeforces.com/problemset/problem/1365/D 题目大意： 有一张地图n行m列（地图外面全是墙）&#xff0c…
阅读更多...
阿里云服务器配置选择详细指导

阿里云服务器配置选择详细指导

云服务器配置如何选择？云服务器配置包括CPU内存、公网带宽和系统盘，阿里云服务器还要注意云服务器规格及轻量应用服务器的选择，云服务器吧以阿里云服务器为例来详细说下小白用户选择云服务器配置攻略： 一、准备工作 如果你不注册…
阅读更多...
文献速递：深度学习肝脏肿瘤诊断---基于多相增强 CT 和临床数据的恶性肝肿瘤鉴别诊断深度学习

文献速递：深度学习肝脏肿瘤诊断---基于多相增强 CT 和临床数据的恶性肝肿瘤鉴别诊断深度学习

Title 题目 Deep learning for diferential diagnosisof malignant hepatic tumors based on multi-phase contrast-enhanced CT and clinical data 基于多相增强 CT 和临床数据的恶性肝肿瘤鉴别诊断深度学习 Abstract 摘要 Liver cancer remains the leading cause of can…
阅读更多...
2024 年 AI代码助手AI Coding Assistant智能工具

2024 年 AI代码助手AI Coding Assistant智能工具

AI代码助手（AI Coding Assistant）是一种利用人工智能帮助开发人员更快、更准确地编写代码的软件工具。 它可以通过根据提示生成代码或在你实时编写代码时建议自动完成代码来实现此目的。 以下是AI代码助手可以做的一些事情： 与你使用的流行代…
阅读更多...
指令集体系简读

指令集体系简读

这一部分，采用问答的方式来进行梳理； 什么是指令集体系？ 指令集体系(Instruction Set Architecture,ISA)是规定处理器的外在行为的一系列内容的统称，它包括： 基本数据类型(data types)、指令(instructions)、寄存器…
阅读更多...
Socks5代理IP如何使用？详细教程解析

Socks5代理IP如何使用？详细教程解析

当我们在互联网上浏览网页、下载文件或者进行在线活动时，隐私和安全问题常常被提及。在这样的环境下，一个有效的解决方案是使用Sock5IP。本教程将向您介绍Sock5IP的使用方法，帮助您保护个人隐私并提升网络安全。 一、什么是Sock5IP&#xff1…
阅读更多...
使用了代理IP怎么还会被封？代理IP到底有没有效果？

使用了代理IP怎么还会被封？代理IP到底有没有效果？

代理IP作为一种网络工具，被广泛应用于各种场景，例如网络爬虫、海外购物、规避地区限制等。然而，很多用户在使用代理IP的过程中却发现自己的账号被封禁，这让他们不禁产生疑问：使用了代理IP怎么还会被封？代理…
阅读更多...
MXNet安装：专业指南与深度解析

MXNet安装：专业指南与深度解析

一、引言 MXNet是一个高效且灵活的深度学习框架，它支持多种编程语言和平台，并提供了丰富的深度学习算法和工具。随着深度学习技术的广泛应用，MXNet因其出色的性能和易用性受到了越来越多开发者和研究人员的青睐。本文将详细介绍MXNet的安装过…
阅读更多...
YOLOV5 分类：利用yolov5进行图像分类

YOLOV5 分类：利用yolov5进行图像分类

1、前言 之前介绍了yolov5的目标检测示例，这次将介绍yolov5的分类展示 目标检测：YOLOv5 项目：训练代码和参数详细介绍（train）_yolov5训练代码的详解-CSDN博客 yolov5和其他网络的性能对比 yolov5分类的代码部分在这 2、数据集准备 yolov5分类的数据集就是常规的摆放方式…
阅读更多...
SpringCloudAlibabaSeate处理分布式事务

SpringCloudAlibabaSeate处理分布式事务

SpringCloudAlibabaSeate处理分布式事务 1、部分面试题 微服务boot/cloud做的项目，你不可能只有一个数据库吧？那么多个数据库之间如何处理分布式事务的？ 一个场景：在订单支付成功后，交易中心会调用订单中心的服务把订…
阅读更多...
如何在公网环境远程管理内网Windows系统部署的MongoDB数据库

如何在公网环境远程管理内网Windows系统部署的MongoDB数据库

文章目录 前言1. 安装数据库2. 内网穿透2.1 安装cpolar内网穿透2.2 创建隧道映射2.3 测试随机公网地址远程连接 3. 配置固定TCP端口地址3.1 保留一个固定的公网TCP端口地址3.2 配置固定公网TCP端口地址3.3 测试固定地址公网远程访问 前言 MongoDB是一个基于分布式文件存储的数…
阅读更多...
通讯录项目（用c语言实现）

通讯录项目（用c语言实现）

一.什么是通讯录 通讯录是一种用于存储联系人信息的工具或应用程序。它是一种电子化的地址簿，用于记录和管理个人、机构或组织的联系方式，如姓名、电话号码、电子邮件地址和邮寄地址等。通讯录的目的是方便用户在需要时查找和联系他人。 通讯录通常以列…
阅读更多...
DC-DC 5V2A异步升压5V2A输出电源升压芯片2.6-5.5V供电

DC-DC 5V2A异步升压5V2A输出电源升压芯片2.6-5.5V供电

一、芯片概述： FP6298是一个电流模式升压DC-DC转换器。它是内置PWM电路0.08Ω功率MOSFET，使该调节器高效。内部补偿网络还可以最小化多达6个外部组件计数。误差放大器的非反相输入连接到一个0.6V的精度参考电压，内部的软启动功能可以降低涌入…
阅读更多...
最新文章

Copyright @ 2022~2023