一、 引言：為什麼需要可擴展的系統？

在軟件開發領域，需求變更如同家常便飯。一個缺乏擴展性的系統，往往在面對新功能需求或業務調整時，陷入“改一行代碼，崩整個系統”的困境。可擴展性設計的核心目標是：讓系統能夠以最小的修改成本，適應未來的變化。對於Go語言開發者而言，利用其接口、併發、組合等特性，可以高效構建出適應業務演進的系統。

本文將從架構設計原則、編碼實踐、架構實現模式、驗證指標到演進路線，系統講解如何設計一個“生長型”系統。

二、可擴展系統的核心設計原則

2.1  開閉原則： 對擴展開放，對修改關閉

理論補充：

開閉原則是面向對象設計的基石之一。它要求系統中的模塊、類或函數，應該對擴展新功能保持開放，而對修改現有代碼保持關閉。這意味着，當需求變更時，我們應通過添加新代碼（如新增實現類）來滿足需求，而不是修改已有的代碼邏輯。

Go語言的實現方式：

Go語言通過接口（Interface）和組合（Composition）特性，天然支持開閉原則。接口定義了穩定的契約，具體實現可以獨立變化；組合則允許通過“搭積木”的方式擴展功能，而無需修改原有結構。

示例：數據源擴展

假設我們需要支持從不同數據源（如MySQL、S3）讀取數據，核心邏輯是“讀取數據”，而具體數據源的實現可能頻繁變化。此時，我們可以通過接口定義穩定的讀取契約：

// DataSource 定義數據讀取的穩定接口（契約）
type DataSource interface {
    Read(p []byte) (n int, err error)  // 讀取數據到緩衝區
    Close() error                      // 關閉數據源
}


// MySQLDataSource 具體實現：MySQL數據源
type MySQLDataSource struct {
    db *sql.DB  // 依賴MySQL連接
}


func (m *MySQLDataSource) Read(p []byte) (int, error) {
    // 實現MySQL數據讀取邏輯（如執行查詢、填充緩衝區）
    return m.db.QueryRow("SELECT data FROM table").Scan(&p)
}


func (m *MySQLDataSource) Close() error {
    return m.db.Close()  // 關閉數據庫連接
}


// S3DataSource 新增實現：S3數據源（無需修改原有代碼）
type S3DataSource struct {
    client *s3.Client  // 依賴AWS S3客户端
    bucket string      // S3存儲桶名
}


func (s *S3DataSource) Read(p []byte) (int, error) {
    // 實現S3數據讀取邏輯（如下載對象到緩衝區）
    obj, err := s.client.GetObject(context.Background(), &s3.GetObjectInput{
        Bucket: aws.String(s.bucket),
        Key:    aws.String("data.txt"),
    })
    if err != nil {
        return 0, err
    }
    defer obj.Body.Close()
    return obj.Body.Read(p)  // 讀取數據到緩衝區
}


func (s *S3DataSource) Close() error {
    // S3客户端通常無需顯式關閉，可根據需要實現
    return nil
}

設計説明：

• DataSource接口定義了所有數據源必須實現的方法（Read和 Close），這是系統的“穩定契約”。
• 當需要新增數據源（如S3）時，只需實現該接口，無需修改現有的MySQL數據源或其他依賴DataSource的代碼。
• 這一設計符合開閉原則：系統對擴展（新增S3數據源）開放，對修改（無需改動現有代碼）關閉。
  -

2.2 模塊化設計：低耦合、高內聚

理論補充：

模塊化設計的核心是將系統拆分為獨立的功能模塊，模塊之間通過明確的接口交互。衡量模塊化質量的關鍵指標是：

• 耦合度：模塊之間的依賴程度（越低越好）。
• 內聚度：模塊內部功能的相關性（越高越好）。

理想情況下，模塊應滿足“高內聚、低耦合”：模塊內部功能高度相關（如訂單處理模塊僅處理訂單相關邏輯），模塊之間通過接口通信（如訂單模塊通過接口調用支付模塊，而非直接依賴支付模塊的實現）。

Go語言的實現方式：

Go語言通過包（Package）管理模塊邊界，通過接口隔離依賴。開發者可以通過以下方式提升模塊化質量：

