Une introduction à multiples facettes aux requêtes réseau de Golang

Avec le développement d'Internet, la communication en réseau devient de plus en plus importante. Pour différents scénarios commerciaux, différents langages de programmation ont également leurs propres caractéristiques. Dans l'utilisation des requêtes réseau, Golang présente également de nombreuses excellentes méthodes de traitement. Cet article présentera les requêtes réseau de Golang sous les aspects suivants :

1. Introduction aux requêtes de base
2. Paramètres de la requête
3. Demandes simultanées
4. Requêtes https

Introduction aux requêtes de base

Pour utiliser Golang pour lancer des requêtes réseau, nous avons besoin En s'appuyant sur la bibliothèque standard "net/http", le client (Client) peut initier des requêtes et recevoir des réponses. Voici un exemple simple de requête GET :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("http://www.example.com/")
    if err != nil {
        // 处理错误
    }
    defer resp.Body.Close()

    // 可以通过 resp 对象获取响应信息，比如响应状态码、响应头等
    fmt.Println(resp.Status)

    // 读取响应数据
    buffer := make([]byte, 1024)
    for {
        n, err := resp.Body.Read(buffer)
        if err != nil && err != io.EOF {
            // 处理错误
        }
        if n == 0 {
            break
        }
        fmt.Println(string(buffer[:n]))
    }
}

Parmi eux, nous utilisons la méthode "http.Get" pour lancer une requête GET Après avoir obtenu l'objet "resp", nous pouvons lire les données de réponse via cet objet. Il convient de noter qu'après avoir lu les données de réponse, le corps de réponse doit être fermé pour éviter une fuite de ressources.

Paramètres de requête

En plus des requêtes GET régulières, nous pouvons également effectuer d'autres types de requêtes, telles que POST, PUT, etc., et nous pouvons également apporter des ajustements plus précis aux requêtes.

Objet de requête

Avant de lancer une requête, nous pouvons définir divers paramètres de la requête, tels que l'URL, l'en-tête de la requête, le corps de la requête, etc., en créant l'objet "http.Request". Par exemple, voici un exemple de requête POST :

package main

import (
    "bytes"
    "net/http"
)

func main() {
    url := "http://www.example.com/api"
    data := bytes.NewBufferString("hello world")

    // 创建一个 POST 请求，并设置请求头和请求体
    req, _ := http.NewRequest("POST", url, data)
    req.Header.Set("Content-Type", "application/json")

    // 发起请求
    client := http.DefaultClient
    resp, err := client.Do(req)
    if err != nil {
        // 处理错误
    }
    defer resp.Body.Close()

    // 处理响应
}

Dans cet exemple, nous utilisons la méthode "http.NewRequest" pour créer un objet de requête POST, puis définissons l'en-tête et le corps de la requête. Ensuite, nous utilisons "http.DefaultClient.Do" pour lancer une requête et obtenir l'objet de réponse "resp". Il est important de ne pas oublier de fermer le corps de la réponse lorsque vous avez terminé.

Délai d'expiration de la demande

En général, le délai d'expiration de la demande est un problème qui doit être pris en compte. "http.Client" de Golang prend en charge la définition du délai d'attente pour les requêtes. Nous pouvons utiliser "http.Client.Timeout" pour définir le délai d'attente. L'exemple de code est le suivant :

package main

import (
    "net/http"
    "time"
)

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

    resp, err := client.Get("http://www.example.com/")
    if err != nil {
        // 处理错误
    }
    defer resp.Body.Close()

    // 处理响应
}

Dans cet exemple, nous créons un "http.Client". object et définissez le délai d'expiration de la demande sur 2 secondes. Il convient de noter que le délai d'attente doit être défini avant l'utilisation, plutôt que d'être traité après la détermination d'une erreur.

Requêtes simultanées

Golang, en tant que langage à haute concurrence, dispose bien sûr également d'excellentes méthodes de traitement des requêtes simultanées. Dans des circonstances normales, nous utiliserons des requêtes simultanées pour améliorer l'efficacité des requêtes réseau. Voici un exemple simple de requête simultanée :

package main

import (
    "fmt"
    "net/http"
    "sync"
)

func main() {
    var urls = []string{"http://www.example.com/", "http://www.example.net/", "http://www.example.org/"}

    result := make(chan string)
    var wg sync.WaitGroup

    for _, url := range urls {
        wg.Add(1)
        go func(url string) {
            defer wg.Done()

            resp, err := http.Get(url)
            if err != nil {
                // 处理错误
            }
            defer resp.Body.Close()

            result <- url + " " + resp.Status
        }(url)
    }

    go func() {
        wg.Wait()
        close(result)
    }()

    // 持续读取结果，直到 result 被关闭
    for r := range result {
        fmt.Println(r)
    }
}

Dans cet exemple, nous utilisons un canal pour transmettre les résultats et démarrons plusieurs goroutines pour lancer des requêtes en même temps. Les points suivants doivent être notés dans cet exemple :

1. Nous utilisons sync.WaitGroup pour compter le nombre de goroutines et nous assurer que toutes les goroutines sont terminées.
2. Dans chaque goroutine, nous utilisons des fonctions anonymes pour le passage des paramètres.
3. Afin d'éviter le blocage des goroutines, nous utilisons des canaux pour transférer les résultats entre les goroutines.

Demande https

Surtout lors du développement d'applications Web, nous rencontrerons toujours des situations où nous devrons utiliser https. En Golang, nous pouvons utiliser directement des URL commençant par « https:// » pour lancer des requêtes https sans effectuer de paramètres supplémentaires. Voici un exemple simple :

package main

import (
    "crypto/tls"
    "fmt"
    "net/http"
)

func main() {
    tr := &http.Transport{
        TLSClientConfig: &tls.Config{
            InsecureSkipVerify: true, // 这里忽略了证书校验，实际情况下不应该这么做
        },
    }

    client := &http.Client{Transport: tr}
    resp, err := client.Get("https://www.example.com/")
    if err != nil {
        // 处理错误
    }
    defer resp.Body.Close()

    // 处理响应
    fmt.Println(resp.Status)
}

Dans cet exemple, nous utilisons l'objet "http.Transport" pour créer l'objet "http.Client" et ignorer la vérification du certificat https. Il convient de noter que cela ne doit pas être effectué en production réelle, car cela pourrait entraîner des risques pour la sécurité.

Résumé

Grâce à l'introduction de cet article, nous avons appris les méthodes de base de traitement des requêtes réseau et les excellentes performances de golang dans les requêtes réseau. Bien entendu, cet article ne présente qu'une méthode de traitement des requêtes relativement basique, et elle doit être ajustée en fonction de scénarios spécifiques d'utilisation réelle.

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!