Golang-Cookie-Anfrage

Wenn Sie eine HTTP-Anfrage in Golang stellen, müssen Sie normalerweise Authentifizierungsinformationen wie Cookies verwenden und auch Cookies erhalten. In diesem Artikel wird erläutert, wie Sie mit Golang eine HTTP-Anfrage mit Cookies initiieren und das Cookie zur späteren Verwendung in einer Variablen speichern.

Einführung in HTTP und Cookies

HTTP (Hypertext Transfer Protocol) ist ein Protokoll, das die Datenübertragung zwischen Clients und Servern ermöglicht. Der Client sendet eine Anfrage und der Server gibt eine Antwort zurück und stellt die angeforderte Ressource bereit. HTTP-Anfragen umfassen hauptsächlich die folgenden Teile:

• HTTP-Methode (GET, POST, PUT, DELETE usw.)
• URL
• Anforderungsheader (Anforderungsheaderinformationen, einschließlich Benutzeragent, Sprache, Inhaltstyp usw.)
• Anfragetext (Optional, anwendbar auf POST- oder PUT-Methode)

Die Antwort enthält normalerweise die folgenden Teile:

• Statuscode (z. B. 200 OK, 404 Nicht gefunden)
• Antwortheader (Antwortheaderinformationen, einschließlich Server Typ, Zeit, Inhaltstyp usw.)
• Antworttext (Inhalt der Antwort)

Der HTTP-Header kann Cookies enthalten und Cookies werden normalerweise zur Authentifizierung, zum Speichern von Benutzerinformationen usw. verwendet. Das Cookie wird im Browser des Kunden gespeichert und enthält Daten über die besuchte Website. Wenn Sie bei einer HTTP-Anfrage Ihre Identität überprüfen müssen, müssen Sie die Authentifizierungsinformationen normalerweise über ein Cookie übergeben.

Golang initiiert Cookie-Anfrage

In Golang können Sie das Paket net/http in der Standardbibliothek verwenden, um HTTP-Anfragen zu initiieren. Wenn Sie eine Anfrage stellen, können Sie das Cookie übergeben, indem Sie das Cookie-Feld im HTTP-Header festlegen, oder Sie können das Cookies-Paket verwenden, um Cookies bequem zu verwalten.

Das Folgende ist ein einfacher Beispielcode, der das Paket net/http verwendet, um eine Anfrage zu initiieren und ein Cookie zu erhalten:

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)
    }
}

Der obige Code erstellt einen Anfrage-Client, verwendet die NewRequest-Methode, um eine GET-Anfrage zu erstellen, und sendet die Anfrage um die Antwort zu bekommen. Die Antwort enthält Cookie-Inhalte. Verwenden Sie die resp.Cookies()-Methode, um die Cookie-Informationen abzurufen und den Ausdruck zu durchlaufen.

Normalerweise müssen wir das Cookie-Feld im Anforderungsheader festlegen, um Cookie-Informationen zu übergeben. Das Folgende ist ein Beispiel für das Initiieren einer Anforderung durch Setzen des Cookie-Felds:

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)
}

Der obige Code erstellt eine GET-Anfrage und übergibt req.AddCookie (Cookie) Die Methode setzt Cookie und verwendet dann die Methode client.Do(req) im Paket net/http, um eine Anfrage zu initiieren, die Antwort abzurufen und den Antwortstatuscode auszugeben.

Cookies-Paket

Neben dem Setzen des Cookie-Feldes und der resp.Cookies()-Methode können wir auch das Cookies-Paket verwenden, um Cookies bequem zu verwalten und zu verarbeiten. Das Paket stellt die folgenden zwei Strukturen bereit:

• Cookie: stellt ein HTTP-Cookie dar.
• Jar: Stellt eine Cookie-Sammlung dar.

Hier ist ein Beispiel für die Verwendung des Cookies-Pakets zum Verwalten von 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)
    }
}

Der obige Code erstellt mithilfe des Cookiejar-Pakets ein CookieJar und übergibt es an den anfordernden Client, ruft dann das Cookie über die URL ab und gibt die Ausgabe aus.

Fazit

In diesem Artikel wird erläutert, wie Sie mit Golang HTTP-Anfragen mit Cookies initiieren. Zusätzlich zu den oben genannten Methoden können Sie auch Bibliotheken von Drittanbietern wie GoRequest, Gin Framework usw. verwenden, die hier nicht vorgestellt werden. Im tatsächlichen Einsatz sollte je nach Situation die am besten geeignete Methode ausgewählt werden.

Das obige ist der detaillierte Inhalt vonGolang-Cookie-Anfrage. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!