如何用Golang实现服务熔断 集成Hystrix或go-kit方案

afex/hystrix-go

go get github.com/afex/hystrix-go/hystrix

package main

import (
    "fmt"
    "net/http"
    "time"

    "github.com/afex/hystrix-go/hystrix"
)

func main() {
    // 配置熔断器
    hystrix.ConfigureCommand("get_user", hystrix.CommandConfig{
        Timeout:                1000, // 超时时间（毫秒）
        MaxConcurrentRequests:  10,   // 最大并发数
        RequestVolumeThreshold: 5,    // 触发熔断的最小请求数
        SleepWindow:            10000, // 熔断后等待时间（毫秒）
        ErrorPercentThreshold:  50,   // 错误率阈值（百分比）
    })

    // 模拟多次调用
    for i := 0; i < 10; i++ {
        resp, err := getUserFromRemote()
        if err != nil {
            fmt.Printf("调用失败: %v\n", err)
        } else {
            fmt.Printf("调用成功: %s\n", resp)
        }
        time.Sleep(500 * time.Millisecond)
    }
}

func getUserFromRemote() (string, error) {
    var resp string
    err := hystrix.Do("get_user", func() error {
        // 正常业务逻辑（比如调用远程服务）
        r, err := http.Get("http://httpbin.org/status/500") // 模拟错误
        if err != nil {
            return err
        }
        defer r.Body.Close()
        resp = fmt.Sprintf("HTTP %d", r.StatusCode)
        return nil
    }, func(err error) error {
        // 降级逻辑（fallback）
        resp = "fallback: 服务暂时不可用"
        return nil
    })

    return resp, err
}

gobreaker

sentinel

sony/gobreaker

go get github.com/go-kit/kit/transport/http
go get github.com/sony/gobreaker

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "net/http"
    "time"

    "github.com/go-kit/kit/circuitbreaker"
    "github.com/go-kit/kit/endpoint"
    "github.com/sony/gobreaker"
)

// 定义请求/响应结构
type UserRequest struct {
    ID int `json:"id"`
}
type UserResponse struct {
    Name  string `json:"name"`
    Error string `json:"error,omitempty"`
}

// 构建远程调用的 endpoint
func makeRemoteEndpoint() endpoint.Endpoint {
    cb := &gobreaker.CircuitBreaker{
        Name:          "getUser",
        MaxRequests:   3,             // 半开状态下允许的请求数
        Interval:      10 * time.Second, // 滚动窗口时间
        Timeout:       30 * time.Second, // 熔断持续时间
        ReadyToTrip: func(counts gobreaker.Counts) bool {
            // 自定义熔断条件：错误率超过 50%
            failureRatio := float64(counts.TotalFailures) / float64(counts.Requests)
            return counts.Requests >= 5 && failureRatio >= 0.5
        },
        OnStateChange: func(name string, from, to gobreaker.State) {
            fmt.Printf("熔断器 %s: %s -> %s\n", name, from, to)
        },
    }

    return circuitbreaker.Gobreaker(cb)(func(ctx context.Context, request interface{}) (interface{}, error) {
        req := request.(UserRequest)
        // 模拟调用远程服务
        resp, err := http.Get(fmt.Sprintf("http://httpbin.org/delay/%d", req.ID%3))
        if err != nil {
            return UserResponse{Error: err.Error()}, err
        }
        defer resp.Body.Close()

        return UserResponse{Name: fmt.Sprintf("User-%d", req.ID)}, nil
    })
}

func main() {
    endpoint := makeRemoteEndpoint()

    for i := 1; i <= 10; i++ {
        resp, err := endpoint(context.Background(), UserRequest{ID: i})
        if err != nil {
            fmt.Printf("请求失败: %v\n", err)
        } else {
            result := resp.(UserResponse)
            if result.Error != "" {
                fmt.Printf("响应错误: %s\n", result.Error)
            } else {
                fmt.Printf("获取用户: %s\n", result.Name)
            }
        }
        time.Sleep(1 * time.Second)
    }
}

afex/hystrix-go