How to implement timeout handling of requests using http.Transport in Go?

How to use http.Transport to implement timeout processing of requests in Go?

In the Go language, we often need to send HTTP requests to obtain data or interact with external APIs. However, due to the complexity of the network environment, request timeouts may sometimes be encountered. In order to avoid the problem of long wait and failure to obtain a response in time, we can use Go's http.Transport to implement timeout processing of requests.

In Go, http.Transport is a structure that is responsible for managing the HTTP client's connection reuse and request transmission. In order to implement timeout processing, we can use the Timeout attribute in http.Transport. The specific steps are as follows:

1. Introduce the necessary packages

In order to use http.Transport and http.Client, we need to first introduce the relevant packages.

package main

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

2. Create http.Client object

In Go, http.Client represents an HTTP client, and we need to use it to send requests. We can get an http.Transport object by calling the Transport method of http.Client and set the timeout.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }
}

In the above code, we set the ResponseHeaderTimeout to 5 seconds. This means that if no response headers are received within 5 seconds, the request will be automatically canceled.

3. Send HTTP request

After setting the http.Client object, we can use it to send HTTP requests.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://api.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }

    defer resp.Body.Close()

    // 处理响应
}

In the above code, we use the client.Get method to send a GET request to "https://api.example.com". If no response header information is received within 5 seconds, the request will be automatically canceled and an error will be returned.

4. Handling the response

After receiving the response, we can process it. Here is just a simple example to read the content of the response.

func main() {
    transport := &http.Transport{
        ResponseHeaderTimeout: time.Second * 5,
    }
    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://api.example.com")
    if err != nil {
        fmt.Println("请求出错:", err)
        return
    }

    defer resp.Body.Close()

    // 处理响应
    body, _ := ioutil.ReadAll(resp.Body)
    fmt.Println("响应内容:", string(body))
}

The above is how to use http.Transport in Go language to implement timeout processing of requests. By setting the Timeout property of http.Transport and using http.Client to send requests and receive responses, we can easily implement timeout processing logic. This can not only improve the robustness of the program, but also avoid blocking of the program due to the inability to obtain a response in time due to long waits.

The above is the detailed content of How to implement timeout handling of requests using http.Transport in Go?. For more information, please follow other related articles on the PHP Chinese website!