SpringBoot实现文件分片断点续传功能（后端篇）
最近想实现一下分片上传的功能，文件分片上传就能实现断点续传了，数据库记录也能保证秒传功能的实现。记录一下宝宝demo。
前端部分可以看看这篇文章：Springboot实现文件分片断点续传功能（前端篇）
项目代码已上传至GitHub。 https://github.com/huiluczP/segment_upload
整体思路
- 首先利用数据库存储文件信息，包括文件物理地址，分片接收进程和对应的md5码。利用md5码可以判断当前上传文件是否在服务器中存在（实现秒传），利用分片接收Index可以判断现在应该上传。
- 前端ajax获取文件存在与否的信息，几种情况：
(1) 不存在，则创建数据库记录，成功后调用分片1的上传。
(2) 存在，Index和总分片数量相同，秒传成功显示结果。
(3) 存在，但index小于总分片数量，调用分片index的上传。 - 分片在前端根据分片Index计算起点末尾，slice切割，ajax调用上传传到服务器并存储。当前分片传递成功，ajax接收success信息，串行进行index+1的分片的上传。
具体后端实现使用的是springboot+mybatis。
数据库设计和持久化操作
主要就是segment_file表，用来存储文件对应信息。
其中file_path表示文件最终的物理路径（未完成的分片文件也会存储在parent文件夹中）。
file_name是uuid，segment_index是已经完成的分片数量，segment_total为总的分片数量。
md5_key是文件对应的唯一key，实现中是在前端计算的。
CREATE TABLE `segment_file` (
`id` int NOT NULL AUTO_INCREMENT,
`file_path` varchar(200) NOT NULL,
`file_name` varchar(200) DEFAULT NULL,
`size` int DEFAULT NULL,
`segment_index` int DEFAULT NULL,
`segment_size` int DEFAULT NULL,
`segment_total` int DEFAULT NULL,
`md5_key` varchar(200) DEFAULT NULL,
PRIMARY KEY (`id`)
)
持久化类 SegmentFile
public class SegmentFile implements Serializable {
private static final long serialVersionUID = -1937877331354085546L;
private int id;
private String filePath;
private String fileName;
private int size;
private int segmentIndex;
private int segmentSize;
private int segmentTotal;
private String md5Key;
getter…
setter…
}
Mapper接口，这边使用注解进行mybatis sql语句的配置.
@Mapper
public interface SegmentFileMapper {
// 获取对应的分片文件实体类
@Select("select * from segment_file where md5_key = #{key}")
@Results(id="segmentFileResult",value={
@Result(id=true, column = "id",property = "id"),
@Result(column = "file_path",property = "filePath"),
@Result(column = "file_name",property = "fileName"),
@Result(column = "size",property = "size"),
@Result(column = "segment_index",property = "segmentIndex"),
@Result(column = "segment_size",property = "segmentSize"),
@Result(column = "segment_total",property = "segmentTotal"),
@Result(column = "md5_key",property = "md5Key")
})
public List<SegmentFile> getSegmentFileByKey(String key);
// 添加对应的文件实体类
@Insert("insert into segment_file(id,file_path,file_name," +
"size,segment_index,segment_size,segment_total,md5_key) " +
"values(#{id},#{filePath},#{fileName},#{size},#{segmentIndex}," +
"#{segmentSize},#{segmentTotal},#{md5Key})")
public int insertSegmentFile(SegmentFile segmentFile);
// 主要用来更新分片信息
@Update({"update segment_file set " +
"file_path = #{filePath},file_name = #{fileName},size = #{size}," +
"segment_index = #{segmentIndex}, segment_size = #{segmentSize}," +
"segment_total = #{segmentTotal}, md5_key = #{md5Key}" +
"where id = #{id}" })
public int updateSegmentFile(SegmentFile segmentFile);
}
特别的，我们对文件保存路径在配置文件application.yml中进行设置。同时，为了实现大文件分片的上传，关闭springboot的文件上传大小限制。数据库配置就不赘述了。
spring:
servlet:
multipart:
max-file-size: -1
max-request-size: -1
file:
save-path: E:/file/
工具类实现
FileUtil为文件处理工具类，包括利用uuid和md5码的文件名生成。特别的，我们将原文件的名称后加上#和分片序号作为对应分片文件的名称。
// 工具类
// 文件名生成
public class FileUtil {
public static String getFileNameWithoutSuffix(String fileName){
int suffixIndex = fileName.lastIndexOf('.');
if(suffixIndex<0)
return fileName;
return fileName.substring(0, suffixIndex);
}
public static String getFileSuffix(String fileName){
int suffixIndex = fileName.lastIndexOf('.');
if(suffixIndex<0)
return "";
return fileName.substring(suffixIndex+1);
}
public static String getSegmentName(String fileName, int segmentIndex){
return fileName + "#" + segmentIndex;
}
public static String createSaveFileName(String key, String fileName){
String suffix = getFileSuffix(fileName);
return key + "." + suffix;
}
public static String createUUIDFileName(String fileName){
String suffix = getFileSuffix(fileName);
String name = UUID.randomUUID().toString();
return name + "." + suffix;
}
}
请求结果返回类，纯纯的简化，根据情况返回成功与否，message字符串也可以携带Json信息给前端使用。
public class ReturnResult {
private boolean success;
private String message;
public ReturnResult(boolean success, String message){
this.success = success;
this.message = message;
}
getter…
setter…
}
service功能实现
比较关键的业务类，包括文件存在确认，文件记录创建，文件信息更新，分片存储，分片合并和分片文件删除功能的实现。
文件存在确认
断点续传第一步就是获取文件上传情况，这样才能知道已上传文件要从哪个分片开始续传。
// 该文件存在，返回数据
public SegmentFile checkSegmentFile(String key){
List<SegmentFile> segmentFiles = segmentFileMapper.getSegmentFileByKey(key);
if(segmentFiles!=null&&segmentFiles.size()>0)
return segmentFiles.get(0);
else
return null;
}
简单调用mapper从数据库中找就行，由于文件的md5码是唯一的，所以使用key进行查询。
文件记录创建
文件不存在，那么第一步需要创建对应的文件记录，方便分片上传。
// 第一次出现的文件，把数据存到数据库中
// savePath为文件夹绝对位置
public boolean createSegmentFile(String originFileName, String savePath, int size, int segmentSize, String key){
String fileName = FileUtil.createUUIDFileName(originFileName);
String saveFileName = FileUtil.createSaveFileName(key, originFileName);
SegmentFile segmentFile = new SegmentFile();
// filepath为完整路径
segmentFile.setFilePath(savePath + saveFileName);
segmentFile.setFileName(fileName);
segmentFile.setSize(size);
segmentFile.setSegmentIndex(0);
segmentFile.setSegmentSize(segmentSize);
// 计算分片总数
int total = size / segmentSize;
if(size % segmentSize != 0)
total++;
segmentFile.setSegmentTotal(total);
segmentFile.setMd5Key(key);
return segmentFileMapper.insertSegmentFile(segmentFile) > 0;
}
使用file工具类创建各种对应文件名称，savePath在调用时从配置文件中读取。之后根据分片大小和文件总体大小计算分片总数，全部存储到数据库中。（其实因为md5码基本就是唯一的了，uuid并不需要直接用key作为文件名就行了，不过写都写了懒得改了。）
文件信息更新
数据库update，没什么好说的。
// 更新总文件的数据库信息
public boolean updateSegmentFileInfo(SegmentFile segmentFile){
int result = segmentFileMapper.updateSegmentFile(segmentFile);
return result>0;
}
分片存储
包括分片文件名称计算，文件物理存储和数据库中信息修改。
// 存储分片到服务器
public boolean saveSegment(MultipartFile file, String savePath, String key, String originFileName, int segmentIndex){
String saveFileName = FileUtil.createSaveFileName(key, originFileName);
String segmentFileName = FileUtil.getSegmentName(saveFileName, segmentIndex);
// 存储分片，方便之后使用
boolean saveSuccess = upload(file, savePath+segmentFileName);
if(saveSuccess){
// 修改数据库中分片记录
SegmentFile segmentFile = segmentFileMapper.getSegmentFileByKey(key).get(0);
segmentFile.setSegmentIndex(segmentFile.getSegmentIndex()+1);
int row = segmentFileMapper.updateSegmentFile(segmentFile);
return row > 0;
}else
return false;
}
// 存储方法
private boolean upload(MultipartFile file, String path){
System.out.println(path);
File dest = new File(path);
//判断文件父目录是否存在
if (!dest.getParentFile().exists()) {
boolean b = dest.getParentFile().mkdir();
if(!b){
return b;
}
}
//保存文件
try {
file.transferTo(dest);
return true;
} catch (IllegalStateException | IOException e) {
e.printStackTrace();
return false;
}
}
这边upload中直接用spring给的transferTo方法进行文件的转储。
分片整合功能
当所有分片成功上传，segmentIndex和segmentTotal相同时，需要将所有分片整合成总文件。总体思路就是根据名称按照index顺序读取所有的分片，同时利用write方法按顺序写到FileOutputStream中去，最后输出总文件。
// 将所有的分片联合成同一文件
public boolean mergeSegment(String key) {
SegmentFile segmentFile = segmentFileMapper.getSegmentFileByKey(key).get(0);
int segmentCount = segmentFile.getSegmentTotal();
FileInputStream fileInputStream = null;
FileOutputStream outputStream = null;
byte[] byt = new byte[10 * 1024 * 1024];
try {
// 整合结果文件
File newFile = new File(segmentFile.getFilePath());
outputStream = new FileOutputStream(newFile, true);
int len;
for (int i = 0; i < segmentCount; i++) {
String segmentFilePath = FileUtil.getSegmentName(segmentFile.getFilePath(), i + 1);
fileInputStream = new FileInputStream(new File(segmentFilePath));
while ((len = fileInputStream.read(byt)) != -1) {
outputStream.write(byt, 0, len);
}
}
} catch (IOException e) {
System.out.println("分片合并异常");
return false;
} finally {
try {
if (fileInputStream != null) {
fileInputStream.close();
}
if (outputStream != null) {
outputStream.close();
}
System.out.println("IO流关闭");
} catch (Exception e) {
System.out.println("IO流关闭");
}
}
System.out.println("分片合并成功");
return true;
}
逻辑简单，主要就是出错时的try-catch和返回比较绕。
分片文件删除功能
完成分片整合后需要将不需要的分片文件删除，需要注意，直接调用删除的话可能会有对象数据流还占用着文件导致删除失败，所以先显示调用下gc回收对象再尝试删除。
之后还有没删干净的文件，利用visit表记录有没有删除同时自旋判断是否删除干净。在外部调用这个方法时需要另开线程并行防止自旋影响正常功能。
// 完成合并，删除分片文件
public void deleteSegments(String key) throws InterruptedException {
// 为了保证不被占用，先回收数据流对象
System.gc();
Thread.sleep(1000);
SegmentFile segmentFile = segmentFileMapper.getSegmentFileByKey(key).get(0);
int segmentCount = segmentFile.getSegmentTotal();
ArrayList<String> remain = new ArrayList<>();
int finished = 0;
int[] visited = new int[segmentCount];
for (int i = 0; i < segmentCount; i++) {
String segmentFilePath = FileUtil.getSegmentName(segmentFile.getFilePath(), i + 1);
remain.add(segmentFilePath);
File file = new File(segmentFilePath);
boolean result = file.delete();
if(result) {
finished++;
visited[i] = 1;
}
System.out.println("分片文件:" + segmentFilePath + "删除" + (result?"成功":"失败"));
}
// visited数组，然后完成了再去除，知道count到达总数
while(finished<segmentCount){
System.gc();
Thread.sleep(1000);
for(int i=0;i<segmentCount;i++){
if(visited[i]==0){
String segmentFilePath = FileUtil.getSegmentName(segmentFile.getFilePath(), i + 1);
remain.add(segmentFilePath);
File file = new File(segmentFilePath);
boolean result = file.delete();
if(result){
visited[i] = 1;
finished++;
}
System.out.println("分片文件:" + segmentFilePath + "删除" + (result?"成功":"失败"));
}
}
}
}
当全部visited之后，就结束自旋，完成分片删除。
controller控制类实现
主要是两个方法，一个是判断当前文件上传状况，主要就是想在前端选中文件后就调用一下，显示文件上传状态，这样就能实现秒传功能的效果了。第二个就是上传分片功能，下面具体讲一下。
controller中先设置service，json objectMapper，存储地址。
@Autowired
SegmentFileService segmentFileService;
@Autowired
private ObjectMapper mapper;
@Value("${file.save-path}")
private String savePath;
查询文件状态checkFileExist
输入参数为文件对应的唯一编码，前端计算。
@RequestMapping("/checkFile")
@ResponseBody
// 检查文件是否已经存在，且返回segment信息
public ReturnResult checkFileExist(String key) throws JsonProcessingException {
SegmentFile segmentFile = segmentFileService.checkSegmentFile(key);
if(segmentFile==null)
return new ReturnResult(false, "该文件未上传");
else{
// 转成json回去用
String fileJson = mapper.writeValueAsString(segmentFile);
return new ReturnResult(true, fileJson);
}
}
返回类中success表示文件是否存在，message中包含文件信息的json结果。
分片上传功能
主要分为以下几步：文件状态判断和信息写入；当前分片存储；分片上传完成判断；分片合并；分片删除；
输入参数包括：文件本身，文件原名（用来获取后缀名），文件总大小，分片序号，分片大小和文件对应唯一码。
文件判断和信息写入，就是简单判断文件是否存在，不存在就调用create方法。
public ReturnResult upLoadSegmentFile(MultipartFile file, String originFileName, Integer fileSize, Integer segmentIndex, Integer segmentSize, String key) throws JsonProcessingException{
System.out.println("文件 " + originFileName + " 开始");
// 查找是否存在，不存在就写入
SegmentFile segmentFile = segmentFileService.checkSegmentFile(key);
if(segmentFile==null){
boolean writeSuccess = segmentFileService.createSegmentFile(originFileName, savePath, fileSize, segmentSize, key);
if(!writeSuccess){
// 写入失败，返回错误信息
return new ReturnResult(false, "文件数据库记录创建失败");
}
}
segmentFile = segmentFileService.checkSegmentFile(key);
当前分片存储，存储后进行数据库记录的更新。
// 将当前分片存入
boolean segmentWriteSuccess = segmentFileService.saveSegment(file, savePath, key, originFileName, segmentIndex);
if(!segmentWriteSuccess)
// 分片存储失败
return new ReturnResult(false, "分片文件失败");
segmentFile.setSegmentIndex(segmentIndex);
boolean isUpdateSuccess = segmentFileService.updateSegmentFileInfo(segmentFile);
if(!isUpdateSuccess)
// 更新失败
return new ReturnResult(false, "文件数据库记录更新失败");
内部线程类，用来后续实现删除功能。
class deleteThread implements Runnable{
@Override
public void run() {
try {
segmentFileService.deleteSegments(key);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
判断分片是否上传完成，合并并开始删除所有分片文件。
// 判断是否分片齐全，齐全则合并生成究极文件
// 其实考虑这步会不会失败应该在数据库再加一个值，再说吧
if(segmentIndex==segmentFile.getSegmentTotal()){
boolean mergeSuccess = segmentFileService.mergeSegment(key);
if(mergeSuccess) {
// 另开线程去自旋删除
new Thread(new deleteThread()).start();
return new ReturnResult(true, mapper.writeValueAsString(segmentFile));
}
else
return new ReturnResult(false, "文件合并失败");
}
return new ReturnResult(true, mapper.writeValueAsString(segmentFile));
总结
这篇文章主要是记录了springboot框架下的文件断点续传后端流程，觉得有用就看看吧。
因为是默认串行调用，文件已上传分片信息直接用当前上传的分片序号覆盖。如果要并行实现的话，数据库中可能需要存储一个总分片数量大小长度的字符串，用来记录上传进度（状态压缩），比如111011，表示6个分片，分片4未上传，这样就能并行上传分片了，有机会实现一下并行的。
项目代码已上传至GitHub https://github.com/huiluczP/segment_upload
前端部分可以看看这篇文章：SpringBoot实现文件分片断点续传功能（前端篇）