https://mp.weixin.qq.com/s?__biz=MzA5MDEwMDYyOA==&mid=2454619166&idx=1&sn=145f2cace28a68ff0948fe6719f73944&chksm=87aae2e5b0dd6bf310c075610a383fe475c56b1a0851657a1650c2bf1d2449513ca037d7e15d&scene=178&cur_album_id=1345538712331042818#rd

嗯，我的代码没有else系列，一个设计模式业务真实使用的golang系列。

2. 客户决策 - 图1

前言

本系列主要分享，如何在我们的真实业务场景中使用设计模式。
本系列文章主要采用如下结构：

  • 什么是「XX设计模式」？
  • 什么真实业务场景可以使用「XX设计模式」？
  • 怎么用「XX设计模式」？

本文主要介绍「策略模式」如何在真实业务场景中使用。

什么是「策略模式」？

「策略模式」比较简单，大家平常工作中应该经常使用到，所以本文作为复习，帮助大家温故知新。我们先来看下定义：

不同的算法按照统一的标准封装，客户端根据不同的场景，决策使用何种算法。

上面的概念的关键词：

  • 算法：就是行为
  • 标准：就是interface
  • 客户端：客户端是相对的，谁调用谁就是客户端
  • 场景：判断条件
  • 决策：判断的过程

概念很容易理解，不多说。
「策略模式」的优势：

  • 典型的高内聚：算法和算法之间完全独立、互不干扰
  • 典型的松耦合：客户端依赖的是接口的抽象方法
  • 沉淀：每一个封装好的算法都是这个技术团队的财富，且未来可以被轻易的修改、复用

    什么真实业务场景可以用「策略模式」？

    每一行代码下面的十字路口

当代码的下一步面临选择的时候都可以使用「策略模式」，我们把不同选择的算法按照统一的标准封装，得到一类算法集的过程，就是实现「策略模式」的过程。

我们有哪些真实业务场景可以用「策略模式」呢？

比如：

  • 缓存: 使用什么样的nosql
  • 存储: 使用什么样的DB
  • 支付: 使用什么样的支付方式
  • 等等…

本文以支付接口举例，说明「策略模式」的具体使用。

怎么用「策略模式」？

关于怎么用，完全可以生搬硬套我总结的使用设计模式的四个步骤：

  • 业务梳理
  • 业务流程图
  • 代码建模

  • 代码demo

    业务梳理

    我们以某团的订单支付页面为例，页面上的每一个支付选项都是一个支付策略。如下：
    用户可以使用：

  • 美团支付(策略)

  • 微信支付(策略)
  • 支付宝支付(策略)

2. 客户决策 - 图2image.gif
用户决定使用美团支付下的银行卡支付方式的参数
2. 客户决策 - 图4image.gif
用户决定使用支付宝网页版支付方式的参数
2. 客户决策 - 图6image.gif

注：不一定完全准确。

业务流程图

我们通过梳理的文本业务流程得到了如下的业务流程图：
2. 客户决策 - 图8image.gif

注：流程不一定完全准确。

代码建模

「策略模式」的核心是接口：

  • PaymentInterface
    • Pay(ctx *Context) error 当前支付方式的支付逻辑
    • Refund(ctx *Context) error 当前支付方式的退款逻辑

伪代码如下：

  1. // 定义一个支付接口
  2. - `PaymentInterface`
  3.     + 抽象方法`Pay(ctx *Context) error`: 当前支付方式的支付逻辑
  4.     + 抽象方法`Refund(ctx *Context) error`: 当前支付方式的退款逻辑
  5. // 定义具体的支付方式 实现接口`PaymentInterface`
  6. - 具体的微信支付方式`WechatPay`
  7.     +  实现方法`Pay`: 支付逻辑
  8.     +  实现方法`Refund`: 支付逻辑
  9. - 具体的支付宝支付网页版方式`AliPayWap`
  10.     +  实现方法`Pay`: 支付逻辑
  11.     +  实现方法`Refund`: 支付逻辑
  12. - 具体的支付宝支付网页版方式`BankPay`
  13.     +  实现方法`Pay`: 支付逻辑
  14.     +  实现方法`Refund`: 支付逻辑
  15. // 客户端代码
  16. 通过接口参数pay_type的值判断是哪种支付方式策略

同时得到了我们的UML图：
2. 客户决策 - 图10
image.gif