• 單一職責原則：每個模塊/包僅負責單一功能（如order包處理訂單邏輯，payment包處理支付邏輯）。
• 接口隔離：模塊間通過小而精的接口交互，避免暴露內部實現細節。

示例：訂單模塊的模塊化設計

// order/order.go：訂單核心邏輯（高內聚）
package order


// Order 表示一個訂單（核心數據結構）
type Order struct {
    ID     string
    Items  []Item
    Status OrderStatus
}


// Item 表示訂單中的商品項
type Item struct {
    ProductID string
    Quantity  int
    Price     float64
}


// OrderStatus 訂單狀態枚舉
type OrderStatus string


const (
    OrderStatusCreated  OrderStatus = "created"
    OrderStatusPaid     OrderStatus = "paid"
    OrderStatusShipped  OrderStatus = "shipped"
)


// CalculateTotal 計算訂單總金額（核心業務邏輯，無外部依賴）
func (o *Order) CalculateTotal() float64 {
    total := 0.0
    for _, item := range o.Items {
        total += item.Price * float64(item.Quantity)
    }
    return total
}


// payment/payment.go：支付模塊（獨立模塊）
package payment


// PaymentService 定義支付接口（與訂單模塊解耦）
type PaymentService interface {
    Charge(orderID string, amount float64) error  // 支付操作
}


// AlipayService 支付寶支付實現
type AlipayService struct {
    client *alipay.Client  // 支付寶SDK客户端
}


func (a *AlipayService) Charge(orderID string, amount float64) error {
    // 調用支付寶API完成支付
    return a.client.TradeAppPay(orderID, amount)
}

設計説明：

• order包專注於訂單的核心邏輯（如計算總金額），不依賴任何外部支付實現。
• payment包定義支付接口，具體實現（如支付寶、微信支付）獨立存在。
• 訂單模塊通過PaymentService接口調用支付功能，與具體支付實現解耦。當需要更換支付方式時，只需新增支付實現（如WechatPayService），無需修改訂單模塊。

三、Go語言的擴展性編碼實踐

3.1 策略模式：動態切換算法

理論補充：

策略模式（Strategy Pattern）屬於行為型設計模式，用於定義一系列算法（策略），並將每個算法封裝起來，使它們可以相互替換。策略模式讓算法的變化獨立於使用它的客户端。

Go語言的實現方式：

Go語言通過接口實現策略的抽象，通過上下文（Context）管理策略的切換。這種模式適用於需要動態選擇不同算法的場景（如緩存策略、路由策略）。

示例：緩存策略的動態切換

假設系統需要支持多種緩存（Redis、Memcached），且可以根據業務場景動態切換。通過策略模式，可以將緩存的Get和Set操作抽象為接口，具體實現由不同緩存提供。

// cache/cache.go：緩存策略接口
package cache


// CacheStrategy 定義緩存操作的接口
type CacheStrategy interface {
    Get(key string) (interface{}, error)       // 從緩存獲取數據
    Set(key string, value interface{}, ttl time.Duration) error  // 向緩存寫入數據
}
// redis_cache.go：Redis緩存實現


type RedisCache struct {
    client *redis.Client  // Redis客户端
    ttl    time.Duration  // 默認過期時間
}


func NewRedisCache(client *redis.Client, ttl time.Duration) *RedisCache {
    return &RedisCache{client: client, ttl: ttl}
}


func (r *RedisCache) Get(key string) (interface{}, error) {
    return r.client.Get(context.Background(), key).Result()
}


func (r *RedisCache) Set(key string, value interface{}, ttl time.Duration) error {
    return r.client.Set(context.Background(), key, value, ttl).Err()
}


// memcached_cache.go：Memcached緩存實現
type MemcachedCache struct {
    client *memcache.Client  // Memcached客户端
}


func NewMemcachedCache(client *memcache.Client) *MemcachedCache {
    return &MemcachedCache{client: client}
}


func (m *MemcachedCache) Get(key string) (interface{}, error) {
    item, err := m.client.Get(key)
    if err != nil {
        return nil, err
    }
    var value interface{}
    if err := json.Unmarshal(item.Value, &value); err != nil {
        return nil, err
    }
    return value, nil
}


