引言

HTTP（超文本传输协议）是互联网上应用最广泛的协议之一，而文件下载是HTTP服务器的核心功能之一。无论是下载文档、图片、视频还是软件安装包，用户每天都在通过浏览器或下载工具与HTTP服务器进行文件传输交互。理解HTTP服务器如何实现文件下载功能，不仅有助于开发者构建高效的文件服务系统，还能帮助解决下载过程中遇到的各种问题。

本文将从HTTP协议的基础原理出发，深入探讨文件下载的实现机制，然后通过实际的代码示例展示如何在不同编程语言和框架中实现文件下载功能。我们将涵盖从最简单的静态文件服务到复杂的动态文件生成和断点续传等高级功能。

HTTP协议基础：文件下载的工作原理

HTTP请求与响应模型

HTTP协议采用客户端-服务器（Client-Server）模型，文件下载过程本质上是客户端向服务器发送请求，服务器返回文件内容的过程。

基本流程：

客户端（如浏览器）向服务器发送HTTP GET请求，请求特定URL的资源

服务器解析请求，定位请求的资源

服务器读取文件内容，构建HTTP响应

服务器将响应发送给客户端

客户端接收响应，将内容保存为本地文件

关键HTTP头部信息

在文件下载过程中，HTTP头部信息起着至关重要的作用，它们告诉浏览器如何处理响应内容。

1. Content-Type（内容类型）

指定响应体的MIME类型，浏览器根据此类型决定如何处理内容。

常见文件类型的Content-Type：

文本文件：text/plain

HTML文件：text/html

CSS文件：text/css

JavaScript文件：application/javascript

JPEG图片：image/jpeg

PNG图片：image/png

PDF文件：application/pdf

ZIP压缩包：application/zip

MP3音频：audio/mpeg

MP4视频：video/mp4

2. Content-Disposition（内容处置）

这个头部告诉浏览器如何处理响应内容，对于文件下载至关重要。

两种主要值：

inline：在浏览器中直接显示内容（默认行为）

attachment：作为附件下载，通常会触发浏览器的下载对话框

带文件名的示例：

Content-Disposition: attachment; filename="document.pdf"

3. Content-Length（内容长度）

指定响应体的大小（字节），帮助浏览器显示下载进度和判断下载是否完成。

4. Accept-Ranges（接受范围）

指示服务器是否支持范围请求，对于实现断点续传很重要。

值：

bytes：支持按字节范围请求

none：不支持范围请求

5. Content-Range（内容范围）

当响应是部分数据时，指定这部分数据在整个文件中的位置。

格式：

Content-Range: bytes start-end/total

例如：Content-Range: bytes 0-1023/5000

状态码

文件下载通常使用以下状态码：

200 OK：完整文件下载

206 Partial Content：部分文件下载（断点续传）

404 Not Found：文件不存在

416 Range Not Satisfiable：请求的范围无效

静态文件下载的实现

最简单的静态文件服务

最基础的文件下载就是直接返回服务器上已存在的静态文件。大多数Web服务器软件（如Nginx、Apache）都内置了静态文件服务功能。

Nginx配置示例

server {

listen 80;

server_name example.com;

# 文件根目录

root /var/www/files;

# 默认首页

index index.html;

# 启用目录浏览（可选）

autoindex on;

# 隐藏文件（以.开头的文件）

location ~ /\. {

deny all;

}

# 下载特定类型的文件

location ~* \.(zip|rar|exe|pdf|doc|docx)$ {

# 添加下载头部

add_header Content-Disposition "attachment";

# 缓存控制

expires 30d;

}

}

Apache配置示例

ServerName example.com

DocumentRoot /var/www/files

# 启用目录浏览

Options +Indexes

# 文件下载配置

Header set Content-Disposition "attachment"

# 安全配置：隐藏.htaccess等文件

Order allow,deny

Deny from all

静态文件服务的性能优化

1. 启用Gzip压缩

对于文本文件，启用Gzip压缩可以显著减少传输数据量。

Nginx配置：

gzip on;

gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

gzip_min_length 1000;

gzip_comp_level 6;

2. 启用缓存

对于不经常变化的文件，设置合适的缓存头部可以减少服务器负载。

Nginx配置：

location ~* \.(jpg|jpeg|png|gif|ico|css|js|pdf|zip)$ {

expires 1y;

add_header Cache-Control "public, immutable";

}

3. 启用Sendfile

Sendfile是操作系统提供的零拷贝机制，可以大幅提升静态文件传输性能。

Nginx配置：

sendfile on;

tcp_nopush on;

tcp_nodelay on;

keepalive_timeout 65;

动态文件生成与下载

在实际应用中，我们经常需要动态生成文件并提供下载，例如生成报表、导出数据、打包文件等。

动态文件下载的实现原理

动态文件下载与静态文件下载的主要区别在于：

文件内容不是预先存储在磁盘上的

文件内容由程序实时生成

通常需要设置特定的HTTP头部来触发下载

Python Flask框架实现动态文件下载

1. 基础示例：返回内存中的文件数据

from flask import Flask, send_file, make_response

import io

import csv

from datetime import datetime

app = Flask(__name__)

@app.route('/download/report')

def download_report():

# 1. 生成CSV数据

output = io.StringIO()

writer = csv.writer(output)

# 写入表头

writer.writerow(['日期', '销售额', '订单数'])

# 写入数据行

data = [

['2024-01-01', 1500, 45],

['2024-01-02', 2300, 67],

['2024-01-03', 1800, 52]

]

writer.writerows(data)

# 2. 转换为字节

output.seek(0)

csv_bytes = output.getvalue().encode('utf-8')

# 3. 创建响应

response = make_response(csv_bytes)

# 4. 设置下载头部

timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')

response.headers['Content-Type'] = 'text/csv'

response.headers['Content-Disposition'] = f'attachment; filename=销售报表_{timestamp}.csv'

response.headers['Content-Length'] = len(csv_bytes)

return response

@app.route('/download/dynamic-zip')

def download_dynamic_zip():

import zipfile

import tempfile

import os

# 1. 创建临时ZIP文件

temp_zip = tempfile.NamedTemporaryFile(delete=False, suffix='.zip')

try:

# 2. 创建ZIP文件并添加内容

