鏈式調用 | 個人代碼沒有else

嗯，個人代碼沒有 else系列，一個設計模式業務真實使用的golang系列。

前言

本系列主要分享，如何在咱們的真實業務場景中使用設計模式。

本系列文章主要採用以下結構：

• 什麼是「XX設計模式」？
• 什麼真實業務場景可使用「XX設計模式」？
• 怎麼用「XX設計模式」？

本文主要介紹「責任鏈模式」如何在真實業務場景中使用。

什麼是「責任鏈模式」？

首先把一系列業務按職責劃分紅不一樣的對象，接着把這一系列對象構成一個鏈，而後在這一系列對象中傳遞請求對象，直到被處理爲止。

咱們從概念中能夠看出責任鏈模式有以下明顯的優點：

• 按職責劃分：解耦
• 對象鏈：邏輯清晰

可是有一點直到被處理爲止，表明最終只會被一個實際的業務對象執行了實際的業務邏輯，明顯適用的場景並很少。可是除此以外，上面的那兩點優點仍是讓人很心動，因此，爲了適用於目前所接觸的絕大多數業務場景，把概念進行了簡單的調整，以下：

首先把一系列業務按職責劃分紅不一樣的對象，接着把這一系列對象構成一個鏈，直到「鏈路結束」爲止。(結束：異常結束，或鏈路執行完畢結束)

簡單的直到「鏈路結束」爲止轉換可讓咱們把責任鏈模式適用於任何複雜的業務場景。

如下是責任鏈模式的具體優點：

• 直觀：一眼可觀的業務調用過程
• 無限擴展：可無限擴展的業務邏輯
• 高度封裝：複雜業務代碼依然高度封裝
• 極易被修改：複雜業務代碼下修改代碼只須要專一對應的業務類(結構體)文件便可，以及極易被調整的業務執行順序

什麼真實業務場景能夠用「責任鏈模式(改)」？

知足以下要求的場景:

業務極度複雜的全部場景

任何雜亂無章的業務代碼，均可以使用責任鏈模式(改)去重構、設計。

咱們有哪些真實業務場景能夠用「責任鏈模式(改)」呢？

好比電商系統的下單接口，隨着業務發展不斷的發展，該接口會充斥着各類各樣的業務邏輯。

怎麼用「責任鏈模式(改)」？

關於怎麼用，徹底能夠生搬硬套我總結的使用設計模式的四個步驟：

• 業務梳理
• 業務流程圖
• 代碼建模
• 代碼demo

業務梳理

步驟	邏輯
1	參數校驗
2	獲取地址信息
3	地址信息校驗
4	獲取購物車數據
5	獲取商品庫存信息
6	商品庫存校驗
7	獲取優惠信息
8	獲取運費信息
9	使用優惠信息
10	扣庫存
11	清理購物車
12	寫訂單表
13	寫訂單商品表
14	寫訂單優惠信息表
XX	以及將來會增長的邏輯...

業務的不斷髮展變化的：

• 新的業務被增長
• 舊的業務被修改

好比增長的新的業務，訂金預售：

• 在4|獲取購物車數據後，須要校驗商品參見訂金預售活動的有效性等邏輯。
• 等等邏輯

注：流程不必定徹底準確

業務流程圖

咱們經過梳理的文本業務流程獲得了以下的業務流程圖：

代碼建模

責任鏈模式主要類主要包含以下特性：

• 成員屬性

  • nextHandler: 下一個等待被調用的對象實例 -> 穩定不變的

• 成員方法

  • SetNext: 把下一個對象的實例綁定到當前對象的nextHandler屬性上 -> 穩定不變的
  • Do: 當前對象業務邏輯入口 -> 變化的
  • Run: 調用當前對象的Do，nextHandler不爲空則調用nextHandler.Do -> 穩定不變的

套用到下單接口僞代碼實現以下：

一個父類(抽象類)：

- 成員屬性
    + `nextHandler`: 下一個等待被調用的對象實例
- 成員方法
    + 實體方法`SetNext`: 實現把下一個對象的實例綁定到當前對象的`nextHandler`屬性上
    + 抽象方法`Do`: 當前對象業務邏輯入口
    + 實體方法`Run`: 實現調用當前對象的`Do`，`nextHandler`不爲空則調用`nextHandler.Do`

子類一(參數校驗)
- 繼承抽象類父類
- 實現抽象方法`Do`：具體的參數校驗邏輯

