Go 語(yǔ)言高級(jí)網(wǎng)絡(luò)編程
作者：Slagga
Go（Golang）中的網(wǎng)絡(luò)編程具有易用性、強(qiáng)大性和樂(lè)趣。本指南深入探討了網(wǎng)絡(luò)編程的復(fù)雜性，涵蓋了協(xié)議、TCP/UDP 套接字、并發(fā)等方面的內(nèi)容，并附有詳細(xì)的注釋。
一、簡(jiǎn)介
Go（Golang）中的網(wǎng)絡(luò)編程具有易用性、強(qiáng)大性和樂(lè)趣。本指南深入探討了網(wǎng)絡(luò)編程的復(fù)雜性，涵蓋了協(xié)議、TCP/UDP 套接字、并發(fā)等方面的內(nèi)容，并附有詳細(xì)的注釋。
二、關(guān)鍵概念
1. 網(wǎng)絡(luò)協(xié)議
- TCP（傳輸控制協(xié)議）：確?？煽康臄?shù)據(jù)傳輸。
- UDP（用戶數(shù)據(jù)報(bào)協(xié)議）：更快，但不保證數(shù)據(jù)傳遞。
2. 套接字
- TCP 套接字：用于面向連接的通信。
- UDP 套接字：用于無(wú)連接通信。
3. 并發(fā)
- Goroutines（協(xié)程）：允許在代碼中實(shí)現(xiàn)并行處理。
- Channels（通道）：用于協(xié)程之間的通信。
三、示例
示例 1：TCP 服務(wù)器和客戶端
TCP 服務(wù)器和客戶端示例演示了TCP通信的基礎(chǔ)。
服務(wù)器：
package main
import (
"net"
"fmt"
)
func main() {
// Listen on TCP port 8080 on all available unicast and
// any unicast IP addresses.
listen, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println(err)
return
}
defer listen.Close()
// Infinite loop to handle incoming connections
for {
conn, err := listen.Accept()
if err != nil {
fmt.Println(err)
continue
}
// Launch a new goroutine to handle the connection
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
buffer := make([]byte, 1024)
// Read the incoming connection into the buffer.
_, err := conn.Read(buffer)
if err != nil {
fmt.Println(err)
return
}
// Send a response back to the client.
conn.Write([]byte("Received: " + string(buffer)))
}客戶端：
package main
import (
"net"
"fmt"
)
func main() {
// Connect to the server at localhost on port 8080.
conn, err := net.Dial("tcp", "localhost:8080")
if err != nil {
fmt.Println(err)
return
}
defer conn.Close()
// Send a message to the server.
conn.Write([]byte("Hello, server!"))
buffer := make([]byte, 1024)
// Read the response from the server.
conn.Read(buffer)
fmt.Println(string(buffer))
}服務(wù)器在端口8080上等待連接，讀取傳入的消息并發(fā)送響應(yīng)?？蛻舳诉B接到服務(wù)器，發(fā)送消息并打印服務(wù)器的響應(yīng)。
示例 2：UDP 服務(wù)器和客戶端
與TCP不同，UDP是無(wú)連接的。以下是UDP服務(wù)器和客戶端的實(shí)現(xiàn)。
服務(wù)器：
package main
import (
"net"
"fmt"
)
func main() {
// Listen for incoming UDP packets on port 8080.
conn, err := net.ListenPacket("udp", ":8080")
if err != nil {
fmt.Println(err)
return
}
defer conn.Close()
buffer := make([]byte, 1024)
// Read the incoming packet data into the buffer.
n, addr, err := conn.ReadFrom(buffer)
if err != nil {
fmt.Println(err)
return
}
fmt.Println("Received: ", string(buffer[:n]))
// Write a response to the client's address.
conn.WriteTo([]byte("Message received!"), addr)
}客戶端：
package main
import (
"net"
"fmt"
)
func main() {
// Resolve the server's address.
addr, err := net.ResolveUDPAddr("udp", "localhost:8080")
if err != nil {
fmt.Println(err)
return
}
// Dial a connection to the resolved address.
conn, err := net.DialUDP("udp", nil, addr)
if err != nil {
fmt.Println(err)
return
}
defer conn.Close()
// Write a message to the server.
conn.Write([]byte("Hello, server!"))
buffer := make([]byte, 1024)
// Read the response from the server.
conn.Read(buffer)
fmt.Println(string(buffer))
}服務(wù)器從任何客戶端讀取消息并發(fā)送響應(yīng)?？蛻舳税l(fā)送消息并等待響應(yīng)。
示例 3：并發(fā) TCP 服務(wù)器
并發(fā)允許同時(shí)處理多個(gè)客戶端。
package main
import (
"net"
"fmt"
)
func main() {
// Listen on TCP port 8080.
listener, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println(err)
return
}
defer listener.Close()
for {
// Accept a connection.
conn, err := listener.Accept()
if err != nil {
fmt.Println(err)
continue
}
// Handle the connection in a new goroutine.
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
buffer := make([]byte, 1024)
// Read the incoming connection.
conn.Read(buffer)
fmt.Println("Received:", string(buffer))
// Respond to the client.
conn.Write([]byte("Message received!"))
}通過(guò)為每個(gè)連接使用新的 goroutine，多個(gè)客戶端可以同時(shí)連接。
示例 4：帶有 Gorilla Mux 的 HTTP 服務(wù)器
Gorilla Mux 庫(kù)簡(jiǎn)化了 HTTP 請(qǐng)求路由。
package main
import (
"fmt"
"github.com/gorilla/mux"
"net/http"
)
func main() {
// Create a new router.
r := mux.NewRouter()
// Register a handler function for the root path.
r.HandleFunc("/", homeHandler)
http.ListenAndServe(":8080", r)
}
func homeHandler(w http.ResponseWriter, r *http.Request) {
// Respond with a welcome message.
fmt.Fprint(w, "Welcome to Home!")
}這段代碼設(shè)置了一個(gè) HTTP 服務(wù)器，并為根路徑定義了一個(gè)處理函數(shù)。
示例 5：HTTPS 服務(wù)器
實(shí)現(xiàn) HTTPS 服務(wù)器可以確保安全通信。
package main
import (
"net/http"
"log"
)
func main() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
// Respond with a message.
w.Write([]byte("Hello, this is an HTTPS server!"))
})
// Use the cert.pem and key.pem files to secure the server.
log.Fatal(http.ListenAndServeTLS(":8080", "cert.pem", "key.pem", nil))
}服務(wù)器使用 TLS（傳輸層安全性）來(lái)加密通信。
示例 6：自定義 TCP 協(xié)議
可以使用自定義的 TCP 協(xié)議進(jìn)行專門的通信。
package main
import (
"net"
"strings"
)
func main() {
// Listen on TCP port 8080.
listener, err := net.Listen("tcp", ":8080")
if err != nil {
panic(err)
}
defer listener.Close()
for {
// Accept a connection.
conn, err := listener.Accept()
if err != nil {
panic(err)
}
// Handle the connection in a new goroutine.
go handleConnection(conn)
}
}
func handleConnection(conn net.Conn) {
defer conn.Close()
buffer := make([]byte, 1024)
// Read the incoming connection.
conn.Read(buffer)
// Process custom protocol command.
cmd := strings.TrimSpace(string(buffer))
if cmd == "TIME" {
conn.Write([]byte("The current time is: " + time.Now().String()))
} else {
conn.Write([]byte("Unknown command"))
}
}這段代碼實(shí)現(xiàn)了一個(gè)簡(jiǎn)單的自定義協(xié)議，當(dāng)客戶端發(fā)送命令“TIME”時(shí)，它會(huì)回復(fù)當(dāng)前時(shí)間。
示例 7：使用 Gorilla WebSocket 進(jìn)行 WebSockets
WebSockets 提供了通過(guò)單一連接的實(shí)時(shí)全雙工通信。
package main
import (
"github.com/gorilla/websocket"
"net/http"
)
var upgrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024,
}
func handler(w http.ResponseWriter, r *http.Request) {
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
http.Error(w, "Could not open websocket connection", http.StatusBadRequest)
return
}
defer conn.Close()
for {
messageType, p, err := conn.ReadMessage()
if err != nil {
return
}
// Echo the message back to the client.
conn.WriteMessage(messageType, p)
}
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}WebSocket 服務(wù)器會(huì)將消息回傳給客戶端。
示例 8：連接超時(shí)
可以使用 context 包來(lái)管理連接超時(shí)。
package main
import (
"context"
"fmt"
"net"
"time"
)
func main() {
// Create a context with a timeout of 2 seconds
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel()
// Dialer using the context
dialer := net.Dialer{}
conn, err := dialer.DialContext(ctx, "tcp", "localhost:8080")
if err != nil {
panic(err)
}
buffer := make([]byte, 1024)
_, err = conn.Read(buffer)
if err == nil {
fmt.Println("Received:", string(buffer))
} else {
fmt.Println("Connection error:", err)
}
}這段代碼為從連接讀取數(shù)據(jù)設(shè)置了兩秒的截止時(shí)間。
示例 9：使用 golang.org/x/time/rate 進(jìn)行速率限制
速率限制控制請(qǐng)求的速率。
package main
import (
"golang.org/x/time/rate"
"net/http"
"time"
)
// Define a rate limiter allowing two requests per second with a burst capacity of five.
var limiter = rate.NewLimiter(2, 5)
func handler(w http.ResponseWriter, r *http.Request) {
// Check if request is allowed by the rate limiter.
if !limiter.Allow() {
http.Error(w, "Too Many Requests", http.StatusTooManyRequests)
return
}
w.Write([]byte("Welcome!"))
}
func main() {
http.HandleFunc("/", handler)
http.ListenAndServe(":8080", nil)
}此示例使用速率限制器，將請(qǐng)求速率限制為每秒兩個(gè)請(qǐng)求，突發(fā)容量為五個(gè)。
責(zé)任編輯：趙寧寧
來(lái)源：
技術(shù)的游戲
