Explication détaillée du package de requête Golang

Golang est un langage de programmation de plus en plus populaire, et ses domaines d'application côté serveur augmentent de jour en jour. Les développeurs savent tous que les requêtes réseau sont une partie essentielle du développement côté serveur, alors comment effectuer des requêtes réseau dans Golang ? Cet article expliquera en détail le package de requêtes Golang afin que chacun puisse mieux comprendre l'utilisation des requêtes réseau Golang.

Qu'est-ce qu'un package de demande ?

Le package de requêtes est une boîte à outils utilisée dans la bibliothèque standard Golang pour effectuer des requêtes réseau. Il fournit plusieurs méthodes de requête telles que http, net, websocket, etc., ainsi que des méthodes de requête de base, des en-têtes de requête, des corps de requête et d'autres fonctions. Lors de l'envoi d'une requête http, nous devons assembler l'en-tête et le corps de la requête, spécifier la méthode de requête, l'adresse de la requête et le numéro de port, puis adresser une requête au serveur. Le package de requête explique comment réaliser ces opérations, ce qui facilite grandement le développement de notre réseau.

Requête HTTP

Dans Golang, pour envoyer des requêtes HTTP, vous devez utiliser les structures Client et Request fournies par la bibliothèque net/http. La structure Client représente un client HTTP et la structure Request représente une requête HTTP. Nous utilisons le client pour envoyer des demandes de requête. Voici comment envoyer une requête GET :

import (
    "net/http"
    "io/ioutil"
    "fmt"
)

func main() {
    resp, err := http.Get("http://example.com/")
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        // handle error
    }
    fmt.Println(string(body))
}

Ce code enverra une requête GET à l'adresse http://example.com/, puis imprimera les informations de réponse renvoyées par le serveur. Nous utilisons la méthode http.Get pour envoyer la requête et renvoyer les informations d'erreur si une erreur se produit. N'oubliez pas de fermer le corps de la réponse une fois la demande terminée pour éviter un gaspillage inutile de ressources.

En plus des requêtes GET, nous pouvons également envoyer des méthodes de requête POST, PUT, DELETE et autres. Il nous suffit d'utiliser la méthode Do du client et de transmettre la requête Request. Voici un exemple de requête POST :

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

func main() {
    url := "http://example.com/api"
    jsonData := []byte(`{"key":"value"}`)

    req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
    req.Header.Set("Content-Type", "application/json")
    
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        // handle error
    }
    defer resp.Body.Close()
    
    // handle response
}

Dans la requête POST, nous devons spécifier la méthode de requête comme POST et transmettre l'adresse et le corps de la requête. Il y a quelque chose à noter ici. Les requêtes POST doivent définir le champ Content-Type dans l'en-tête de la requête pour informer le serveur du type de données du corps de la requête. Ici, nous utilisons le package json dans golang pour convertir le corps de la requête au format json et le transmettre dans le corps de la requête.

Requête WebSocket

WebSocket est un protocole fourni en HTML5 pour la communication full-duplex entre le navigateur et le serveur. Dans Golang, nous pouvons utiliser la méthode Dial fournie par la bibliothèque websocket pour établir une connexion WebSocket et utiliser les méthodes WriteMessage et ReadMessage pour l'échange de données. Voici un exemple de connexion WebSocket :

import (
    "fmt"
    "log"
    "net/url"
    "github.com/gorilla/websocket"
)

func main() {
    u := url.URL{Scheme: "ws", Host: "echo.websocket.org", Path: "/"}
    fmt.Println("connecting to ", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    message := []byte("hello, world!")
    err = conn.WriteMessage(websocket.TextMessage, message)
    if err != nil {
        log.Println("write:", err)
        return
    }

    _, p, err := conn.ReadMessage()
    if err != nil {
        log.Println("read:", err)
        return
    }
    fmt.Printf("received: %s\n", p)
}

Ce code établira une connexion WebSocket à https://echo.websocket.org, puis enverra un message texte "hello, world!" informations sur le serveur. Nous avons utilisé la méthode Dial fournie par la bibliothèque websocket pour établir une connexion, ainsi que la méthode WriteMessage pour envoyer des messages et la méthode ReadMessage pour recevoir des messages. Par rapport aux requêtes HTTP, les requêtes WebSocket offrent des performances en temps réel et en temps réel plus élevées.

Résumé

Cet article explique en détail le package de requêtes dans Golang, y compris les requêtes HTTP, les requêtes WebSocket, ainsi que l'assemblage et l'envoi de requêtes. En étudiant cet article, nous pouvons mieux maîtriser l'utilisation et les techniques des requêtes réseau Golang, et fournir davantage d'outils et de méthodes pour le développement côté serveur.

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!