37、Go语言网络编程基础

eee77

于 2025-11-23 11:53:29 发布

阅读量12

点赞数

CC 4.0 BY-SA版权

分类专栏：掌握Go：从入门到精通文章标签： Go语言网络编程 HTTP跟踪

本文链接：https://blog.youkuaiyun.com/eee77/article/details/155250012

掌握Go：从入门到精通专栏收录该内容

40 篇文章 ¥499.90

订阅专栏¥69.90

会员秒杀 ¥9.9 重磅福利

超级会员免费看

Go语言网络编程基础

1. 开发网站和Web应用

可以使用Go开发完整的网站和Web应用，如 kvWeb.go 示例所示。虽然需求各异，但开发技术是相通的，并且定制网站通常比使用流行内容管理系统创建的网站更安全。

2. HTTP跟踪

Go借助 net/http/httptrace 标准包支持HTTP跟踪，该包可跟踪HTTP请求的各个阶段。以下是 httpTrace.go 的代码实现：

package main
import (
    "fmt"
    "io"
    "net/http"
    "net/http/httptrace"
    "os"
)
func main() {
    if len(os.Args) != 2 {
        fmt.Printf("Usage: URL\n")
        return
    }
    URL := os.Args[1]
    client := http.Client{}
    req, _ := http.NewRequest("GET", URL, nil)
    trace := &httptrace.ClientTrace{
        GotFirstResponseByte: func() {
            fmt.Println("First response byte!")
        },
        GotConn: func(connInfo httptrace.GotConnInfo) {
            fmt.Printf("Got Conn: %+v\n", connInfo)
        },
        DNSDone: func(dnsInfo httptrace.DNSDoneInfo) {
            fmt.Printf("DNS Info: %+v\n", dnsInfo)
        },
        ConnectStart: func(network, addr string) {
            fmt.Println("Dial start")
        },
        ConnectDone: func(network, addr string, err error) {
            fmt.Println("Dial done")
        },
        WroteHeaders: func() {
            fmt.Println("Wrote headers")
        },
    }
    req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
    fmt.Println("Requesting data from server!")
    _, err := http.DefaultTransport.RoundTrip(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    response, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    io.Copy(os.Stdout, response.Body)
}

执行 httpTrace.go 会生成详细的输出，展示HTTP请求的各个阶段信息。

2.1 `httpTrace.go` 执行步骤

导入必要的包，包括 net/http/httptrace 以启用HTTP跟踪。
读取命令行参数，获取要请求的URL，并创建一个 http.Client 对象。
创建一个 http.Request 对象，并设置跟踪信息。
执行请求并跟踪各个阶段的事件。
获取响应并将其内容输出到标准输出。

3. 测试HTTP处理程序

测试HTTP处理程序是Go中测试的一个特殊情况。以下是 testWWW.go 和 testWWW_test.go 的代码实现：

3.1 `testWWW.go` 代码

package main
import (
    "fmt"
    "net/http"
    "os"
)
func CheckStatusOK(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusOK)
    fmt.Fprintf(w, `Fine!`)
}
func StatusNotFound(w http.ResponseWriter, r *http.Request) {
    w.WriteHeader(http.StatusNotFound)
}
func MyHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Serving: %s\n", r.URL.Path)
    fmt.Printf("Served: %s\n", r.Host)
}
func main() {
    PORT := ":8001"
    arguments := os.Args
    if len(arguments) == 1 {
        fmt.Println("Using default port number: ", PORT)
    } else {
        PORT = ":" + arguments[1]
    }
    http.HandleFunc("/CheckStatusOK", CheckStatusOK)
    http.HandleFunc("/StatusNotFound", StatusNotFound)
    http.HandleFunc("/", MyHandler)
    err := http.ListenAndServe(PORT, nil)
    if err != nil {
        fmt.Println(err)
        return
    }
}

3.2 `testWWW_test.go` 代码