func (m *MemcachedCache) Set(key string, value interface{}, ttl time.Duration) error {
    data, err := json.Marshal(value)
    if err != nil {
        return err
    }
    return m.client.Set(&memcache.Item{
        Key:        key,
        Value:      data,
        Expiration: int32(ttl.Seconds()),
    }).Err()
}


// cache_context.go：緩存上下文（管理策略切換）
type CacheContext struct {
    strategy CacheStrategy  // 當前使用的緩存策略
}


func NewCacheContext(strategy CacheStrategy) *CacheContext {
    return &CacheContext{strategy: strategy}
}


// SwitchStrategy 動態切換緩存策略
func (c *CacheContext) SwitchStrategy(strategy CacheStrategy) {
    c.strategy = strategy
}


// Get 使用當前策略獲取緩存
func (c *CacheContext) Get(key string) (interface{}, error) {
    return c.strategy.Get(key)
}


// Set 使用當前策略寫入緩存
func (c *CacheContext) Set(key string, value interface{}, ttl time.Duration) error {
    return c.strategy.Set(key, value, ttl)
}

設計説明：

• CacheStrategy接口定義了緩存的核心操作（Get和Set），所有具體緩存實現必須實現該接口。
• RedisCache和MemcachedCache是具體的策略實現，分別封裝了Redis和Memcached的底層邏輯。
• CacheContext作為上下文，持有當前使用的緩存策略，並提供SwitchStrategy方法動態切換策略。客户端只需與CacheContext交互，無需關心具體使用的是哪種緩存。

優勢： 當需要新增緩存類型（如本地內存緩存）時，只需實現CacheStrategy接口，無需修改現有代碼；切換緩存策略時，只需調用SwitchStrategy方法，客户端無感知。

3.2 中間件鏈：可插拔的請求處理流程

理論補充：

中間件（Middleware）是位於請求處理鏈中的組件，用於實現橫切關注點（如日誌記錄、限流、鑑權）。中間件鏈模式允許將多箇中間件按順序組合，形成處理流水線，每個中間件可以處理請求、傳遞請求或終止請求。

Go語言的實現方式：

Go語言通過函數類型（func(http.HandlerFunc) http.HandlerFunc）定義中間件，通過組合多箇中間件形成處理鏈。這種模式靈活且易於擴展，適用於HTTP服務的請求處理。

示例：HTTP中間件鏈的實現

假設需要為Web服務添加日誌記錄、限流和鑑權功能，通過中間件鏈可以將這些功能解耦，按需組合。

// middleware/middleware.go：中間件定義
package middleware


import (
    "net/http"
    "time"
    "golang.org/x/time/rate"
)


// Middleware 定義中間件類型：接收http.HandlerFunc，返回新的http.HandlerFunc
type Middleware func(http.HandlerFunc) http.HandlerFunc


// LoggingMiddleware 日誌中間件：記錄請求信息
func LoggingMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        // 記錄請求方法和路徑
        println("Request received:", r.Method, r.URL.Path)
        // 調用下一個中間件或處理函數
        next(w, r)
        // 記錄請求耗時
        println("Request completed in:", time.Since(start))
    }
}


// RateLimitMiddleware 限流中間件：限制請求頻率
func RateLimitMiddleware(next http.HandlerFunc, limiter *rate.Limiter) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if !limiter.Allow() {
            http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
            return
        }
        next(w, r)
    }
}


// AuthMiddleware 鑑權中間件：驗證請求令牌
func AuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next(w, r)
    }
}


// chain.go：中間件鏈組合
func Chain(middlewares ...Middleware) Middleware {
    return func(final http.HandlerFunc) http.HandlerFunc {
        // 反向組合中間件（確保執行順序正確）
        for i := len(middlewares) - 1; i >= 0; i-- {
            final = middlewares[i](final)
        }
        return final
    }
}

使用示例：

// main.go：Web服務入口
package main


import (
    "net/http"
    "middleware"
    "golang.org/x/time/rate"
)


