【Go语言快速上手】第二部分：Go语言进阶之网络编程

前言：网络编程

Go 语言提供了强大的网络编程能力，支持 TCP/UDP 协议的开发、HTTP 服务的构建，以及 WebSocket 协议的支持。通过内置的 net 和 net/http 包，Go 使得网络编程变得简洁高效。我们也可以使用第三方库，如 gorilla/websocket 来简化 WebSocket 的使用。

一、TCP/UDP 编程：net 包的使用

Go 的 net 包提供了多种方法来处理 TCP 和 UDP 网络编程。你可以通过它创建网络连接、发送和接收数据。

1. TCP 编程

TCP 是面向连接的协议，它保证数据的可靠传输。在 Go 中，可以使用 net 包提供的 Dial 和 Listen 方法来建立 TCP 客户端和服务器。

1.1 TCP 服务器

package main

import (
    "fmt"
    "net"
    "log"
)

func handleConnection(conn net.Conn) {
    fmt.Println("Client connected:", conn.RemoteAddr())
    defer conn.Close()
    conn.Write([]byte("Hello, client!"))
}

func main() {
    // 创建 TCP 监听
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    fmt.Println("Server is listening on port 8080...")
    for {
        conn, err := listener.Accept() // 接受客户端连接
        if err != nil {
            log.Fatal(err)
        }
        go handleConnection(conn) // 为每个连接启动一个 goroutine 处理
    }
}

1.2 TCP 客户端

package main

import (
    "fmt"
    "net"
    "log"
)

func main() {
    // 创建 TCP 客户端连接
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    // 接收并打印服务器返回的消息
    buffer := make([]byte, 1024)
    n, err := conn.Read(buffer)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Server says:", string(buffer[:n]))
}

2. UDP 编程

UDP 是无连接的协议，传输速度较快，但不保证数据的可靠性。在 Go 中，使用 net 包提供的 ListenUDP 和 DialUDP 方法来处理 UDP 通信。

2.1 UDP 服务器

package main

import (
    "fmt"
    "net"
    "log"
)

func main() {
    // 创建 UDP 监听地址
    addr, err := net.ResolveUDPAddr("udp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    buffer := make([]byte, 1024)
    for {
        n, clientAddr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("Received:", string(buffer[:n]), "from", clientAddr)
    }
}

2.2 UDP 客户端

package main

import (
    "fmt"
    "net"
    "log"
)

func main() {
    // 创建 UDP 目标地址
    serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
    if err != nil {
        log.Fatal(err)
    }

    // 创建 UDP 连接
    conn, err := net.DialUDP("udp", nil, serverAddr)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    // 发送数据
    message := []byte("Hello, UDP server!")
    _, err = conn.Write(message)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Message sent to server")
}

二、HTTP 编程：net/http 包的使用，编写 HTTP 服务器和客户端

Go 语言的 net/http 包提供了简单而强大的 HTTP 服务器和客户端功能。通过该包，你可以很容易地编写 HTTP 服务器，并与 HTTP 客户端进行通信。

2.1 HTTP 服务器

Go 提供了非常简洁的方式来构建 HTTP 服务器。你只需要实现处理请求的函数，并通过 http.HandleFunc 注册路由，然后调用 http.ListenAndServe 启动服务器。

package main

import (
    "fmt"
    "net/http"
)

func helloHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/hello", helloHandler) // 注册路由
    fmt.Println("Starting server on :8080...")
    http.ListenAndServe(":8080", nil) // 启动 HTTP 服务器
}

在这个示例中，HTTP 服务器会监听 8080 端口，并且在请求 /hello 路径时返回 Hello, World!。

2.2 HTTP 客户端

Go 语言的 http 包也提供了简单的方式来发起 HTTP 请求。你可以使用 http.Get、http.Post 等方法发起请求，并接收返回的响应。

package main

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

func main() {
    // 发起 GET 请求
    resp, err := http.Get("http://localhost:8080/hello")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

    // 打印响应状态和内容
    fmt.Println("Response Status:", resp.Status)
}

在这个示例中，客户端发起一个 GET 请求，访问服务器的 /hello 路径，获取服务器的响应。

三、WebSocket 编程：gorilla/websocket 包的使用

WebSocket 是一种在单个连接上进行全双工通信的协议。Go 中可以使用第三方库 gorilla/websocket 来实现 WebSocket 服务端和客户端。

3.1 WebSocket 服务器

首先，你需要安装 gorilla/websocket 包：

go get github.com/gorilla/websocket

然后，编写 WebSocket 服务器：

package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool { return true },
}

func handleConnection(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()

    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        if err := conn.WriteMessage(messageType, p); err != nil {
            log.Println(err)
            return
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleConnection)
    fmt.Println("WebSocket server is running on :8080...")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

3.2 WebSocket 客户端

WebSocket 客户端同样也可以使用 gorilla/websocket 包来连接到 WebSocket 服务器。

package main

import (
    "fmt"
    "log"
    "github.com/gorilla/websocket"
)

func main() {
    // 连接到 WebSocket 服务器
    conn, _, err := websocket.DefaultDialer.Dial("ws://localhost:8080/ws", nil)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    message := []byte("Hello, WebSocket server!")
    err = conn.WriteMessage(websocket.TextMessage, message)
    if err != nil {
        log.Fatal(err)
    }

    _, response, err := conn.ReadMessage()
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Received from server:", string(response))
}

在这个示例中，WebSocket 客户端连接到 WebSocket 服务器并发送消息，然后等待服务器的响应。