package main
import (
    "fmt"
    "net/http"
    "net/http/httptest"
    "testing"
)
func TestCheckStatusOK(t *testing.T) {
    req, err := http.NewRequest("GET", "/CheckStatusOK", nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(CheckStatusOK)
    handler.ServeHTTP(rr, req)
    status := rr.Code
    if status != http.StatusOK {
        t.Errorf("handler returned %v", status)
    }
    expect := `Fine!`
    if rr.Body.String() != expect {
        t.Errorf("handler returned %v", rr.Body.String())
    }
}
func TestStatusNotFound(t *testing.T) {
    req, err := http.NewRequest("GET", "/StatusNotFound", nil)
    if err != nil {
        fmt.Println(err)
        return
    }
    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(StatusNotFound)
    handler.ServeHTTP(rr, req)
    status := rr.Code
    if status != http.StatusNotFound {
        t.Errorf("handler returned %v", status)
    }
}

3.3 测试步骤

创建 testWWW.go 文件，定义HTTP处理函数。
创建 testWWW_test.go 文件，导入 net/http/httptest 包进行测试。
编写测试函数，使用 httptest.NewRecorder() 记录HTTP响应。
验证响应状态码和响应体是否符合预期。

4. 创建Web客户端

4.1 简单Web客户端 `webClient.go`

package main
import (
    "fmt"
    "io"
    "net/http"
    "os"
    "path/filepath"
)
func main() {
    if len(os.Args) != 2 {
        fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0]))
        return
    }
    URL := os.Args[1]
    data, err := http.Get(URL)
    if err != nil {
        fmt.Println(err)
        return
    } else {
        defer data.Body.Close()
        _, err := io.Copy(os.Stdout, data.Body)
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

4.2 操作步骤

导入必要的包。
读取命令行参数，获取要请求的URL。
使用 http.Get() 发送请求并获取响应。
将响应内容复制到标准输出。

4.3 存在的问题

webClient.go 几乎没有提供对请求过程的控制，要么获取整个HTML输出，要么什么都得不到。

5. 高级Web客户端

5.1 `advancedWebClient.go` 代码

package main
import (
    "fmt"
    "net/http"
    "net/http/httputil"
    "net/url"
    "os"
    "path/filepath"
    "strings"
    "time"
)
func main() {
    if len(os.Args) != 2 {
        fmt.Printf("Usage: %s URL\n", filepath.Base(os.Args[0]))
        return
    }
    URL, err := url.Parse(os.Args[1])
    if err != nil {
        fmt.Println("Error in parsing:", err)
        return
    }
    c := &http.Client{
        Timeout: 15 * time.Second,
    }
    request, err := http.NewRequest("GET", URL.String(), nil)
    if err != nil {
        fmt.Println("Get:", err)
        return
    }
    httpData, err := c.Do(request)
    if err != nil {
        fmt.Println("Error in Do():", err)
        return
    }
    fmt.Println("Status code:", httpData.Status)
    header, _ := httputil.DumpResponse(httpData, false)
    fmt.Print(string(header))
    contentType := httpData.Header.Get("Content-Type")
    characterSet := strings.SplitAfter(contentType, "charset=")
    if len(characterSet) > 1 {
        fmt.Println("Character Set:", characterSet[1])
    }
    if httpData.ContentLength == -1 {
        fmt.Println("ContentLength is unknown!")
    } else {
        fmt.Println("ContentLength:", httpData.ContentLength)
    }
    length := 0
    var buffer [1024]byte
    r := httpData.Body
    for {
        n, err := r.Read(buffer[0:])
        if err != nil {
            fmt.Println(err)
            break
        }
        length = length + n
    }
    fmt.Println("Calculated response data length:", length)
}

5.2 操作步骤

导入必要的包。
读取命令行参数，解析URL。
创建 http.Client 对象并设置超时时间。
创建 http.Request 对象并发送请求。
处理响应，输出状态码、响应头、字符集和内容长度。
计算响应数据的长度。

5.3 优点

advancedWebClient.go 提供了更多的控制和选项，比 webClient.go 更灵活。

6. HTTP连接超时处理

可以使用 clientTimeOut.go 实现HTTP连接超时处理，代码如下：

package main
import (
    "fmt"
    "io"
    "net"
    "net/http"
    "os"
    "path/filepath"
    "strconv"
    "time"
)
var timeout = time.Duration(time.Second)
func Timeout(network, host string) (net.Conn, error) {
    conn, err := net.DialTimeout(network, host, timeout)
    if err != nil {
        return nil, err
    }
    conn.SetDeadline(time.Now().Add(timeout))
    return conn, nil
}
func main() {
    if len(os.Args) == 1 {
        fmt.Printf("Usage: %s URL TIMEOUT\n", filepath.Base(os.Args[0]))
        return
    }
    if len(os.Args) == 3 {
        temp, err := strconv.Atoi(os.Args[2])
        if err != nil {
            fmt.Println("Using Default Timeout!")
        } else {
            timeout = time.Duration(time.Duration(temp) * time.Second)
        }
    }
    URL := os.Args[1]
    t := http.Transport{
        Dial: Timeout,
    }
    client := http.Client{
        Transport: &t,
    }
    data, err := client.Get(URL)
    if err != nil {
        fmt.Println(err)
        return
    } else {
        defer data.Body.Close()
        _, err := io.Copy(os.Stdout, data.Body)
        if err != nil {
            fmt.Println(err)
            return
        }
    }
}

6.1 操作步骤

导入必要的包。
定义默认超时时间。
实现 Timeout() 函数，用于设置连接超时和读写截止时间。
读取命令行参数，设置超时时间。
创建 http.Transport 和 http.Client 对象。
发送请求并处理响应。

6.2 `SetDeadline()` 函数说明

SetDeadline() 函数由 net 包用于设置网络连接的读写截止时间。在进行任何读写操作之前需要调用该函数，并且Go使用截止时间来实现超时，因此无需在每次应用程序接收或发送数据时重置。

以下是一个简单的流程图，展示 clientTimeOut.go 的执行流程：

graph TD;
    A[开始] --> B{参数检查};
    B -- 参数不足 --> C[输出使用说明并退出];
    B -- 参数足够 --> D{是否指定超时时间};
    D -- 是 --> E[设置超时时间];
    D -- 否 --> F[使用默认超时时间];
    E --> G[创建http.Transport和http.Client];
    F --> G;
    G --> H[发送HTTP请求];
    H -- 出错 --> I[输出错误信息并退出];
    H -- 成功 --> J[处理响应并输出];
    J --> K[结束];
    C --> K;
    I --> K;

通过以上内容，我们学习了如何使用Go进行网站和Web应用开发、HTTP跟踪、测试HTTP处理程序、创建Web客户端以及处理HTTP连接超时等操作。这些技术可以帮助我们更好地开发和调试网络应用程序。

7. 各代码功能总结对比

为了更清晰地了解上述不同代码的功能和特点，我们可以通过以下表格进行对比：
| 代码名称 | 功能描述 | 优点 | 缺点 |
| ---- | ---- | ---- | ---- |
| kvWeb.go | 用于开发网站和Web应用，可更新键值存储中键的值 | 可用于开发完整网站和应用，定制化程度高，更安全 | 代码不完善，需要进一步优化 |
| httpTrace.go | 实现HTTP请求跟踪，展示请求各阶段信息 | 能详细跟踪HTTP请求各阶段，便于调试 | 代码相对复杂，对于简单请求可能过于繁琐 |
| testWWW.go | 定义HTTP处理函数，用于处理不同请求 | 可自定义处理函数，满足不同业务需求 | 需配合测试文件使用 |
| testWWW_test.go | 测试 testWWW.go 中的HTTP处理函数 | 确保处理函数按预期工作，提高代码稳定性 | 仅能测试特定处理函数，覆盖范围有限 |
| webClient.go | 简单的Web客户端，获取指定URL的HTML内容 | 代码简单，使用方便 | 缺乏对请求过程的控制，灵活性差 |
| advancedWebClient.go | 高级Web客户端，提供更多控制和选项 | 可设置超时时间，获取更多响应信息，更灵活 | 代码相对复杂，学习成本较高 |
| clientTimeOut.go | 实现HTTP连接超时处理 | 可避免长时间无响应的连接，提高性能 | 需要手动设置超时时间，不够智能 |

8. 实际应用场景分析

8.1 网站开发与维护

开发阶段 ：使用 kvWeb.go 可以快速搭建网站的基础架构，开发完整的Web应用。同时， httpTrace.go 可用于调试HTTP请求，帮助开发者了解请求的各个阶段，及时发现和解决问题。
维护阶段 ： testWWW.go 和 testWWW_test.go 可用于对网站的HTTP处理程序进行测试，确保其在各种情况下都能正常工作，提高网站的稳定性和可靠性。

8.2 数据抓取与分析

简单数据抓取 ：对于只需要获取网页HTML内容的简单需求， webClient.go 是一个不错的选择，它代码简单，使用方便。
复杂数据抓取 ：当需要对请求过程进行更多控制，如设置超时时间、获取响应头信息等， advancedWebClient.go 则更为合适。

8.3 网络性能优化

在网络环境不稳定或服务器响应较慢的情况下， clientTimeOut.go 可以避免长时间无响应的连接，提高应用程序的性能和用户体验。

9. 代码优化建议

9.1 `kvWeb.go`

增加错误处理机制，提高代码的健壮性。
优化用户界面，提升用户体验。

9.2 `httpTrace.go`

封装跟踪逻辑，减少代码重复，提高代码的可维护性。
提供更多的跟踪选项，满足不同的调试需求。

9.3 `testWWW.go` 和 `testWWW_test.go`

增加更多的测试用例，覆盖更多的业务场景。
优化测试代码，提高测试效率。

9.4 `webClient.go`

增加对请求参数和选项的支持，提高灵活性。
实现分页抓取和数据筛选功能，满足更复杂的需求。

9.5 `advancedWebClient.go`

优化超时时间的设置方式，根据不同的请求自动调整超时时间。
增加对响应数据的解析和处理功能，方便后续分析。

9.6 `clientTimeOut.go`

实现动态调整超时时间的功能，根据网络状况自动优化。
增加对不同超时错误的处理逻辑，提供更详细的错误信息。

10. 总结与展望

通过对上述代码的学习和分析，我们掌握了使用Go进行网络编程的多种技术，包括网站和Web应用开发、HTTP跟踪、测试HTTP处理程序、创建Web客户端以及处理HTTP连接超时等。这些技术在实际应用中具有重要的价值，可以帮助我们开发出高效、稳定、安全的网络应用程序。

未来，随着互联网技术的不断发展，网络编程的需求也会越来越多样化和复杂化。我们可以进一步探索Go语言的更多特性和功能，结合其他技术如机器学习、大数据等，开发出更加强大的网络应用。同时，不断优化代码，提高程序的性能和可靠性，以适应不断变化的市场需求。

以下是一个总结性的流程图，展示整个网络编程流程：

graph TD;
    A[开始] --> B[选择开发方向];
    B -- 网站开发 --> C[使用kvWeb.go搭建架构];
    B -- 数据抓取 --> D{简单或复杂需求};
    D -- 简单需求 --> E[使用webClient.go];
    D -- 复杂需求 --> F[使用advancedWebClient.go];
    C --> G[使用httpTrace.go调试];
    C --> H[使用testWWW.go和testWWW_test.go测试];
    E --> I[获取数据];
    F --> I;
    G --> J{是否有问题};
    J -- 是 --> K[优化代码];
    J -- 否 --> L[继续开发];
    H --> J;
    K --> L;
    L --> M[处理HTTP连接超时];
    M --> N[使用clientTimeOut.go];
    N --> O[完成开发];
    I --> P[数据处理与分析];
    P --> Q[得出结论];
    Q --> R[应用结果];
    O --> R;
    R --> S[结束];

希望本文能为大家在Go语言网络编程方面提供一些帮助和启发，让大家在实际开发中能够更加得心应手。