with zipfile.ZipFile(temp_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:

# 添加第一个文件

zipf.writestr('report.txt', '销售数据分析报告\n日期：2024-01-01\n...')

# 添加第二个文件

zipf.writestr('data.csv', '产品,数量,价格\n产品A,10,100\n产品B,20,200')

# 3. 读取ZIP文件内容

temp_zip.close()

with open(temp_zip.name, 'rb') as f:

zip_content = f.read()

# 4. 创建响应

response = make_response(zip_content)

response.headers['Content-Type'] = 'application/zip'

response.headers['Content-Disposition'] = 'attachment; filename=动态打包文件.zip'

response.headers['Content-Length'] = len(zip_content)

return response

finally:

# 5. 清理临时文件

if os.path.exists(temp_zip.name):

os.unlink(temp_zip.name)

if __name__ == '__main__':

app.run(debug=True, port=5000)

2. 使用send_file函数简化实现

Flask提供了send_file函数，可以更方便地处理文件下载：

from flask import Flask, send_file

import io

import tempfile

import os

app = Flask(__name__)

@app.route('/download/simple-csv')

def simple_csv():

# 生成CSV数据

csv_data = "姓名,年龄,城市\n张三,25,北京\n李四,30,上海"

# 转换为字节流

csv_bytes = csv_data.encode('utf-8')

file_obj = io.BytesIO(csv_bytes)

# 使用send_file发送

return send_file(

file_obj,

mimetype='text/csv',

as_attachment=True,

download_name='用户数据.csv'

)

@app.route('/download/large-file')

def download_large_file():

# 对于大文件，使用临时文件而不是内存

temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.txt')

try:

# 生成大文件内容（这里简化为重复文本）

content = "这是一行测试数据。\n" * 100000 # 生成约2MB数据

temp_file.write(content.encode('utf-8'))

temp_file.close()

# 发送文件

return send_file(

temp_file.name,

mimetype='text/plain',

as_attachment=True,

download_name='大文件.txt'

)

except Exception as e:

# 确保清理临时文件

if os.path.exists(temp_file.name):

os.unlink(temp_file.name)

raise e

if __name__ == '__main__':

app.run(debug=True, port=5000)

Node.js Express框架实现动态文件下载

const express = require('express');

const fs = require('fs');

const path = require('path');

const archiver = require('archiver'); // 用于创建ZIP文件

const app = express();

// 基础文本文件下载

app.get('/download/text', (req, res) => {

const content = `用户报告

生成时间: ${new Date().toLocaleString()}

用户ID: ${req.query.userId || '未知'}

这是一个动态生成的文本文件。

包含多行内容，用于演示文件下载功能。`;

// 设置响应头部

res.setHeader('Content-Type', 'text/plain; charset=utf-8');

res.setHeader('Content-Disposition', 'attachment; filename="用户报告.txt"');

res.setHeader('Content-Length', Buffer.byteLength(content, 'utf-8'));

// 发送内容

res.send(content);

});

// JSON数据导出

app.get('/download/json', (req, res) => {

const data = {

timestamp: new Date().toISOString(),

user: {

id: 123,

name: "张三",

email: "zhangsan@example.com"

},

products: [

{ id: 1, name: "产品A", price: 100 },

{ id: 2, name: "产品B", price: 200 }

]

};

const jsonData = JSON.stringify(data, null, 2);

res.setHeader('Content-Type', 'application/json');

res.setHeader('Content-Disposition', 'attachment; filename="数据导出.json"');

res.setHeader('Content-Length', Buffer.byteLength(jsonData, 'utf-8'));

res.send(jsonData);

});

// 动态生成ZIP文件

app.get('/download/zip', (req, res) => {

// 设置响应头部

res.setHeader('Content-Type', 'application/zip');

res.setHeader('Content-Disposition', 'attachment; filename="打包文件.zip"');

// 创建ZIP归档

const archive = archiver('zip', {

zlib: { level: 9 } // 最大压缩级别

});

// 处理错误

archive.on('error', (err) => {

console.error('ZIP创建错误:', err);

res.status(500).send('创建ZIP文件失败');

});

// 将ZIP流管道到响应

archive.pipe(res);

// 添加文件到ZIP

archive.append('这是第一个文件的内容', { name: 'file1.txt' });

archive.append('这是第二个文件的内容', { name: 'file2.txt' });

// 也可以添加JSON数据

const jsonData = JSON.stringify({ message: "配置数据", version: "1.0" }, null, 2);

archive.append(jsonData, { name: 'config.json' });

// 完成归档

archive.finalize();

});

// 大文件流式下载（避免内存占用）

app.get('/download/stream', (req, res) => {

const filePath = path.join(__dirname, 'large-file.txt');

// 检查文件是否存在

if (!fs.existsSync(filePath)) {

// 如果文件不存在，动态创建一个

const writeStream = fs.createWriteStream(filePath);

for (let i = 0; i < 100000; i++) {

writeStream.write(`行 ${i + 1}: 这是大文件的测试数据行\n`);

}

writeStream.end();

// 等待文件写入完成

writeStream.on('finish', () => {

streamFile(filePath, res);

});

} else {

streamFile(filePath, res);

}

});

function streamFile(filePath, res) {

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'text/plain');

res.setHeader('Content-Disposition', 'attachment; filename="大文件.txt"');

res.setHeader('Content-Length', stats.size);

res.setHeader('Accept-Ranges', 'bytes');

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('文件流错误:', err);

res.status(500).send('文件读取失败');

});

}

// 断点续传支持

app.get('/download/resumable', (req, res) => {

const filePath = path.join(__dirname, 'large-file.txt');

// 确保文件存在

if (!fs.existsSync(filePath)) {

// 创建一个2MB的测试文件

const writeStream = fs.createWriteStream(filePath);

const buffer = Buffer.alloc(1024 * 1024, 'A'); // 1MB数据

writeStream.write(buffer);

writeStream.write(buffer);

writeStream.end();

}

const stats = fs.statSync(filePath);

const range = req.headers.range;

if (range) {

// 解析范围请求

const parts = range.replace(/bytes=/, "").split("-");

const start = parseInt(parts[0], 10);

const end = parts[1] ? parseInt(parts[1], 10) : stats.size - 1;

const chunkSize = (end - start) + 1;

// 检查范围是否有效

if (start >= stats.size || end >= stats.size || start > end) {

res.setHeader('Content-Range', `bytes */${stats.size}`);

res.status(416).send('Range Not Satisfiable');

return;

}

// 设置部分内容响应

res.status(206);

res.setHeader('Content-Type', 'text/plain');

res.setHeader('Content-Range', `bytes ${start}-${end}/${stats.size}`);

res.setHeader('Content-Length', chunkSize);

res.setHeader('Accept-Ranges', 'bytes');

res.setHeader('Content-Disposition', 'attachment; filename="大文件.txt"');

// 发送指定范围的数据

const readStream = fs.createReadStream(filePath, { start, end });

readStream.pipe(res);

} else {

// 完整文件下载

res.setHeader('Content-Type', 'text/plain');

res.setHeader('Content-Disposition', 'attachment; filename="大文件.txt"');

res.setHeader('Content-Length', stats.size);

res.setHeader('Accept-Ranges', 'bytes');

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

}

});