func main() {
    // 創建限流器：每秒允許100個請求，突發10個
    limiter := rate.NewLimiter(100, 10)
    
    // 定義業務處理函數
    handleRequest := func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, World"))
    }
    
    // 組合中間件鏈：日誌 → 限流 → 鑑權
    middlewareChain := middleware.Chain(
        middleware.LoggingMiddleware,
        middleware.RateLimitMiddlewareWithLimiter(limiter),
        middleware.AuthMiddleware,
    )
    
    // 應用中間件鏈到處理函數
    http.HandleFunc("/", middlewareChain(handleRequest))
    
    // 啓動服務
    http.ListenAndServe(":8080", nil)
}

設計説明：

• 每個中間件（如LoggingMiddleware、RateLimitMiddleware）專注於單一功能，通過Middleware類型定義，確保接口統一。
• Chain函數將多箇中間件按順序組合，形成一個處理鏈。請求會依次經過日誌記錄、限流、鑑權，最後到達業務處理函數。
• 新增中間件（如CORS跨域中間件）時，只需實現Middleware類型，即可通過Chain函數輕鬆加入處理鏈，無需修改現有中間件或業務邏輯。

四、可擴展架構的實現模式

4.1 插件化架構：熱插拔的功能擴展

理論補充：

插件化架構允許系統在運行時動態加載、卸載插件，從而實現功能的靈活擴展。這種架構適用於需要支持第三方擴展或多租户定製的場景（如IDE插件、電商平台應用市場）。

Go語言的實現方式：

Go語言通過plugin包支持動態庫加載，結合接口定義插件契約，可以實現安全的插件化架構。插件需實現統一的接口，主程序通過接口調用插件功能。

示例：插件化系統的實現

假設需要開發一個支持插件的數據處理系統，主程序可以動態加載處理數據的插件（如csv_parser、json_parser）。

// plugin/interface.go：插件接口定義（主程序與插件共享）
package plugin


// DataProcessor 定義數據處理插件的接口
type DataProcessor interface {
    Name() string                      // 插件名稱（如"csv_parser"）
    Process(input []byte) (output []byte, err error)  // 處理數據
}


// plugin/csv_parser/csv_processor.go：CSV處理插件（動態庫）
package main


import (
    "encoding/csv"
    "io"
    "os"
    "plugin"
)


// CSVProcessor 實現DataProcessor接口
type CSVProcessor struct{}


func (c *CSVProcessor) Name() string {
    return "csv_parser"
}


func (c *CSVProcessor) Process(input []byte) ([]byte, error) {
    // 解析CSV數據
    r := csv.NewReader(bytes.NewReader(input))
    records, err := r.ReadAll()
    if err != nil {
        return nil, err
    }
    // 轉換為JSON格式輸出
    var result []map[string]string
    for _, record := range records {
        row := make(map[string]string)
        for i, field := range record {
            row[fmt.Sprintf("col_%d", i)] = field
        }
        result = append(result, row)
    }
    jsonData, err := json.Marshal(result)
    if err != nil {
        return nil, err
    }
    return jsonData, nil
}


// 插件的入口函數（必須命名為"Plugin"，主程序通過此函數獲取插件實例）
var Plugin plugin.DataProcessor = &CSVProcessor{}

// main.go：主程序（加載插件並調用）
package main


import (
    "fmt"
    "plugin"
    "path/filepath"
)


func main() {
    // 插件路徑（假設編譯為so文件）
    pluginPath := filepath.Join("plugins", "csv_parser.so")
    
    // 加載插件
    p, err := plugin.Open(pluginPath)
    if err != nil {
        panic(err)
    }


        // 獲取插件實例（通過接口類型斷言）
    sym, err := p.Lookup("Plugin")
    if err != nil {
        panic(err)
    }
    processor, ok := sym.(plugin.DataProcessor)
    if !ok {
        panic("插件未實現DataProcessor接口")
    }


        // 使用插件處理數據
    inputData := []byte("name,age
張三,20
李四,25")
    output, err := processor.Process(inputData)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(output))  // 輸出JSON格式數據
}

設計説明：

• 接口定義：主程序定義DataProcessor接口，規定插件必須實現的方法（Name和Process）。
• 插件實現：插件（如csv_parser）實現DataProcessor接口，並導出名為Plugin的全局變量（主程序通過此變量獲取插件實例）。
• 動態加載：主程序通過plugin.Open加載插件，通過Lookup獲取插件實例，並轉換為DataProcessor接口調用。

