Golang ferme le client http

Dans le langage Go, le Client http est une bibliothèque de requêtes réseau très couramment utilisée. Lors des requêtes réseau, afin d'optimiser les performances et de libérer des ressources, nous devons souvent fermer le client http à temps une fois la requête terminée. Alors, comment fermer le client http en langage Go ? Cet article explique comment fermer le client http et quelques précautions.

Méthode pour fermer le client http

En langage Go, la fermeture du client http s'effectue en appelant la méthode Close du client http. La méthode Close du client http libérera toutes les connexions, y compris les connexions non fermées. De manière générale, nous devons appeler la méthode http Client's Close rapidement une fois la demande terminée pour libérer des ressources.

L'exemple de code est le suivant :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    client := http.Client{}
    req, _ := http.NewRequest("GET", "http://www.example.com", nil)

    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("Error:", err)
    }

    defer resp.Body.Close()
    defer client.Close()

    fmt.Println(resp.Body)
}

Dans l'exemple de code ci-dessus, nous utilisons le client http pour envoyer une requête GET et appelons la méthode Close du client http après la requête est terminé.

Notes

Lors de l'utilisation du client http, nous devons faire attention aux points suivants :

1. Réutilisation du client http : dans certains cas Dans certains cas, nous devons réutiliser le Client http, afin d'éviter de créer un nouveau Client http pour chaque requête. Nous pouvons transmettre un http.Client réutilisé lors de l'appel de la méthode Do.

package main

import (
    "fmt"
    "net/http"
)

func main() {
    transport := http.DefaultTransport.(*http.Transport).Clone()
    client := http.Client{Transport: transport}

    req1, _ := http.NewRequest("GET", "http://www.example.com", nil)
    resp1, err := client.Do(req1)
    if err != nil {
        fmt.Println("Error:", err)
    }

    req2, _ := http.NewRequest("GET", "http://www.example.com", nil)
    resp2, err := client.Do(req2)
    if err != nil {
        fmt.Println("Error:", err)
    }

    defer resp1.Body.Close()
    defer resp2.Body.Close()

    fmt.Println(resp1.Body)
    fmt.Println(resp2.Body)
}

Dans l'exemple de code ci-dessus, nous avons d'abord copié le http.DefaultTransport, puis créé un nouveau client http. Ensuite, nous avons envoyé deux requêtes GET respectivement et lu respectivement le corps de la réponse.

2. Demandes simultanées : Lorsque nous effectuons des requêtes simultanées, nous devons également faire attention à l'utilisation du client http. Si plusieurs requêtes sont envoyées en même temps, il n'est pas judicieux de créer un nouveau client http pour chaque requête. Cela entraînera un gaspillage de ressources système et d'éventuels blocages. Par conséquent, nous devrions réutiliser le client http existant.

package main

import (
    "fmt"
    "net/http"
)

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

    respChan := make(chan *http.Response)

    get := func(url string) {
        req, _ := http.NewRequest("GET", url, nil)
        resp, _ := client.Do(req)
        defer resp.Body.Close()

        respChan <- resp
    }

    urls := []string{"http://www.example.com", "http://www.example.org", "http://www.example.net"}
    for _, url := range urls {
        go get(url)
    }

    for range urls {
        resp := <-respChan
        fmt.Println(resp.Body)
    }

    client.Close()
}

Dans l'exemple de code ci-dessus, nous avons envoyé trois requêtes GET simultanément. Nous utilisons un canal respChan pour recevoir la réponse à chaque requête. Dans la boucle, nous lisons chaque réponse du canal respChan et générons le corps de la réponse.

Conclusion

Il est très important de fermer le client http s'il n'est pas fermé à temps, cela entraînera un gaspillage de ressources système et pourra même causer de graves problèmes. Lors de l'utilisation du client http, nous devons prêter attention à certains problèmes tels que les requêtes simultanées et la réutilisation du client http pour optimiser les performances et libérer des ressources. En langage Go, pour fermer le Client http, il suffit d'appeler la méthode Close.

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!