使用 net/http 时需自定义 Client 设超时、显式设 Header、手动检查 StatusCode；响应体须用 io.ReadAll 读取后再 json.Unmarshal；调试需禁用自动重定向、启用 CookieJar、用 httputil.Dump 抓包；推荐封装 DebugClient 结构体统一处理。
用 net/http 发起带超时和自定义 Header 的 API 请求
直接硬写 http.Get 或 http.Post 很难调试，容易卡死或忽略状态码。必须手动控制超时、设置 Content-Type、透传认证头。
-
http.DefaultClient没有默认超时，生产环境请求可能永久挂起，务必用自定义http.Client - Header 必须在
req.Header.Set()中显式设置，http.Post不支持传 Header - 如果服务端返回非 2xx 状态码，
resp.Body仍可读，但resp.StatusCode需主动检查，不能只看 err 是否为 nil
client := &http.Client{
Timeout: 10 * time.Second,
}
req, _ := http.NewRequest("GET", "https://api.example.com/data", nil)
req.Header.Set("Authorization", "Bearer abc123")
req.Header.Set("Accept", "application/json")
resp, err := client.Do(req)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
log.Printf("HTTP %d: %s", resp.StatusCode, resp.Status)
}
用 json.Unmarshal 安全解析响应体，避开 panic 和字段丢失
直接 json.Unmarshal(resp.Body, &v) 会因 Body 已关闭或结构体字段未导出而静默失败。常见错误是没检查 err，或用 map[string]interface{} 导致类型模糊、取值易错。
- Body 是流式读取，只能读一次；若先用
ioutil.ReadAll（Go 1.16+ 改为io.ReadAll）转成字节切片，才能多次解析或打印原始内容 - 结构体字段名必须首字母大写（导出），且建议加
json:"field_name"标签匹配服务端 key，否则默认按 Go 字段名匹配（大小写敏感） - 对可选字段，用指针或
omitempty配合零值判断，避免把空字符串或 0 当作有效数据
body, _ := io.ReadAll(resp.Body)
var data struct {
ID int `json:"id"`
Name string `json:"name"`
Email *string `json:"email,omitempty"` // 可为空
}
if err := json.Unmarshal(body, &data); err != nil {
log.Printf("JSON parse error: %v, raw: %s", err, body)
return
}
fmt.Printf("ID=%d, Name=%s", data.ID, data.Name)处理重定向、Cookie 和调试日志的实用组合方案
调试时经常需要看到真实请求路径（是否被重定向）、携带了哪些 Cookie、服务端返回了什么 Set-Cookie。默认 http.Client 自动跟随 3xx 重定向，且不暴露中间响应。
- 禁用自动重定向：设
CheckRedirect返回http.ErrUseLastResponse，再手动处理Location头 - 启用 Cookie：用
http.CookieJar（如cookiejar.New(nil)），否则每次请求都是无状态的 - 调试输出原始请求/响应：用
httputil.DumpRequestOut和httputil.DumpResponse，注意它们会消费 Body，需提前用io.TeeReader或重复读取
jar, _ := cookiejar.New(nil)
client := &http.Client{
Jar: jar,
CheckRedirect: func(req *http.Request, via []*http.Request) error {
return http.ErrUseLastResponse // 停在 302，不跳转
},
}
req, _ := http.NewRequest("POST", "https://www./link/052c3ffc93bd3a4d5fc379bf96fabea8", strings.NewReader({"u":"a","p":"b"}))
req.Header.Set("Content-Type", "application/json")
dump, _ := httputil.DumpRequestOut(req, true)
log.Printf("REQUEST:\n%s", dump)
resp, := client.Do(req)
dumpResp, := httputil.DumpResponse(resp, true)
log.Printf("RESPONSE:\n%s", dumpResp)
封装一个可复用的调试型 HTTP 客户端结构体
把超时、Header 模板、JSON 编解码、日志开关打包成结构体，比零散函数更利于维护和测试。重点是让 DoJSON 方法能统一处理请求构造、错误分类、响应解析。
- 不要把
*http.Client直接暴露为 public field，防止外部误改 Timeout 或 Jar - 用函数选项模式（functional options）初始化客户端，比一堆参数更易扩展（比如后续加 trace、metrics）
- 错误类型应区分网络错误、HTTP 错误（4xx/5xx）、JSON 解析错误，方便上层做不同重试或提示
type DebugClient struct {
client *http.Client
headers map[string]string
debug bool
}
func NewDebugClient(opts ...func(DebugClient)) DebugClient {
c := &DebugClient{
client: &http.Client{Timeout: 8 * time.Second},
headers: map[string]string{"Accept": "application/json"},
debug: false,
}
for _, opt := range opts {
opt(c)
}
return c
}
func WithDebug() func(DebugClient) {
return func(c DebugClient) { c.debug = true }
}
func (c *DebugClient) DoJSON(method, url string, body interface{}, out interface{}) error {
var reqBody io.Reader
if body != nil {
b, := json.Marshal(body)
reqBody = bytes.NewReader(b)
}
req, := http.NewRequest(method, url, reqBody)
for k, v := range c.headers {
req.Header.Set(k, v)
}
if c.debug {
dump, := httputil.DumpRequestOut(req, true)
log.Printf("[DEBUG] %s %s\n%s", method, url, dump)
}
resp, err := c.client.Do(req)
if err != nil {
return fmt.Errorf("network error: %w", err)
}
defer resp.Body.Close()
if c.debug {
dump, := httputil.DumpResponse(resp, true)
log.Printf("[DEBUG] response\n%s", dump)
}
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
return fmt.Errorf("HTTP %d: %s", resp.StatusCode, resp.Status)
}
if out != nil {
if err := json.NewDecoder(resp.Body).Decode(out); err != nil {
return fmt.Errorf("JSON decode error: %w", err)
}
}
return nil
}
调试工具里最易被忽略的是：Body 读取不可逆、JSON 字段导出规则、以及 3xx 重定向默认被吞掉。这三个点不提前处理，后面花半天查不到问题在哪。
