如何发送 N 个获取请求，其中 N > 10 个 URL

今天编程网给大家带来了《如何发送 N 个获取请求，其中 N > 10 个 URL》，其中涉及到的知识点包括等等，无论你是小白还是老手，都适合看一看哦~有好的建议也欢迎大家在评论留言，若是看完有所收获，也希望大家能多多点赞支持呀！一起加油学习~

问题内容

我正在尝试发出 n 个 get 请求，但我的代码适用于 8 个 url，但 10 个 url 始终可以毫无问题地堆叠。

我是 go 新手，所以我无法理解这个问题。

我正在尝试编写一个应用程序来完成相同任务，以击败 .net 应用程序。

您能否提出问题所在？

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "os"
    //"bufio"
    "time"
)

type HttpResponse struct {
    url      string
    response *http.Response
    err      error
}

func main() {
    fmt.Println("Hello, world3.")

    var urls []string = []string{
    "www.webmagnat.ro",
    "nickelfreesolutions.com",
    "scheepvaarttelefoongids.nl",
    "tursan.net",
    "plannersanonymous.com",
    "saltstack.com",
    "deconsquad.com",
    "migom.com",
    "tjprc.org",
    "worklife.dk",
    "food-hub.org"}

    start := time.Now()
    results := asyncHttpGets(urls)

    f, err := os.Create("test.txt")
    if err != nil {
        fmt.Println(err)
        return
    }


    for _, result := range results {
        fmt.Printf("%s status: %s\n", result.url,
            result.response.Status)

            l, err := f.WriteString(result.url+"\n")
            if err != nil {
                fmt.Println(err)
                f.Close()
                return
            }
            _ = l
    }
    t := time.Now()
    elapsed := t.Sub(start)
    fmt.Printf("Ellipsed: %s\n", elapsed)

    err = f.Close()
    if err != nil {
        fmt.Println(err)
        return
    }


    fmt.Println("Buy, world2.")
}


func asyncHttpGets(urls []string) []*HttpResponse {
    ch := make(chan *HttpResponse, len(urls)) // buffered
    responses := []*HttpResponse{}
    for _, url := range urls {
         go func(url string) {
            fmt.Printf("Fetching %s \n", url)
            resp, err := http.Get("http://" + url)
            if err != nil {
                fmt.Printf("Failed to fetch %s\n", err)
                return
            }
            defer resp.Body.Close()

            if resp.StatusCode == http.StatusOK {
                fmt.Printf("HTTP Response Status : %v", resp.StatusCode)
                bodyBytes, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    log.Fatal(err)
                }
                bodyString := string(bodyBytes)

                fmt.Printf("HTTP Response Content Length : %v\n", len(bodyString))
            }

            ch <- &HttpResponse{url, resp, err}
        }(url)
    }

    for {
        select {
        case r := <-ch:
            fmt.Printf("%s was fetched\n", r.url)
            responses = append(responses, r)
            if len(responses) == len(urls) {
                return responses
            }
        case <-time.After(50 * time.Millisecond):
            fmt.Printf(".")
        }
    }

    return responses

}

https://play.golang.org/p/pckyym_pgix

解决方案

这里的第一个问题是，如果发生错误，您不会返回响应，因此 len(responses) == len(urls) 可能永远不会匹配，从而迫使循环永远继续。

首先为并发请求添加 sync.waitgroup

var wg sync.waitgroup

    ch := make(chan *httpresponse) 
    responses := []*httpresponse{}
    for _, url := range urls {
        wg.add(1)
        go func(url string) {
            defer wg.done()

然后你可以调整响应范围，直到所有未完成的 goroutine 完成

go func() {
        wg.wait()
        close(ch)
    }()

    for r := range ch {
        fmt.printf("%s was fetched\n", r.url)
        responses = append(responses, r)
    }

    return responses

然后，您必须决定如何处理响应，是要在并发调用中读取它们，还是返回未读的响应体。由于如果您想重新使用连接，您将希望始终尝试消耗主体，并且由于您已经推迟了 body.close()，因此当前需要在同一个函数调用。您可以更改 httpresponse 类型来实现此目的，或者将 resp.body 替换为包含响应的缓冲区。

最后，您将希望为客户端设置某种超时（可能使用 context），并对发出的并发请求数量进行限制。

问题是您正在返回发生错误而未写入通道的情况。查看您的 if err != nil { return } 语句。因为您不写入通道，所以 len(responses) == len(urls) 语句永远不可能为 true。

 go func(url string) {
            fmt.Printf("Fetching %s \n", url)
            resp, err := http.Get("http://" + url)
            if err != nil {
                fmt.Printf("Failed to fetch %s\n", err)
                return
            }
            defer resp.Body.Close()

            if resp.StatusCode == http.StatusOK {
                fmt.Printf("HTTP Response Status : %v", resp.StatusCode)
                bodyBytes, err := ioutil.ReadAll(resp.Body)
                if err != nil {
                    log.Fatal(err)
                }
                bodyString := string(bodyBytes)

                fmt.Printf("HTTP Response Content Length : %v\n", len(bodyString))
            }

            ch <- &HttpResponse{url, resp, err}
        }(url)

今天关于《如何发送 N 个获取请求，其中 N > 10 个 URL》的内容介绍就到此结束，如果有什么疑问或者建议，可以在编程网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！