Requêtes HTTP asynchrones en langage Go

À l'ère d'Internet d'aujourd'hui, de nombreuses applications doivent effectuer des requêtes réseau pour obtenir ou envoyer des données. Les requêtes HTTP sont l'une des méthodes de requête réseau les plus couramment utilisées. Dans le langage Go, nous pouvons utiliser le package net/http dans la bibliothèque standard pour lancer des requêtes HTTP, mais cela bloquera la coroutine actuelle. Alors comment implémenter des requêtes HTTP asynchrones en langage Go ? Cet article présentera deux méthodes d'implémentation de requêtes HTTP asynchrones dans le langage Go.

Méthode 1 : Utiliser goroutine et canal

Goroutine nous permet de mettre en œuvre facilement une programmation asynchrone, et le canal peut faciliter la communication entre les coroutines. Par conséquent, nous pouvons lancer une requête HTTP dans une goroutine, puis utiliser un canal pour renvoyer la réponse à la goroutine principale. Voici un exemple simple :

func asyncHTTP(url string, ch chan<- []byte) {
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatal(err)
    }

    ch <- body
}

func main() {
    ch := make(chan []byte)
    url := "https://www.example.com"
    go asyncHTTP(url, ch)

    fmt.Println("Waiting for response...")
    responseBody := <-ch
    fmt.Println("Received response:", string(responseBody))
}

Dans l'exemple ci-dessus, nous créons d'abord un ch (tapez chan[]byte) pour renvoyer le résultat de la réponse à la coroutine principale. Ensuite, nous appelons la fonction asyncHTTP pour lancer une requête HTTP, qui écrira le résultat de la réponse dans ch. Enfin, nous lisons le résultat de la réponse de ch en utilisant l'opérateur <-ch. asyncHTTP函数发起HTTP请求，该函数会将响应结果写入ch中。最后，我们通过使用<-ch操作符从ch中读取响应结果。

需要注意的是，如果没有通过goroutine来发起HTTP请求，那么读取响应结果的操作<-ch会导致当前协程阻塞。使用goroutine和channel的方式可以让我们轻松地实现异步HTTP请求。

方法二：使用context和http.Do

在Go语言中，我们可以使用context包来控制函数的执行时间和可取消性。结合使用context和http.Do函数，我们可以实现可取消的异步HTTP请求。下面是一个简单的例子：

func asyncHTTPWithCtx(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
    if err != nil {
        return nil, err
    }

    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        return nil, err
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, err
    }

    return body, nil
}

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    url := "https://www.example.com"
    resp, err := asyncHTTPWithCtx(ctx, url)

    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Response:", string(resp))
}

在上面的例子中，我们使用了context.WithTimeout函数来创建一个可取消的context。然后我们调用了asyncHTTPWithCtx函数，该函数会使用http.Do函数来发起HTTP请求。http.Do函数可以接受一个context参数，当context被取消时，http.Do函数会将正在执行的HTTP请求取消。

需要注意的是，在使用http.Do函数时，我们必须手动关闭响应主体。否则，这可能会导致资源泄漏或连接池的耗尽。因此，在asyncHTTPWithCtx

Il est à noter que si la requête HTTP n'est pas initiée via goroutine, l'opération de lecture du résultat de la réponse <-ch entraînera le blocage de la coroutine actuelle. L'utilisation de goroutine et de canaux nous permet d'implémenter facilement des requêtes HTTP asynchrones.

Méthode 2 : Utilisation du contexte et de http.Do

En langage Go, nous pouvons utiliser le package de contexte pour contrôler le temps d'exécution et l'annulation des fonctions. En utilisant le contexte en conjonction avec la fonction http.Do, nous pouvons implémenter des requêtes HTTP asynchrones annulables. Voici un exemple simple : 🎜rrreee🎜Dans l'exemple ci-dessus, nous utilisons la fonction context.WithTimeout pour créer un contexte annulable. Ensuite, nous avons appelé la fonction asyncHTTPWithCtx, qui utilise la fonction http.Do pour lancer une requête HTTP. La fonction http.Do peut accepter un paramètre de contexte Lorsque le contexte est annulé, la fonction http.Do annulera l'exécution de la requête HTTP. 🎜🎜Il est à noter que lors de l'utilisation de la fonction http.Do, il faut fermer manuellement le corps de la réponse. Sinon, cela peut entraîner des fuites de ressources ou un épuisement du pool de connexions. Par conséquent, dans la fonction asyncHTTPWithCtx, nous utilisons une instruction defer pour garantir que le corps de la réponse est fermé au retour de la fonction. 🎜🎜Résumé🎜🎜Cet article présente deux méthodes d'implémentation de requêtes HTTP asynchrones en langage Go : en utilisant goroutine et canal et en utilisant le contexte et la fonction http.Do. La méthode utilisant goroutine et canal est une méthode plus générale et peut être utilisée pour demander de manière asynchrone tout type de ressource réseau. La méthode d'utilisation des fonctions contextuelles et http.Do est plus adaptée aux scénarios dans lesquels l'annulation de la demande doit être contrôlée. Grâce à ces technologies, nous pouvons facilement implémenter des requêtes HTTP asynchrones, améliorant ainsi les performances et la réactivité des applications. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!