SpringBoot 優雅實作超大檔上傳，通用方案

大家好，我是磊哥。

檔上傳是一個老生常談的話題了，在檔相對比較小的情況下，可以直接把檔轉化為字節流上傳到伺服器，但在檔比較大的情況下，用普通的方式進行上傳，這可不是一個好的辦法，畢竟很少有人會忍受，當檔上傳到一半中斷後，繼續上傳卻只能重頭開始上傳，這種讓人不爽的體驗。

那有沒有比較好的上傳體驗呢，答案有的，就是下邊要介紹的幾種上傳方式

詳細教程

秒傳

1、什麽是秒傳

通俗的說，你把要上傳的東西上傳，伺服器會先做MD5校驗，如果伺服器上有一樣的東西，它就直接給你個新地址，其實你下載的都是伺服器上的同一個檔，想要不秒傳，其實只要讓MD5改變，就是對檔本身做一下修改（改名字不行），例如一個文字檔案，你多加幾個字，MD5就變了，就不會秒傳了。

2、本文實作的秒傳核心邏輯

a、利用redis的set方法存放檔上傳狀態，其中key為檔上傳的md5，value為是否上傳完成的標誌位，

b、當標誌位true為上傳已經完成，此時如果有相同檔上傳，則進入秒傳邏輯。如果標誌位為false，則說明還沒上傳完成，此時需要在呼叫set的方法，保存塊號檔記錄的路徑，其中key為上傳檔md5加一個固定字首，value為塊號檔記錄路徑

分片上傳

1.什麽是分片上傳

分片上傳，就是將所要上傳的檔，按照一定的大小，將整個檔分隔成多個數據塊（我們稱之為Part）來進行分別上傳，上傳完之後再由伺服端對所有上傳的檔進行匯總整合成原始的檔。

2.分片上傳的場景

1. 大檔上傳

2. 網路環境環境不好，存在需要重傳風險的場景

斷點續傳

1、什麽是斷點續傳

斷點續傳是在下載或上傳時，將下載或上傳任務（一個檔或一個壓縮包）人為的劃分為幾個部份，每一個部份采用一個執行緒進行上傳或下載，如果碰到網路故障，可以從已經上傳或下載的部份開始繼續上傳或者下載未完成的部份，而沒有必要從頭開始上傳或者下載。本文的斷點續傳主要是針對斷點上傳場景。

2、套用場景

斷點續傳可以看成是分片上傳的一個衍生，因此可以使用分片上傳的場景，都可以使用斷點續傳。

3、實作斷點續傳的核心邏輯

在分片上傳的過程中，如果因為系統崩潰或者網路中斷等異常因素導致上傳中斷，這時候客戶端需要記錄上傳的進度。在之後支持再次上傳時，可以繼續從上次上傳中斷的地方進行繼續上傳。

為了避免客戶端在上傳之後的進度數據被刪除而導致重新開始從頭上傳的問題，伺服端也可以提供相應的介面便於客戶端對已經上傳的分片數據進行查詢，從而使客戶端知道已經上傳的分片數據，從而從下一個分片數據開始繼續上傳。

4、實作流程步驟

a、方案一，常規步驟

b、方案二、本文實作的步驟

5、分片上傳/斷點上傳程式碼實作

a、前端采用百度提供的webuploader的外掛程式，進行分片。因本文主要介紹伺服端程式碼實作，webuploader如何進行分片

b、後端用兩種方式實作檔寫入，一種是用RandomAccessFile

另一種是使用MappedByteBuffer，對MappedByteBuffer不熟悉的朋友，可以檢視如下連結進行了解:

後端進行寫入操作的核心程式碼

a、RandomAccessFile實作方式

