怎样用Golang实现前哨模式 构建服务熔断与降级的防护机制

package main

import (
    "context"
    "errors"
    "fmt"
    "log"
    "time"

    "github.com/sony/gobreaker"
)

// MockExternalService 模拟一个可能失败的外部服务
func MockExternalService(shouldFail bool) (string, error) {
    time.Sleep(100 * time.Millisecond) // 模拟网络延迟
    if shouldFail {
        return "", errors.New("external service unavailable")
    }
    return "Data from external service", nil
}

// GetProtectedData 封装了熔断和降级逻辑的函数
func GetProtectedData(cb *gobreaker.CircuitBreaker, failService bool) (string, error) {
    result, err := cb.Execute(func() (interface{}, error) {
        log.Println("Attempting to call external service...")
        data, svcErr := MockExternalService(failService)
        if svcErr != nil {
            log.Printf("External service call failed: %v", svcErr)
            return nil, svcErr // 返回错误给熔断器
        }
        log.Println("External service call successful.")
        return data, nil
    })

    if err != nil {
        // 熔断器开启或执行失败，触发降级
        if errors.Is(err, gobreaker.ErrOpenState) {
            log.Println("Circuit breaker is OPEN! Falling back to degraded data.")
            return "Degraded data (from cache/default)", nil // 降级处理
        }
        log.Printf("Service call failed with unexpected error: %v. Falling back.", err)
        return "Degraded data (fallback due to error)", nil // 其他错误也降级
    }
    return result.(string), nil
}

func main() {
    // 配置熔断器
    // MaxRequests: 半开状态下允许通过的请求数
    // Interval: 熔断器从关闭状态到半开状态的间隔时间
    // Timeout: 熔断器在开启状态下保持开启的时间
    // ReadyToTrip: 判断是否需要开启熔断器的函数，这里表示失败率超过60%且请求数大于等于3时开启
    // OnStateChange: 状态变化时的回调
    st := gobreaker.Settings{
        Name:        "ExternalServiceBreaker",
        MaxRequests: 3,
        Interval:    5 * time.Second,
        Timeout:     3 * time.Second,
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
            return counts.Requests >= 3 && failureRatio >= 0.6
        },
        OnStateChange: func(name string, from gobreaker.State, to gobreaker.State) {
            log.Printf("Circuit Breaker '%s' changed state from %s to %s", name, from, to)
        },
    }
    cb := gobreaker.NewCircuitBreaker(st)

    fmt.Println("--- Scenario 1: Service is healthy ---")
    for i := 0; i < 5; i++ {
        data, err := GetProtectedData(cb, false) // 服务健康
        if err != nil {
            log.Printf("Error: %v", err)
        } else {
            log.Printf("Received: %s", data)
        }
        time.Sleep(50 * time.Millisecond)
    }

    fmt.Println("\n--- Scenario 2: Service starts failing ---")
    for i := 0; i < 10; i++ {
        fail := i%2 == 0 // 模拟一半失败
        data, err := GetProtectedData(cb, fail)
        if err != nil {
            log.Printf("Error: %v", err)
        } else {
            log.Printf("Received: %s", data)
        }
        time.Sleep(50 * time.Millisecond)
    }

    fmt.Println("\n--- Scenario 3: Circuit breaker is open, then half-open ---")
    time.Sleep(st.Timeout + 1*time.Second) // 等待熔断器从open到half-open
    for i := 0; i < 5; i++ {
        data, err := GetProtectedData(cb, false) // 此时服务可能已恢复，测试半开状态
        if err != nil {
            log.Printf("Error: %v", err)
        } else {
            log.Printf("Received: %s", data)
        }
        time.Sleep(50 * time.Millisecond)
    }
}

// 这是一个更具体的降级例子，假设我们要获取商品详情
func GetProductDetail(cb *gobreaker.CircuitBreaker, productID string, simulateFailure bool) (map[string]interface{}, error) {
    data, err := cb.Execute(func() (interface{}, error) {
        log.Printf("Attempting to fetch product %s from primary service...", productID)
        // 模拟实际的外部调用
        time.Sleep(50 * time.Millisecond)
        if simulateFailure {
            return nil, errors.New("primary product service down")
        }
        return map[string]interface{}{
            "id":    productID,
            "name":  fmt.Sprintf("Product %s (Primary)", productID),
            "price": 99.99,
            "desc":  "Full detailed description.",
        }, nil
    })

    if err != nil {
        if errors.Is(err, gobreaker.ErrOpenState) || errors.Is(err, context.DeadlineExceeded) {
            log.Printf("Circuit breaker open or timeout for product %s. Falling back to cache/default.", productID)
            // 降级逻辑：从缓存获取或返回默认简略信息
            return map[string]interface{}{
                "id":    productID,
                "name":  fmt.Sprintf("Product %s (Cached/Degraded)", productID),
                "price": 0.00, // 价格可能不准确或显示为0
                "desc":  "Limited information available due to service issues.",
            }, nil
        }
        // 其他错误，也可能需要降级或返回通用错误
        return nil, fmt.Errorf("failed to get product detail for %s: %w", productID, err)
    }
    return data.(map[string]interface{}), nil
}