子類二(獲取地址信息)
- 繼承抽象類父類
- 實現抽象方法`Do`：具體獲取地址信息的邏輯

子類三(獲取購物車數據)
- 繼承抽象類父類
- 實現抽象方法`Do`：具體獲取購物車數據的邏輯

......略

子類X(以及將來會增長的邏輯)
- 繼承抽象類父類
- 實現抽象方法`Do`：以及將來會增長的邏輯

可是，golang裏沒有的繼承的概念，要複用成員屬性nextHandler、成員方法SetNext、成員方法Run怎麼辦呢？咱們使用合成複用的特性變相達到「繼承複用」的目的，以下：

一個接口(interface)：

- 抽象方法`SetNext`: 待實現把下一個對象的實例綁定到當前對象的`nextHandler`屬性上
- 抽象方法`Do`: 待實現當前對象業務邏輯入口
- 抽象方法`Run`: 待實現調用當前對象的`Do`，`nextHandler`不爲空則調用`nextHandler.Do`

一個基礎結構體：

- 成員屬性
    + `nextHandler`: 下一個等待被調用的對象實例
- 成員方法
    + 實體方法`SetNext`: 實現把下一個對象的實例綁定到當前對象的`nextHandler`屬性上
    + 實體方法`Run`: 實現調用當前對象的`Do`，`nextHandler`不爲空則調用`nextHandler.Do`

子類一(參數校驗)
- 合成複用基礎結構體
- 實現抽象方法`Do`：具體的參數校驗邏輯

子類二(獲取地址信息)
- 合成複用基礎結構體
- 實現抽象方法`Do`：具體獲取地址信息的邏輯

子類三(獲取購物車數據)
- 合成複用基礎結構體
- 實現抽象方法`Do`：具體獲取購物車數據的邏輯

......略

子類X(以及將來會增長的邏輯)
- 合成複用基礎結構體
- 實現抽象方法`Do`：以及將來會增長的邏輯

同時獲得了咱們的UML圖：

代碼demo

package main

//---------------
//個人代碼沒有`else`系列
//責任鏈模式
//@auhtor TIGERB<https://github.com/TIGERB>
//---------------

import (
    "fmt"
    "runtime"
)

// Context Context
type Context struct {
}

// Handler 處理
type Handler interface {
    // 自身的業務
    Do(c *Context) error
    // 設置下一個對象
    SetNext(h Handler) Handler
    // 執行
    Run(c *Context) error
}

// Next 抽象出來的 可被合成複用的結構體
type Next struct {
    // 下一個對象
    nextHandler Handler
}

// SetNext 實現好的 可被複用的SetNext方法
// 返回值是下一個對象 方便寫成鏈式代碼優雅
// 例如 nullHandler.SetNext(argumentsHandler).SetNext(signHandler).SetNext(frequentHandler)
func (n *Next) SetNext(h Handler) Handler {
    n.nextHandler = h
    return h
}

// Run 執行
func (n *Next) Run(c *Context) (err error) {
    // 因爲go無繼承的概念 這裏沒法執行當前handler的Do
    // n.Do(c)
    if n.nextHandler != nil {
        // 合成複用下的變種
        // 執行下一個handler的Do
        if err = (n.nextHandler).Do(c); err != nil {
            return
        }
        // 執行下一個handler的Run
        return (n.nextHandler).Run(c)
    }
    return
}

// NullHandler 空Handler
// 因爲go無繼承的概念 做爲鏈式調用的第一個載體 設置實際的下一個對象
type NullHandler struct {
    // 合成複用Next的`nextHandler`成員屬性、`SetNext`成員方法、`Run`成員方法
    Next
}

// Do 空Handler的Do
func (h *NullHandler) Do(c *Context) (err error) {
    // 空Handler 這裏什麼也不作 只是載體 do nothing...
    return
}

// ArgumentsHandler 校驗參數的handler
type ArgumentsHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *ArgumentsHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "校驗參數成功...")
    return
}

// AddressInfoHandler 地址信息handler
type AddressInfoHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *AddressInfoHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "獲取地址信息...")
    fmt.Println(runFuncName(), "地址信息校驗...")
    return
}

// CartInfoHandler 獲取購物車數據handler
type CartInfoHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *CartInfoHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "獲取購物車數據...")
    return
}

// StockInfoHandler 商品庫存handler
type StockInfoHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *StockInfoHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "獲取商品庫存信息...")
    fmt.Println(runFuncName(), "商品庫存校驗...")
    return
}