app.listen(3000, () => {

console.log('文件下载服务器运行在 http://localhost:3000');

console.log('可用的下载端点:');

console.log(' /download/text - 文本文件');

console.log(' /download/json - JSON数据');

console.log(' /download/zip - ZIP压缩包');

console.log(' /download/stream - 大文件流式下载');

console.log(' /download/resumable - 支持断点续传的文件');

});

Java Spring Boot实现文件下载

import org.springframework.core.io.Resource;

import org.springframework.core.io.UrlResource;

import org.springframework.http.HttpHeaders;

import org.springframework.http.MediaType;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;

import java.io.*;

import java.net.MalformedURLException;

import java.nio.charset.StandardCharsets;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.time.LocalDateTime;

import java.time.format.DateTimeFormatter;

import java.util.zip.ZipEntry;

import java.util.zip.ZipOutputStream;

@RestController

@RequestMapping("/api/download")

public class FileDownloadController {

// 基础文本文件下载

@GetMapping("/text")

public ResponseEntity downloadTextFile() {

String content = "用户报告\n" +

"生成时间: " + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")) + "\n" +

"这是一个动态生成的文本文件。";

byte[] bytes = content.getBytes(StandardCharsets.UTF_8);

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.TEXT_PLAIN);

headers.setContentDispositionFormData("attachment", "用户报告.txt");

headers.setContentLength(bytes.length);

return ResponseEntity.ok()

.headers(headers)

.body(bytes);

}

// CSV文件下载

@GetMapping("/csv")

public ResponseEntity downloadCsv() {

StringBuilder csv = new StringBuilder();

csv.append("姓名,年龄,城市\n");

csv.append("张三,25,北京\n");

csv.append("李四,30,上海\n");

csv.append("王五,28,广州\n");

byte[] bytes = csv.toString().getBytes(StandardCharsets.UTF_8);

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.parseMediaType("text/csv"));

headers.setContentDispositionFormData("attachment", "用户数据.csv");

headers.setContentLength(bytes.length);

return ResponseEntity.ok()

.headers(headers)

.body(bytes);

}

// 动态生成ZIP文件

@GetMapping("/zip")

public ResponseEntity downloadZip() throws IOException {

// 创建临时文件

File tempFile = File.createTempFile("download", ".zip");

try (FileOutputStream fos = new FileOutputStream(tempFile);

ZipOutputStream zos = new ZipOutputStream(fos)) {

// 添加第一个文件

ZipEntry entry1 = new ZipEntry("report.txt");

zos.putNextEntry(entry1);

String content1 = "销售报告\n日期: " + LocalDateTime.now() + "\n数据: ...";

zos.write(content1.getBytes(StandardCharsets.UTF_8));

zos.closeEntry();

// 添加第二个文件

ZipEntry entry2 = new ZipEntry("data.csv");

zos.putNextEntry(entry2);

String content2 = "产品,数量,价格\n产品A,10,100\n产品B,20,200";

zos.write(content2.getBytes(StandardCharsets.UTF_8));

zos.closeEntry();

zos.finish();

}

// 读取ZIP文件内容

byte[] zipBytes = Files.readAllBytes(tempFile.toPath());

// 清理临时文件

tempFile.delete();

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.parseMediaType("application/zip"));

headers.setContentDispositionFormData("attachment", "动态打包文件.zip");

headers.setContentLength(zipBytes.length);

return ResponseEntity.ok()

.headers(headers)

.body(zipBytes);

}

// 流式下载大文件

@GetMapping("/stream")

public void streamLargeFile(HttpServletResponse response) throws IOException {

// 创建临时大文件（如果不存在）

Path tempFile = Paths.get("large-file.txt");

if (!Files.exists(tempFile)) {

try (BufferedWriter writer = Files.newBufferedWriter(tempFile)) {

for (int i = 0; i < 100000; i++) {

writer.write("行 " + (i + 1) + ": 这是大文件的测试数据行\n");

}

}

}

// 设置响应头部

response.setContentType("text/plain");

response.setHeader("Content-Disposition", "attachment; filename=\"大文件.txt\"");

response.setHeader("Content-Length", String.valueOf(Files.size(tempFile)));

response.setHeader("Accept-Ranges", "bytes");

// 流式传输

try (InputStream inputStream = Files.newInputStream(tempFile);

OutputStream outputStream = response.getOutputStream()) {

byte[] buffer = new byte[8192];

int bytesRead;

while ((bytesRead = inputStream.read(buffer)) != -1) {

outputStream.write(buffer, 0, bytesRead);

}

}

}

// 支持断点续传的下载

@GetMapping("/resumable")

public ResponseEntity downloadResumable(

@RequestHeader(value = "Range", required = false) String rangeHeader) throws IOException {

Path filePath = Paths.get("large-file.txt");

// 创建文件如果不存在

if (!Files.exists(filePath)) {

try (BufferedWriter writer = Files.newBufferedWriter(filePath)) {

for (int i = 0; i < 100000; i++) {

writer.write("行 " + (i + 1) + ": 这是大文件的测试数据行\n");

}

}

}

long fileSize = Files.size(filePath);

if (rangeHeader != null) {

// 解析范围请求

String[] ranges = rangeHeader.replace("bytes=", "").split("-");

long start = Long.parseLong(ranges[0]);

long end = ranges.length > 1 ? Long.parseLong(ranges[1]) : fileSize - 1;

// 检查范围有效性

if (start >= fileSize || end >= fileSize || start > end) {

return ResponseEntity.status(416)

.header("Content-Range", "bytes */" + fileSize)

.build();

}

// 创建部分资源

Resource resource = new UrlResource(filePath.toUri());

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.TEXT_PLAIN);

headers.setContentDispositionFormData("attachment", "大文件.txt");

headers.set("Content-Range", "bytes " + start + "-" + end + "/" + fileSize);

headers.set("Accept-Ranges", "bytes");

headers.setContentLength(end - start + 1);

return ResponseEntity.status(206)

.headers(headers)

.body(resource);

} else {

// 完整文件下载

Resource resource = new UrlResource(filePath.toUri());

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.TEXT_PLAIN);

