Skip to content

错误处理 ​

HTTPC 将请求失败统一封装为 ClientError,携带错误分类、可重试判断与请求上下文。配合 errors.Is/errors.As 可匹配哨兵错误,也可按分类分支处理。

ErrorType 完整参考 ​

HTTPC 定义了 12 种错误类型,覆盖网络层到应用层的失败场景:

ErrorTypeCode()含义典型场景可重试
ErrorTypeNetworkNETWORK_ERROR网络层错误连接拒绝、连接重置、断管视原因而定
ErrorTypeTimeoutTIMEOUT超时拨号超时、请求超时、context 截止是
ErrorTypeContextCanceledCONTEXT_CANCELED上下文取消ctx.Cancel() 被调用否
ErrorTypeDNSDNS_ERRORDNS 解析失败域名不存在、DNS 服务器故障临时/超时可重试
ErrorTypeTLSTLS_ERRORTLS 握手错误协议版本不支持、算法协商失败否
ErrorTypeCertificateCERTIFICATE_ERROR证书验证失败证书过期、签名无效、CA 不受信否
ErrorTypeTransportTRANSPORT_ERRORHTTP 传输层错误协议错误、传输异常中断是
ErrorTypeResponseReadRESPONSE_READ_ERROR响应体读取错误连接中断导致 EOF、读取超时视原因而定
ErrorTypeRetryExhaustedRETRY_EXHAUSTED重试耗尽仅防御性兜底路径设置;正常耗尽保留原始分类,用 Attempts 判断否
ErrorTypeValidationVALIDATION_ERROR请求验证失败URL 格式非法、HTTP 头含控制字符否
ErrorTypeHTTPHTTP_ERRORHTTP 状态码错误错误消息含 HTTP 4xx/HTTP 5xx 时由分类器归入(常规 4xx/5xx 不作为 error 返回)按状态码判断
ErrorTypeUnknownUNKNOWN_ERROR未分类错误其他未匹配的异常否

可重试判断的完整规则

IsRetryable() 的判定比上表更细粒度:

  • ErrorTypeDNS 仅在 net.DNSError 标记为临时或超时时可重试。
  • ErrorTypeNetwork 检查 syscall.Errno(ECONNREFUSED/ECONNRESET/EPIPE/ETIMEDOUT/ENETUNREACH/EHOSTUNREACH/ECONNABORTED)与错误消息模式。
  • ErrorTypeResponseRead 仅在 read/readfrom 操作的网络错误时可重试。

规则见下方「可重试判定的实现细节」。

错误分类决策树 ​

非 nil 错误进入引擎后经过同一套分类流程,按优先级自上而下匹配,命中即止:

text
错误 err
├─ errors.Is(err, context.Canceled)          → ContextCanceled「请求被取消」
├─ errors.Is(err, context.DeadlineExceeded)  → Timeout「请求超时」
├─ 连接池耗尽(内部哨兵 ErrPoolExhausted)   → Network「connection pool exhausted」
├─ *url.Error(先解包,按内层错误继续分类)
│   ├─ 消息含 "http2" + "invalid"           → Validation「非法 HTTP/2 请求头」
│   ├─ 消息含 "parse" / "invalid url" / "missing protocol" → Validation「URL 校验失败」
│   └─ 其余用内层错误走下列分支
├─ *net.DNSError                             → DNS「DNS resolution timed out / failed」
├─ *net.OpError                              → Network「网络操作超时 / 失败」
├─ net.Error                                 → Timeout(超时)/ Network(其他)
└─ 错误消息模式匹配(大小写不敏感,节选)
    ├─ "stopped after … redirect"            → Validation「redirect limit exceeded」
    ├─ "circular redirect"                   → Validation「circular redirect detected」
    ├─ "redirect blocked"                    → Validation「redirect blocked by policy」
    ├─ "connection refused / reset / closed"、"broken pipe" → Network
    ├─ "no such host"                        → DNS
    ├─ "tls" / "ssl" + "handshake"           → TLS
    ├─ "certificate"、"x509"                 → Certificate
    ├─ "transport"、"protocol error"         → Transport
    ├─ "failed to read response body"、"unexpected eof"    → ResponseRead
    ├─ "http 4xx" / "http 5xx"               → HTTP(同时提取状态码)
    └─ "timeout" / "timed out"(不含 "context")           → Timeout

