1. Spring MVC文件上传概述
1.1 文件上传的核心原理
文件上传是Web应用中常见的功能需求，它允许用户将本地文件传输到服务器进行存储、处理或共享。在HTTP协议中，文件上传是通过multipart/form-data编码方式实现的。当用户提交包含文件的表单时，浏览器会将表单数据分割成多个部分（parts），每个部分可以包含文本数据或二进制文件数据。这些部分通过特定的边界字符串（boundary）分隔，并一起发送到服务器。
Spring MVC文件上传的核心是MultipartResolver接口，它负责解析HTTP请求中的multipart/form-data内容，将文件和表单字段转换为Spring MVC可以处理的对象。Spring提供了两种主要的MultipartResolver实现：CommonsMultipartResolver和StandardServletMultipartResolver。
CommonsMultipartResolver基于Apache Commons FileUpload库，它在解析文件上传请求时会将文件完全加载到内存中，适合处理小文件上传。而StandardServletMultipartResolver则基于Servlet 3.0+标准，可以将文件直接写入磁盘，避免内存溢出，适合处理大文件上传。无论使用哪种实现，Spring MVC都会将上传的文件封装为MultipartFile对象，开发者可以通过这个对象获取文件信息并进行处理。
1.2 Spring MVC文件上传的典型应用场景
Spring MVC文件上传功能在实际应用中有着广泛的应用场景，主要包括：
- 用户资料管理：用户上传头像、证件照等个人资料。
- 内容管理系统：用户上传文章、图片、视频等多媒体内容。
- 文件共享平台：用户上传各种类型的文件供他人下载。
- 电子签名系统：用户上传签名文件或图片。
- 在线教育平台：用户上传作业、论文或项目成果。
- 电商平台：商家上传商品图片、视频或详细介绍文档。
- 医疗信息系统：上传患者病历、检查报告、影像资料等。
在这些场景中，文件上传功能的实现需要考虑文件大小、类型、存储位置、安全性等多方面因素。对于不同的应用场景，可能需要采用不同的文件存储策略和处理方式。例如，在医疗信息系统中，可能需要对上传的影像文件进行加密存储和传输；而在电商平台中，可能需要对上传的商品图片进行压缩和格式转换以节省存储空间。
2. Spring MVC文件上传的前置条件
2.1 表单配置要求
要在Spring MVC中实现文件上传功能，首先需要确保前端表单正确配置。表单的enctype属性必须设置为"multipart/form-data"，method属性必须设置为"post"。这是因为只有使用这种编码方式，浏览器才会将文件数据以二进制形式发送，而不会将文件内容转换为文本格式。
<form action="/upload" method="post"
enctype="multipart/form-data">
<!-- 文件输入字段 -->
<input type="file" name="file" />
<!-- 其他表单字段 -->
<input type="text" name="description" />
<!-- 提交按钮 -->
<input type="submit" value="上传文件" />
</form>
在表单中，每个文件输入字段的name属性值必须与后端控制器中使用的参数名一致。例如，如果文件输入字段的name是"file"，那么后端控制器方法中对应的参数名也应该是"file"。
2.2 依赖库配置
根据选择的MultipartResolver实现，需要配置相应的依赖库。以下是两种主要实现方式的依赖配置：
使用CommonsMultipartResolver（基于Apache Commons FileUpload库）：
<!-- 在pom.xml中添加依赖 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.4</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
使用StandardServletMultipartResolver（基于Servlet 3.0+标准）：
<!-- 无需额外依赖，但需要确保Servlet容器支持Servlet 3.0+ -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>3.1.0</version>
<scope>provided</scope>
</dependency>
两种实现方式的对比：
| 特性 | CommonsMultipartResolver | StandardServletMultipartResolver |
|---|---|---|
| 依赖库 | 需要Apache Commons FileUpload | 无需额外依赖，基于Servlet标准 |
| 内存使用 | 将文件完全加载到内存 | 文件直接写入磁盘，内存占用少 |
| 最大文件限制 | 受内存限制 | 仅受磁盘空间限制 |
| 适用场景 | 小文件上传 | 大文件上传 |
| 版本要求 | 无特殊要求 | 需要Servlet 3.0+容器 |
选择哪种实现方式取决于具体的应用需求和运行环境。对于处理小文件上传，CommonsMultipartResolver可能更简单直接；而对于处理大文件上传，StandardServletMultipartResolver更为适合，因为它可以避免内存溢出问题。
3. Spring MVC文件上传的配置与实现
3.1 MultipartResolver配置详解
在Spring MVC中，MultipartResolver是处理文件上传的核心组件。根据选择的实现方式，配置方法有所不同。
使用CommonsMultipartResolver的配置：
<!-- 在spring-mvc.xml中配置 -->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons CommonMultipartResolver">
<!-- 设置最大文件上传大小（单位：字节） -->
<property name="maxUploadSize" value="10485760" />
<!-- 设置内存中处理的最大文件大小（超过则写入临时目录） -->
<property name="maxInMemorySize" value="1048576" />
</bean>
使用StandardServletMultipartResolver的配置：
<!-- 在spring-mvc.xml中配置 -->
<bean id="multipartResolver"
class="org.springframework.web.multipart support StandardServletMultipartResolver">
<!-- 设置是否延迟解析请求 -->
<property name="resolveLazily" value="true" />
</bean>
配置参数说明：
| 参数 | 描述 | 默认值 | 推荐值 |
|---|---|---|---|
| maxUploadSize | 最大允许上传的文件大小（字节） | 无限大 | 根据应用需求设置，如10485760（10MB） |
| maxInMemorySize | 文件在内存中处理的最大大小（超过则写入临时目录） | 1048576（1MB） | 根据应用需求设置，如1048576（1MB） |
| resolveLazily | 是否延迟解析请求，直到需要获取文件或表单字段时才解析 | false | true（对于大文件上传更安全） |
两种MultipartResolver实现的区别：
CommonsMultipartResolver基于Apache Commons FileUpload库，它在解析请求时会将所有文件和表单字段加载到内存中，适合处理小文件上传。而StandardServletMultipartResolver则利用Servlet 3.0+的内置文件上传支持，可以将文件直接写入磁盘，避免内存溢出，适合处理大文件上传。
在实际应用中，如果使用Spring Boot，StandardServletMultipartResolver会自动配置，无需手动声明Bean。只需在application.properties中设置相关参数即可：
# 设置文件上传参数
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
3.2 单文件上传的实现步骤与代码示例
单文件上传是最基本的文件上传场景，实现步骤如下：
- 创建表单，设置enctype为multipart/form-data。
- 在控制器中定义处理上传的请求方法。
- 使用MultipartFile参数接收上传的文件。
- 处理文件，如保存到本地、上传到云存储等。
- 返回结果，告知用户上传是否成功。
单文件上传的控制器代码示例：
@Controller
public class FileUploadController {
// 文件上传处理方法
@PostMapping("/upload")
public String handleFileUpload(
@RequestParam("file") MultipartFile file,
Model model) {
// 检查文件是否为空
if (file.isEmpty()) {
model.addAttribute("message", "文件为空，请重新上传");
return "uploadForm";
}
try {
// 获取文件名
String fileName = file.getOriginalFilename();
// 指定文件保存路径
String uploadPath = "/home/user/uploads/" + fileName;
// 创建目录（如果不存在）
File uploadDir = new File("/home/user/uploads");
if (!uploadDir.exists()) {
uploadDir.mkdirs();
}
// 保存文件到指定路径
File destFile = new File(uploadDir, fileName);
file.transferTo(destFile);
// 设置成功消息
model.addAttribute("message", "文件上传成功: " + fileName);
model.addAttribute("fileName", fileName);
return "uploadSuccess";
} catch (IOException e) {
e.printStackTrace();
model.addAttribute("message", "文件上传失败: " + e.getMessage());
return "uploadForm";
}
}
// 显示上传表单
@GetMapping("/upload")
public String showUploadForm(Model model) {
model.addAttribute("message", "");
return "uploadForm";
}
}
关键点总结：
- 使用
@RequestParam("file")注解接收上传的文件，参数名必须与表单中文件字段的name属性一致。 - 检查文件是否为空是必要的，避免处理空文件。
- 处理文件时应考虑异常情况，如IO异常，并进行适当的错误处理。
- 文件保存路径应设置为安全目录，避免与Web应用的根目录直接关联，防止路径遍历攻击。
- 在实际应用中，应避免使用文件的原始名称，而是使用随机生成的名称，防止文件名冲突和安全风险。
3.3 多文件上传的实现步骤与代码示例
多文件上传允许用户同时上传多个文件，实现方式与单文件上传类似，但需要调整参数类型。
使用数组接收多个文件的示例：
@PostMapping("/upload/multiple")
public String handleMultipleFiles(
@RequestParam("files") MultipartFile[] files,
Model model) {
List<String> successfulFiles = new ArrayList<>();
List<String> failedFiles = new ArrayList<>();
for (MultipartFile file : files) {
if (file.isEmpty()) {
failedFiles.add("文件为空: " + file.getName());
continue;
}
try {
// 获取文件名
String fileName = file.getOriginalFilename();
// 指定文件保存路径
String uploadPath = "/home/user/uploads/" + fileName;
// 创建目录（如果不存在）
File uploadDir = new File("/home/user/uploads");
if (!uploadDir.exists()) {
uploadDir.mkdirs();
}
// 保存文件到指定路径
File destFile = new File(uploadDir, fileName);
file.transferTo(destFile);
successfulFiles.add("上传成功: " + fileName);
} catch (IOException e) {
failedFiles.add("上传失败: " + file.getName() + " - " + e.getMessage());
}
}
model.addAttribute("successfulFiles", successfulFiles);
model.addAttribute("failedFiles", failedFiles);
return "uploadResult";
}
使用Map接收多个文件的示例：
@PostMapping("/upload/multiple(map)")
public String handleMultipleFilesMap(
@RequestParam Map<String, MultipartFile> filesMap,
Model model) {
List<String> successfulFiles = new ArrayList<>();
List<String> failedFiles = new ArrayList<>();
for (Map.Entry<String, MultipartFile> entry : filesMap.entrySet()) {
String paramKey = entry.getKey();
MultipartFile file = entry.getValue();
if (file.isEmpty()) {
failedFiles.add("文件为空: " + paramKey);
continue;
}
try {
// 获取文件名
String fileName = file.getOriginalFilename();
// 指定文件保存路径
String uploadPath = "/home/user/uploads/" + fileName;
// 保存文件到指定路径
File destFile = new File(uploadPath);
file.transferTo(destFile);
successfulFiles.add("上传成功: " + paramKey + " -> " + fileName);
} catch (IOException e) {
failedFiles.add("上传失败: " + paramKey + " - " + e.getMessage());
}
}
model.addAttribute("successfulFiles", successfulFiles);
model.addAttribute("failedFiles", failedFiles);
return "uploadResult";
}
关键点总结：
- 多文件上传可以通过
MultipartFile[]或Map<String, MultipartFile>接收。 - 使用数组方式时，表单中所有文件字段的name属性必须相同。
- 使用Map方式时，可以为每个文件字段使用不同的name属性，键即为name属性值。
- 处理多个文件时，需要遍历所有文件并逐个处理。
- 应记录每个文件的上传结果，以便向用户反馈哪些文件上传成功，哪些失败。
- 对于多文件上传，应考虑服务器资源限制，避免同时处理过多大文件导致性能问题。
4. Spring MVC文件上传的高级功能
4.1 文件大小限制与异常处理
文件大小限制是文件上传功能中重要的安全措施，可以防止用户上传过大的文件占用过多服务器资源。
在Spring MVC配置中设置文件大小限制：
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons CommonMultipartResolver">
<!-- 设置最大文件上传大小（单位：字节） -->
<property name="maxUploadSize" value="10485760" />
<!-- 设置内存中处理的最大文件大小（超过则写入临时目录） -->
<property name="maxInMemorySize" value="1048576" />
</bean>
在Spring Boot中设置文件大小限制：
# 设置文件上传参数
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
处理文件大小限制异常：
当用户上传的文件超过配置的大小限制时，Spring MVC会抛出FileSizeLimitExceededException异常。可以通过全局异常处理机制捕获并处理这些异常。
@ControllerAdvice
public class GlobalExceptionHandler {
// 捕获文件大小限制异常
@ExceptionHandler FileSizeLimitExceededException.class)
@ResponseBody
public Map<String, Object> handleFileSizeLimit(
FileSizeLimitExceededException ex) {
Map<String, Object> response = new HashMap<>();
response.put("code", 400);
response.put("message", "文件大小超出限制，请上传不超过10MB的文件");
response.put("details", ex.getMessage());
return response;
}
// 捕获其他上传相关异常
@ExceptionHandler MultipartException.class)
@ResponseBody
public Map<String, Object> handleMultipartException(
MultipartException ex) {
Map<String, Object> response = new HashMap<>();
response.put("code", 500);
response.put("message", "文件上传失败，请稍后重试");
response.put("details", ex.getMessage());
return response;
}
// 捕获参数缺失异常
@ExceptionHandler MissingServletRequestParameterException.class)
@ResponseBody
public Map<String, Object> handleMissingParameter(
MissingServletRequestParameterException ex) {
Map<String, Object> response = new HashMap<>();
response.put("code", 400);
response.put("message", "缺少必要参数，请检查表单提交");
response.put("details", ex.getMessage());
return response;
}
}
关键点总结：
- 文件大小限制可以通过配置maxUploadSize和maxInMemorySize参数实现。
- 文件大小限制异常（FileSizeLimitExceededException）和其他上传异常（MultipartException）可以通过全局异常处理机制统一捕获和处理。
- 全局异常处理使用@ControllerAdvice和@ExceptionHandler注解实现，可以返回结构化的错误信息（如JSON格式）。
- 对于不同的异常类型，应返回不同的错误代码和消息，以便前端正确处理。
- 文件大小限制不应仅依赖客户端验证，服务器端验证是必须的，因为客户端验证可以被绕过。
4.2 文件类型校验与安全性加固
文件类型校验是防止恶意文件上传的重要安全措施。攻击者可能上传包含恶意代码的文件（如WebShell），从而危害服务器安全。
文件类型校验的实现方式：
@PostMapping("/upload/secure")
public String handleSecureUpload(
@RequestParam("file") MultipartFile file,
Model model) {
// 检查文件是否为空
if (file.isEmpty()) {
model.addAttribute("message", "文件为空，请重新上传");
return "uploadForm";
}
// 获取文件名和MIME类型
String fileName = file.getOriginalFilename();
String contentType = file.getContentType();
// 白名单校验
List<String> allowedTypes = Arrays.asList(
"image/jpeg", "image/png", "application/pdf"
);
List<String> allowedExtensions = Arrays.asList(
"jpg", "png", "pdf"
);
// 校验MIME类型
if (!allowedTypes.contains(contentType)) {
model.addAttribute("message", "不支持的文件类型，请上传图片或PDF文件");
return "uploadForm";
}
// 校验文件扩展名
String extension = fileName.substring(
fileName.lastIndexOf('.') + 1).toLowerCase();
if (!allowedExtensions.contains(extension)) {
model.addAttribute("message", "不支持的文件扩展名，请上传.jpg、.png或.pdf文件");
return "uploadForm";
}
// 重命名文件，避免路径遍历和文件覆盖
String randomName = UUID.randomUUID().toString()
+ "." + extension;
// 保存文件到安全路径
String uploadPath = "/home/user/uploads/secured/" + randomName;
try {
// 创建目录（如果不存在）
File uploadDir = new File("/home/user/uploads/secured");
if (!uploadDir.exists()) {
uploadDir.mkdirs();
}
// 保存文件
File destFile = new File(uploadDir, randomName);
file transferTo(destFile);
model.addAttribute("message", "文件上传成功: " + randomName);
return "uploadSuccess";
} catch (IOException e) {
e.printStackTrace();
model.addAttribute("message", "文件上传失败: " + e.getMessage());
return "uploadForm";
}
}
关键点总结：
- 文件类型校验应同时检查MIME类型和文件扩展名，因为仅检查其中一个可能被绕过。
- 使用白名单机制，只允许特定类型的文件上传，而不是黑名单。
- 对文件名进行重命名，使用UUID等随机值生成安全文件名，避免路径遍历攻击和文件覆盖。
- 存储路径应设置为安全目录，避免与Web应用的根目录直接关联。
- 文件类型校验不应仅依赖客户端验证，服务器端验证是必须的。
4.3 文件存储策略
文件上传后的存储策略决定了文件的存储位置、方式和管理方法。常见的文件存储策略包括本地存储、数据库存储和云存储。
本地存储策略：
// 保存到本地文件系统
File destFile = new File("/home/user/uploads", fileName);
file transferTo(destFile);
数据库存储策略：
// 将文件内容保存到数据库
byte[] fileData = file.getBytes();
FileEntity fileEntity = new FileEntity();
fileEntity setsName(file.getOriginalFilename());
fileEntity setsContent(fileData);
fileEntity setsType(file.getContentType());
fileRepository.save(fileEntity);
云存储策略（以阿里云OSS为例）：
// 上传到阿里云OSS
OSSClient ossClient = new OSSClient(endpoint, accessKeyId, accessKeySecret);
PutObjectRequest putreq = new PutObjectRequest(bucketName, objectName, file.getInputStream());
ossClient.putObject(putreq);
ossClient.shutdown();
三种存储策略的对比：
| 策略 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
| 本地存储 | 实现简单，速度快，成本低 | 可扩展性差，存储空间有限，安全性较低 | 小型应用，文件量不大的场景 |
| 数据库存储 | 数据集中管理，安全性较高 | 查询效率低，存储成本高，不适合大文件 | 需要与业务数据紧密关联的小文件 |
| 云存储 | 高可用性，高扩展性，安全性高 | 实现复杂，需要额外配置，成本可能较高 | 大型应用，高并发，大文件存储需求 |
关键点总结：
- 本地存储是最简单的实现方式，但安全性较低，不适合敏感文件。
- 数据库存储适合需要与业务数据紧密结合的小文件，但不适合大文件。
- 云存储（如阿里云OSS、AWS S3等）适合大规模、高可用的文件存储需求，但需要额外配置和成本。
- 无论选择哪种存储策略，都应考虑文件安全性、访问控制、存储成本和性能等因素。
- 在实际应用中，可能需要结合多种存储策略，如将元数据保存在数据库，而实际文件保存在云存储。
5. Spring MVC文件上传的优化与扩展
5.1 与Spring Boot集成的简化配置
Spring Boot简化了文件上传的配置过程，通过自动配置减少了手动配置的工作量。
Spring Boot自动配置原理：
Spring Boot通过@SpringBootApplication注解自动启用默认配置。当引入spring-boot-starter-web时，内嵌Tomcat和默认的StandardServletMultipartResolver会自动配置，无需手动声明Bean。
Spring Boot文件上传配置：
# 设置文件上传参数
spring.servlet.multipart.max-file-size=10MB
spring.servlet.multipart.max-request-size=10MB
spring.servlet.multipart.enabled=true
spring.servlet.multipart.file-size-threshold=0
spring.servlet.multipart.resolve-lazily=true
Spring Boot文件上传控制器：
@RestController
public class BootFileUploadController {
// 单文件上传
@PostMapping("/boot/upload")
public ResponseEntity<String> handleBootUpload(
@RequestParam("file") MultipartFile file) {
if (file.isEmpty()) {
return ResponseEntity badRequest()
.body("文件为空，请重新上传");
}
try {
// 保存文件
String uploadPath = "/home/user/bootuploads/"
+ UUID.randomUUID().toString()
+ "." + getExtension(file.getOriginalFilename());
File destFile = new File(uploadPath);
file transferTo(destFile);
return ResponseEntity ok()
.body("文件上传成功: " + destFile.getName());
} catch (IOException e) {
e.printStackTrace();
return ResponseEntity internal ServerError()
.body("文件上传失败: " + e.getMessage());
}
}
// 获取文件扩展名
private String getExtension(String filename) {
return filename.substring(filename.lastIndexOf('.') + 1);
}
}
关键点总结：
- Spring Boot采用"约定优于配置"原则，简化了文件上传的配置。
- 默认使用
StandardServletMultipartResolver，无需额外依赖。 - 通过
application.properties或application.yml设置文件上传参数。 - Spring Boot的文件上传处理更加高效，特别是对于大文件。
- Spring Boot与传统Spring MVC在文件上传配置上的主要区别在于自动配置和依赖管理。
5.2 大文件分片上传实现方案
对于大文件上传，直接上传可能面临网络不稳定、服务器资源不足等问题。分片上传是一种有效的解决方案，它将大文件分割成多个小块，分别上传，最后在服务器端合并。
分片上传的基本流程：
- 初始化上传：客户端向服务器发送初始化请求，获取上传ID。
- 分片上传：客户端将文件分割成多个分片，逐个上传到服务器。
- 上传进度记录：服务器记录已上传的分片信息。
- 完成上传：客户端确认所有分片已上传，服务器合并分片为完整文件。
Spring MVC分片上传实现：
@RestController
public classChunkUploadController {
// 临时目录
private static final String TEMP_DIR = "/home/user/uploads/chunks";
// 分片大小（单位：字节）
private static final long chunkSize = 5 * 1024 * 1024; // 5MB
// 初始化上传
@PostMapping("/initiate")
public ResponseEntity<UploadInitiateResponse> initiateUpload(
@RequestParam("filename") String filename,
@RequestParam("fileSize") long fileSize,
@RequestParam("md5") String md5) {
// 检查文件是否已经存在
if (fileAlreadyExists(md5)) {
return ResponseEntity ok()
.body(new UploadInitiateResponse(md5, 0));
}
// 生成唯一标识符
String identifier = UUID.randomUUID().toString();
// 创建临时目录
File tempDir = new File(TEMP_DIR + File.separator + identifier);
if (!tempDir.exists()) {
tempDir.mkdirs();
}
// 记录分片信息
recordChunkInfo(identifier, filename, fileSize, md5);
return ResponseEntity ok()
.body(new UploadInitiateResponse(md5, identifier));
}
// 分片上传
@PostMapping("/chunk")
public ResponseEntity<String> uploadChunk(
@RequestParam("file") MultipartFile file,
@RequestParam("chunkNumber") int chunkNumber,
@RequestParam("totalChunks") int totalChunks,
@RequestParam("identifier") String identifier) {
if (file.isEmpty()) {
return ResponseEntity badRequest()
.body("分片文件为空");
}
try {
// 创建临时目录
File tempDir = new File(TEMP_DIR + File.separator + identifier);
if (!tempDir.exists()) {
return ResponseEntity notFound()
.body("上传会话不存在");
}
// 生成分片文件名
String chunkFilename = identifier + "-" + chunkNumber;
File chunkFile = new File(tempDir, chunkFilename);
// 保存分片文件
file transferTo(chunkFile);
// 记录上传进度
updateProgress(identifier, chunkNumber);
return ResponseEntity ok()
.body("分片" + chunkNumber + "上传成功");
} catch (IOException e) {
e.printStackTrace();
return ResponseEntity internal ServerError()
.body("分片上传失败: " + e.getMessage());
}
}
// 完成分片上传
@PostMapping("/complete")
public ResponseEntity<String> completeUpload(
@RequestParam("identifier") String identifier,
@RequestParam("md5") String md5,
@RequestParam("filename") String filename) {
try {
// 检查所有分片是否已上传
if (!allChunksUploaded(identifier)) {
return ResponseEntity badRequest()
.body("仍有分片未上传");
}
// 合并分片
mergeChunks(identifier, filename);
// 清理临时文件
cleanTempFiles(identifier);
return ResponseEntity ok()
.body("文件上传完成: " + filename);
} catch (IOException e) {
e.printStackTrace();
return ResponseEntity internal ServerError()
.body("文件上传失败: " + e.getMessage());
}
}
// 合并分片方法
private void mergeChunks(String identifier, String filename)
throws IOException {
// 获取临时目录
File tempDir = new File(TEMP_DIR + File.separator + identifier);
File[] chunkFiles = tempDir.listFiles();
// 按分片号排序
Arrays.sort(chunkFiles, (f1, f2) -> {
int chunkNum1 = Integer.parseInt(
f1.getName().split("-")[1]);
int chunkNum2 = Integer.parseInt(
f2.getName().split("-")[1]);
return chunkNum1 - chunkNum2;
});
// 合并文件
String mergedPath = "/home/user/uploads/merged/"
+ UUID.randomUUID().toString()
+ "." + getExtension(filename);
try (FileOutputStream合并输出流 = new FileOutputStream(mergedPath)) {
for (File chunkFile : chunkFiles) {
try (FileInputStream分片输入流 = new FileInputStream(chunkFile)) {
byte[] buffer = new byte[1024];
int length;
while ((length = chunkInputStream.read(buffer)) > 0) {
mergedOutputStream.write(buffer, 0, length);
}
}
}
}
// 验证合并后的文件MD5
if (!validateMD5(mergedPath, md5)) {
throw new IOException("文件合并后MD5校验失败");
}
// 清理临时目录
tempDir.deleteOnExit();
}
// 验证MD5
private boolean validateMD5(String filePath, String expectedMD5)
throws IOException {
// 计算文件MD5
String actualMD5 = calculateMD5(new File(filePath));
// 比较MD5值
return actualMD5.equals(expectedMD5);
}
// 计算MD5
private String calculateMD5(File file) throws IOException {
try (FileInputStream fileInputStream = new FileInputStream(file);
MessageDigest md = MessageDigest.getInstance("MD5")) {
byte[] buffer = new byte[8192];
int length;
while ((length = fileInputStream.read(buffer)) > 0) {
md.update(buffer, 0, length);
}
byte[] digest = md.digest();
return bytesToHex(digest);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
// 将字节数组转换为十六进制字符串
private String bytesToHex(byte[] bytes) {
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
sb.append(String.format("%02x", b));
}
return sb.toString();
}
// 检查文件是否存在
private boolean fileAlreadyExists(String md5) {
// 检查数据库或存储系统中是否已存在该MD5的文件
return false;
}
// 记录分片信息
private void recordChunkInfo(String identifier,
String filename, long fileSize, String md5) {
// 将分片信息保存到数据库或缓存中
}
// 更新上传进度
private void updateProgress(String identifier, int chunkNumber) {
// 更新数据库或缓存中的上传进度
}
// 检查所有分片是否已上传
private boolean allChunksUploaded(String identifier) {
// 检查数据库或缓存中记录的分片信息
return true;
}
// 清理临时文件
private void cleanTempFiles(String identifier) {
// 删除临时目录及其内容
File tempDir = new File(TEMP_DIR + File.separator + identifier);
if (tempDir.exists()) {
deleteDirectory(tempDir);
}
}
// 删除目录及其内容
private void deleteDirectory(File directory) {
File[] files = directory.listFiles();
if (files != null) {
for (File file : files) {
if (file.isDirectory()) {
deleteDirectory(file);
} else {
file.delete();
}
}
}
directory.delete();
}
}
关键点总结：
- 分片上传将大文件分割成多个小块，分别上传，减少网络不稳定带来的影响。
- 使用临时目录存储分片文件，上传完成后合并为完整文件，并清理临时文件。
- 通过MD5校验确保文件完整性，防止传输过程中的数据损坏。
- 分片上传需要记录上传进度和状态，可以通过数据库或缓存实现。
- 分片上传适合处理大文件（如超过100MB的文件），但实现复杂度较高。
5.3 文件上传进度监控与实现
文件上传进度监控可以提升用户体验，让用户了解上传进度，特别是对于大文件上传。
前端进度监控实现：
// 前端上传进度监控
function uploadFileWithProgress(file) {
const formData = new FormData();
formData.append('file', file);
const xhr = new XMLHttpRequest();
xhr.upload.addEventListener('progress', function (e) {
if (e.lengthComputable) {
const percent = (e.loaded / e.total) * 100;
console.log(`上传进度: ${percent}%`);
// 更新前端进度条
updateProgressUI percent);
}
}, false);
xhr.addEventListener('load', function () {
if (xhr.status === 200) {
console.log('文件上传成功');
// 处理成功响应
handleSuccess响应);
}
}, false);
xhr.addEventListener('error', function () {
console.log('文件上传失败');
// 处理失败响应
handleFailure响应);
}, false);
xhr.open('POST', '/upload', true);
xhr.send(formData);
}
后端进度监控实现：
@RestController
public class ProgressUploadController {
// 使用Redis记录上传进度
@Autowired
private RedisTemplate<String, String> redisTemplate;
// 分片上传
@PostMapping("/chunk")
public ResponseEntity<String> uploadChunk(
@RequestParam("file") MultipartFile file,
@RequestParam("chunkNumber") int chunkNumber,
@RequestParam("totalChunks") int totalChunks,
@RequestParam("identifier") String identifier) {
if (file.isEmpty()) {
return ResponseEntity badRequest()
.body("分片文件为空");
}
try {
// 保存分片文件
saveChunk(file, identifier, chunkNumber);
// 更新上传进度
updateProgress redisTemplate, identifier, chunkNumber, totalChunks);
// 返回进度信息
return ResponseEntity ok()
.body JSON.stringify({
progress: (chunkNumber + 1) / totalChunks * 100,
status: "success"
}));
} catch (IOException e) {
e.printStackTrace();
return ResponseEntity internal ServerError()
.body("分片上传失败: " + e.getMessage());
}
}
// 保存分片
private void saveChunk(MultipartFile file,
String identifier, int chunkNumber) throws IOException {
// 指定分片保存路径
String chunkPath = "/home/user/uploads/chunks/"
+ identifier + "-" + chunkNumber;
// 保存分片文件
File chunkFile = new File(chunkPath);
file transferTo(chunkFile);
}
// 更新进度
private void updateProgress(RedisTemplate<String, String> redisTemplate,
String identifier, int chunkNumber, int totalChunks) {
// 计算已上传分片数
int uploaded = redisTemplate.opsForValue().increment(
"upload:progress:" + identifier, 1);
// 设置总分片数
if ( uploaded == 1 ) {
redisTemplate.opsForValue().set(
"upload:total:" + identifier, totalChunks);
}
// 计算进度百分比
double progress = ( uploaded / (double) totalChunks ) * 100;
redisTemplate.opsForValue().set(
"upload:progress:" + identifier, String.valueOf progress));
}
// 查询进度
@GetMapping("/progress")
public ResponseEntity<String> getProgress(
@RequestParam("identifier") String identifier) {
// 从Redis获取进度
String progress = redisTemplate.opsForValue().get(
"upload:progress:" + identifier);
String total = redisTemplate.opsForValue().get(
"upload:total:" + identifier);
// 构建响应
Map<String, Object> response = new HashMap<>();
response.put("progress", progress != null ? progress : "0");
response.put("total", total != null ? total : "0");
response.put("status", "processing");
return ResponseEntity ok().body JSON.stringify(response));
}
}
关键点总结：
- 前端通过XMLHttpRequest的upload事件监听上传进度，实时更新进度条。
- 后端可以使用Redis等缓存系统记录上传进度，提供接口供前端查询。
- 进度监控需要考虑前端与后端的通信频率和方式，避免过多请求影响性能。
- 进度信息可以存储在内存、数据库或缓存系统中，根据应用需求选择合适的方式。
- 分片上传结合进度监控，可以提供更好的用户体验，特别是在处理大文件时。
6. 常见问题与解决方案
6.1 文件上传失败的常见原因分析
文件上传失败是开发过程中常见的问题，以下是几种常见的原因及解决方案：
1. 表单enctype未设置为multipart/form-data
现象：上传文件时，后端无法获取到文件，抛出MissingServletRequestParameterException异常。
原因：表单的enctype属性未设置为"multipart/form-data"，导致浏览器将文件内容转换为文本格式。
解决方案：确保表单的enctype属性设置为"multipart/form-data"。
<!-- 正确设置enctype -->
<form action="/upload" method="post"
enctype="multipart/form-data">
<input type="file" name="file" />
<input type="submit" value="上传" />
</form>
2. 文件大小超过限制
现象：上传大文件时，服务器抛出FileSizeLimitExceededException异常。
原因：文件大小超过了在配置中设置的maxUploadSize或maxRequestSize参数。
解决方案：调整配置中的文件大小限制参数，或在前端添加文件大小检查。
<!-- 调整文件大小限制 -->
<bean id="multipartResolver"
class="org.springframework.web.multipart.commons CommonMultipartResolver">
<property name="maxUploadSize" value="52428800" /> <!-- 50MB -->
<property name="maxInMemorySize" value="5242880" /> <!-- 5MB -->
</bean>
3. 依赖库冲突
现象：使用CommonsMultipartResolver时，出现ClassCastException或NoClassDefFoundError异常。
原因：项目中存在多个版本的Apache Commons FileUpload或IO库，导致依赖冲突。
解决方案：检查项目依赖，排除冲突的库版本。
<!-- 排除冲突的依赖 -->
<dependency>
<groupId>commons-fileupload</groupId>
<artifactId>commons-fileupload</artifactId>
<version>1.4</version>
<exclusions>
<exclusion>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.11.0</version>
</dependency>
4. 文件名编码问题
现象：上传的文件名包含中文或特殊字符时，保存到文件系统后无法正确读取或显示。
原因：浏览器和服务器对文件名的编码方式不同，导致解析错误。
解决方案：使用URLEncoder对文件名进行编码处理，确保前后端编码一致。
// 对文件名进行编码处理
String fileName = file.getOriginalFilename();
String encodedName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.toString());
// 保存文件时使用编码后的文件名
File destFile = new File("/home/user/uploads", encodedName);
file transferTo(destFile);
5. 文件上传路径权限问题
现象：上传文件时，服务器抛出IOException，提示权限不足。
原因：服务器对指定的上传目录没有写入权限。
解决方案：检查并设置上传目录的权限。
# 设置目录权限（Linux系统）
chmod 755 /home/user/uploads
6.2 文件路径冲突与文件名编码问题解决
文件路径冲突和文件名编码是文件上传中常见的问题，需要特别注意。
1. 文件名冲突
现象：上传相同名称的文件时，覆盖已存在的文件，导致数据丢失。
原因：直接使用文件的原始名称，未进行重命名处理。
解决方案：使用随机值或UUID对文件名进行重命名。
// 使用UUID重命名文件
String originalName = file.getOriginalFilename();
String extension = originalName.substring(
originalName.lastIndexOf('.') + 1);
String newfileName = UUID.randomUUID().toString()
+ "." + extension;
File destFile = new File("/home/user/uploads", newfileName);
file transferTo(destFile);
2. 路径遍历攻击
现象：上传的文件名包含"../"等路径信息，导致文件被保存到非预期的目录。
原因：未对文件名进行安全校验，直接使用原始文件名。
解决方案：对文件名进行安全校验，过滤掉路径信息。
// 安全校验文件名
String fileName = file.getOriginalFilename();
// 过滤特殊字符
String safeName = fileName.replaceAll("[^a-zA-Z0-9._-]", "_");
// 检查是否包含路径信息
if (safeName.contains../")) {
safeName = safeName.replace../", "");
}
// 生成最终文件名
String finalName = UUID.randomUUID().toString()
+ "." + getExtension(safeName);
// 获取文件扩展名
private String getExtension(String filename) {
if (filename == null) {
return null;
}
int dotIndex = filename最后一次出现索引('.');
if (dotIndex < 0 || dotIndex == filename.length() - 1) {
return null;
}
return filename.substring(dotIndex + 1).toLowerCase();
}
3. 文件名编码问题
现象：上传的文件名包含中文或特殊字符时，保存到文件系统后无法正确读取或显示。
原因：浏览器和服务器对文件名的编码方式不同，导致解析错误。
解决方案：使用URLEncoder对文件名进行编码处理，确保前后端编码一致。
// 对文件名进行编码处理
String fileName = file.getOriginalFilename();
String encodedName = URLEncoder.encode(fileName, StandardCharsets.UTF_8.toString());
// 保存文件时使用编码后的文件名
File destFile = new File("/home/user/uploads", encodedName);
file transferTo(destFile);
// 读取文件时进行解码
String encodedName = "test%20file.jpg";
String decodedName = URLDecoder.decode(encodedName, StandardCharsets.UTF_8.toString());
关键点总结：
- 文件名冲突可以通过随机重命名解决，避免覆盖已有文件。
- 路径遍历攻击是常见的安全威胁，必须对文件名进行安全校验。
- 文件名编码问题需要前后端一致的处理方式，通常使用UTF-8编码。
- 在处理文件名时，应同时考虑安全性、唯一性和可读性。
- 对于云存储，文件名编码问题可能不那么重要，但安全性校验仍然必要。
扫一扫
1346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
