PHP处理大文件上传与下载：Stream分块处理与断点续传（Range Header）实现

好的，以下是一篇关于PHP处理大文件上传与下载的文章，以讲座模式呈现，涵盖Stream分块处理与断点续传（Range Header）实现：

PHP大文件上传与下载：Stream分块处理与断点续传（Range Header）实现

大家好！今天我们来探讨一个在Web开发中非常重要的话题：PHP如何处理大文件上传与下载。 随着互联网的发展，用户上传和下载的文件越来越大，例如高清视频、大型压缩包等。传统的上传和下载方式在处理这些大文件时往往会遇到性能瓶颈，甚至导致服务器崩溃。 为了解决这个问题，我们需要采用一些高级技术，例如Stream分块处理和断点续传。

一、传统上传下载的局限性

在深入研究Stream分块处理和断点续传之前，让我们先回顾一下传统的上传和下载方式及其局限性。

• 传统上传： 使用<input type="file">表单元素，将文件一次性上传到服务器。PHP通过$_FILES数组获取文件信息。
  • 局限性： 内存消耗大，容易超时，网络不稳定导致上传失败，用户体验差。
• 传统下载： 使用header()函数设置Content-Disposition等头部信息，然后使用readfile()函数将文件内容一次性发送给客户端。
  • 局限性： 同样存在内存消耗大、容易超时等问题，不支持断点续传。

二、Stream分块处理：化整为零，逐块处理

Stream分块处理的核心思想是将大文件分割成多个小块，然后逐个处理这些小块，而不是一次性将整个文件加载到内存中。 这样可以显著降低内存消耗，提高程序的稳定性。

2.1 上传分块处理

在PHP中，我们可以使用fopen(), fread(), fwrite()等函数来操作文件流。

• 客户端（JavaScript）:

  function uploadFile(file, chunkSize = 1024 * 1024) { // 默认1MB分块大小
      let offset = 0;
      let totalChunks = Math.ceil(file.size / chunkSize);
      let chunkIndex = 0;
  
      function uploadChunk() {
          if (offset >= file.size) {
              console.log("文件上传完成！");
              return;
          }
  
          const chunk = file.slice(offset, offset + chunkSize);
          const formData = new FormData();
          formData.append("chunk", chunk);
          formData.append("filename", file.name);
          formData.append("chunkIndex", chunkIndex);
          formData.append("totalChunks", totalChunks);
          formData.append("totalSize", file.size);
  
          fetch("/upload.php", {
              method: "POST",
              body: formData
          })
          .then(response => response.json())
          .then(data => {
              if (data.success) {
                  offset += chunkSize;
                  chunkIndex++;
                  console.log(`已上传 ${chunkIndex}/${totalChunks} 块`);
                  uploadChunk(); // 继续上传下一个分块
              } else {
                  console.error("分块上传失败:", data.message);
              }
          })
          .catch(error => {
              console.error("网络错误:", error);
          });
      }
  
      uploadChunk(); // 开始上传
  }
  
  const fileInput = document.getElementById("fileInput");
  fileInput.addEventListener("change", function(event) {
      const file = event.target.files[0];
      if (file) {
          uploadFile(file);
      }
  });
  

• 服务端（PHP）:

  <?php
  $targetDir = "uploads/"; // 上传目录
  if (!is_dir($targetDir)) {
      mkdir($targetDir, 0777, true);
  }
  
  $filename = $_POST["filename"];
  $chunkIndex = $_POST["chunkIndex"];
  $totalChunks = $_POST["totalChunks"];
  $totalSize = $_POST["totalSize"];
  $chunk = $_FILES["chunk"]["tmp_name"];
  
  $targetFile = $targetDir . $filename . ".part" . $chunkIndex; // 临时文件名
  $finalFile = $targetDir . $filename; // 最终文件名
  
  if (move_uploaded_file($chunk, $targetFile)) {
      // 检查是否所有分块都已上传
      $allChunksUploaded = true;
      for ($i = 0; $i < $totalChunks; $i++) {
          if (!file_exists($targetDir . $filename . ".part" . $i)) {
              $allChunksUploaded = false;
              break;
          }
      }
  
      if ($allChunksUploaded) {
          // 合并分块文件
          $outputFile = fopen($finalFile, "wb");
          for ($i = 0; $i < $totalChunks; $i++) {
              $chunkFile = fopen($targetDir . $filename . ".part" . $i, "rb");
              stream_copy_to_stream($chunkFile, $outputFile);
              fclose($chunkFile);
              unlink($targetDir . $filename . ".part" . $i); // 删除临时文件
          }
          fclose($outputFile);
          echo json_encode(["success" => true, "message" => "文件上传完成"]);
      } else {
          echo json_encode(["success" => true, "message" => "分块上传成功"]);
      }
  } else {
      echo json_encode(["success" => false, "message" => "分块上传失败"]);
  }
  
  ?>

  代码说明：

  1. 客户端将文件分割成多个分块，并使用FormData对象将每个分块、文件名、分块索引、总分块数等信息发送到服务器。
  2. 服务端接收到分块后，将其保存为临时文件，文件名包含分块索引。
  3. 服务端检查是否所有分块都已上传，如果是，则将所有分块合并成最终文件，并删除临时文件。
  4. 服务端返回JSON格式的响应，告知客户端上传结果。
  5. 客户端循环调用 uploadChunk() 直至全部上传。

