File 如何使用go传输多个文件

我正试图用围棋写一个程序，它有两个部分。一部分是试图将多张图片上载到服务器另一部分的客户端

服务器端应执行以下操作：

func getFileFromClient(connection net.Conn) {
    var numberOfPics int
    var err error
    var receivedBytes int64
    var fileName string
    r := bufio.NewReader(connection)
    strNumberOfPics, err := r.ReadString('\n')
    if err != nil {
        fmt.Printf("Error reading: %s\n", err)
        return
    }
    fmt.Printf("Read: %s\n", strNumberOfPics)
    strNumberOfPics = strings.Trim(strNumberOfPics, "\n")
    numberOfPics, err = strconv.Atoi(strNumberOfPics)
    if err != nil {
        fmt.Printf("Error Atoi: %s\n", err)
        panic("Atoi")
    }
    fmt.Printf("Receiving %d pics:\n", numberOfPics)
    for i := 0; i < numberOfPics; i++ {
        // Getting the file name:
        fileName, err = r.ReadString('\n')
        if err != nil {
            fmt.Printf("Error receiving: %s\n", err)
        }
        fmt.Printf("Filename: %s\n", fileName)
        fileName = strings.Trim(fileName, "\n")
        f, err := os.Create(fileName)
        defer f.Close()
        if err != nil {
            fmt.Println("Error creating file")
        }
        receivedBytes, err = io.Copy(f, connection)
        if err != nil {
            panic("Transmission error")
        }

        fmt.Printf("Transmission finished. Received: %d \n", receivedBytes)
    }
}

获取将要发送的文件数

循环每个文件

获取文件名

获取文件并保存它

去3号

到目前为止，服务器端正在执行以下操作：

func getFileFromClient(connection net.Conn) {
    var numberOfPics int
    var err error
    var receivedBytes int64
    var fileName string
    r := bufio.NewReader(connection)
    strNumberOfPics, err := r.ReadString('\n')
    if err != nil {
        fmt.Printf("Error reading: %s\n", err)
        return
    }
    fmt.Printf("Read: %s\n", strNumberOfPics)
    strNumberOfPics = strings.Trim(strNumberOfPics, "\n")
    numberOfPics, err = strconv.Atoi(strNumberOfPics)
    if err != nil {
        fmt.Printf("Error Atoi: %s\n", err)
        panic("Atoi")
    }
    fmt.Printf("Receiving %d pics:\n", numberOfPics)
    for i := 0; i < numberOfPics; i++ {
        // Getting the file name:
        fileName, err = r.ReadString('\n')
        if err != nil {
            fmt.Printf("Error receiving: %s\n", err)
        }
        fmt.Printf("Filename: %s\n", fileName)
        fileName = strings.Trim(fileName, "\n")
        f, err := os.Create(fileName)
        defer f.Close()
        if err != nil {
            fmt.Println("Error creating file")
        }
        receivedBytes, err = io.Copy(f, connection)
        if err != nil {
            panic("Transmission error")
        }

        fmt.Printf("Transmission finished. Received: %d \n", receivedBytes)
    }
}