headers.setContentDispositionFormData("attachment", "大文件.txt");

headers.set("Accept-Ranges", "bytes");

headers.setContentLength(fileSize);

return ResponseEntity.ok()

.headers(headers)

.body(resource);

}

}

// 安全下载：验证用户权限

@GetMapping("/secure/{fileId}")

public ResponseEntity downloadSecure(

@PathVariable String fileId,

@RequestHeader("Authorization") String authHeader) throws IOException {

// 这里应该实现实际的权限验证逻辑

if (!isValidUser(authHeader)) {

return ResponseEntity.status(401).build();

}

// 根据fileId查找实际文件路径（这里使用模拟数据）

String fileName = "机密文件_" + fileId + ".txt";

String content = "这是受保护的文件内容，只有授权用户才能下载。\n" +

"文件ID: " + fileId + "\n" +

"下载时间: " + LocalDateTime.now();

byte[] bytes = content.getBytes(StandardCharsets.UTF_8);

HttpHeaders headers = new HttpHeaders();

headers.setContentType(MediaType.TEXT_PLAIN);

headers.setContentDispositionFormData("attachment", fileName);

headers.setContentLength(bytes.length);

return ResponseEntity.ok()

.headers(headers)

.body(bytes);

}

private boolean isValidUser(String authHeader) {

// 这里应该实现实际的认证逻辑

// 例如：验证JWT token或检查session

return authHeader != null && authHeader.startsWith("Bearer ");

}

}

高级功能实现

1. 断点续传（Range请求）

断点续传允许客户端在下载中断后从上次的位置继续下载，而不是重新开始。这在下载大文件时特别有用。

实现原理

客户端发送带有Range头部的请求

服务器解析Range头部，确定请求的字节范围

服务器返回206 Partial Content状态码

服务器在响应头中包含Content-Range指示返回的数据范围

客户端可以组合多个部分响应来重建完整文件

完整实现示例（Node.js）

const fs = require('fs');

const path = require('path');

const express = require('express');

const app = express();

// 支持断点续传的文件下载

app.get('/download/:filename', (req, res) => {

const filename = req.params.filename;

const filePath = path.join(__dirname, 'downloads', filename);

// 检查文件是否存在

if (!fs.existsSync(filePath)) {

return res.status(404).send('文件不存在');

}

const stats = fs.statSync(filePath);

const fileSize = stats.size;

const range = req.headers.range;

// 如果有Range头部，处理部分请求

if (range) {

// 解析Range头部

const parts = range.replace(/bytes=/, "").split("-");

const start = parseInt(parts[0], 10);

const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;

// 检查范围是否有效

if (start >= fileSize || end >= fileSize || start > end) {

res.setHeader('Content-Range', `bytes */${fileSize}`);

return res.status(416).send('Range Not Satisfiable');

}

const chunkSize = (end - start) + 1;

// 设置响应头部

res.status(206);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Range', `bytes ${start}-${end}/${fileSize}`);

res.setHeader('Content-Length', chunkSize);

res.setHeader('Accept-Ranges', 'bytes');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

// 创建读取流并发送指定范围的数据

const readStream = fs.createReadStream(filePath, { start, end });

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('读取文件错误:', err);

res.status(500).send('文件读取失败');

});

} else {

// 完整文件下载

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

res.setHeader('Content-Length', fileSize);

res.setHeader('Accept-Ranges', 'bytes');

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('读取文件错误:', err);

res.status(500).send('文件读取失败');

});

}

});

// 上传文件端点（用于测试下载）

app.post('/upload', (req, res) => {

const filename = req.query.filename || 'test-file.bin';

const size = parseInt(req.query.size) || (10 * 1024 * 1024); // 默认10MB

const filePath = path.join(__dirname, 'downloads', filename);

// 创建测试文件

const writeStream = fs.createWriteStream(filePath);

const buffer = Buffer.alloc(1024 * 1024, 'X'); // 1MB数据

let written = 0;

const writeChunk = () => {

if (written >= size) {

writeStream.end();

res.send(`文件 ${filename} 创建完成，大小: ${size} 字节`);

return;

}

const toWrite = Math.min(size - written, buffer.length);

writeStream.write(buffer.slice(0, toWrite));

written += toWrite;

setImmediate(writeChunk);

};

writeChunk();

});

app.listen(3000, () => {

console.log('断点续传服务器运行在 http://localhost:3000');

console.log('测试命令:');

console.log(' curl -X POST "http://localhost:3000/upload?filename=test.bin&size=5000000"');

console.log(' curl -H "Range: bytes=0-1023" http://localhost:3000/download/test.bin');

});

Python实现断点续传

from flask import Flask, request, send_file, make_response

import os

import math

app = Flask(__name__)

DOWNLOAD_DIR = 'downloads'

# 确保下载目录存在

os.makedirs(DOWNLOAD_DIR, exist_ok=True)

@app.route('/download/')

def download_file(filename):

file_path = os.path.join(DOWNLOAD_DIR, filename)

if not os.path.exists(file_path):

return "文件不存在", 404

file_size = os.path.getsize(file_path)

range_header = request.headers.get('Range')

if range_header:

# 解析Range头部

try:

range_value = range_header.replace('bytes=', '').split('-')

start = int(range_value[0])

end = int(range_value[1]) if range_value[1] else file_size - 1

# 验证范围有效性

if start >= file_size or end >= file_size or start > end:

response = make_response()

response.headers['Content-Range'] = f'bytes */{file_size}'

response.status_code = 416

return response

chunk_size = end - start + 1

# 创建部分响应

response = make_response()

response.status_code = 206

response.headers['Content-Type'] = 'application/octet-stream'

response.headers['Content-Range'] = f'bytes {start}-{end}/{file_size}'