2.2 下载分块处理

下载分块处理与上传类似，也是将大文件分割成多个小块，然后逐个发送给客户端。 但是，下载分块处理通常与HTTP Range请求结合使用，实现断点续传功能。

三、断点续传：从中断处继续，节省时间和带宽

断点续传是指在下载过程中，如果连接中断或下载失败，可以从上次中断的地方继续下载，而不是从头开始。 这对于下载大文件来说非常重要，可以节省大量的时间和带宽。

3.1 Range Header

HTTP协议定义了一个名为Range的头部，用于指定请求的文件范围。 服务器收到带有Range头部的请求后，会返回指定范围的文件内容，并设置Content-Range头部，告知客户端返回的内容范围。

• 客户端请求：

  GET /large_file.zip HTTP/1.1
  Range: bytes=1024000-2047999

  这个请求表示客户端请求large_file.zip文件中从第1024000字节到第2047999字节的内容。

• 服务器响应：

  HTTP/1.1 206 Partial Content
  Content-Type: application/zip
  Content-Range: bytes 1024000-2047999/10485760  //10485760 是文件总大小
  Content-Length: 1024000

  • 206 Partial Content：表示服务器成功处理了部分内容请求。
  • Content-Range：告知客户端返回的内容范围和文件总大小。
  • Content-Length：告知客户端返回的内容长度。

3.2 PHP实现断点续传

<?php
$file = "large_file.zip"; // 文件名
$filepath = "path/to/" . $file; // 文件路径

// 检查文件是否存在
if (!file_exists($filepath)) {
    header("HTTP/1.0 404 Not Found");
    exit;
}

$filesize = filesize($filepath);

// 处理 Range 请求
if (isset($_SERVER["HTTP_RANGE"])) {
    list($size_unit, $range_orig) = explode("=", $_SERVER["HTTP_RANGE"], 2);
    if ($size_unit == "bytes") {
        // Multiple ranges are not supported.
        list($range, $extra_ranges) = explode(",", $range_orig, 2);
    } else {
        $range = "";
    }
} else {
    $range = "";
}

if ($range) {
    list($range_start, $range_end) = explode("-", $range, 2);
    if (!$range_end) {
        $range_end = $filesize - 1;
    } else {
        $range_end = min(intval($range_end), $filesize - 1);
    }
    $range_start = intval($range_start);

    // 确保 Range 的有效性
    if ($range_start > $range_end) {
        header("HTTP/1.1 416 Requested Range Not Satisfiable");
        exit;
    }

    $content_length = $range_end - $range_start + 1;
    header("HTTP/1.1 206 Partial Content");
    header("Content-Range: bytes " . $range_start . "-" . $range_end . "/" . $filesize);
    header("Content-Length: " . $content_length);
} else {
    $content_length = $filesize;
    header("HTTP/1.1 200 OK");
    header("Content-Length: " . $content_length);
}

// 设置其他头部信息
header("Content-Type: application/zip");
header("Content-Disposition: attachment; filename="" . $file . """);
header("Accept-Ranges: bytes");

// 读取文件并发送给客户端
$buffer = 1024 * 8; // 8KB buffer
$file = fopen($filepath, "rb");
fseek($file, $range_start);

$bytes_send = 0;
while ($bytes_send < $content_length && !feof($file)) {
    $read_length = min($buffer, ($content_length - $bytes_send));
    $buffer_content = fread($file, $read_length);
    echo $buffer_content;
    flush(); // 强制输出缓冲区的内容
    $bytes_send += strlen($buffer_content);
}
fclose($file);

exit;
?>

代码说明：

1. 首先，检查文件是否存在，如果不存在，则返回404错误。
2. 获取文件大小。
3. 检查是否存在HTTP_RANGE头部，如果存在，则解析Range头部，获取请求的范围。
4. 根据Range头部设置相应的HTTP头部信息，例如Content-Range、Content-Length等。
5. 使用fopen()函数打开文件，并使用fseek()函数将文件指针移动到请求的起始位置。
6. 使用fread()函数读取文件内容，并使用echo函数将内容发送给客户端。
7. 使用flush()函数强制输出缓冲区的内容，确保数据及时发送给客户端。
8. 循环读取和发送文件内容，直到发送完所有请求的内容。