已分类的错误不会二次包装

错误链中已存在 ClientError(如中间件返回的引擎错误)时,分类器复用其字段,只补全 URL、方法与尝试次数,不再嵌套包装。errors.As 命中最外层即可拿到完整上下文。

ClientError 字段详解 ​

ClientError 携带请求失败的完整上下文:

字段类型用途
TypeErrorType错误分类,用于 switch 分支处理
Messagestring人类可读的错误描述
Causeerror底层原始错误,支持 errors.Unwrap 链
URLstring请求的 URL(已脱敏,见下方)
MethodstringHTTP 方法(GET/POST/...)
Attemptsint已尝试次数(含首次),重试耗尽时 > 1
StatusCodeintHTTP 状态码;仅 ErrorTypeHTTP 会填充,其余分类为 0
Hoststring目标主机名(用于断路器等)
ProxyURLstring最后一次尝试所用代理的脱敏 URL;直连、发送前错误与系统代理时为空

Error() 输出格式 ​

ClientError.Error() 按固定格式输出(URL 已脱敏):

text
METHOD url: message: cause (attempt N)

实际示例:

text
GET https://api.example.com/data: network error occurred: dial tcp 1.2.3.4:443: connect: connection refused (attempt 4)

Unwrap() 返回 Cause,因此可穿透包装直达底层错误:errors.Is(err, context.DeadlineExceeded)、errors.As(err, &opErr)(提取 *net.OpError)。err 的字符串已含方法、脱敏 URL、原因链与尝试次数,可直接写入日志。

错误类型判断 ​

go
package main

import (
	"errors"
	"fmt"
	"log"

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	result, err := client.Get("https://api.example.com/data")
	if err != nil {
		var clientErr *httpc.ClientError
		if errors.As(err, &clientErr) {
			switch clientErr.Type {
			case httpc.ErrorTypeTimeout:
				log.Printf("请求超时(已尝试 %d 次): %v", clientErr.Attempts, err)
			case httpc.ErrorTypeNetwork:
				log.Printf("网络错误: %v", err)
			case httpc.ErrorTypeDNS:
				log.Printf("DNS 解析失败: %v", err)
			case httpc.ErrorTypeTLS:
				log.Printf("TLS 握手失败: %v", err)
			case httpc.ErrorTypeCertificate:
				log.Printf("证书验证失败: %v", err)
			case httpc.ErrorTypeRetryExhausted:
				log.Printf("重试 %d 次后仍失败: %v", clientErr.Attempts, err)
			case httpc.ErrorTypeValidation:
				log.Printf("请求验证失败: %v", err)
			case httpc.ErrorTypeContextCanceled:
				log.Printf("请求已取消: %v", err)
			default:
				log.Printf("其他错误 [%s]: %v", clientErr.Code(), err)
			}
		}
		return
	}
	fmt.Printf("成功:%d\n", result.StatusCode())
}

可重试判断 ​

IsRetryable() 综合考虑错误类型和底层原因,返回是否值得重试:

go
package main

import (
	"errors"
	"fmt"
	"log"

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	_, err = client.Get("https://api.example.com/data")
	if err != nil {
		var clientErr *httpc.ClientError
		if errors.As(err, &clientErr) {
			if clientErr.IsRetryable() {
				fmt.Println("可重试错误,上层逻辑可稍后重试")
			} else {
				fmt.Printf("不可重试错误 [%s],需人工介入\n", clientErr.Code())
			}
		}
	}
}

IsRetryable 与自动重试的区别

IsRetryable() 判断该错误是否值得重试,HTTPC 内部的重试引擎默认使用同一判定。一个例外:ProxyRotateOnStatus 注入的扩展状态码只进入引擎的重试判定,IsRetryable() 对这些码仍返回 false。配置了 RetryConfig.MaxRetries 时,网络/超时类错误到达调用方即表示重试已耗尽。上层逻辑(断路器、任务队列)可用 IsRetryable() 决定是否再次发起请求。