response.headers['Content-Length'] = chunk_size

response.headers['Accept-Ranges'] = 'bytes'

response.headers['Content-Disposition'] = f'attachment; filename="{filename}"'

# 读取并返回指定范围的数据

with open(file_path, 'rb') as f:

f.seek(start)

response.data = f.read(chunk_size)

return response

except ValueError:

return "无效的Range头部", 400

else:

# 完整文件下载

response = send_file(file_path, as_attachment=True, download_name=filename)

response.headers['Accept-Ranges'] = 'bytes'

return response

@app.route('/upload', methods=['POST'])

def upload_file():

"""创建测试文件"""

filename = request.args.get('filename', 'test.bin')

size = int(request.args.get('size', 10 * 1024 * 1024))

file_path = os.path.join(DOWNLOAD_DIR, filename)

# 创建指定大小的文件

with open(file_path, 'wb') as f:

# 写入1MB的块

chunk_size = 1024 * 1024

for _ in range(math.ceil(size / chunk_size)):

f.write(b'X' * min(chunk_size, size - f.tell()))

return f'文件 {filename} 创建完成，大小: {size} 字节'

if __name__ == '__main__':

app.run(debug=True, port=5000)

2. 下载限速（流量控制）

为了防止服务器带宽被占满，影响其他服务，有时需要对下载速度进行限制。

Node.js实现下载限速

const fs = require('fs');

const path = require('path');

const express = require('express');

const app = express();

// 限速下载

app.get('/download/throttled/:filename', (req, res) => {

const filename = req.params.filename;

const filePath = path.join(__dirname, 'downloads', filename);

if (!fs.existsSync(filePath)) {

return res.status(404).send('文件不存在');

}

const stats = fs.statSync(filePath);

const speedLimit = parseInt(req.query.speed) || (100 * 1024); // 默认100KB/s

// 设置响应头部

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath);

let totalBytes = 0;

let startTime = Date.now();

// 通过暂停和恢复来控制速度

const throttle = () => {

const elapsed = (Date.now() - startTime) / 1000; // 秒

const expectedBytes = elapsed * speedLimit;

if (totalBytes > expectedBytes) {

// 速度过快，暂停

readStream.pause();

const delay = ((totalBytes - expectedBytes) / speedLimit) * 1000;

setTimeout(() => {

if (!readStream.destroyed) {

readStream.resume();

}

}, delay);

}

};

readStream.on('data', (chunk) => {

totalBytes += chunk.length;

// 发送数据

const canWrite = res.write(chunk);

// 如果缓冲区已满，暂停读取

if (!canWrite) {

readStream.pause();

res.once('drain', () => {

if (!readStream.destroyed) {

readStream.resume();

}

});

}

// 检查是否需要限速

throttle();

});

readStream.on('end', () => {

res.end();

});

readStream.on('error', (err) => {

console.error('下载错误:', err);

if (!res.headersSent) {

res.status(500).send('下载失败');

}

});

// 处理客户端断开连接

req.on('close', () => {

readStream.destroy();

});

});

// 使用Token Bucket算法的更精确限速

class TokenBucket {

constructor(capacity, refillRate) {

this.capacity = capacity; // 桶容量

this.tokens = capacity; // 当前令牌数

this.refillRate = refillRate; // 每秒补充速率

this.lastRefill = Date.now();

}

consume(amount = 1) {

this.refill();

if (this.tokens >= amount) {

this.tokens -= amount;

return true;

}

return false;

}

refill() {

const now = Date.now();

const elapsed = (now - this.lastRefill) / 1000;

const newTokens = elapsed * this.refillRate;

if (newTokens > 0) {

this.tokens = Math.min(this.capacity, this.tokens + newTokens);

this.lastRefill = now;

}

}

getWaitTime(amount = 1) {

this.refill();

if (this.tokens >= amount) {

return 0;

}

const needed = amount - this.tokens;

return (needed / this.refillRate) * 1000;

}

}

app.get('/download/token-bucket/:filename', (req, res) => {

const filename = req.params.filename;

const filePath = path.join(__dirname, 'downloads', filename);

if (!fs.existsSync(filePath)) {

return res.status(404).send('文件不存在');

}

const stats = fs.statSync(filePath);

const speedLimit = parseInt(req.query.speed) || (100 * 1024); // 字节/秒

// 创建令牌桶：容量为1秒的数据，每秒补充speedLimit个令牌

const bucket = new TokenBucket(speedLimit, speedLimit);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath, { highWaterMark: 64 * 1024 }); // 64KB chunks

let paused = false;

const checkAndSend = () => {

if (paused) return;

// 尝试消费令牌（每次发送64KB）

if (bucket.consume(64 * 1024)) {

// 可以发送数据

let chunk;

while ((chunk = readStream.read()) !== null) {

if (!res.write(chunk)) {

// 响应缓冲区已满

paused = true;

res.once('drain', () => {

paused = false;

checkAndSend();

});

return;

}

}

} else {

// 需要等待

const waitTime = bucket.getWaitTime(64 * 1024);

paused = true;

setTimeout(() => {

paused = false;

checkAndSend();

}, waitTime);

}

};

readStream.on('readable', checkAndSend);

readStream.on('end', () => {

res.end();

});

readStream.on('error', (err) => {

console.error('下载错误:', err);

if (!res.headersSent) {

res.status(500).send('下载失败');

}

});

req.on('close', () => {

readStream.destroy();

});

});

app.listen(3000, () => {

console.log('限速下载服务器运行在 http://localhost:3000');

});

3. 下载统计与监控

记录下载统计信息对于分析用户行为、优化服务器配置和排查问题非常有用。

Node.js实现下载统计

const fs = require('fs');

const path = require('path');

const express = require('express');

const app = express();

// 下载统计存储

const downloadStats = {

totalDownloads: 0,

fileStats: {}, // 每个文件的下载次数

userStats: {}, // 每个IP的下载统计

dailyStats: {} // 每日统计

};

// 中间件：记录下载统计

