Error handling in Golang: How to handle network request errors

Error handling in Golang: How to handle network request errors

Introduction:
In network programming, network request errors are often encountered, such as request timeout, connection interruption, etc. A good error handling mechanism can not only improve the stability of the program, but also enhance the user experience. This article will introduce how to handle network request errors in Golang and provide code examples.

1. Basic error handling
   In Golang, error handling is implemented by returning an error value. Normally, a function returns a non-null error value when the operation cannot be performed successfully.

Sample code:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("https://www.example.com")
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

    // 处理响应数据
    // ...
}

In the above example, if an error occurs in the request, the error message will be printed and returned early. Doing so ensures that errors can be caught and handled in a timely manner to avoid errors that may result from continued execution of the program.

2. Continuous multiple request error handling
   In actual development, it is often necessary to send network requests multiple times in a row. When an error occurs in a request, corresponding error handling needs to be carried out according to the specific situation.

Sample code:

package main

import (
    "fmt"
    "net/http"
)

func main() {
    urls := []string{"https://www.example1.com", "https://www.example2.com", "https://www.example3.com"}

    for _, url := range urls {
        resp, err := http.Get(url)
        if err != nil {
            fmt.Println("请求错误：", err)
            continue
        }
        defer resp.Body.Close()

        // 处理响应数据
        // ...
    }
}

In the above example, if an error occurs in a request, the error message will be printed and the next request will continue. By using the continue statement, a program can continue looping execution in the event of an error.

3. Timeout processing
   Network requests often need to set a timeout to prevent unexpected situations during the request process from causing the program to be blocked for a long time. In Golang, you can use the time package to set the timeout and implement timeout control through the context package.

Sample code:

package main

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

func main() {
    timeout := time.Duration(5 * time.Second)
    ctx, cancel := context.WithTimeout(context.Background(), timeout)
    defer cancel()

    req, err := http.NewRequest(http.MethodGet, "https://www.example.com", nil)
    if err != nil {
        fmt.Println("创建请求错误：", err)
        return
    }

    req = req.WithContext(ctx)
    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("请求错误：", err)
        return
    }
    defer resp.Body.Close()

    // 处理响应数据
    // ...
}

In the above example, a context with a timeout is created through context.WithTimeout as the context of the request , and use http.Client to send the request. When the set timeout period is exceeded, the request will be automatically canceled, avoiding the problem of request blocking.

Conclusion:
A good error handling mechanism is an important part of writing a stable network request program. In Golang, we can implement error handling by returning error values, combined with appropriate control structures and context timeout settings, to achieve reliable network request error handling.

Reference materials:

• Golang official documentation: https://golang.org/pkg/net/http/
• Golang official documentation: https:// golang.org/pkg/context/
• How to handle errors in Go：https://go.dev/blog/error-handling-and-go

The above is the detailed content of Error handling in Golang: How to handle network request errors. For more information, please follow other related articles on the PHP Chinese website!