可重试判定的实现细节 ​

IsRetryable() 在类型分类之下还有一层原因级判定,这是各类型可重试行为差异的来源。

网络错误:syscall 与消息模式 ​

ErrorTypeNetwork 逐层检查错误原因,任一层命中即可重试:

检查层可重试条件
net.OpError.Timeout()超时 → 重试
syscall.Errno(POSIX)ECONNREFUSED / ECONNRESET / EPIPE / ETIMEDOUT / ENETUNREACH / EHOSTUNREACH / ECONNABORTED
Windows WSA 错误码10053(连接中止)/ 10054(连接被重置)/ 10060(连接超时)/ 10061(连接被拒绝)/ 10051(网络不可达)/ 10065(主机不可达)
错误消息模式connection reset / eof / connection closed / broken pipe / network error / transport failed
其他 net.Error默认重试(服务端主动断开、EOF 等瞬时故障)

为什么 Windows 需要单独的 WSA 映射表

Go 1.25 起,Windows 上的 POSIX 风格 syscall.E* 常量带 1<<29 偏移(如 ECONNREFUSED = 536870934),而网络栈返回的是原始 WSA 码(如 WSAECONNREFUSED = 10061),两种编码永不相等。

HTTPC 内置 WSA 码映射表,使 Windows 与 Unix 的重试判定保持一致。

DNS:仅临时/超时可重试 ​

ErrorTypeDNS 仅在 net.DNSError 标记 IsTemporary 或 IsTimeout 时可重试。域名不存在(NXDOMAIN)等永久性失败不占用重试次数。

响应体读取:只重试读操作 ​

ErrorTypeResponseRead 仅对读取类网络错误重试:net.OpError 的操作名为 read / readfrom,或错误消息含 eof / connection / timeout。文件错误与写错误不在此列。

HTTP 状态码 ​

ErrorTypeHTTP 直接查内置可重试状态码表:408/429/500/502/503/504。ProxyRotateOnStatus 扩展码只进入引擎的重试判定,不在该表内(见上方 warning)。StatusCode 缺失(= 0)时退化为按错误消息中的 HTTP 4xx / HTTP 5xx 前缀判断。

哨兵错误完整参考 ​

HTTPC 定义以下哨兵错误变量,可通过 errors.Is 精确匹配:

哨兵变量触发条件推荐处理
ErrClientClosed在 client.Close() 之后继续使用该客户端初始化新 Client 或修复生命周期管理
ErrNilConfig传给 New() 的 Config 指针为 nil使用 DefaultConfig() 获取默认值
ErrInvalidHeaderHTTP 头校验失败(含控制字符或格式非法)修正 Header 值后重试
ErrInvalidTimeout超时值非法:负值或超过 30 分钟上限(WithTimeout 另行拒绝 0)调整到合法区间;解除超时用 WithNoTimeout()
ErrInvalidRetry重试配置非法(MaxRetries 不在 0-10,BackoffFactor 不在 1.0-10.0)修正重试参数
ErrInvalidMaxRedirects重定向次数非法:请求级 WithMaxRedirects 为负或超过 50,或配置级 Security.MaxRedirects 为负或超过 50调整到 0–50 区间
ErrInvalidConnection连接配置非法(连接池大小超出范围、代理 URL 格式错误)修正连接参数
ErrInvalidSecurity安全配置非法:响应体/解压后/请求体大小上限越界、TLS 版本非法或 min>max、SSRFExemptCIDRs 含非法 CIDR、SensitiveHeaders 键非法、TLSFingerprint 预设未知或与 TLSConfig 同设修正安全参数
ErrInvalidMiddlewareDefaults.UserAgent 超过 512 字符或含控制字符(名称属历史遗留,不覆盖中间件配置;重定向次数超限属 ErrInvalidMaxRedirects)修正 Defaults.UserAgent
ErrEmptyFilePath下载时未指定文件路径设置 DownloadConfig.FilePath
ErrFileExists目标文件已存在且 Overwrite=false、ResumeDownload=false设置覆盖或续传,或换路径
ErrResponseBodyEmpty响应体为空时调用 Unmarshal() 等解析方法先检查 RawBody 再解析
ErrResponseBodyTooLargeResult.Unmarshal 解析的响应体超过 50MB JSON 上限改用流式处理或自行解析