function recordDownloadStats(req, res, next) {

const filename = req.params.filename || 'unknown';

const clientIP = req.ip || req.connection.remoteAddress;

const today = new Date().toISOString().split('T')[0];

// 总下载数

downloadStats.totalDownloads++;

// 文件统计

if (!downloadStats.fileStats[filename]) {

downloadStats.fileStats[filename] = 0;

}

downloadStats.fileStats[filename]++;

// 用户统计

if (!downloadStats.userStats[clientIP]) {

downloadStats.userStats[clientIP] = {

total: 0,

files: {}

};

}

downloadStats.userStats[clientIP].total++;

if (!downloadStats.userStats[clientIP].files[filename]) {

downloadStats.userStats[clientIP].files[filename] = 0;

}

downloadStats.userStats[clientIP].files[filename]++;

// 每日统计

if (!downloadStats.dailyStats[today]) {

downloadStats.dailyStats[today] = 0;

}

downloadStats.dailyStats[today]++;

next();

}

// 应用统计中间件

app.use('/download/:filename', recordDownloadStats);

// 下载端点

app.get('/download/:filename', (req, res) => {

const filename = req.params.filename;

const filePath = path.join(__dirname, 'downloads', filename);

if (!fs.existsSync(filePath)) {

return res.status(404).send('文件不存在');

}

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('下载错误:', err);

if (!res.headersSent) {

res.status(500).send('下载失败');

}

});

});

// 统计查询接口

app.get('/stats', (req, res) => {

const format = req.query.format || 'json';

if (format === 'html') {

// HTML格式统计

const html = `

文件下载统计

`;

res.send(html);

} else {

// JSON格式统计

res.json(downloadStats);

}

});

// 导出统计为CSV

app.get('/stats/export', (req, res) => {

let csv = '文件名,下载次数\n';

Object.entries(downloadStats.fileStats)

.sort((a, b) => b[1] - a[1])

.forEach(([file, count]) => {

csv += `${file},${count}\n`;

});

res.setHeader('Content-Type', 'text/csv');

res.setHeader('Content-Disposition', 'attachment; filename="下载统计.csv"');

res.send(csv);

});

// 重置统计

app.post('/stats/reset', (req, res) => {

downloadStats.totalDownloads = 0;

downloadStats.fileStats = {};

downloadStats.userStats = {};

downloadStats.dailyStats = {};

res.send('统计已重置');

});

app.listen(3000, () => {

console.log('带统计功能的下载服务器运行在 http://localhost:3000');

console.log('统计查看: http://localhost:3000/stats');

});

4. 安全下载：权限验证与访问控制

在实际应用中，不是所有文件都应该公开下载。需要实现权限验证机制。

Node.js实现安全下载

const express = require('express');

const jwt = require('jsonwebtoken'); // 用于JWT验证

const fs = require('fs');

const path = require('path');

const app = express();

app.use(express.json());

// JWT密钥（生产环境应该使用环境变量）

const JWT_SECRET = 'your-secret-key-change-in-production';

// 模拟用户数据库

const users = {

'admin': { password: 'admin123', role: 'admin', allowedFiles: ['*'] },

'user1': { password: 'user123', role: 'user', allowedFiles: ['public.pdf', 'report.txt'] },

'guest': { password: 'guest', role: 'guest', allowedFiles: ['public.pdf'] }

};

// 登录接口

app.post('/login', (req, res) => {

const { username, password } = req.body;

if (!username || !password) {

return res.status(400).json({ error: '用户名和密码不能为空' });

}

const user = users[username];

if (!user || user.password !== password) {

return res.status(401).json({ error: '用户名或密码错误' });

}

// 生成JWT token

const token = jwt.sign(

{

username,

role: user.role,

allowedFiles: user.allowedFiles

},

JWT_SECRET,

{ expiresIn: '1h' }

);

res.json({

message: '登录成功',

token,

expiresIn: '1小时'

});

});

// JWT验证中间件

function authenticateToken(req, res, next) {

const authHeader = req.headers['authorization'];

const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

if (!token) {

return res.status(401).json({ error: '未提供访问令牌' });

}

jwt.verify(token, JWT_SECRET, (err, user) => {

if (err) {

return res.status(403).json({ error: '令牌无效或已过期' });

}

req.user = user;

next();

});

}

// 权限检查中间件

function checkFilePermission(req, res, next) {

const filename = req.params.filename;

const user = req.user;

// 管理员可以访问所有文件

if (user.role === 'admin') {

return next();

}

// 检查用户是否有权限访问该文件

if (user.allowedFiles.includes('*') || user.allowedFiles.includes(filename)) {

next();

} else {

res.status(403).json({

error: '无权访问该文件',

reason: `用户 ${user.username} 没有文件 ${filename} 的访问权限`

});

}

}

// 安全下载端点

app.get('/secure-download/:filename', authenticateToken, checkFilePermission, (req, res) => {

const filename = req.params.filename;

const filePath = path.join(__dirname, 'secure-files', filename);

// 额外的安全检查：防止路径遍历攻击

const resolvedPath = path.resolve(filePath);

const secureDir = path.resolve(__dirname, 'secure-files');

if (!resolvedPath.startsWith(secureDir)) {

return res.status(403).json({ error: '无效的文件路径' });

}

if (!fs.existsSync(filePath)) {

return res.status(404).json({ error: '文件不存在' });

}

// 记录访问日志

console.log(`[${new Date().toISOString()}] 用户 ${req.user.username} 下载了 ${filename}`);

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('下载错误:', err);

if (!res.headersSent) {

res.status(500).json({ error: '下载失败' });

}

});

});

// 临时下载链接（一次性访问）

const tempLinks = new Map(); // 存储临时链接信息

app.post('/generate-temp-link', authenticateToken, (req, res) => {

const { filename, expiresIn = 300 } = req.body; // 默认5分钟

// 验证用户对该文件的权限

if (req.user.role !== 'admin' && !req.user.allowedFiles.includes('*') && !req.user.allowedFiles.includes(filename)) {

return res.status(403).json({ error: '无权生成该文件的临时链接' });

}

const filePath = path.join(__dirname, 'secure-files', filename);

if (!fs.existsSync(filePath)) {

return res.status(404).json({ error: '文件不存在' });

}

// 生成唯一token

const token = Math.random().toString(36).substring(2, 15);

// 存储临时链接信息

tempLinks.set(token, {

filename,

expires: Date.now() + expiresIn * 1000,

creator: req.user.username

});

// 清理过期链接（每5分钟）

if (cleanupInterval === null) {

cleanupInterval = setInterval(() => {

const now = Date.now();

for (const [token, info] of tempLinks.entries()) {

if (info.expires < now) {

tempLinks.delete(token);

}

}

}, 5 * 60 * 1000);

}

const tempUrl = `${req.protocol}://${req.get('host')}/temp-download/${token}`;

res.json({

message: '临时链接生成成功',

url: tempUrl,

expiresIn: `${expiresIn}秒`

});

});