3.3 客户端实现

客户端需要记录已经下载的字节数，并在下次请求时设置Range头部。

• JavaScript:

  function downloadFile(url, filename) {
      let downloadedBytes = 0;
      let xhr = new XMLHttpRequest();
  
      xhr.open("GET", url, true);
      xhr.responseType = "blob"; // 以blob形式接收数据
  
      xhr.onload = function() {
          if (xhr.status === 200 || xhr.status === 206) {
              let blob = xhr.response;
              // 创建下载链接
              let a = document.createElement("a");
              a.href = URL.createObjectURL(blob);
              a.download = filename;
              document.body.appendChild(a);
              a.click();
              document.body.removeChild(a);
              URL.revokeObjectURL(a.href); // 释放URL对象
              downloadedBytes += blob.size; // 更新已下载字节数
              localStorage.setItem(filename, downloadedBytes.toString()); // 保存进度
              console.log("下载完成！");
          } else {
              console.error("下载失败:", xhr.status);
          }
      };
  
      xhr.onerror = function() {
          console.error("网络错误");
      };
  
      xhr.onprogress = function(event) {
          if (event.lengthComputable) {
              let percentage = Math.round((downloadedBytes + event.loaded) / event.total * 100);
              console.log(`下载进度: ${percentage}%`);
          }
      };
  
      // 设置 Range 头部
      let savedBytes = localStorage.getItem(filename) || "0";
      downloadedBytes = parseInt(savedBytes, 10);
      if (downloadedBytes > 0) {
          xhr.setRequestHeader("Range", "bytes=" + downloadedBytes + "-");
          console.log("断点续传，从 " + downloadedBytes + " 字节开始");
      }
  
      xhr.send();
  }
  
  // 使用示例
  const downloadButton = document.getElementById("downloadButton");
  downloadButton.addEventListener("click", function() {
      downloadFile("/large_file.zip", "large_file.zip");
  });
  

  代码说明：

  1. 客户端首先从localStorage中获取已经下载的字节数。
  2. 如果已经下载了部分内容，则设置Range头部，告知服务器从上次中断的地方继续下载。
  3. 使用XMLHttpRequest对象发送请求，并设置responseType为blob，以便接收二进制数据。
  4. 在onload事件处理函数中，创建下载链接，并触发下载。
  5. 在onprogress事件处理函数中，显示下载进度。
  6. 下载完成后，将已下载字节数保存到localStorage中。

四、代码改进与注意事项

• 错误处理： 在服务器端，需要对各种可能出现的错误进行处理，例如文件不存在、权限不足、磁盘空间不足等。
• 安全性： 需要对上传的文件进行安全检查，防止恶意代码注入。
• 并发处理： 在高并发环境下，需要考虑并发处理的问题，例如使用锁机制防止文件被同时写入。
• 存储方式： 可以将分块文件存储在对象存储服务上，例如Amazon S3、阿里云OSS等，以提高存储效率和可靠性。
• 优化： 可以使用Gzip压缩来减小文件大小，提高传输速度。
• 传输校验: 在分块上传中，可以采用MD5或者SHA256等算法，对每个分块进行hash计算，然后将hash值传递给服务器，服务器在合并分块的时候，对每个分块也进行hash计算，比较客户端传递过来的hash值和服务端计算的hash值是否一致，如果不一致，则说明该分块在传输过程中发生了错误，需要重新上传。
• 前端UI: 增加更好的UI交互，比如上传进度条，上传速度显示，上传取消，上传暂停/继续等功能。

五、Stream流处理的优势

Stream流处理在处理大文件上传和下载时，具有以下显著优势：

• 内存效率高: 通过分块读取和处理文件，避免一次性加载整个文件到内存，显著降低了内存消耗，尤其适用于资源受限的服务器环境。
• 性能提升: 减少了I/O操作的阻塞时间，提高了数据传输的效率。可以边读取边处理，实现更快的响应速度。
• 可扩展性强: 能够更好地应对高并发场景，通过异步处理和缓冲机制，提高系统的吞吐量。
• 错误恢复能力: 结合断点续传技术，即使在网络不稳定或连接中断的情况下，也能保证文件传输的完整性，提高了用户体验。

六、多种技术结合使用，打造高性能方案

综上所述，PHP处理大文件上传和下载，需要结合多种技术： 使用Stream分块处理降低内存消耗，使用HTTP Range头部实现断点续传，并结合适当的错误处理、安全措施和并发处理机制，才能打造出一个高性能、稳定可靠的解决方案。 通过合理的方案设计和代码实现，我们可以轻松应对大文件上传和下载的挑战，为用户提供更好的体验。

文件分块传输，断点续传是关键

希望本次讲座对大家有所帮助！谢谢！