@UploadMode(mode = UploadModeEnum.RANDOM_ACCESS)
@Slf4j
public classRandomAccessUploadStrategyextendsSliceUploadTemplate{
@Autowired
private FilePathUtil filePathUtil;
@Value("${upload.chunkSize}")
privatelong defaultChunkSize;
@Override
publicbooleanupload(FileUploadRequestDTO param){
RandomAccessFile accessTmpFile = null;
try {
String uploadDirPath = filePathUtil.getPath(param);
File tmpFile = super.createTmpFile(param);
accessTmpFile = new RandomAccessFile(tmpFile, "rw");
//這個必須與前端設定的值一致
long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
: param.getChunkSize();
long offset = chunkSize * param.getChunk();
//定位到該分片的偏移量
accessTmpFile.seek(offset);
//寫入該分片數據
accessTmpFile.write(param.getFile().getBytes());
boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
return isOk;
} catch (IOException e) {
log.error(e.getMessage(), e);
} finally {
FileUtil.close(accessTmpFile);
}
returnfalse;
}
}




b、MappedByteBuffer實作方式

@UploadMode(mode = UploadModeEnum.MAPPED_BYTEBUFFER)
@Slf4j
public classMappedByteBufferUploadStrategyextendsSliceUploadTemplate{
@Autowired
private FilePathUtil filePathUtil;
@Value("${upload.chunkSize}")
privatelong defaultChunkSize;
@Override
publicbooleanupload(FileUploadRequestDTO param){
RandomAccessFile tempRaf = null;
FileChannel fileChannel = null;
MappedByteBuffer mappedByteBuffer = null;
try {
String uploadDirPath = filePathUtil.getPath(param);
File tmpFile = super.createTmpFile(param);
tempRaf = new RandomAccessFile(tmpFile, "rw");
fileChannel = tempRaf.getChannel();
long chunkSize = Objects.isNull(param.getChunkSize()) ? defaultChunkSize * 1024 * 1024
: param.getChunkSize();
//寫入該分片數據
long offset = chunkSize * param.getChunk();
byte[] fileData = param.getFile().getBytes();
mappedByteBuffer = fileChannel
.map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);
mappedByteBuffer.put(fileData);
boolean isOk = super.checkAndSetUploadProgress(param, uploadDirPath);
return isOk;
} catch (IOException e) {
log.error(e.getMessage(), e);
} finally {
FileUtil.freedMappedByteBuffer(mappedByteBuffer);
FileUtil.close(fileChannel);
FileUtil.close(tempRaf);
}
returnfalse;
}
}










c、檔操作核心樣版類程式碼