let cleanupInterval = null;

// 临时下载端点

app.get('/temp-download/:token', (req, res) => {

const token = req.params.token;

const linkInfo = tempLinks.get(token);

if (!linkInfo) {

return res.status(404).json({ error: '临时链接无效或已过期' });

}

// 检查是否过期

if (linkInfo.expires < Date.now()) {

tempLinks.delete(token);

return res.status(410).json({ error: '临时链接已过期' });

}

const filePath = path.join(__dirname, 'secure-files', linkInfo.filename);

if (!fs.existsSync(filePath)) {

tempLinks.delete(token);

return res.status(404).json({ error: '文件不存在' });

}

// 记录访问

console.log(`[${new Date().toISOString()}] 临时链接下载: ${linkInfo.filename} (创建者: ${linkInfo.creator})`);

// 一次性链接，使用后删除

tempLinks.delete(token);

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${linkInfo.filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

readStream.on('error', (err) => {

console.error('下载错误:', err);

if (!res.headersSent) {

res.status(500).json({ error: '下载失败' });

}

});

});

// 下载历史记录

const downloadHistory = [];

// 记录每次下载的中间件

function logDownload(req, res, next) {

const originalSend = res.send;

const originalEnd = res.end;

const logEntry = {

timestamp: new Date().toISOString(),

user: req.user ? req.user.username : 'anonymous',

filename: req.params.filename || 'unknown',

clientIP: req.ip,

userAgent: req.get('User-Agent'),

status: null,

error: null

};

res.send = function(body) {

logEntry.status = this.statusCode;

downloadHistory.push(logEntry);

originalSend.call(this, body);

};

res.end = function(body) {

if (!logEntry.status) {

logEntry.status = this.statusCode;

downloadHistory.push(logEntry);

}

originalEnd.call(this, body);

};

res.on('error', (err) => {

logEntry.error = err.message;

logEntry.status = 500;

downloadHistory.push(logEntry);

});

next();

}

app.get('/secure-download/:filename', authenticateToken, checkFilePermission, logDownload, (req, res) => {

// ... 下载逻辑同上 ...

});

// 下载历史查询

app.get('/download-history', authenticateToken, (req, res) => {

if (req.user.role !== 'admin') {

return res.status(403).json({ error: '只有管理员可以查看下载历史' });

}

// 支持查询参数

const { user, filename, limit = 100 } = req.query;

let filtered = downloadHistory;

if (user) {

filtered = filtered.filter(entry => entry.user === user);

}

if (filename) {

filtered = filtered.filter(entry => entry.filename.includes(filename));

}

res.json({

total: filtered.length,

history: filtered.slice(-limit)

});

});

// 清理资源

process.on('SIGINT', () => {

if (cleanupInterval) {

clearInterval(cleanupInterval);

}

process.exit();

});

app.listen(3000, () => {

console.log('安全下载服务器运行在 http://localhost:3000');

console.log('使用方法:');

console.log('1. 登录: POST /login, body: {"username":"admin","password":"admin123"}');

console.log('2. 下载: GET /secure-download/filename, Header: Authorization: Bearer TOKEN');

});

性能优化与最佳实践

1. 使用CDN加速下载

对于全球用户，使用CDN可以显著提升下载速度。

配置示例：

// 在响应头部添加CDN缓存控制

app.get('/download/:filename', (req, res) => {

// ... 文件处理逻辑 ...

// CDN缓存控制

res.setHeader('Cache-Control', 'public, max-age=31536000'); // 1年缓存

res.setHeader('CDN-Cache-Control', 'max-age=31536000');

res.setHeader('Surrogate-Control', 'max-age=31536000');

// 对于静态文件，可以添加版本号或哈希来控制缓存失效

// 例如: /download/file-v1.2.3.zip

});

2. 文件压缩

对于文本文件，启用压缩可以减少传输数据量。

Nginx配置：

gzip on;

gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

gzip_min_length 1000;

gzip_comp_level 6;

gzip_vary on;

Node.js动态压缩：

const zlib = require('zlib');

const fs = require('fs');

app.get('/download/compressed/:filename', (req, res) => {

const filePath = path.join(__dirname, 'files', req.params.filename);

// 检查客户端是否支持压缩

const acceptEncoding = req.headers['accept-encoding'];

if (acceptEncoding && acceptEncoding.includes('gzip')) {

res.setHeader('Content-Encoding', 'gzip');

const readStream = fs.createReadStream(filePath);

const gzip = zlib.createGzip();

readStream.pipe(gzip).pipe(res);

} else {

// 不支持压缩，直接发送

res.sendFile(filePath);

}

});

3. 连接池与并发控制

对于高并发下载场景，需要控制并发连接数。

Node.js并发控制：

const express = require('express');

const Semaphore = require('semaphore'); // 需要安装: npm install semaphore

const app = express();

// 创建信号量，限制并发数为10

const downloadSemaphore = new Semaphore(10);

app.get('/download/controlled/:filename', (req, res) => {

const filePath = path.join(__dirname, 'files', req.params.filename);

// 获取信号量

downloadSemaphore.take(() => {

// 释放信号量的函数

const release = () => downloadSemaphore.leave();

// 检查文件是否存在

if (!fs.existsSync(filePath)) {

release();

return res.status(404).send('文件不存在');

}

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${req.params.filename}"`);

res.setHeader('Content-Length', stats.size);

const readStream = fs.createReadStream(filePath);

// 数据传输完成或错误时释放信号量

readStream.on('end', release);

readStream.on('error', (err) => {

console.error('下载错误:', err);

release();

});

// 处理客户端断开连接

req.on('close', () => {

if (!readStream.destroyed) {

readStream.destroy();

}

release();

});

readStream.pipe(res);

});

});

4. 异步I/O与零拷贝

使用操作系统的零拷贝功能可以大幅提升性能。

Node.js使用pipe（自动零拷贝优化）：

// 使用pipe而不是手动data事件处理

app.get('/download/optimal/:filename', (req, res) => {

const filePath = path.join(__dirname, 'files', req.params.filename);

// pipe会自动处理背压（backpressure）

const readStream = fs.createReadStream(filePath);

// 设置正确的头部

const stats = fs.statSync(filePath);

res.setHeader('Content-Type', 'application/octet-stream');

res.setHeader('Content-Disposition', `attachment; filename="${req.params.filename}"`);

res.setHeader('Content-Length', stats.size);

readStream.pipe(res);

// 错误处理

readStream.on('error', (err) => {

console.error('流错误:', err);

if (!res.headersSent) {

res.status(500).send('下载失败');

}

});

});

5. 内存管理

对于大文件下载，避免一次性加载到内存中。

错误做法（内存占用高）：

// ❌ 不要这样做

app.get('/download/bad/:filename', (req, res) => {

const filePath = path.join(__dirname, 'files', req.params.filename);

const data = fs.readFileSync(filePath); // 一次性读取整个文件到内存

res.send(data);

});

正确做法（流式传输）：

// ✅ 正确做法

app.get('/download/good/:filename', (req, res) => {

const filePath = path.join(__dirname, 'files', req.params.filename);

const readStream = fs.createReadStream(filePath);

readStream.pipe(res);

});

常见问题与解决方案

1. 下载文件名乱码

问题： 中文文件名在某些浏览器中显示为乱码。

解决方案：

// 使用URL编码或RFC 5987标准

function encodeFileName(fileName) {

// 检测是否需要编码（包含非ASCII字符）

if (/^[a-zA-Z0-9._-]+$/.test(fileName)) {

return fileName;

}

// UTF-8编码

const encoded = encodeURIComponent(fileName);

// 同时提供两种格式，兼容不同浏览器

return `filename*=UTF-8''${encoded}; filename="${encoded}"`;

}

// 使用示例

app.get('/download/chinese', (req, res) => {

const fileName = '中文文件名.pdf';

res.setHeader('Content-Disposition', `attachment; ${encodeFileName(fileName)}`);

// ... 发送文件内容

});

2. 跨域下载

问题： 从不同域名下载文件时遇到CORS限制。

解决方案：

// 设置CORS头部

app.use((req, res, next) => {

res.header('Access-Control-Allow-Origin', '*'); // 或指定具体域名

res.header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');

res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization, Range');

// 处理预检请求

if (req.method === 'OPTIONS') {

return res.sendStatus(200);

}

next();

});

// 对于需要认证的下载

app.get('/download/cors', (req, res) => {

// 验证来源（可选）

const origin = req.headers.origin;

if (origin && isAllowedOrigin(origin)) {

res.header('Access-Control-Allow-Origin', origin);

res.header('Access-Control-Allow-Credentials', 'true');

}

// ... 下载逻辑

});

3. 下载进度跟踪

问题： 用户需要知道大文件的下载进度。

解决方案（客户端）：

// 使用Fetch API跟踪进度

async function downloadWithProgress(url, filename) {

const response = await fetch(url);

if (!response.ok) {

throw new Error(`HTTP ${response.status}: ${response.statusText}`);

}

const contentLength = response.headers.get('Content-Length');

const total = parseInt(contentLength, 10);

let loaded = 0;

const reader = response.body.getReader();

const chunks = [];

while (true) {

const { done, value } = await reader.read();

if (done) break;

chunks.push(value);

loaded += value.length;

// 更新进度

const progress = (loaded / total) * 100;

console.log(`下载进度: ${progress.toFixed(2)}% (${loaded}/${total} bytes)`);

// 更新UI

if (window.updateProgress) {

window.updateProgress(progress);

}

}

// 组合所有chunks

const blob = new Blob(chunks);

const downloadUrl = URL.createObjectURL(blob);

// 创建下载链接

const a = document.createElement('a');

a.href = downloadUrl;

a.download = filename;

document.body.appendChild(a);

a.click();

document.body.removeChild(a);

// 清理

URL.revokeObjectURL(downloadUrl);

}

// 使用XMLHttpRequest（更兼容）

function downloadWithProgressXHR(url, filename) {

const xhr = new XMLHttpRequest();

xhr.responseType = 'blob';

xhr.onprogress = (event) => {

if (event.lengthComputable) {

const progress = (event.loaded / event.total) * 100;

console.log(`下载进度: ${progress.toFixed(2)}%`);

}

};

xhr.onload = () => {

if (xhr.status === 200) {

const blob = xhr.response;

const downloadUrl = URL.createObjectURL(blob);

const a = document.createElement('a');

a.href = downloadUrl;

a.download = filename;

document.body.appendChild(a);

a.click();

document.body.removeChild(a);

URL.revokeObjectURL(downloadUrl);

}

};

xhr.open('GET', url);

xhr.send();

}

4. 大文件下载超时

问题： 下载大文件时连接超时。

解决方案：

// 增加服务器超时设置

app.get('/download/large', (req, res) => {

// 增加响应超时

res.setTimeout(0); // 无超时限制

// 或者设置较长的超时时间

// res.setTimeout(30 * 60 * 1000); // 30分钟

// 使用keep-alive保持连接

res.setHeader('Connection', 'keep-alive');

res.setHeader('Keep-Alive', 'timeout=300'); // 5分钟

// ... 流式传输文件

});

// Nginx配置

/*

proxy_read_timeout 300;

proxy_connect_timeout 75;

*/

总结

HTTP服务器实现文件下载功能涉及多个层面的知识，从基础的HTTP协议理解到实际的代码实现，再到性能优化和安全考虑。本文详细介绍了：

基础原理：HTTP协议中文件下载的工作机制，关键头部信息的作用

静态文件服务：使用Nginx/Apache等Web服务器实现

动态文件生成：在Python、Node.js、Java中实现动态文件下载

高级功能：断点续传、下载限速、统计监控、安全控制

性能优化：CDN、压缩、并发控制、零拷贝等

常见问题：文件名乱码、跨域、进度跟踪、超时等

在实际项目中，选择合适的实现方式取决于具体需求：

对于静态文件，优先使用Nginx/Apache等专业Web服务器

对于动态生成的文件，使用流式传输避免内存占用

对于大文件，务必实现断点续传和限速功能

对于敏感文件，必须实现完整的权限验证和访问控制

通过合理运用这些技术和最佳实践，可以构建出高效、安全、可靠的文件下载服务。