Golang http request takes time

Golang is a programming language that is very suitable for network programming. Golang provides very easy-to-use standard libraries, such as net/http. This library provides the function of creating and sending HTTP requests and receiving responses. In actual projects, we sometimes need to calculate the time consumption of HTTP requests, so that we can better perform performance evaluation and optimization. This article will introduce how to calculate the time consumption of HTTP requests in Golang.

HTTP request time-consuming calculation

Before calculating the HTTP request time-consuming, we need to understand the life cycle of the HTTP request. The life cycle of an HTTP request is mainly divided into the following four stages.

1. DNS resolution: resolve the domain name to an IP address
2. TCP connection: establish a TCP connection through the IP address
3. Server processing request: The server processes the HTTP request for processing Search for resources and other operations
4. Response content transmission: The server transmits the response text to the client

In Golang, we can passtime## of the standard library #Now() function is used to record the time at a certain point in time, and then calculate the time consumption of the HTTP request through the time difference. Below we will introduce in turn the calculation method of the HTTP request time in the above four stages.

DNS resolution takes time

In Golang, we can perform DNS resolution through the

net.LookupIP() function. This function receives a hostname as a parameter and returns a list of its corresponding IP addresses. We can record the time points before DNS resolution and after DNS resolution, and then calculate the time difference to get the DNS resolution time. The following is a sample code that takes time to resolve DNS:

start := time.Now()
ips, err := net.LookupIP("www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to resolve DNS:", err)
    return
}
dnsTime := end.Sub(start)
fmt.Println("DNS resolution time:", dnsTime)

TCP connection takes time

In Golang, we can pass

net.Dial()Function to establish TCP connection. This function receives two parameters, the first parameter is the protocol ("tcp" or "tcp4" or "tcp6"), and the second parameter is the target host name or IP address plus port number (for example: "example.com:80" "). We can record the time points before and after the TCP connection is established, and then calculate the time difference to get the TCP connection time. The following is a sample code that takes time for a TCP connection:

start := time.Now()
conn, err := net.Dial("tcp", "www.example.com:80")
end := time.Now()
if err != nil {
    fmt.Println("Failed to connect to server:", err)
    return
}
connTime := end.Sub(start)
fmt.Println("TCP connection time:", connTime)

It takes time for the server to process the request

In Golang, through the

http.Client type The Do() function can send an HTTP request and return a response. We can record the time point before sending the request, and then record the time point after receiving the response. By calculating the time difference, we can get the time it takes for the server to process the request. The following is a sample code that takes time for the server to process the request:

start := time.Now()
resp, err := http.Get("http://www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
serverTime := end.Sub(start)
fmt.Println("Server response time:", serverTime)

It takes time to send the response content

In Golang, through

http.Client The Do() function of type can send an HTTP request and return a response. We can record the time point after getting the response, and then record the time point after the response content transmission is completed. By calculating the time difference, we can get the elapsed time of the response content transmission time. The following is a sample code that shows the time taken to transmit response content:

start := time.Now()
resp, err := http.Get("http://www.example.com")
end := time.Now()
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
transferTime := end.Sub(start)
fmt.Println("Server response time:", transferTime)

The sum of the time spent in the above four stages is the total time taken by the HTTP request. We can put the above code snippets together to calculate the total time spent on HTTP requests. The following is a sample code for calculating the total time-consuming of HTTP requests:

start := time.Now()
ips, err := net.LookupIP("www.example.com")
if err != nil {
    fmt.Println("Failed to resolve DNS:", err)
    return
}

conn, err := net.Dial("tcp", ips[0].String()+":80")
if err != nil {
    fmt.Println("Failed to connect to server:", err)
    return
}
connTime := time.Now().Sub(start)

req, err := http.NewRequest("GET", "http://www.example.com", nil)
if err != nil {
    fmt.Println("Failed to create HTTP request:", err)
    return
}

start = time.Now()
resp, err := http.DefaultClient.Do(req)
if err != nil {
    fmt.Println("Failed to get response:", err)
    return
}
body, _ := ioutil.ReadAll(resp.Body)
defer resp.Body.Close()
serverTime := time.Now().Sub(start)

transferTime := time.Now().Sub(start)
totalTime := connTime + serverTime + transferTime
fmt.Println("HTTP request total time:", totalTime)

Summary

The above is the method for calculating the time-consuming of HTTP requests in Golang. By separately calculating the DNS resolution time, TCP connection time, server processing request time, and response content delivery time, we can better evaluate and optimize the performance of network requests.

The above is the detailed content of Golang http request takes time. For more information, please follow other related articles on the PHP Chinese website!