代码demo

  1. package main
  2. import (
  3.     "fmt"
  4.     "runtime"
  5. )
  6. //------------------------------------------------------------
  7. //我的代码没有`else`系列
  8. //策略模式
  9. //@auhtor TIGERB<https://github.com/TIGERB>
  10. //------------------------------------------------------------
  11. const (
  12.     // ConstWechatPay 微信支付
  13.     ConstWechatPay = "wechat_pay"
  14.     // ConstAliPayWap 支付宝支付 网页版
  15.     ConstAliPayWap = "AliPayWapwap"
  16.     // ConstBankPay 银行卡支付
  17.     ConstBankPay = "quickbank"
  18. )
  19. // Context 上下文
  20. type Context struct {
  21.     // 用户选择的支付方式
  22.     PayType string `json:"pay_type"`
  23. }
  24. // PaymentInterface 支付方式接口
  25. type PaymentInterface interface {
  26.     Pay(ctx *Context) error    // 支付
  27.     Refund(ctx *Context) error // 退款
  28. }
  29. // WechatPay 微信支付
  30. type WechatPay struct {
  31. }
  32. // Pay 当前支付方式的支付逻辑
  33. func (p *WechatPay) Pay(ctx *Context) (err error) {
  34.     // 当前策略的业务逻辑写这
  35.     fmt.Println(runFuncName(), "使用微信支付...")
  36.     return
  37. }
  38. // Refund 当前支付方式的支付逻辑
  39. func (p *WechatPay) Refund(ctx *Context) (err error) {
  40.     // 当前策略的业务逻辑写这
  41.     fmt.Println(runFuncName(), "使用微信退款...")
  42.     return
  43. }
  44. // AliPayWap 支付宝网页版
  45. type AliPayWap struct {
  46. }
  47. // Pay 当前支付方式的支付逻辑
  48. func (p *AliPayWap) Pay(ctx *Context) (err error) {
  49.     // 当前策略的业务逻辑写这
  50.     fmt.Println(runFuncName(), "使用支付宝网页版支付...")
  51.     return
  52. }
  53. // Refund 当前支付方式的支付逻辑
  54. func (p *AliPayWap) Refund(ctx *Context) (err error) {
  55.     // 当前策略的业务逻辑写这
  56.     fmt.Println(runFuncName(), "使用支付宝网页版退款...")
  57.     return
  58. }
  59. // BankPay 银行卡支付
  60. type BankPay struct {
  61. }
  62. // Pay 当前支付方式的支付逻辑
  63. func (p *BankPay) Pay(ctx *Context) (err error) {
  64.     // 当前策略的业务逻辑写这
  65.     fmt.Println(runFuncName(), "使用银行卡支付...")
  66.     return
  67. }
  68. // Refund 当前支付方式的支付逻辑
  69. func (p *BankPay) Refund(ctx *Context) (err error) {
  70.     // 当前策略的业务逻辑写这
  71.     fmt.Println(runFuncName(), "使用银行卡退款...")
  72.     return
  73. }
  74. // 获取正在运行的函数名
  75. func runFuncName() string {
  76.     pc := make([]uintptr, 1)
  77.     runtime.Callers(2, pc)
  78.     f := runtime.FuncForPC(pc[0])
  79.     return f.Name()
  80. }
  81. func main() {
  82.     // 相对于被调用的支付策略 这里就是支付策略的客户端
  83.     // 业务上下文
  84.     ctx := &Context{
  85.         PayType: "wechat_pay",
  86.     }
  87.     // 获取支付方式
  88.     var instance PaymentInterface
  89.     switch ctx.PayType {
  90.     case ConstWechatPay:
  91.         instance = &WechatPay{}
  92.     case ConstAliPayWap:
  93.         instance = &AliPayWap{}
  94.     case ConstBankPay:
  95.         instance = &BankPay{}
  96.     default:
  97.         panic("无效的支付方式")
  98.     }
  99.     // 支付
  100.     instance.Pay(ctx)
  101. }

代码运行结果：

  1. [Running] go run "../easy-tips/go/src/patterns/strategy/strategy.go"
  2. main.(*WechatPay).Pay 使用微信支付...

结语

最后总结下，「策略模式」抽象过程的核心是：
在每一行代码下面的十字路口

  • 声明标准：定义interface
  • 封装算法：按照标准interface封装分支代码，得到每一个具体策略
  • 构建算法集：每一个具体策略构成策略池子 -> 这就是沉淀的过程
  1. 特别说明：
  2. 1. 我的代码没有`else`，只是一个在代码合理设计的情况下自然而然无限接近或者达到的结果，并不是一个硬性的目标，务必较真。
  3. 2. 本系列的一些设计模式的概念可能和原概念存在差异，因为会结合实际使用，取其精华，适当改变，灵活使用。

我的代码没有else系列 更多文章

image.gif