通过 Go 语言 Socket 传输文件数据
本文将深入探讨如何使用 Go 语言的 Socket 进行文件数据传输。理解 TCP 协议的流式特性是解决问题的关键。TCP 是一种面向连接的、可靠的、基于字节流的传输层通信协议。这意味着，与 UDP 等协议不同，TCP 不保证消息的边界。发送方将数据视为字节流发送，接收方也以字节流的形式接收，而不会自动分割成消息。
因此，在处理大数据传输时，简单地使用固定大小的缓冲区读取数据可能会导致问题。例如，如果发送方发送了一个 100KB 的图像数据，接收方使用 1024 字节的缓冲区读取数据，则需要多次读取才能获取完整的数据。更重要的是，每次 Read 调用返回的数据量是不确定的，可能小于缓冲区的大小。
为了解决这个问题，我们需要在应用层协议中定义消息的边界。以下介绍两种常用的方法：
1. 使用长度字段
如果可以控制应用层协议，最简单的方法是在每个消息前添加一个固定长度的字段，用于表示消息体的长度。接收方首先读取长度字段，然后根据长度字段的值读取相应数量的字节，从而获取完整的消息。
package main
import (
"encoding/binary"
"fmt"
"io"
"net"
"os"
)
// sendFile 函数通过 TCP 连接发送文件
func sendFile(conn net.Conn, filePath string) error {
file, err := os.Open(filePath)
if err != nil {
return err
}
defer file.Close()
fileInfo, err := file.Stat()
if err != nil {
return err
}
fileSize := fileInfo.Size()
// 1. 发送文件大小
sizeBuf := make([]byte, 8) // 使用 8 字节存储文件大小 (int64)
binary.BigEndian.PutUint64(sizeBuf, uint64(fileSize))
_, err = conn.Write(sizeBuf)
if err != nil {
return err
}
// 2. 发送文件内容
buf := make([]byte, 4096) // 使用 4KB 的缓冲区
for {
bytesRead, err := file.Read(buf)
if err != nil {
if err != io.EOF {
return err
}
break // 文件读取完毕
}
_, err = conn.Write(buf[:bytesRead])
if err != nil {
return err
}
}
return nil
}
// receiveFile 函数通过 TCP 连接接收文件
func receiveFile(conn net.Conn, savePath string) error {
// 1. 接收文件大小
sizeBuf := make([]byte, 8)
_, err := io.ReadFull(conn, sizeBuf)
if err != nil {
return err
}
fileSize := binary.BigEndian.Uint64(sizeBuf)
// 2. 接收文件内容
file, err := os.Create(savePath)
if err != nil {
return err
}
defer file.Close()
buf := make([]byte, 4096)
var totalBytesReceived uint64 = 0
for totalBytesReceived < fileSize {
bytesToRead := uint64(len(buf))
if fileSize-totalBytesReceived < uint64(len(buf)) {
bytesToRead = fileSize - totalBytesReceived
}
bytesRead, err := conn.Read(buf[:bytesToRead])
if err != nil {
return err
}
_, err = file.Write(buf[:bytesRead])
if err != nil {
return err
}
totalBytesReceived += uint64(bytesRead)
}
return nil
}
func main() {
// 示例：启动一个简单的 TCP 服务器
listener, err := net.Listen("tcp", ":8080")
if err != nil {
fmt.Println("Error listening:", err.Error())
os.Exit(1)
}
defer listener.Close()
fmt.Println("Listening on :8080")
for {
conn, err := listener.Accept()
if err != nil {
fmt.Println("Error accepting: ", err.Error())
continue
}
go func(conn net.Conn) {
defer conn.Close()
// 接收文件
err := receiveFile(conn, "received_file.dat")
if err != nil {
fmt.Println("Error receiving file:", err.Error())
return
}
fmt.Println("File received successfully!")
// (可选) 发送文件
// err = sendFile(conn, "example.dat")
// if err != nil {
// fmt.Println("Error sending file:", err.Error())
// return
// }
// fmt.Println("File sent successfully!")
}(conn)
}
}注意事项:
- 示例代码中，文件大小使用 uint64 类型存储，占据 8 个字节。
- 在发送和接收文件时，都使用了 4KB 的缓冲区。可以根据实际情况调整缓冲区大小，以提高传输效率。
- io.ReadFull 函数确保读取指定数量的字节，避免因 Socket 缓冲区未满而提前返回。
- 在接收文件时，需要循环读取数据，直到接收到所有字节。
- 需要进行错误处理，例如文件打开失败、Socket 连接断开等。
2. 使用状态机
如果无法控制应用层协议，例如需要解析现有的协议，则可能需要使用状态机来解析消息。状态机根据当前的状态和接收到的数据，决定下一步的操作。例如，可以定义以下状态：
- 读取消息头： 读取固定长度的消息头，例如消息类型和消息长度。
- 读取消息体： 根据消息头中的长度信息，读取消息体。
- 处理消息： 对消息进行处理，例如解析消息内容或将消息写入文件。
使用状态机需要更复杂的代码，但可以处理更复杂的消息格式。
总结
通过 Go 语言的 Socket 传输文件数据，需要理解 TCP 协议的流式特性，并采取适当的方法来处理消息边界问题。使用长度字段是最简单的方法，适用于可以控制应用层协议的情况。使用状态机可以处理更复杂的消息格式，但需要更复杂的代码。在实际应用中，需要根据具体情况选择合适的方法。
