C++游戏开发：如何通过单次HTTP请求下载指定URL文件夹下所有文件？

Hey there! Great question—HTTP doesn’t natively support grabbing an entire folder in one single request, but there are a few practical, game-friendly workarounds that will get the job done. Let’s go through the most common and effective options:

1. Serve a Compressed Archive (ZIP/RAR) – The Simplest Approach #

This is the go-to solution for game resource downloads. Instead of trying to pull individual files, ask your server to package the entire folder into a single ZIP (or similar) archive. Then you can use your existing single-file download function to grab this archive, and unpack it locally to your game’s target path.

Implementation Steps: #

• On the server side: Automate or manually create a ZIP file containing all .png, .txt, and other files in the target folder. Host this ZIP at a dedicated URL (e.g., https://ServerName/../FolderName/resources.zip).
• In your C++ code:
  1. Use your existing download function to fetch the ZIP file to a temporary location.
  2. Unpack the ZIP to your game’s desired resource path. For this, you can use lightweight C++ libraries like minizip (a zip/unzip library compatible with zlib) or libzip.

Quick Minizip Unpack Example (Simplified):

#include "minizip/unzip.h"
#include <string>
#include <direct.h> // Windows-specific; use <sys/stat.h> for Linux/macOS

bool unpackZip(const std::string& zipPath, const std::string& destPath) {
    unzFile zipFile = unzOpen(zipPath.c_str());
    if (!zipFile) return false;

    unz_global_info globalInfo;
    if (unzGetGlobalInfo(zipFile, &globalInfo) != UNZ_OK) {
        unzClose(zipFile);
        return false;
    }

    // Create destination directory if it doesn't exist
    _mkdir(destPath.c_str()); // Use mkdir(destPath.c_str(), 0755) for Linux/macOS

    for (uLong i = 0; i < globalInfo.number_entry; i++) {
        char filename[256];
        unz_file_info fileInfo;
        if (unzGetCurrentFileInfo(zipFile, &fileInfo, filename, sizeof(filename), NULL, 0, NULL, 0) != UNZ_OK) {
            unzClose(zipFile);
            return false;
        }

        std::string fullDestPath = destPath + "/" + filename;

        // Handle directories in the ZIP
        if (filename[strlen(filename)-1] == '/') {
            _mkdir(fullDestPath.c_str());
        } else {
            // Extract file contents
            if (unzOpenCurrentFile(zipFile) == UNZ_OK) {
                FILE* outFile = fopen(fullDestPath.c_str(), "wb");
                if (outFile) {
                    char buffer[4096];
                    int bytesRead;
                    while ((bytesRead = unzReadCurrentFile(zipFile, buffer, sizeof(buffer))) > 0) {
                        fwrite(buffer, 1, bytesRead, outFile);
                    }
                    fclose(outFile);
                }
                unzCloseCurrentFile(zipFile);
            }
        }

        unzGoToNextFile(zipFile);
    }

    unzClose(zipFile);
    return true;
}

2. Fetch a File List First, Then Batch Download #

If creating a ZIP archive isn’t feasible (e.g., dynamic folder content), have your server generate a simple file list (like a .txt or .json file) that lists all the files in the folder. You can then:

1. Make one request to download this file list.
2. Parse the list to get each file’s relative path.
3. Use your existing download function to fetch each file (you can optimize this with async/multithreaded requests to speed things up).

Example File List (filelist.txt): #

texture1.png
texture2.png
dialogue.txt
config.json

C++ Code Snippet to Process the List:

#include <fstream>
#include <string>
#include <vector>

// Assume this is your existing download function
bool downloadSingleFile(const std::string& url, const std::string& destPath);

void downloadAllFiles(const std::string& listUrl, const std::string& baseUrl, const std::string& destPath) {
    // First download the file list
    std::string listPath = destPath + "/filelist.txt";
    if (!downloadSingleFile(listUrl, listPath)) {
        // Handle error (e.g., log message, exit early)
        return;
    }

    // Read and parse the list
    std::ifstream listFile(listPath);
    std::string filename;
    while (std::getline(listFile, filename)) {
        if (filename.empty()) continue;
        std::string fileUrl = baseUrl + filename;
        std::string fileDestPath = destPath + "/" + filename;
        downloadSingleFile(fileUrl, fileDestPath);
        // Add error handling here (e.g., retry failed downloads)
    }

    // Optional: Delete the temporary file list
    remove(listPath.c_str());
}

3. WebDAV (Advanced, If Server Supports It) #

If your server supports WebDAV, you can send a PROPFIND request to the folder URL to retrieve a list of all files and subfolders. Then you can iterate over that list to download each file. This is more complex and requires handling XML responses, so it’s only recommended if you already have WebDAV set up on your server.

Key Takeaway #

For game development, the ZIP archive approach is almost always the best choice—it’s efficient, reduces the number of HTTP requests, and simplifies error handling. The file list method is a solid backup if you need to handle dynamic, frequently updated content.

内容的提问来源于stack exchange，提问作者yogesh sriraman