引擎侧读取响应体时的 MaxResponseBodySize 上限不包装该哨兵:超限请求以 ErrorTypeResponseRead 的 ClientError 结束,错误信息形如 failed to read response body: response body exceeds limit of N bytes,需按错误消息判断。

配置类错误 vs 运行时错误

ErrInvalid* 系列(ErrInvalidHeader/ErrInvalidTimeout/ErrInvalidRetry/ErrInvalidConnection/ErrInvalidSecurity/ErrInvalidMiddleware)属配置类错误,通常由 New() 的校验返回。它们在请求路径上也可能出现,但来源是选项本身非法而非服务端行为:WithHeader/WithHeaderMap 返回 ErrInvalidHeader,WithTimeout 返回 ErrInvalidTimeout,WithMaxRedirects 返回 ErrInvalidMaxRedirects,WithBasicAuth/WithBearerToken 返回 ErrInvalidCredentials——这类错误在应用选项时即返回,不会发出请求。

运行时错误通过 ClientError 分类处理。

go
package main

import (
	"errors"
	"fmt"
	"log"

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	result, err := client.Get("https://api.example.com/data")

	switch {
	case errors.Is(err, httpc.ErrClientClosed):
		fmt.Println("客户端已关闭,需重新创建")
	case errors.Is(err, httpc.ErrResponseBodyTooLarge):
		fmt.Println("Unmarshal 的响应体超过 50MB 上限,改用流式处理")
	case errors.Is(err, httpc.ErrResponseBodyEmpty):
		fmt.Println("响应体为空,调用解析方法前先检查 RawBody")
	case errors.Is(err, httpc.ErrInvalidHeader):
		fmt.Println("请求头无效,修正后重试")
	}

	if result != nil {
		fmt.Printf("状态码:%d\n", result.StatusCode())
	}
}

URL 自动脱敏 ​

