demande de cookie golang

Lorsque vous effectuez une requête HTTP dans Golang, vous devez généralement utiliser des informations d'authentification telles que les cookies, et vous devez également obtenir des cookies. Cet article explique comment utiliser Golang pour lancer une requête HTTP avec des cookies et enregistrer le cookie dans une variable pour une utilisation ultérieure.

Introduction à HTTP et aux cookies

HTTP (Hypertext Transfer Protocol) est un protocole qui permet la transmission de données entre clients et serveurs. Le client envoie une requête et le serveur renvoie une réponse et fournit la ressource demandée. Les requêtes HTTP comprennent principalement les parties suivantes :

• Méthode HTTP (GET, POST, PUT, DELETE, etc.)
• URL
• En-tête de demande (informations d'en-tête de demande, y compris l'agent utilisateur, la langue, le type de contenu, etc.)
• Corps de la requête (facultatif, applicable à la méthode POST ou PUT)

La réponse contient généralement les parties suivantes :

• Code d'état (tel que 200 OK, 404 Not Found)
• En-tête de réponse (informations d'en-tête de réponse, y compris les informations du serveur type, heure, type de contenu, etc.)
• Corps de la réponse (contenu de la réponse)

L'en-tête HTTP peut contenir des cookies, et les cookies sont généralement utilisés pour l'authentification, la mémorisation des informations utilisateur, etc. Le cookie est stocké dans le navigateur du client et contient des données sur le site visité. Lorsque vous effectuez une requête HTTP, si vous devez vérifier votre identité, vous devez généralement transmettre les informations d'authentification via un cookie.

Golang lance une demande de cookie

Dans Golang, vous pouvez utiliser le package net/http dans la bibliothèque standard pour lancer des requêtes HTTP. Lorsque vous effectuez une demande, vous pouvez transmettre le cookie en définissant le champ Cookie dans l'en-tête HTTP, ou vous pouvez utiliser le package cookies pour gérer facilement les cookies.

Ce qui suit est un exemple de code simple qui utilise le package net/http pour lancer une requête et obtenir un cookie :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 创建请求客户端
    client := &http.Client{}

    // 创建请求
    req, err := http.NewRequest("GET", "https://example.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 发送请求并获取响应
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    // 获取 Cookie
    cookies := resp.Cookies()
    for _, cookie := range cookies {
        fmt.Printf("%s: %s
", cookie.Name, cookie.Value)
    }
}

Le code ci-dessus crée un client de requête, utilise la méthode NewRequest pour créer une requête GET et envoie la requête pour obtenir la réponse. La réponse contient du contenu Cookie, utilisez la méthode resp.Cookies() pour obtenir les informations Cookie et parcourez l'impression.

Normalement, nous devons définir le champ Cookie dans l'en-tête de la requête pour transmettre les informations sur les cookies. Voici un exemple de lancement d'une requête en définissant le champ Cookie :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    // 创建请求
    req, err := http.NewRequest("GET", "https://example.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 设置 Cookie
    cookie := &http.Cookie{Name: "name", Value: "value"}
    req.AddCookie(cookie)

    // 发起请求并获取响应
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    // 获取响应内容
    fmt.Println(resp.Status)
}

Le code ci-dessus crée une requête GET et transmet req.AddCookie. (cookie) La méthode définit Cookie, puis utilise la méthode client.Do(req) dans le package net/http pour lancer une requête, obtenir la réponse et afficher le code d'état de la réponse.

Package Cookies

En plus de définir le champ Cookie et la méthode resp.Cookies(), nous pouvons également utiliser le package cookies pour gérer et traiter facilement les cookies. Le package propose les deux structures suivantes :

• Cookie : représente un Cookie HTTP.
• Jar : Représente une collection de cookies.

Voici un exemple d'utilisation du package cookies pour gérer les cookies :

package main

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

func main() {
    // 创建 Cookie 集合
    jar, err := cookiejar.New(nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 创建请求客户端
    client := &http.Client{
        Jar: jar,
    }

    // 创建请求
    req, err := http.NewRequest("GET", "https://example.com", nil)
    if err != nil {
        fmt.Println(err)
        return
    }

    // 发送请求并获取响应
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer resp.Body.Close()

    // 打印 Cookie
    cookies := jar.Cookies(req.URL)
    for _, cookie := range cookies {
        fmt.Printf("%s: %s
", cookie.Name, cookie.Value)
    }
}

Le code ci-dessus crée un CookieJar en utilisant le package cookiejar et le transmet au client demandeur, puis récupère le cookie via l'URL et imprime le résultat.

Conclusion

Cet article explique comment utiliser Golang pour lancer des requêtes HTTP avec des cookies. En plus des méthodes ci-dessus, vous pouvez également utiliser des bibliothèques tierces telles que GoRequest, gin framework, etc., qui ne seront pas présentées ici. En utilisation réelle, la méthode la plus appropriée doit être sélectionnée en fonction de la situation spécifique.

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!