golang cookie request

When making an HTTP request in Golang, you usually need to use authentication information such as cookies, and you also need to obtain cookies. This article will introduce how to use Golang to initiate an HTTP request with cookies and save the cookie to a variable for subsequent use.

Introduction to HTTP and Cookies

HTTP (Hypertext Transfer Protocol) is a protocol that enables data transfer between clients and servers. The client sends a request and the server returns a response and provides the requested resource. HTTP requests mainly include the following parts:

• HTTP method (GET, POST, PUT, DELETE, etc.)
• URL
• Request header (request header information, Contains user agent, language, content type, etc.)
• Request body (optional, applicable to POST or PUT method)

And the response usually contains the following parts:

• Status code (such as 200 OK, 404 Not Found)
• Response header (response header information, including server type, time, content type, etc.)
• Response body (response content )

HTTP header can contain cookies, and cookies are usually used for authentication, remembering user information, etc. The cookie is stored in the client's browser and contains data about the site visited. When making an HTTP request, if you need to verify your identity, you usually need to pass the authentication information through a cookie.

Golang initiates a Cookie request

In Golang, you can use the net/http package in the standard library to initiate an HTTP request. When making a request, you can pass the cookie by setting the Cookie field in the HTTP header, or you can use the cookies package to conveniently manage cookies.

The following is a simple sample code that uses the net/http package to initiate a request and obtain 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)
    }
}

The above code creates a request client, uses the NewRequest method to create a GET request, and Send a request to get a response. The response contains Cookie content, use the resp.Cookies() method to obtain the Cookie information and iterate through the printout.

Normally, we need to set the Cookie field in the request header to pass Cookie information. The following is an example of initiating a request by setting the Cookie field:

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

The above code creates a GET request, And set the Cookie through the req.AddCookie(cookie) method, and then use the client.Do(req) method in the net/http package to initiate a request, obtain the response and output the response status code.

Cookies package

In addition to setting the Cookie field and the resp.Cookies() method, we can also use the cookies package to conveniently manage and process Cookies. The package provides the following two structures:

• Cookie: represents an HTTP Cookie.
• Jar: Represents a Cookie collection.

The following is an example of using the cookies package to manage 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)
    }
}

The above code creates a CookieJar by using the cookiejar package and passes it to the requesting client, and then obtains the Cookie through the URL and Printout.

Conclusion

This article introduces how to use Golang to initiate HTTP requests with cookies. In addition to the above methods, you can also use third-party libraries such as GoRequest, gin framework, etc., which will not be introduced here. In actual use, the most suitable method should be selected according to the specific situation.

The above is the detailed content of golang cookie request. For more information, please follow other related articles on the PHP Chinese website!