// PromotionInfoHandler 獲取優惠信息handler
type PromotionInfoHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *PromotionInfoHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "獲取優惠信息...")
    return
}

// ShipmentInfoHandler 獲取運費信息handler
type ShipmentInfoHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *ShipmentInfoHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "獲取運費信息...")
    return
}

// PromotionUseHandler 使用優惠信息handler
type PromotionUseHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *PromotionUseHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "使用優惠信息...")
    return
}

// StockSubtractHandler 庫存操做handler
type StockSubtractHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *StockSubtractHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "扣庫存...")
    return
}

// CartDelHandler 清理購物車handler
type CartDelHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *CartDelHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "清理購物車...")
    // err = fmt.Errorf("CartDelHandler.Do fail")
    return
}

// DBTableOrderHandler 寫訂單表handler
type DBTableOrderHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *DBTableOrderHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "寫訂單表...")
    return
}

// DBTableOrderSkusHandler 寫訂單商品表handler
type DBTableOrderSkusHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *DBTableOrderSkusHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "寫訂單商品表...")
    return
}

// DBTableOrderPromotionsHandler 寫訂單優惠信息表handler
type DBTableOrderPromotionsHandler struct {
    // 合成複用Next
    Next
}

// Do 校驗參數的邏輯
func (h *DBTableOrderPromotionsHandler) Do(c *Context) (err error) {
    fmt.Println(runFuncName(), "寫訂單優惠信息表...")
    return
}

// 獲取正在運行的函數名
func runFuncName() string {
    pc := make([]uintptr, 1)
    runtime.Callers(2, pc)
    f := runtime.FuncForPC(pc[0])
    return f.Name()
}

func main() {
    // 初始化空handler
    nullHandler := &NullHandler{}

    // 鏈式調用 代碼是否是很優雅
    // 很明顯的鏈 邏輯關係盡收眼底
    nullHandler.SetNext(&ArgumentsHandler{}).
        SetNext(&AddressInfoHandler{}).
        SetNext(&CartInfoHandler{}).
        SetNext(&StockInfoHandler{}).
        SetNext(&PromotionInfoHandler{}).
        SetNext(&ShipmentInfoHandler{}).
        SetNext(&PromotionUseHandler{}).
        SetNext(&StockSubtractHandler{}).
        SetNext(&CartDelHandler{}).
        SetNext(&DBTableOrderHandler{}).
        SetNext(&DBTableOrderSkusHandler{}).
        SetNext(&DBTableOrderPromotionsHandler{})
        //無限擴展代碼...

    // 開始執行業務
    if err := nullHandler.Run(&Context{}); err != nil {
        // 異常
        fmt.Println("Fail | Error:" + err.Error())
        return
    }
    // 成功
    fmt.Println("Success")
    return
}

代碼運行結果：

[Running] go run "../easy-tips/go/src/patterns/responsibility/responsibility-order-submit.go"
main.(*ArgumentsHandler).Do 校驗參數成功...
main.(*AddressInfoHandler).Do 獲取地址信息...
main.(*AddressInfoHandler).Do 地址信息校驗...
main.(*CartInfoHandler).Do 獲取購物車數據...
main.(*StockInfoHandler).Do 獲取商品庫存信息...
main.(*StockInfoHandler).Do 商品庫存校驗...
main.(*PromotionInfoHandler).Do 獲取優惠信息...
main.(*ShipmentInfoHandler).Do 獲取運費信息...
main.(*PromotionUseHandler).Do 使用優惠信息...
main.(*StockSubtractHandler).Do 扣庫存...
main.(*CartDelHandler).Do 清理購物車...
main.(*DBTableOrderHandler).Do 寫訂單表...
main.(*DBTableOrderSkusHandler).Do 寫訂單商品表...
main.(*DBTableOrderPromotionsHandler).Do 寫訂單優惠信息表...
Success

結語

最後總結下，「責任鏈模式(改)」抽象過程的核心是：

• 按職責劃分：業務邏輯歸類，收斂的過程。
• 對象鏈：把收斂以後的業務對象構成對象鏈，依次被執行。

特別說明：
1. 個人代碼沒有`else`，只是一個在代碼合理設計的狀況下天然而然無限接近或者達到的結果，並非一個硬性的目標，務必較真。
2. 本系列的一些設計模式的概念可能和原概念存在差別，由於會結合實際使用，取其精華，適當改變，靈活使用。

個人代碼沒有else系列 更多文章 點擊此處查看