Go语言函数类型适配与自定义类型转换实践

// 假设 Request 是 type Request *http.Request
// 这是一个适配器函数的片段
func(r *http.Request) {
    myCustomFunc(Request(r)) // 直接将 *http.Request 转换为 Request
}

// 假设 Request 是 type Request *http.Request
// 这是一个适配器函数的片段
func(v []*http.Request) {
    // 创建一个目标切片，长度与源切片相同
    targetSlice := make([]Request, len(v))
    // 遍历源切片，逐个元素进行类型转换并赋值给目标切片
    for i, item := range v {
        targetSlice[i] = Request(item)
    }
    myCustomFunc(targetSlice) // 调用自定义函数
}

package main

import (
    "fmt"
    "net/http"
)

// 定义自定义类型别名，用于包装标准库类型
type Request *http.Request
type Response *http.Response

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

// NewSuperAgent 创建 SuperAgent 实例
func NewSuperAgent() *SuperAgent {
    return &SuperAgent{
        Client: &http.Client{},
    }
}

// RedirectPolicy 方法，接收一个自定义签名的策略函数
// 该函数期望接收自定义的 Request 和 []Request 类型
func (s *SuperAgent) RedirectPolicy(policy func(req Request, via []Request) error) *SuperAgent {
    // 使用匿名函数作为适配器
    // 这个匿名函数符合 http.Client.CheckRedirect 所期望的签名：
    // func(req *http.Request, via []*http.Request) error
    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)
        }

        // 调用用户提供的原始 policy 函数，传入转换后的参数
        return policy(convertedReq, convertedVia)
    }
    return s
}

// 示例：一个符合 RedirectPolicy 签名的自定义重定向策略函数
func myCustomRedirectPolicy(req Request, via []Request) error {
    fmt.Printf("Custom Policy: Redirecting request to %s, via %d previous requests.\n", req.URL, len(via))
    // 模拟一些业务逻辑，例如限制重定向次数
    if len(via) >= 10 {
        fmt.Println("Custom Policy: Exceeded maximum redirects (10).")
        return http.ErrUseLastResponse // 停止重定向
    }
    return nil // 允许继续重定向
}

func main() {
    sa := NewSuperAgent()
    // 将自定义策略函数传递给 RedirectPolicy
    sa.RedirectPolicy(myCustomRedirectPolicy)

    // 模拟一个 HTTP 请求来触发 CheckRedirect
    // 假设这是一个重定向链中的第二个请求
    initialReq, _ := http.NewRequest("GET", "http://example.com/initial", nil)
    currentReq, _ := http.NewRequest("GET", "http://example.com/redirected", nil)

    // CheckRedirect 会接收 *http.Request 和 []*http.Request
    // 我们的适配器会将其转换为 Request 和 []Request
    err := sa.Client.CheckRedirect(currentReq, []*http.Request{initialReq})
    if err != nil {
        fmt.Printf("CheckRedirect error: %v\n", err)
    } else {
        fmt.Println("CheckRedirect returned nil, redirection allowed.")
    }

    // 模拟更多重定向，以触发策略限制
    fmt.Println("\n--- Testing Redirect Limit ---")
    longVia := make([]*http.Request, 10)
    for i := 0; i < 10; i++ {
        longVia[i], _ = http.NewRequest("GET", fmt.Sprintf("http://example.com/redirect/%d", i), nil)
    }
    err = sa.Client.CheckRedirect(currentReq, longVia)
    if err != nil {
        fmt.Printf("CheckRedirect error (limit reached): %v\n", err)
    } else {
        fmt.Println("CheckRedirect returned nil, redirection allowed.")
    }
}