優勢：

• 主程序與插件解耦，插件的添加、刪除或升級不影響主程序運行。
• 支持熱插拔：插件可以在運行時動態加載（需注意Go插件的侷限性，如版本兼容性）。
  -

4.2 配置驅動架構：外部化的靈活配置

理論補充：

配置驅動架構（Configuration-Driven Architecture）通過將系統行為參數化，使系統可以通過修改配置（而非代碼）來適應不同的運行環境或業務需求。這種架構適用於需要支持多環境（開發、測試、生產）、多租户定製或多場景適配的系統。

Go語言的實現方式：

Go語言通過encoding/json、encoding/yaml等包支持配置文件的解析，結合viper等第三方庫可以實現更復雜的配置管理（如環境變量覆蓋、熱更新）。

示例：配置驅動的數據庫連接

假設系統需要支持不同環境（開發、生產）的數據庫配置，通過配置文件動態加載數據庫連接參數。

// config/config.go：配置結構體定義
package config


// DBConfig 數據庫配置
type DBConfig struct {
    DSN         string `json:"dsn"`          // 數據庫連接字符串
    MaxOpenConn int    `json:"max_open_conn"` // 最大打開連接數
    MaxIdleConn int    `json:"max_idle_conn"` // 最大空閒連接數
    ConnTimeout int    `json:"conn_timeout"`  // 連接超時時間（秒）
}


// AppConfig 應用全局配置
type AppConfig struct {
    Env  string   `json:"env"`   // 環境（dev/test/prod）
    DB   DBConfig `json:"db"`    // 數據庫配置
    Log  LogConfig `json:"log"`   // 日誌配置
}


// LogConfig 日誌配置
type LogConfig struct {
    Level string `json:"level"` // 日誌級別（debug/info/warn/error）
    Path  string `json:"path"`  // 日誌文件路徑
}

// config/loader.go：配置加載器（支持熱更新）
package config


import (
    "encoding/json"
    "os"
    "path/filepath"
    "time"


        "github.com/fsnotify/fsnotify"
)


// LoadConfig 加載配置文件
func LoadConfig(path string) (*AppConfig, error) {
    file, err := os.Open(path)
    if err != nil {
        return nil, err
    }
    defer file.Close()
    
    var cfg AppConfig
    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&cfg); err != nil {
        return nil, err
    }
    return &cfg, nil
}


// WatchConfig 監聽配置文件變化（熱更新）
func WatchConfig(path string, callback func(*AppConfig)) error {
    watcher, err := fsnotify.NewWatcher()
    if err != nil {
        return err
    }
    defer watcher.Close()
    
    // 監聽配置文件所在目錄
    dir := filepath.Dir(path)
    if err := watcher.Add(dir); err != nil {
        return err
    }
    
    go func() {
        for {
            select {
            case event, ok := <-watcher.Events:
                if !ok {
                    return
                }
                // 僅處理寫事件
                if event.Op&fsnotify.Write == fsnotify.Write {
                    // 重新加載配置
                    newCfg, err := LoadConfig(path)
                    if err != nil {
                        println("加載配置失敗:", err.Error())
                        continue
                    }
                    // 觸發回調（通知其他模塊配置已更新）
                    callback(newCfg)
                }
            case err, ok := <-watcher.Errors:
                if !ok {
                    return
                }
                println("配置監聽錯誤:", err.Error())
            }
        }
    }()
    
    // 保持程序運行
    select {}
}

// main.go：使用配置驅動的數據庫連接
package main


import (
    "database/sql"
    "fmt"
    "config"
    _ "github.com/go-sql-driver/mysql"
)