@Slf4j
publicabstract classSliceUploadTemplateimplementsSliceUploadStrategy{
publicabstractbooleanupload(FileUploadRequestDTO param);
protected File createTmpFile(FileUploadRequestDTO param){
FilePathUtil filePathUtil = SpringContextHolder.getBean(FilePathUtil. class);
param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));
String fileName = param.getFile().getOriginalFilename();
String uploadDirPath = filePathUtil.getPath(param);
String tempFileName = fileName + "_tmp";
File tmpDir = new File(uploadDirPath);
File tmpFile = new File(uploadDirPath, tempFileName);
if (!tmpDir.exists()) {
tmpDir.mkdirs();
}
return tmpFile;
}
@Override
public FileUploadDTO sliceUpload(FileUploadRequestDTO param){
boolean isOk = this.upload(param);
if (isOk) {
File tmpFile = this.createTmpFile(param);
FileUploadDTO fileUploadDTO = this.saveAndFileUploadDTO(param.getFile().getOriginalFilename(), tmpFile);
return fileUploadDTO;
}
String md5 = FileMD5Util.getFileMD5(param.getFile());
Map<Integer, String> map = new HashMap<>();
map.put(param.getChunk(), md5);
return FileUploadDTO.builder().chunkMd5Info(map).build();
}
/**
* 檢查並修改檔上傳進度
*/
publicbooleancheckAndSetUploadProgress(FileUploadRequestDTO param, String uploadDirPath){
String fileName = param.getFile().getOriginalFilename();
File confFile = new File(uploadDirPath, fileName + ".conf");
byte isComplete = 0;
RandomAccessFile accessConfFile = null;
try {
accessConfFile = new RandomAccessFile(confFile, "rw");
//把該分段標記為 true 表示完成
System.out.println("set part " + param.getChunk() + " complete");
//建立conf檔檔長度為總分片數，每上傳一個分塊即向conf檔中寫入一個127，那麽沒上傳的位置就是預設0,已上傳的就是Byte.MAX_VALUE 127
accessConfFile.setLength(param.getChunks());
accessConfFile.seek(param.getChunk());
accessConfFile.write(Byte.MAX_VALUE);
//completeList 檢查是否全部完成,如果陣列裏是否全部都是127(全部份片都成功上傳)
byte[] completeList = FileUtils.readFileToByteArray(confFile);
isComplete = Byte.MAX_VALUE;
for (int i = 0; i < completeList.length && isComplete == Byte.MAX_VALUE; i++) {
//與運算, 如果有部份沒有完成則 isComplete 不是 Byte.MAX_VALUE
isComplete = (byte) (isComplete & completeList[i]);
System.out.println("check part " + i + " complete?:" + completeList[i]);
}
} catch (IOException e) {
log.error(e.getMessage(), e);
} finally {
FileUtil.close(accessConfFile);
}
boolean isOk = setUploadProgress2Redis(param, uploadDirPath, fileName, confFile, isComplete);
return isOk;
}
/**
* 把上傳進度資訊存進redis
*/
privatebooleansetUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
String fileName, File confFile, byte isComplete){
RedisUtil redisUtil = SpringContextHolder.getBean(RedisUtil. class);
if (isComplete == Byte.MAX_VALUE) {
redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "true");
redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
confFile.delete();
returntrue;
} else {
if (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {
redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), "false");
redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + ".conf");
}
returnfalse;
}
}
/**
* 保存檔操作
*/
public FileUploadDTO saveAndFileUploadDTO(String fileName, File tmpFile){
FileUploadDTO fileUploadDTO = null;
try {
fileUploadDTO = renameFile(tmpFile, fileName);
if (fileUploadDTO.isUploadComplete()) {
System.out
.println("upload complete !!" + fileUploadDTO.isUploadComplete() + " name=" + fileName);
//TODO 保存檔資訊到資料庫
}
} catch (Exception e) {
log.error(e.getMessage(), e);
} finally {
}
return fileUploadDTO;
}
/**
* 檔重新命名
*
* @param toBeRenamed 將要修改名字的檔
* @param toFileNewName 新的名字
*/
private FileUploadDTO renameFile(File toBeRenamed, String toFileNewName){
//檢查要重新命名的檔是否存在，是否是檔
FileUploadDTO fileUploadDTO = new FileUploadDTO();
if (!toBeRenamed.exists() || toBeRenamed.isDirectory()) {
log.info("File does not exist: {}", toBeRenamed.getName());
fileUploadDTO.setUploadComplete(false);
return fileUploadDTO;
}
String ext = FileUtil.getExtension(toFileNewName);
String p = toBeRenamed.getParent();
String filePath = p + FileConstant.FILE_SEPARATORCHAR + toFileNewName;
File newFile = new File(filePath);
//修改檔名
boolean uploadFlag = toBeRenamed.renameTo(newFile);
fileUploadDTO.setMtime(DateUtil.getCurrentTimeStamp());
fileUploadDTO.setUploadComplete(uploadFlag);
fileUploadDTO.setPath(filePath);
fileUploadDTO.setSize(newFile.length());
fileUploadDTO.setFileExt(ext);
fileUploadDTO.setFileId(toFileNewName);
return fileUploadDTO;
}
}





















總結

在實作 分片上傳的過程，需要前端和後端配合，比如前後端的上傳塊號的檔大小，前後端必須得要一致，否則上傳就會有問題。 其次檔相關操作正常都是要搭建一個檔伺服器的，比如使用fastdfs、hdfs等。

本範例程式碼在電腦配置為4核記憶體8G情況下，上傳24G大小的檔，上傳時間需要30多分鐘，主要時間耗費在前端的md5值計算，後端寫入的速度還是比較快。如果計畫組覺得自建檔伺服器太花費時間，且計畫的需求僅僅只是上傳下載，那麽推薦使用阿裏的oss伺服器

阿裏的oss它本質是一個物件儲存伺服器，而非檔伺服器，因此如果有涉及到大量刪除或者修改檔的需求，oss可能就不是一個好的選擇。

🔥 磊哥私藏精品 熱門推薦 🔥