ClientError.Error() 会移除 URL 中的敏感信息:含用户名密码的 URL(如 https://user:pass@host/path)被脱敏为 https://***:***@host/path,日志与错误消息中不出现凭证。

go
package main

import (
	"fmt"
	"log"

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	// URL 中包含凭证信息
	result, err := client.Get("https://admin:[email protected]/data")
	if err != nil {
		// 错误消息中的凭证被自动脱敏:
		// "GET https://***:***@api.example.com/data: network error occurred"
		fmt.Println(err)
	}
	if result != nil {
		fmt.Println(result.StatusCode())
	}
}

脱敏的覆盖范围

脱敏除移除 user:pass@host 格式的凭证外,也处理敏感查询参数(如 token、key、secret)。不含凭证或敏感参数的 URL 走快速路径跳过解析,避免 url.Parse 开销。

panic 恢复安全网 ​

Request() 与 Download() 内置 panic 安全网:来自引擎、传输层、TLS 库或中间件的意外 panic 会被捕获并转换为普通 error(文本形如 panic recovered: <原因>,附完整堆栈),调用方进程不会崩溃。

兜底 panic 不是 ClientError

兜底 recover 位于 clientImpl.Request/Download 的最外层,转换后的错误不会再经过分类器,因此 errors.As(err, &clientErr) 匹配不到它,也没有 Code()/IsRetryable()。RecoveryMiddleware 同理(同样调用 panicToError)。需要分类信息时,应在外层自行判断或用 errors.Is 匹配具体原因。

go
// client.go 内部实现(概念示意)
func (c *clientImpl) Request(ctx context.Context, method, url string, ...) (*Result, error) {
    defer func() {
        if r := recover(); r != nil {
            result = nil
            err = panicToError(r) // 转换为普通 error(不经过分类器)
        }
    }()
    // ... 正常请求逻辑
}

安全网不替代中间件恢复

内置安全网是最后的防线,将 panic 转换为错误而非崩溃。中间件自身会触发 panic 时,应额外使用 RecoveryMiddleware(),它在中间件链中更早捕获 panic,并保留更完整的日志上下文:

go
cfg := httpc.DefaultConfig()
cfg.Middleware.Middlewares = []httpc.MiddlewareFunc{
    httpc.RecoveryMiddleware(),       // 中间件层 panic 恢复
    httpc.LoggingMiddleware(nil),     // 日志
    httpc.MetricsMiddleware(nil),     // 指标
}

自动重试与错误的关系 ​

HTTPC 的重试引擎自动处理可重试错误;应用层可据此避免重复重试。完整的重试条件与退避策略见重试与容错。

自动重试的错误 ​

条件是否重试说明
网络错误(连接拒绝、重置、EOF)是isRetryableNetworkMessage 匹配
拨号/请求超时是ErrorTypeTimeout
临时/超时类 DNS 失败是dnsErr.IsTemporary || dnsErr.IsTimeout
响应体读取网络错误是读取操作的 net.OpError
可重试 HTTP 状态码是408/429/500/502/503/504
ProxyRotateOnStatus 指定的状态码是如 403 触发代理轮换

不重试的错误 ​

条件是否重试说明
context.Canceled否快速路径直接返回
context.DeadlineExceeded否快速路径直接返回
TLS 握手失败否ErrorTypeTLS 不可重试
证书验证失败否ErrorTypeCertificate 不可重试
配置验证错误否ErrorTypeValidation 不可重试
其他 4xx 客户端错误否如 400/401/403/404

context 取消是快速路径

isRetryableError 先检查 context.Canceled 与 context.DeadlineExceeded,命中即返回 false,跳过完整的错误分类。

go
package main

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

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	result, err := client.Request(ctx, "GET", "https://api.example.com/slow")
	if err != nil {
		var clientErr *httpc.ClientError
		if errors.As(err, &clientErr) {
			if clientErr.Type == httpc.ErrorTypeContextCanceled {
				// 手动取消(cancel()),不会被自动重试
				fmt.Println("请求被手动取消,不会重试")
			} else if clientErr.Type == httpc.ErrorTypeTimeout {
				// context 截止(DeadlineExceeded)也归入此分类,同样不触发自动重试
				fmt.Println("请求超时(含 context 截止),不会重试")
			}
		}
		return
	}
	fmt.Println(result.StatusCode())
}

错误处理最佳实践 ​

1. 区分客户端错误和服务端错误 ​

err != nil 表示未取得响应(网络层失败);Result 上的 4xx/5xx 表示已取得响应但状态码非 2xx。

go
package main

import (
	"fmt"
	"log"

	"github.com/cybergodev/httpc"
)

func main() {
	client, err := httpc.NewDefault()
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	result, err := client.Get("https://api.example.com/data")
	if err != nil {
		// 网络层错误——连接、TLS、DNS 等问题
		log.Printf("网络层错误: %v", err)
		return
	}

	// HTTP 层错误——收到了响应但状态码非 2xx
	if result.IsClientError() {
		// 4xx:客户端请求有误(参数错误、权限不足等)
		log.Printf("客户端错误:%d", result.StatusCode())
	} else if result.IsServerError() {
		// 5xx:服务端故障(重试已耗尽,上游仍不可用)
		log.Printf("服务端错误:%d", result.StatusCode())
	} else {
		fmt.Printf("成功:%d\n", result.StatusCode())
	}
}

2. 断路器模式 ​

服务持续失败时,断路器暂停请求,避免级联故障与资源浪费:

go
type CircuitBreaker struct {
    mu           sync.Mutex
    failures     int
    threshold    int           // 连续失败阈值
    cooldown     time.Duration // 熔断冷却时间
    trippedAt    time.Time
}

func (cb *CircuitBreaker) Allow() bool {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    if cb.failures >= cb.threshold {
        if time.Since(cb.trippedAt) < cb.cooldown {
            return false // 熔断中,拒绝请求
        }
        cb.failures = 0 // 冷却期过,重置
    }
    return true
}

