permintaan biskut golang

Apabila membuat permintaan HTTP di Golang, anda biasanya perlu menggunakan maklumat pengesahan seperti kuki, dan anda juga perlu mendapatkan kuki. Artikel ini akan memperkenalkan cara menggunakan Golang untuk memulakan permintaan HTTP dengan kuki dan menyimpan kuki kepada pembolehubah untuk kegunaan seterusnya.

Pengenalan kepada HTTP dan Kuki

HTTP (Hypertext Transfer Protocol) ialah protokol yang membolehkan pemindahan data antara pelanggan dan pelayan. Pelanggan menghantar permintaan dan pelayan mengembalikan respons dan menyediakan sumber yang diminta. Permintaan HTTP terutamanya termasuk bahagian berikut:

• Kaedah HTTP (GET, POST, PUT, DELETE, dll.)
• URL
• Minta pengepala (minta maklumat pengepala , Mengandungi ejen pengguna, bahasa, jenis kandungan, dll.)
• Isi permintaan (pilihan, untuk kaedah POST atau PUT)

Dan respons biasanya mengandungi bahagian berikut:

• Kod status (seperti 200 OK, 404 Tidak Ditemui)
• Pengepala respons (maklumat pengepala respons, termasuk jenis pelayan, masa, jenis kandungan, dll.)
• Badan respons (kandungan respons )

Pengepala HTTP boleh mengandungi kuki dan kuki biasanya digunakan untuk pengesahan, mengingati maklumat pengguna, dsb. Kuki disimpan dalam penyemak imbas pelanggan dan mengandungi data tentang tapak yang dilawati. Apabila membuat permintaan HTTP, jika anda perlu mengesahkan identiti anda, anda biasanya perlu menghantar maklumat pengesahan melalui kuki.

Golang memulakan permintaan Kuki

Di Golang, anda boleh menggunakan pakej net/http dalam pustaka standard untuk memulakan permintaan HTTP. Apabila membuat permintaan, anda boleh menghantar kuki dengan menetapkan medan Kuki dalam pengepala HTTP, atau anda boleh menggunakan pakej kuki untuk mengurus kuki dengan mudah.

Berikut ialah contoh kod mudah yang menggunakan pakej net/http untuk memulakan permintaan dan mendapatkan kuki:

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

Kod di atas mencipta klien permintaan, menggunakan kaedah NewRequest untuk mencipta permintaan GET, dan Hantar permintaan untuk mendapatkan respons. Respons mengandungi kandungan Kuki Gunakan kaedah resp.Cookies() untuk mendapatkan maklumat Kuki dan lelaran melalui cetakan.

Biasanya, kita perlu menetapkan medan Kuki dalam pengepala permintaan untuk menghantar maklumat Kuki Berikut ialah contoh untuk memulakan permintaan dengan menetapkan medan Kuki:

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

Kod di atas mencipta. permintaan GET, Dan tetapkan Cookie melalui kaedah req.AddCookie(cookie), dan kemudian gunakan kaedah klien.Do(req) dalam pakej net/http untuk memulakan permintaan, dapatkan respons dan keluarkan kod status respons.

Pakej kuki

Selain menetapkan medan Kuki dan kaedah resp.Cookies(), kami juga boleh menggunakan pakej kuki untuk mengurus dan memproses Kuki dengan mudah. Pakej ini menyediakan dua struktur berikut:

• Kuki: mewakili Kuki HTTP.
• Balang: Mewakili koleksi Kuki.

Berikut ialah contoh menggunakan pakej kuki untuk mengurus kuki:

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

Kod di atas mencipta CookieJar dengan menggunakan pakej cookiejar dan menyerahkannya kepada pelanggan yang meminta, kemudian mendapatkan kuki melalui URL dan Cetakan.

Kesimpulan

Artikel ini memperkenalkan cara menggunakan Golang untuk memulakan permintaan HTTP dengan kuki. Selain kaedah di atas, anda juga boleh menggunakan perpustakaan pihak ketiga seperti GoRequest, rangka kerja gin, dsb., yang tidak akan diperkenalkan di sini. Dalam penggunaan sebenar, kaedah yang paling sesuai harus dipilih mengikut situasi tertentu.

Atas ialah kandungan terperinci permintaan biskut golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!