requête asynchrone Golang http

Le traitement asynchrone est l'une des fonctionnalités les plus importantes de nombreuses applications Web modernes. En langage Go, il fournit un moyen simple mais puissant d'effectuer des requêtes asynchrones - en utilisant le package http. Cet article explique comment utiliser le package http de Golang pour effectuer des requêtes asynchrones.

1. Introduction

Le package http en langage Go est un package très puissant qui peut être utilisé pour envoyer des requêtes GET, POST et autres requêtes HTTP diverses. Il fournit également un client pour interagir avec le serveur HTTP. Dans le cas de base, le package http fournit un moyen très simple d'envoyer des requêtes synchrones, mais nous avons généralement besoin d'une solution asynchrone. Heureusement, le package http fournit des fonctionnalités simples mais puissantes pour gérer les requêtes asynchrones. "Dans Go, nous implémentons des requêtes asynchrones via goroutine, ce qui permet à Go de gérer facilement un grand nombre de requêtes asynchrones hautement concurrentes.

2. Méthode d'utilisation

1. Créer un client

Dans Go, dans le package http Le client L'objet peut être utilisé pour effectuer des requêtes HTTP asynchrones. Nous pouvons créer un client par défaut en suivant le code :

package main

import (
    "net/http"
)

func main() {
    client := &http.Client{}
}

Dans l'exemple ci-dessus, nous avons créé un objet client HTTP par défaut et l'avons attribué à la variable " client".

2. Envoyer une requête

Une fois la création du client HTTP terminée, nous pouvons utiliser la fonction http.NewRequest pour créer un objet de requête HTTP. HttpClient exécute la requête et reçoit la réponse en appelant Do. Pour rendre la requête asynchrone, nous avons besoin de l'utiliser. de goroutine. Voici l'exemple de code :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := &http.Client{}

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
    //等待goroutine结束
    //time.Sleep(5 * time.Second)
}

Dans le code ci-dessus, nous créons d'abord un client HTTP, puis créons un objet de requête GET à l'aide de la fonction http.NewRequest(). Ensuite, nous utilisons goroutine pour construire la requête asynchrone. . Le code qui envoie la requête est en dehors de la goroutine et affiche "Demande envoyée de manière asynchrone." Le reste du code imprime l'état de la requête asynchrone. Notez que nous appelons resp.Body.Close() dans l'instruction defer pour fermer la requête. corps de la réponse.

3. Gestion des erreurs

Lorsque nous envoyons une requête HTTP asynchrone, diverses erreurs peuvent se produire. Voici quelques types d'erreurs courantes

1. Lorsque le serveur répond trop lentement ou en raison du réseau. problèmes. , le client peut expirer en attendant une réponse. Pour résoudre ce problème, nous pouvons contrôler le délai d'attente et l'annulation de la demande via les fonctions SetTimeout et CancelRequest. Voici l'exemple de code :

package main

import (
    "context"
    "fmt"
    "net/http"
    "time"
)

func main() {
    client := &http.Client{
        Timeout: 5 * time.Second,
    }

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

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

    req = req.WithContext(ctx)

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
}

Dans l'exemple ci-dessus, nous définissez d'abord le délai d'attente du client. Le délai d'attente est de 5 secondes. Ensuite, un nouveau contexte et un nouvel objet de requête sont créés à l'aide de la fonction WithTimeout dans le package de contexte. Cette fonction renverra une fonction d'annulation, pour laquelle nous utilisons une instruction defer pour garantir que la requête est exécutée. est annulé avant la fin de la fonction (s'il existe toujours).

2. Erreur de connexion réseau

L'erreur qui se produit fréquemment est l'erreur de connexion réseau. Elle est généralement liée à l'appareil avec une vitesse réseau lente. problème de connexion réseau, nous pouvons utiliser http.Transport. La fonction Dialer fournie définit le délai d'expiration de la connexion. Voici l'exemple de code :

package main

import (
    "context"
    "fmt"
    "net"
    "net/http"
    "time"
)

func main() {
    dialer := &net.Dialer{
        Timeout: 5 * time.Second,
    }

    transport := &http.Transport{
        DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
            return dialer.DialContext(ctx, network, addr)
        },
    }

    client := &http.Client{
        Transport: transport,
    }

    req, err := http.NewRequest("GET", "https://www.google.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    go func() {
        resp, err := client.Do(req)
        if err != nil {
            fmt.Println(err)
            return
        }
        defer resp.Body.Close()
        fmt.Println("Async response status:", resp.Status)
    }()

    fmt.Println("Request sent asynchronously.")
}

En utilisant à nouveau la méthode ci-dessus, nous définissons le délai d'expiration du numéroteur à 5 secondes. Le client utilise ensuite le DialContext. fonction fournie dans http.Transport pour faire la demande. Cette fonction utilisera le numéroteur que nous avons défini pour la connexion réseau et fermera la connexion après l'expiration du délai. Notez que nous devons nous assurer de fermer le corps de la réponse après avoir reçu la réponse.

4. Conclusion

Dans cet article, nous avons présenté la méthode d'utilisation du package http pour effectuer des requêtes HTTP asynchrones dans le langage Go. Nous avons créé goroutine pour envoyer des requêtes de manière asynchrone et introduit des méthodes courantes de gestion des erreurs. Cette approche est très simple mais puissante et peut gérer les situations de concurrence élevée pouvant survenir dans les applications Web, ce qui la rend plus flexible que la plupart des bibliothèques réseau traditionnelles. Vous pouvez désormais appliquer cette technique à votre code, économisant ainsi un temps et des ressources précieux.

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!