func (cb *CircuitBreaker) Record(err error) {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    if err != nil {
        cb.failures++
        if cb.failures >= cb.threshold {
            cb.trippedAt = time.Now()
        }
    } else {
        cb.failures = 0 // 成功则重置
    }
}

// 使用时结合 IsRetryable 判断
func requestWithBreaker(client httpc.Client, cb *CircuitBreaker, url string) error {
    if !cb.Allow() {
        return fmt.Errorf("circuit breaker open")
    }
    result, err := client.Get(url)
    cb.Record(err)
    if err != nil {
        var clientErr *httpc.ClientError
        if errors.As(err, &clientErr) && !clientErr.IsRetryable() {
            cb.Record(nil) // 不可重试错误不算服务故障
        }
        return err
    }
    _ = result
    return nil
}

3. 降级 fallback ​

主服务不可用时回退到缓存或默认值:

go
package main

import (
    "errors"
    "log"

    "github.com/cybergodev/httpc"
)

func fetchWithFallback(client httpc.Client, url string, fallback []byte) []byte {
    result, err := client.Get(url)
    if err != nil {
        var clientErr *httpc.ClientError
        if errors.As(err, &clientErr) {
            switch clientErr.Type {
            case httpc.ErrorTypeTimeout, httpc.ErrorTypeRetryExhausted:
                log.Printf("主服务不可用,使用降级数据: %v", err)
                return fallback
            case httpc.ErrorTypeValidation:
                // 验证错误是本地 bug,不应降级
                log.Fatalf("请求配置错误: %v", err)
            }
        }
        log.Printf("未知错误,使用降级数据: %v", err)
        return fallback
    }
    return result.RawBody()
}

4. 使用中间件统一处理 ​

go
package main

import (
	"log"
	"time"

	"github.com/cybergodev/httpc"
)

func main() {
	cfg := httpc.DefaultConfig()
	cfg.Middleware.Middlewares = []httpc.MiddlewareFunc{
		httpc.RecoveryMiddleware(),
		httpc.LoggingMiddleware(&httpc.LoggingConfig{
			LogFunc: func(format string, args ...any) {
				log.Printf("[HTTP] "+format, args...)
			},
		}),
		httpc.MetricsMiddleware(&httpc.MetricsConfig{
			OnMetrics: func(method, url string, statusCode int, duration time.Duration, err error) {
				if err != nil {
					log.Printf("[METRICS] %s %s 失败: %v (耗时 %v)", method, url, err, duration)
				} else {
					log.Printf("[METRICS] %s %s -> %d (耗时 %v)", method, url, statusCode, duration)
				}
			},
		}),
	}

	client, err := httpc.New(cfg)
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	result, err := client.Get("https://api.example.com/data")
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("状态码:%d", result.StatusCode())
}

5. 超时分层 ​

HTTPC 提供多个层级的超时控制,从粗到细:

go
// 第一层:客户端默认超时(所有请求的全局上限)
cfg := httpc.DefaultConfig()
cfg.Timeouts.Request = 30 * time.Second

// 第二层:中间件强制超时(在客户端内置超时之前生效)
timeoutMW := httpc.TimeoutMiddleware(&httpc.TimeoutMiddlewareConfig{
    Duration: 30 * time.Second,
})

// 第三层:单请求覆盖(WithTimeout 只覆盖客户端默认超时;
// 中间件超时从请求自身的 Context() 派生,更短的中间件超时无法被 WithTimeout 延长)
result, err := client.Get(url, httpc.WithTimeout(10*time.Second))

// 第四层:context 超时(最精确,推荐用于关键路径)
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
result, err := client.Request(ctx, "GET", url)

ResponseHeader 超时与 WithTimeout 的交互

Timeouts.ResponseHeader = 0(默认)时传输层不强制响应头超时,WithTimeout 拥有完全控制权。设为正值(如 SecureConfig() 的 10s)后,它在传输层对所有请求强制执行,WithTimeout 无法延长。设计原因见配置 API。

下一步 ​