func getFileFromClient（connection net.Conn）{
变量numberOfPics int
变量错误
var接收字节int64
变量文件名字符串
r:=bufio.NewReader（连接）
strNumberOfPics，err:=r.ReadString（'\n'）
如果错误！=零{
fmt.Printf（“读取错误：%s\n”，错误）
返回
}
fmt.Printf（“读取：%s\n”，字符数）
strNumberOfPics=strings.Trim（strNumberOfPics，“\n”）
numberOfPics，err=strconv.Atoi（strNumberOfPics）
如果错误！=零{
fmt.Printf（“错误原子：%s\n”，错误）
恐慌（“Atoi”）
}
fmt.Printf（“接收%d张图片：\n”，图片编号）
对于i:=0；i

Copy只为一个文件工作，没有任何附加文件（因为我认为它不会清空队列）。我不想每次都重新连接每个文件，如果我没有太多。但我不确定我能为此做些什么

有人对现有的软件包或方法有什么建议可以帮助你吗？还是示例代码？还是我完全错了，用围棋试试都不是个好主意

我认为，如果服务器能够在每次读取后刷新连接缓冲区，这样就不会读取和/或复制额外的信息，这就足够了

非常期待您的帮助，提前谢谢

编辑：更新的代码仍不工作。我想可能是bufio阅读器

func getFileFromClient(connection net.Conn) {
    var numberOfPics int
    var err error
    var receivedBytes int64
    var fileName string
    r := bufio.NewReader(connection)
    strNumberOfPics, err := r.ReadString('\n')
    if err != nil {
        fmt.Printf("Error reading: %s\n", err)
        return
    }
    strNumberOfPics = strings.Trim(strNumberOfPics, "\n")
    numberOfPics, err = strconv.Atoi(strNumberOfPics)
    if err != nil {
        fmt.Printf("Error Atoi: %s\n", err)
        panic("Atoi")
    }
    fmt.Printf("Receiving %d pics:\n", numberOfPics)
    for i := 0; i < numberOfPics; i++ {
        // Getting the file name:
        fileName, err = r.ReadString('\n')
        if err != nil {
            fmt.Printf("Error receiving: %s\n", err)
        }
        fileName = strings.Trim(fileName, "\n")
        fmt.Printf("Filename: %s\n", fileName)
        f, err := os.Create(fileName)
        defer f.Close()
        if err != nil {
            fmt.Println("Error creating file")
        }
        // Get the file size
        strFileSize, err := r.ReadString('\n')
        if err != nil {
            fmt.Printf("Read size error %s\n", err)
            panic("Read size")
        }
        strFileSize = strings.Trim(strFileSize, "\n")
        fileSize, err := strconv.Atoi(strFileSize)
        if err != nil {
            fmt.Printf("Error size Atoi: %s\n", err)
            panic("size Atoi")
        }
        fmt.Printf("Size of pic: %d\n", fileSize)

        receivedBytes, err = io.CopyN(f, connection, int64(fileSize))
        if err != nil {
            fmt.Printf("Transmission error: %s\n", err)
            panic("Transmission error")
        }
        fmt.Printf("Transmission finished. Received: %d \n", receivedBytes)
    }
}

func getFileFromClient（connection net.Conn）{
变量numberOfPics int
变量错误
var接收字节int64
变量文件名字符串
r:=bufio.NewReader（连接）
strNumberOfPics，err:=r.ReadString（'\n'）
如果错误！=零{
fmt.Printf（“读取错误：%s\n”，错误）
返回
}
strNumberOfPics=strings.Trim（strNumberOfPics，“\n”）
numberOfPics，err=strconv.Atoi（strNumberOfPics）
如果错误！=零{
fmt.Printf（“错误原子：%s\n”，错误）
恐慌（“Atoi”）
}
fmt.Printf（“接收%d张图片：\n”，图片编号）
对于i:=0；i

---

编辑2：我没有让这个解决方案起作用。我很确定是因为我用了bufio。不过，我确实是通过使用io.copy传输一个zip文件来实现的。另一个有效的解决方案是使用http传输zip文件。如果你被困在尝试类似的东西，需要帮助，请随时给我发个信息。多亏了大家的帮助

使您的实现保持至今，您缺少的是从源代码读取数据，直到找到EOF为止，因此它将一次性读取所有剩余的图像

此外，客户端必须为每个图像发送其大小（以字节为单位）（您可以在发送名称后执行此操作）。 在服务器中，只需读取大小，然后使用读取准确的字节数

编辑：事实上，您也可以像以前那样并行发送图像，而不是串行发送，这意味着您可以为每次文件传输打开一个新连接，然后读取所有文件，而无需发送图像的数量或大小

---

如果您想要一个替代方案，一个好的选择是使用好的“OLHTTP”和多部分请求。内置模块允许您通过HTTP进行文件传输。当然，这意味着您必须重写程序。

我的建议是压缩所有要传输的图像，然后作为单个多部分POST请求发送它们。这样，您就有了一个了解所有验收标准的标准方法

---

您可以使用

https://golang.org/pkg/archive/zip/

为什么不使用现有协议传输图像？你没有办法对图像数据进行定界，你只需复制，直到客户端关闭连接