Go语言并行HTTP请求与超时控制：高效抓取多URL数据

package main

import (
    "net/http"
    "time"
)

func createHttpClientWithTimeout(timeout time.Duration) *http.Client {
    return &http.Client{
        Timeout: timeout, // 设置整个请求的超时时间
    }
}

func main() {
    // 示例：创建一个1秒超时的HTTP客户端
    client := createHttpClientWithTimeout(1 * time.Second)
    _ = client // 客户端已创建，后续可用于发起请求
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"
)

// URLResult 结构体用于存储每个URL请求的结果
type URLResult struct {
    URL  string
    Data []byte
    Err  error
}

// fetchURL 函数在Goroutine中执行，负责获取单个URL的数据
func fetchURL(client *http.Client, url string, results chan<- URLResult, wg *sync.WaitGroup) {
    defer wg.Done() // Goroutine完成时通知WaitGroup

    resp, err := client.Get(url)
    if err != nil {
        results <- URLResult{URL: url, Err: fmt.Errorf("请求 %s 失败: %w", url, err)}
        return
    }
    defer resp.Body.Close() // 确保响应体关闭，释放资源

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        results <- URLResult{URL: url, Err: fmt.Errorf("读取 %s 响应体失败: %w", url, err)}
        return
    }

    results <- URLResult{URL: url, Data: body}
}

package main

import (
    "fmt"
    "io/ioutil"
    "net/http"
    "sync"
    "time"
)

// URLResult 结构体用于存储每个URL请求的结果
type URLResult struct {
    URL  string
    Data []byte
    Err  error
}

// fetchURL 函数在Goroutine中执行，负责获取单个URL的数据
func fetchURL(client *http.Client, url string, results chan<- URLResult, wg *sync.WaitGroup) {
    defer wg.Done() // Goroutine完成时通知WaitGroup

    resp, err := client.Get(url)
    if err != nil {
        results <- URLResult{URL: url, Err: fmt.Errorf("请求 %s 失败: %w", url, err)}
        return
    }
    defer resp.Body.Close() // 确保响应体关闭，释放资源

    // 检查HTTP状态码，例如4xx或5xx
    if resp.StatusCode >= 400 {
        results <- URLResult{URL: url, Err: fmt.Errorf("请求 %s 返回非成功状态码: %d", url, resp.StatusCode)}
        return
    }

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        results <- URLResult{URL: url, Err: fmt.Errorf("读取 %s 响应体失败: %w", url, err)}
        return
    }

    results <- URLResult{URL: url, Data: body}
}

func main() {
    // 待抓取的URL列表
    urls := []string{
        "https://www.google.com",
        "https://www.baidu.com",
        "https://example.com/slow-response", // 假设这是一个响应慢的URL
        "https://httpbin.org/delay/2",       // 模拟2秒延迟
        "https://www.github.com",
        "https://nonexistent-domain.com",    // 模拟一个不存在的域名
    }

    // 设置每个请求的超时时间为1秒
    const requestTimeout = 1 * time.Second
    client := &http.Client{
        Timeout: requestTimeout,
    }

    // 创建一个带缓冲的Channel来收集结果，缓冲大小与URL数量相同
    results := make(chan URLResult, len(urls))
    var wg sync.WaitGroup

    fmt.Printf("开始并行抓取 %d 个URL，每个请求超时 %s\n", len(urls), requestTimeout)

    // 为每个URL启动一个Goroutine
    for _, url := range urls {
        wg.Add(1) // 增加WaitGroup计数器
        go fetchURL(client, url, results, &wg)
    }

    // 启动一个Goroutine来等待所有请求完成，并关闭结果Channel
    go func() {
        wg.Wait()      // 等待所有Goroutine完成
        close(results) // 关闭Channel，表示没有更多结果会写入
    }()

    // 从结果Channel中读取并处理所有结果
    for result := range results {
        if result.Err != nil {
            fmt.Printf("错误: %s\n", result.Err)
        } else {
            // 为了简洁，这里只打印响应体的前100个字符
            bodyPreview := string(result.Data)
            if len(bodyPreview) > 100 {
                bodyPreview = bodyPreview[:100] + "..."
            }
            fmt.Printf("成功获取 %s (%d 字节): %s\n", result.URL, len(result.Data), bodyPreview)
        }
    }

    fmt.Println("所有URL抓取任务完成。")
}