Go实现网络通信
Go 语言提供了强大的网络编程能力，包括 TCP、UDP、HTTP、WebSocket 等协议的支持。下面是 Go 语言中常用的网络操作：
TCP 通信
使用 net 包进行 TCP 通信，可以创建 TCP 客户端和服务器。
客户端使用 net.Dial 方法连接到指定的 TCP 地址，并使用返回的连接对象进行通信。
服务器使用 net.Listen 方法监听指定的 TCP 地址，接受客户端连接，并使用返回的连接对象进行通信。
TCP 客户端
package main
import (
"fmt"
"net"
)
func main() {
// 连接到 TCP 服务器
conn, err := net.Dial("tcp", "localhost:8080")
if err != nil {
fmt.Println("无法连接到服务器:", err)
return
}
defer conn.Close()
// 发送数据
message := "Hello, TCP server!"
_, err = conn.Write([]byte(message))
if err != nil {
fmt.Println("发送数据失败:", err)
return
}
// 接收服务器响应
buffer := make([]byte, 1024)
n, err := conn.Read(buffer)
if err != nil {
fmt.Println("接收响应失败:", err)
return
}
fmt.Println("服务器响应:", string(buffer[:n]))
}
TCP 服务器
package main
import (
"fmt"
"net"
)
func main() {
// 监听 TCP 连接
listener, err := net.Listen("tcp", "localhost:8080")
if err != nil {
fmt.Println("无法监听端口:", err)
return
}
defer listener.Close()
fmt.Println("等待客户端连接...")
for {
// 接受客户端连接
conn, err := listener.Accept()
if err != nil {
fmt.Println("接受连接失败:", err)
continue
}
// 处理客户端请求
go handleClient(conn)
}
}
func handleClient(conn net.Conn) {
defer conn.Close()
// 接收客户端数据
buffer := make([]byte, 1024)
n, err := conn.Read(buffer)
if err != nil {
fmt.Println("读取数据失败:", err)
return
}
fmt.Println("接收到客户端数据:", string(buffer[:n]))
// 发送响应给客户端
response := "Hello, TCP client!"
_, err = conn.Write([]byte(response))
if err != nil {
fmt.Println("发送响应失败:", err)
return
}
}
UDP 通信
使用 net 包进行 UDP 通信，可以创建 UDP 客户端和服务器。
客户端使用 net.DialUDP 方法连接到指定的 UDP 地址，并使用返回的连接对象进行通信。
服务器使用 net.ListenUDP 方法监听指定的 UDP 地址，接收客户端发送的数据，并使用返回的连接对象进行通信。
UDP 客户端
package main
import (
"fmt"
"net"
)
func main() {
// 连接到 UDP 服务器
conn, err := net.Dial("udp", "localhost:8080")
if err != nil {
fmt.Println("无法连接到服务器:", err)
return
}
defer conn.Close()
// 发送数据
message := "Hello, UDP server!"
_, err = conn.Write([]byte(message))
if err != nil {
fmt.Println("发送数据失败:", err)
return
}
}
UDP 服务器
package main
import (
"fmt"
"net"
)
func main() {
// 监听 UDP 连接
addr, err := net.ResolveUDPAddr("udp", "localhost:8080")
if err != nil {
fmt.Println("无法解析地址:", err)
return
}
conn, err := net.ListenUDP("udp", addr)
if err != nil {
fmt.Println("无法监听端口:", err)
return
}
defer conn.Close()
fmt.Println("等待客户端连接...")
// 接收客户端数据
buffer := make([]byte, 1024)
n, addr, err := conn.ReadFromUDP(buffer)
if err != nil {
fmt.Println("读取数据失败:", err)
return
}
fmt.Println("接收到客户端数据:", string(buffer[:n]))
// 发送响应给客户端
response := "Hello, UDP client!"
_, err = conn.WriteToUDP([]byte(response), addr)
if err != nil {
fmt.Println("发送响应失败:", err)
return
}
}
HTTP通信
HTTP 客户端
使用 net/http 包进行 HTTP 客户端编程，可以发送 HTTP 请求并接收响应。
使用 http.Get、http.Post 等方法发送不同类型的 HTTP 请求。
可以通过设置请求头、请求方法、请求体等来定制请求，并使用响应对象获取服务器的响应数据。
- 发起 HTTP GET 请求：
package main
import (
"fmt"
"io/ioutil"
"net/http"
)
func main() {
// 发送 GET 请求
response, err := http.Get("http://localhost:8080")
if err != nil {
fmt.Println("发送请求失败:", err)
return
}
defer response.Body.Close()
// 读取响应内容
body, err := ioutil.ReadAll(response.Body)
if err != nil {
fmt.Println("读取响应失败:", err)
return
}
fmt.Println("服务器响应:", string(body))
}
- 发起 HTTP POST 请求：
package main
import (
"bytes"
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://jsonplaceholder.typicode.com/posts" // 要发送 POST 请求的网址
payload := []byte(`{"title": "foo", "body": "bar", "userId": 1}`)
resp, err := http.Post(url, "application/json", bytes.NewBuffer(payload))
if err != nil {
fmt.Println("HTTP POST 请求失败:", err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("读取响应体失败:", err)
return
}
fmt.Println("POST 响应：", string(body))
}
- 发起 HTTP PUT 请求：
package main
import (
"bytes"
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://jsonplaceholder.typicode.com/posts/1" // 要更新的资源网址
payload := []byte(`{"id": 1, "title": "foo", "body": "bar", "userId": 1}`)
req, err := http.NewRequest("PUT", url, bytes.NewBuffer(payload))
req.Header.Set("Content-Type", "application/json")
client := &http.Client{}
resp, err := client.Do(req)
if err != nil {
fmt.Println("HTTP PUT 请求失败:", err)
return
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("读取响应体失败:", err)
return
}
fmt.Println("PUT 响应：", string(body))
}
HTTP 服务器
使用 net/http 包进行 HTTP 服务器编程，可以创建一个 HTTP 服务器来处理客户端的请求。
使用 http.HandleFunc 方法来注册处理不同路由的处理函数，或者使用自定义的 http.Handler 对象处理请求。
可以通过设置路由和处理逻辑来实现 RESTful API、静态文件服务等功能。
package main
import (
"fmt"
"net/http"
)
func main() {
// 注册处理函数
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
fmt.Fprint(w, "Hello, HTTP client!")
})
// 启动 HTTP 服务器
err := http.ListenAndServe(":8080", nil)
if err != nil {
fmt.Println("启动服务器失败:", err)
return
}
}
WebSocket 通信
使用 net/http 包进行 WebSocket 通信，可以创建一个 WebSocket 服务器和客户端。
服务器可以使用 http.HandleFunc 方法来注册 WebSocket 的处理函数，处理客户端的连接和消息。
客户端可以使用 gorilla/websocket 等第三方库来建立 WebSocket 连接，并进行消息的发送和接收。
WebSocket 服务器
package main
import (
"fmt"
"log"
"net/http"
"github.com/gorilla/websocket"
)
func main() {
// 注册 WebSocket 处理函数
http.HandleFunc("/", handleWebSocket)
// 启动 WebSocket 服务器
err := http.ListenAndServe(":8080", nil)
if err != nil {
log.Fatal("启动服务器失败:", err)
}
}
func handleWebSocket(w http.ResponseWriter, r *http.Request) {
// 升级 HTTP 连接为 WebSocket 连接
upgrader := websocket.Upgrader{}
conn, err := upgrader.Upgrade(w, r, nil)
if err != nil {
log.Println("升级连接失败:", err)
return
}
defer conn.Close()
fmt.Println("客户端已连接")
// 处理 WebSocket 消息
for {
// 读取消息
_, message, err := conn.ReadMessage()
if err != nil {
log.Println("读取消息失败:", err)
break
}
fmt.Println("接收到消息:", string(message))
// 发送消息
err = conn.WriteMessage(websocket.TextMessage, []byte("Hello, WebSocket client!"))
if err != nil {
log.Println("发送消息失败:", err)
break
}
}
fmt.Println("客户端已断开连接")
}
WebSocket 客户端（使用 JavaScript）
const socket = new WebSocket("ws://localhost:8080");
// 连接建立时触发
socket.onopen = function() {
console.log("连接已建立");
// 发送消息
socket.send("Hello, WebSocket server!");
};
// 接收消息时触发
socket.onmessage = function(event) {
console.log("接收到消息:", event.data);
};
// 连接关闭时触发
socket.onclose = function(event) {
console.log("连接已关闭");
};