Go语言函数参数类型转换：从自定义类型到标准库接口的适配实践

type Request *http.Request
type Response *http.Response

// 假设 SuperAgent.RedirectPolicy 接收 func(req Request, via []Request) error
func (s *SuperAgent) RedirectPolicy(policy func(req Request, via []Request) error) *SuperAgent {
   s.Client.CheckRedirect = policy // 编译错误！
   return s
}

// 假设 policy 是 func(req Request, ...) error
// 目标是 func(req *http.Request, ...) error
s.Client.CheckRedirect = func(r *http.Request, via []*http.Request) error {
    convertedReq := Request(r) // 显式将 *http.Request 转换为 Request
    // ... 处理 via 参数并调用 policy
    return policy(convertedReq, /* convertedVia */)
}

// 假设 policy 是 func(..., via []Request) error
// 目标是 func(..., via []*http.Request) error
s.Client.CheckRedirect = func(r *http.Request, v []*http.Request) error {
    // 转换单个请求
    convertedReq := Request(r)

    // 转换切片：创建新切片并逐元素转换
    convertedVia := make([]Request, len(v))
    for i, item := range v {
        convertedVia[i] = Request(item) // 逐个将 *http.Request 转换为 Request
    }

    // 调用原始的 policy 函数
    return policy(convertedReq, convertedVia)
}

package main

import (
    "fmt"
    "net/http"
)

// 定义自定义类型，封装标准库的 *http.Request 和 *http.Response
type Request *http.Request
type Response *http.Response

// SuperAgent 结构体，模拟一个HTTP客户端
type SuperAgent struct {
    Client *http.Client
}

// NewSuperAgent 构造函数
func NewSuperAgent() *SuperAgent {
    return &SuperAgent{
        Client: &http.Client{},
    }
}

// RedirectPolicy 方法，接收一个使用自定义 Request 类型的重定向策略函数
func (s *SuperAgent) RedirectPolicy(policy func(req Request, via []Request) error) *SuperAgent {
    // 使用匿名函数作为适配器，其签名与 http.Client.CheckRedirect 期望的完全一致
    s.Client.CheckRedirect = func(r *http.Request, v []*http.Request) error {
        // 1. 转换当前请求：将 *http.Request 显式转换为 Request
        convertedReq := Request(r)

        // 2. 转换历史请求切片：创建新切片，并逐元素将 []*http.Request 转换为 []Request
        convertedVia := make([]Request, len(v))
        for i, item := range v {
            convertedVia[i] = Request(item)
        }

        // 3. 调用原始的 policy 函数，传入转换后的自定义类型参数
        return policy(convertedReq, convertedVia)
    }
    return s
}

func main() {
    agent := NewSuperAgent()

    // 定义一个使用自定义 Request 类型的重定向策略函数
    myCustomRedirectPolicy := func(req Request, via []Request) error {
        if len(via) > 0 {
            fmt.Printf("重定向中：从 %s 到 %s。已重定向 %d 次。\n", via[len(via)-1].URL, req.URL, len(via))
        } else {
            fmt.Printf("首次请求 %s。\n", req.URL)
        }

        // 示例：如果重定向次数超过10次，则停止重定向
        if len(via) >= 10 {
            fmt.Println("达到最大重定向次数，停止重定向。")
            return http.ErrUseLastResponse // 停止重定向并使用最后一次响应
        }
        return nil // 继续重定向
    }

    // 将自定义策略应用到 SuperAgent，通过适配器桥接
    agent.RedirectPolicy(myCustomRedirectPolicy)

    fmt.Println("自定义重定向策略已成功应用。")

    // 实际使用 http.Client 发送请求时，CheckRedirect 就会被调用
    // 例如：
    // resp, err := agent.Client.Get("http://example.com/some/redirect/chain")
    // if err != nil {
    //     fmt.Printf("请求错误: %v\n", err)
    // } else {
    //     fmt.Printf("最终响应状态: %s\n", resp.Status)
    //     resp.Body.Close()
    // }
}