go如何准确识别各种网络错误

package main

import (
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("https://example.com")
    if err != nil {
        // 错误做法：靠字符串包含判断错误类型
        if strings.Contains(err.Error(), "timeout") {
            fmt.Println("超时错误")
        } else if strings.Contains(err.Error(), "refused") {
            fmt.Println("连接被拒")
        } else {
            fmt.Println("未知错误")
        }
        return
    }
    defer resp.Body.Close()
}

type error interface {
        Error() string
}

type Error interface {
        error
        Timeout() bool   // Is the error a timeout?
        Temporary() bool // Is the error temporary?
}

type OpError struct {
        // Op is the operation which caused the error, such as
        // "dial", "read" or "write".
        Op string

        // Net is the network type on which this error occurred,
        // such as "tcp" or "udp6".
        Net string

        // For operations involving a remote network connection, like
        // Dial, Read, or Write, Source is the corresponding local
        // network address.
        Source Addr

        // Addr is the network address for which this error occurred.
        // For local operations, like Listen or SetDeadline, Addr is
        // the address of the local endpoint being manipulated.
        // For operations involving a remote network connection, like
        // Dial, Read, or Write, Addr is the remote address of that
        // connection.
        Addr Addr

        // Err is the error that occurred during the operation.
        Err error
}

func isCaredNetError(err error) bool {
    netErr, ok := err.(net.Error)
    if !ok {
        return false
    }

    if netErr.Timeout() {
        log.Println("timeout")
        return true
    }

    opErr, ok := netErr.(*net.OpError)
    if !ok {
        return false
    }

    switch t := opErr.Err.(type) {
    case *net.DNSError:
        log.Printf("net.DNSError:%+v", t)
        return true
    case *os.SyscallError:
        log.Printf("os.SyscallError:%+v", t)
        if errno, ok := t.Err.(syscall.Errno); ok {
            switch errno {
            case syscall.ECONNREFUSED:
                log.Println("connect refused")
                return true
            case syscall.ETIMEDOUT:
                log.Println("timeout")
                return true
            }
        }
    }

    return false
}

var netErr net.Error
if errors.As(err, &netErr) && netErr.Timeout() {
    // 是超时错误
}

resp, err := client.Get(url)
if err != nil {
    // 处理底层网络错误（如超时、连接被拒）
} else {
    defer resp.Body.Close()
    switch resp.StatusCode {
    case 408:
        fmt.Println("应用层超时：请求超时")
    case 503:
        fmt.Println("应用层错误：服务不可用（可重试）")
    case 200:
        fmt.Println("请求成功")
    default:
        fmt.Println("其他应用层错误：", resp.StatusCode)
    }
}