文件上傳是一個老生常談的話題了,在文件相對比較小的情況下,可以直接把文件轉化為位元組流上傳到伺服器,但在文件比較大的情況下,用普通的方式進行上傳,這可不是一個好的辦法,畢竟很少有人會忍受,當文件上傳到一半中斷後,繼續上傳卻只能重頭開始上傳,這種讓人不爽的體驗。那有沒有比較好的上傳體驗呢,答案有的,就是 ...
文件上傳是一個老生常談的話題了,在文件相對比較小的情況下,可以直接把文件轉化為位元組流上傳到伺服器,但在文件比較大的情況下,用普通的方式進行上傳,這可不是一個好的辦法,畢竟很少有人會忍受,當文件上傳到一半中斷後,繼續上傳卻只能重頭開始上傳,這種讓人不爽的體驗。那有沒有比較好的上傳體驗呢,答案有的,就是下邊要介紹的幾種上傳方式。
1、分片上傳
1.1 什麼是分片上傳
分片上傳,就是將所要上傳的文件,按照一定的大小,將整個文件分隔成多個數據塊(我們稱之為Part)來進行分別上傳,上傳完之後再由服務端對所有上傳的文件進行彙總整合成原始的文件。
1.2 分片上傳的場景
- 大文件上傳
- 網路環境環境不好,存在需要重傳風險的場景
2斷點續傳
2.1 什麼是斷點續傳
斷點續傳是在下載或上傳時,將下載或上傳任務(一個文件或一個壓縮包)人為的劃分為幾個部分,每一個部分採用一個線程進行上傳或下載,如果碰到網路故障,可以從已經上傳或下載的部分開始繼續上傳或者下載未完成的部分,而沒有必要從頭開始上傳或者下載。
本文的斷點續傳主要是針對斷點上傳場景。
2.2 應用場景
斷點續傳可以看成是分片上傳的一個衍生,因此可以使用分片上傳的場景,都可以使用斷點續傳。
2.3 實現斷點續傳的核心邏輯
在分片上傳的過程中,如果因為系統崩潰或者網路中斷等異常因素導致上傳中斷,這時候客戶端需要記錄上傳的進度。在之後支持再次上傳時,可以繼續從上次上傳中斷的地方進行繼續上傳。
為了避免客戶端在上傳之後的進度數據被刪除而導致重新開始從頭上傳的問題,服務端也可以提供相應的介面便於客戶端對已經上傳的分片數據進行查詢,從而使客戶端知道已經上傳的分片數據,從而從下一個分片數據開始繼續上傳。
整體的過程如下:
- 前端將文件安裝百分比進行計算,每次上傳文件的百分之一(文件分片),給文件分片做上序號
- 後端將前端每次上傳的文件,放入到緩存目錄
- 等待前端將全部的文件內容都上傳完畢後,發送一個合併請求
- 後端使用RandomAccessFile進多線程讀取所有的分片文件,一個線程一個分片
- 後端每個線程按照序號將分片的文件寫入到目標文件中
- 在上傳文件的過程中發生斷網了或者手動暫停了,下次上傳的時候發送續傳請求,讓後端刪除最後一個分片
- 前端重新發送上次的文件分片
2.4 實現流程步驟
方案一,常規步驟
- 將需要上傳的文件按照一定的分割規則,分割成相同大小的數據塊;
- 初始化一個分片上傳任務,返回本次分片上傳唯一標識;
- 按照一定的策略(串列或並行)發送各個分片數據塊;
- 發送完成後,服務端根據判斷數據上傳是否完整,如果完整,則進行數據塊合成得到原始文件。
方案二、本文實現的步驟
- 前端(客戶端)需要根據固定大小對文件進行分片,請求後端(服務端)時要帶上分片序號和大小。
- 服務端創建conf文件用來記錄分塊位置,conf文件長度為總分片數,每上傳一個分塊即向conf文件中寫入一個127,那麼沒上傳的位置就是預設的0,已上傳的就是Byte.MAX_VALUE 127(這步是實現斷點續傳和秒傳的核心步驟)
- 伺服器按照請求數據中給的分片序號和每片分塊大小(分片大小是固定且一樣的)算出開始位置,與讀取到的文件片段數據,寫入文件。
整體的實現流程如下:
3、分片上傳/斷點上傳代碼實現
3.1 前端實現
前端的File對象是特殊類型的Blob,且可以用在任意的Blob類型的上下文中。
就是說能夠處理Blob對象的方法也能處理File對象。在Blob的方法里有有一個Slice方法可以幫完成切片。
推薦一個開源免費的 Spring Boot 最全教程:
核心代碼:
fileMD5 (files) {
// 計算文件md5
return new Promise((resolve,reject) => {
const fileReader = new FileReader();
const piece = Math.ceil(files.size / this.pieceSize);
const nextPiece = () => {
let start = currentPieces * this.pieceSize;
let end = start * this.pieceSize >= files.size ? files.size : start + this.pieceSize;
fileReader.readAsArrayBuffer(files.slice(start,end));
};
let currentPieces = 0;
fileReader.onload = (event) => {
let e = window.event || event;
this.spark.append(e.target.result);
currentPieces++
if (currentPieces < piece) {
nextPiece()
} else {
resolve({fileName: files.name, fileMd5: this.spark.end()})
}
}
// fileReader.onerror = (err => { reject(err) })
nextPiece()
})
}
當然如果我們是vue項目的話還有更好的選擇,我們可以使用一些開源的框架,本文推薦使用vue-simple-uploader 實現文件分片上傳、斷點續傳及秒傳。
當然我們也可以採用百度提供的webuploader的插件,進行分片。
操作方式也特別簡單,直接按照官方文檔給出的操作進行即可。
3.2 後端寫入文件
後端用兩種方式實現文件寫入:
- RandomAccessFile
- MappedByteBuffer
在向下學習之前,我們先簡單瞭解一下這兩個類的使用
RandomAccessFile
Java除了File類之外,還提供了專門處理文件的類,即RandomAccessFile(隨機訪問文件)類。
該類是Java語言中功能最為豐富的文件訪問類,它提供了眾多的文件訪問方法。RandomAccessFile類支持“隨機訪問”方式,這裡“隨機”是指可以跳轉到文件的任意位置處讀寫數據。在訪問一個文件的時候,不必把文件從頭讀到尾,而是希望像訪問一個資料庫一樣“隨心所欲”地訪問一個文件的某個部分,這時使用RandomAccessFile類就是最佳選擇。
RandomAccessFile對象類有個位置指示器,指向當前讀寫處的位置,當前讀寫n個位元組後,文件指示器將指向這n個位元組後面的下一個位元組處。
剛打開文件時,文件指示器指向文件的開頭處,可以移動文件指示器到新的位置,隨後的讀寫操作將從新的位置開始。
RandomAccessFile類在數據等長記錄格式文件的隨機(相對順序而言)讀取時有很大的優勢,但該類僅限於操作文件,不能訪問其他的I/O設備,如網路、記憶體映像等。
RandomAccessFile類的構造方法如下所示:
//創建隨機存儲文件流,文件屬性由參數File對象指定
RandomAccessFile(File file , String mode)
//創建隨機存儲文件流,文件名由參數name指定
RandomAccessFile(String name , String mode)
這兩個構造方法均涉及到一個String類型的參數mode,它決定隨機存儲文件流的操作模式,其中mode值及對應的含義如下:
- “r”:以只讀的方式打開,調用該對象的任何write(寫)方法都會導致IOException異常
- “rw”:以讀、寫方式打開,支持文件的讀取或寫入。若文件不存在,則創建之。
- “rws”:以讀、寫方式打開,與“rw”不同的是,還要對文件內容的每次更新都同步更新到潛在的存儲設備中去。這裡的“s”表示synchronous(同步)的意思
- “rwd”:以讀、寫方式打開,與“rw”不同的是,還要對文件內容的每次更新都同步更新到潛在的存儲設備中去。使用“rwd”模式僅要求將文件的內容更新到存儲設備中,而使用“rws”模式除了更新文件的內容,還要更新文件的元數據(metadata),因此至少要求1次低級別的I/O操作
import java.io.RandomAccessFile;
import java.nio.charset.StandardCharsets;
public class RandomFileTest {
private static final String filePath = "C:\\Users\\NineSun\\Desktop\\employee.txt";
public static void main(String[] args) throws Exception {
Employee e1 = new Employee("zhangsan", 23);
Employee e2 = new Employee("lisi", 24);
Employee e3 = new Employee("wangwu", 25);
RandomAccessFile ra = new RandomAccessFile(filePath, "rw");
ra.write(e1.name.getBytes(StandardCharsets.UTF_8));//防止寫入文件亂碼
ra.writeInt(e1.age);
ra.write(e2.name.getBytes());
ra.writeInt(e2.age);
ra.write(e3.name.getBytes());
ra.writeInt(e3.age);
ra.close();
RandomAccessFile raf = new RandomAccessFile(filePath, "r");
int len = 8;
raf.skipBytes(12);//跳過第一個員工的信息,其姓名8位元組,年齡4位元組
System.out.println("第二個員工信息:");
String str = "";
for (int i = 0; i < len; i++) {
str = str + (char) raf.readByte();
}
System.out.println("name:" + str);
System.out.println("age:" + raf.readInt());
System.out.println("第一個員工信息:");
raf.seek(0);//將文件指針移動到文件開始位置
str = "";
for (int i = 0; i < len; i++) {
str = str + (char) raf.readByte();
}
System.out.println("name:" + str);
System.out.println("age:" + raf.readInt());
System.out.println("第三個員工信息:");
raf.skipBytes(12);//跳過第二個員工的信息
str = "";
for (int i = 0; i < len; i++) {
str = str + (char) raf.readByte();
}
System.out.println("name:" + str);
System.out.println("age:" + raf.readInt());
raf.close();
}
}
class Employee {
String name;
int age;
final static int LEN = 8;
public Employee(String name, int age) {
if (name.length() > LEN) {
name = name.substring(0, 8);
} else {
while (name.length() < LEN) {
name = name + "\u0000";
}
this.name = name;
this.age = age;
}
}
}
MappedByteBuffer
java io操作中通常採用BufferedReader,BufferedInputStream等帶緩衝的IO類處理大文件,不過java nio中引入了一種基於MappedByteBuffer操作大文件的方式,其讀寫性能極高
3.3 進行寫入操作的核心代碼
為了節約文章篇幅,下麵我只展示核心代碼,完整代碼可以在文末進行下載
RandomAccessFile實現方式
@UploadMode(mode = UploadModeEnum.RANDOM_ACCESS)
@Slf4j
public class RandomAccessUploadStrategy extends SliceUploadTemplate {
@Autowired
private FilePathUtil filePathUtil;
@Value("${upload.chunkSize}")
private long defaultChunkSize;
@Override
public boolean upload(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);
}
return false;
}
}
MappedByteBuffer實現方式
@UploadMode(mode = UploadModeEnum.MAPPED_BYTEBUFFER)
@Slf4j
public class MappedByteBufferUploadStrategy extends SliceUploadTemplate {
@Autowired
private FilePathUtil filePathUtil;
@Value("${upload.chunkSize}")
private long defaultChunkSize;
@Override
public boolean upload(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);
}
return false;
}
}
文件操作核心模板類代碼
@Slf4j
public abstract class SliceUploadTemplate implements SliceUploadStrategy {
public abstract boolean upload(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();
}
/**
* 檢查並修改文件上傳進度
*/
public boolean checkAndSetUploadProgress(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
*/
private boolean setUploadProgress2Redis(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();
return true;
} 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");
}
return false;
}
}
/**
* 保存文件操作
*/
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;
}
}
上傳介面
@PostMapping(value = "/upload")
@ResponseBody
public Result<FileUploadDTO> upload(FileUploadRequestDTO fileUploadRequestDTO) throws IOException {
boolean isMultipart = ServletFileUpload.isMultipartContent(request);
FileUploadDTO fileUploadDTO = null;
if (isMultipart) {
StopWatch stopWatch = new StopWatch();
stopWatch.start("upload");
if (fileUploadRequestDTO.getChunk() != null && fileUploadRequestDTO.getChunks() > 0) {
fileUploadDTO = fileService.sliceUpload(fileUploadRequestDTO);
} else {
fileUploadDTO = fileService.upload(fileUploadRequestDTO);
}
stopWatch.stop();
log.info("{}",stopWatch.prettyPrint());
return new Result<FileUploadDTO>().setData(fileUploadDTO);
}
throw new BizException("上傳失敗", 406);
}
4、秒傳
4.1 什麼是秒傳
通俗的說,你把要上傳的東西上傳,伺服器會先做MD5校驗,如果伺服器上有一樣的東西,它就直接給你個新地址,其實你下載的都是伺服器上的同一個文件,想要不秒傳,其實只要讓MD5改變,就是對文件本身做一下修改(改名字不行),例如一個文本文件,你多加幾個字,MD5就變了,就不會秒傳了。
4.2 實現的秒傳核心邏輯
利用redis的set方法存放文件上傳狀態,其中key為文件上傳的md5,value為是否上傳完成的標誌位,當標誌位true為上傳已經完成,此時如果有相同文件上傳,則進入秒傳邏輯。
如果標誌位為false,則說明還沒上傳完成,此時需要在調用set的方法,保存塊號文件記錄的路徑,其中,key為上傳文件md5加一個固定首碼,value為塊號文件記錄路徑
4.3 核心代碼
private boolean setUploadProgress2Redis(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();
return true;
} 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");
}
return false;
}
}
5、總結
在實現分片上傳的過程,需要前端和後端配合,比如前後端的上傳塊號的文件大小,前後端必須得要一致,否則上傳就會有問題。
其次文件相關操作正常都是要搭建一個文件伺服器的,比如使用fastdfs、hdfs等。
版權聲明:本文為CSDN博主「ZNineSun」的原創文章,遵循CC 4.0 BY-SA版權協議,轉載請附上原文出處鏈接及本聲明。原文鏈接:https://blog.csdn.net/zhiyikeji/article/details/128242775
近期熱文推薦:
1.1,000+ 道 Java面試題及答案整理(2022最新版)
4.別再寫滿屏的爆爆爆炸類了,試試裝飾器模式,這才是優雅的方式!!
覺得不錯,別忘了隨手點贊+轉發哦!