func main() {
    // 加載初始配置
    cfg, err := config.LoadConfig("config.json")
    if err != nil {
        panic(err)
    }
    
    // 初始化數據庫連接
    db, err := sql.Open("mysql", cfg.DB.DSN)
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    // 設置連接池參數（從配置中讀取）
    db.SetMaxOpenConns(cfg.DB.MaxOpenConn)
    db.SetMaxIdleConns(cfg.DB.MaxIdleConn)
    db.SetConnMaxLifetime(time.Duration(cfg.DB.ConnTimeout) * time.Second)
    
    // 啓動配置監聽（熱更新）
    go func() {
        err := config.WatchConfig("config.json", func(newCfg *config.AppConfig) {
            // 配置更新時，重新設置數據庫連接池參數
            db.SetMaxOpenConns(newCfg.DB.MaxOpenConn)
            db.SetMaxIdleConns(newCfg.DB.MaxIdleConn)
            db.SetConnMaxLifetime(time.Duration(newCfg.DB.ConnTimeout) * time.Second)
            fmt.Println("配置已更新，數據庫連接池參數調整")
        })
        if err != nil {
            panic(err)
        }
    }()
    
    // 業務邏輯...
}

設計説明：

• 配置結構化：通過AppConfig、DBConfig等結構體定義配置的層次結構，確保配置的清晰性和可維護性。
• 熱更新支持：通過fsnotify監聽配置文件變化，觸發回調函數重新加載配置，並更新系統狀態（如數據庫連接池參數）。
• 多環境適配：通過不同的配置文件（如config-dev.json、config-prod.json）或環境變量覆蓋，實現不同環境的配置隔離。

優勢：

• 系統行為的調整無需修改代碼，只需修改配置文件，降低了維護成本。
• 支持動態調整關鍵參數（如數據庫連接池大小、日誌級別），提升了系統的靈活性和可觀測性。

五、可擴展性的驗證與演進

5.1 擴展性驗證指標

為了確保系統具備良好的擴展性，需要從多個維度進行驗證。以下是關鍵指標及測量方法：

5.2 擴展性演進路線

系統的擴展性不是一蹴而就的，需要隨着業務的發展逐步演進。以下是一個典型的演進路線：

graph TD
    A[單體架構] -->|垂直拆分| B[核心服務+支撐服務]
    B -->|接口抽象| C[模塊化架構]
    C -->|策略模式/中間件| D[可擴展的分佈式架構]
    D -->|插件化/配置驅動| E[雲原生可擴展架構]

• 階段1：單體架構：初期業務簡單，系統以單體形式存在。此時應注重代碼的可讀性和可維護性，為後續擴展打下基礎。
• 階段2：核心服務+支撐服務：隨着業務增長，將核心功能（如訂單、用户）與非核心功能（如日誌、監控）拆分，降低耦合。
• 階段3：模塊化架構：通過接口抽象和依賴倒置，將系統拆分為高內聚、低耦合的模塊，支持獨立開發和部署。
• 階段4：可擴展的分佈式架構：引入策略模式、中間件鏈等模式，支持動態切換算法和處理流程，適應多樣化的業務需求。
• 階段5：雲原生可擴展架構：結合容器化（Docker）、編排（Kubernetes）和Serverless技術，實現資源的彈性擴展和自動伸縮。
  -

六、結 語

可擴展性設計是軟件系統的“生命力”所在。通過遵循開閉原則、模塊化設計等核心原則，結合策略模式、中間件鏈、插件化架構等Go語言友好的編碼模式，開發者可以構建出適應業務變化的“生長型”系統。

需要注意的是，擴展性設計並非追求“過度設計”，而是在當前需求和未來變化之間找到平衡。建議定期進行架構評審，通過壓力測試和代碼分析（如go mod graph查看模塊依賴）評估系統的擴展性健康度，及時調整設計策略。

最後，記住：優秀的系統不是完美的，而是能夠持續進化的。保持開放的心態，擁抱變化，才能在快速發展的技術領域中立於不敗之地。

往期回顧

1. 得物新商品審核鏈路建設分享

2. 營銷會場預覽直通車實踐｜得物技術

3. 基於TinyMce富文本編輯器的客服自研知識庫的技術探索和實踐｜得物技術

4. AI質量專項報告自動分析生成｜得物技術

5. Rust 性能提升“最後一公里”：詳解 Profiling 瓶頸定位與優化｜得物技術

文 / 悟

關注得物技術，每週更新技術乾貨

要是覺得文章對你有幫助的話，歡迎評論轉發點贊～

未經得物技術許可嚴禁轉載，否則依法追究法律責任。