AI专业者开发社区 1 号成员
  •  0 回帖  •  4 浏览  •  4 个月前
   

Spring Boot 分片上传、断点续传、大文件上传、秒传，应有尽有，建议收藏！！

文件上传是一个老生常谈的话题了，在文件相对比较小的情况下，可以直接把文件转化为字节流上传到服务器，但在文件比较大的情况下，用普通的方式进行上传，这可不是一个好的办法，毕竟很少有人会忍受，当文件上传到一半中断后，继续上传却只能重头开始上传，这种让人不爽的体验。那有没有比较好的上传体验呢，答案有的，就是下边要介绍的几种上传方式。

1、分片上传

1.1 什么是分片上传

分片上传，就是将所要上传的文件，按照一定的大小，将整个文件分隔成多个数据块（我们称之为 Part）来进行分别上传，上传完之后再由服务端对所有上传的文件进行汇总整合成原始的文件。

1.2 分片上传的场景

  • 大文件上传
  • 网络环境环境不好，存在需要重传风险的场景

2 断点续传

2.1 什么是断点续传

断点续传是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部分，每一个部分采用一个线程进行上传或下载，如果碰到网络故障，可以从已经上传或下载的部分开始继续上传或者下载未完成的部分，而没有必要从头开始上传或者下载。

本文的断点续传主要是针对断点上传场景。

2.2 应用场景

断点续传可以看成是分片上传的一个衍生，因此可以使用分片上传的场景，都可以使用断点续传。

2.3 实现断点续传的核心逻辑

在分片上传的过程中，如果因为系统崩溃或者网络中断等异常因素导致上传中断，这时候客户端需要记录上传的进度。在之后支持再次上传时，可以继续从上次上传中断的地方进行继续上传。

为了避免客户端在上传之后的进度数据被删除而导致重新开始从头上传的问题，服务端也可以提供相应的接口便于客户端对已经上传的分片数据进行查询，从而使客户端知道已经上传的分片数据，从而从下一个分片数据开始继续上传。

整体的过程如下：

  1. 前端将文件安装百分比进行计算, 每次上传文件的百分之一 (文件分片), 给文件分片做上序号
  2. 后端将前端每次上传的文件, 放入到缓存目录
  3. 等待前端将全部的文件内容都上传完毕后, 发送一个合并请求
  4. 后端使用 RandomAccessFile 进多线程读取所有的分片文件, 一个线程一个分片
  5. 后端每个线程按照序号将分片的文件写入到目标文件中
  6. 在上传文件的过程中发生断网了或者手动暂停了, 下次上传的时候发送续传请求, 让后端删除最后一个分片
  7. 前端重新发送上次的文件分片

2.4 实现流程步骤

方案一，常规步骤

  • 将需要上传的文件按照一定的分割规则，分割成相同大小的数据块；
  • 初始化一个分片上传任务，返回本次分片上传唯一标识；
  • 按照一定的策略（串行或并行）发送各个分片数据块；
  • 发送完成后，服务端根据判断数据上传是否完整，如果完整，则进行数据块合成得到原始文件。

方案二、本文实现的步骤

  • 前端（客户端）需要根据固定大小对文件进行分片，请求后端（服务端）时要带上分片序号和大小。
  • 服务端创建 conf 文件用来记录分块位置，conf 文件长度为总分片数，每上传一个分块即向 conf 文件中写入一个 127，那么没上传的位置就是默认的 0, 已上传的就是 Byte.MAX_VALUE 127（这步是实现断点续传和秒传的核心步骤）
  • 服务器按照请求数据中给的分片序号和每片分块大小（分片大小是固定且一样的）算出开始位置，与读取到的文件片段数据，写入文件。

整体的实现流程如下：

3、分片上传 / 断点上传代码实现

3.1 前端实现

前端的 File 对象是特殊类型的 Blob，且可以用在任意的 Blob 类型的上下文中。

就是说能够处理 Blob 对象的方法也能处理 File 对象。在 Blob 的方法里有有一个 Slice 方法可以帮完成切片。

推荐一个开源免费的 Spring Boot 最全教程：

https://github.com/javastacks/spring-boot-best-practice

核心代码：

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));
    };

<span class="hljs-keyword">let</span> currentPieces = <span class="hljs-number">0</span>;
fileReader.<span class="hljs-property">onload</span> = <span class="hljs-function">(<span class="hljs-params">event</span>) =&gt;</span> {
  <span class="hljs-keyword">let</span> e = <span class="hljs-variable language_">window</span>.<span class="hljs-property">event</span> || event;
  <span class="hljs-variable language_">this</span>.<span class="hljs-property">spark</span>.<span class="hljs-title function_">append</span>(e.<span class="hljs-property">target</span>.<span class="hljs-property">result</span>);
  currentPieces++
  <span class="hljs-keyword">if</span> (currentPieces &lt; piece) {
    <span class="hljs-title function_">nextPiece</span>()
  } <span class="hljs-keyword">else</span> {
    <span class="hljs-title function_">resolve</span>({<span class="hljs-attr">fileName</span>: files.<span class="hljs-property">name</span>, <span class="hljs-attr">fileMd5</span>: <span class="hljs-variable language_">this</span>.<span class="hljs-property">spark</span>.<span class="hljs-title function_">end</span>()})
  }
}
<span class="hljs-comment">// fileReader.onerror = (err =&gt; { reject(err) })</span>
<span class="hljs-title function_">nextPiece</span>()



})
}

当然如果我们是 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";

<span class="hljs-keyword">public</span> <span class="hljs-keyword">static</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">main</span><span class="hljs-params">(String[] args)</span> <span class="hljs-keyword">throws</span> Exception {
    <span class="hljs-type">Employee</span> <span class="hljs-variable">e1</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Employee</span>(<span class="hljs-string">"zhangsan"</span>, <span class="hljs-number">23</span>);
    <span class="hljs-type">Employee</span> <span class="hljs-variable">e2</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Employee</span>(<span class="hljs-string">"lisi"</span>, <span class="hljs-number">24</span>);
    <span class="hljs-type">Employee</span> <span class="hljs-variable">e3</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Employee</span>(<span class="hljs-string">"wangwu"</span>, <span class="hljs-number">25</span>);
    <span class="hljs-type">RandomAccessFile</span> <span class="hljs-variable">ra</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">RandomAccessFile</span>(filePath, <span class="hljs-string">"rw"</span>);
    ra.write(e1.name.getBytes(StandardCharsets.UTF_8));<span class="hljs-comment">//防止写入文件乱码</span>
    ra.writeInt(e1.age);
    ra.write(e2.name.getBytes());
    ra.writeInt(e2.age);
    ra.write(e3.name.getBytes());
    ra.writeInt(e3.age);
    ra.close();
    <span class="hljs-type">RandomAccessFile</span> <span class="hljs-variable">raf</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">RandomAccessFile</span>(filePath, <span class="hljs-string">"r"</span>);
    <span class="hljs-type">int</span> <span class="hljs-variable">len</span> <span class="hljs-operator">=</span> <span class="hljs-number">8</span>;
    raf.skipBytes(<span class="hljs-number">12</span>);<span class="hljs-comment">//跳过第一个员工的信息，其姓名8字节，年龄4字节</span>
    System.out.println(<span class="hljs-string">"第二个员工信息："</span>);
    <span class="hljs-type">String</span> <span class="hljs-variable">str</span> <span class="hljs-operator">=</span> <span class="hljs-string">""</span>;
    <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i &lt; len; i++) {
        str = str + (<span class="hljs-type">char</span>) raf.readByte();
    }
    System.out.println(<span class="hljs-string">"name:"</span> + str);
    System.out.println(<span class="hljs-string">"age:"</span> + raf.readInt());
    System.out.println(<span class="hljs-string">"第一个员工信息："</span>);
    raf.seek(<span class="hljs-number">0</span>);<span class="hljs-comment">//将文件指针移动到文件开始位置</span>
    str = <span class="hljs-string">""</span>;
    <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i &lt; len; i++) {
        str = str + (<span class="hljs-type">char</span>) raf.readByte();
    }
    System.out.println(<span class="hljs-string">"name:"</span> + str);
    System.out.println(<span class="hljs-string">"age:"</span> + raf.readInt());
    System.out.println(<span class="hljs-string">"第三个员工信息："</span>);
    raf.skipBytes(<span class="hljs-number">12</span>);<span class="hljs-comment">//跳过第二个员工的信息</span>
    str = <span class="hljs-string">""</span>;
    <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i &lt; len; i++) {
        str = str + (<span class="hljs-type">char</span>) raf.readByte();
    }
    System.out.println(<span class="hljs-string">"name:"</span> + str);
    System.out.println(<span class="hljs-string">"age:"</span> + raf.readInt());
    raf.close();
}



}


class Employee {
String name;
int age;
final static int LEN = 8;


<span class="hljs-keyword">public</span> <span class="hljs-title function_">Employee</span><span class="hljs-params">(String name, <span class="hljs-type">int</span> age)</span> {
    <span class="hljs-keyword">if</span> (name.length() &gt; LEN) {
        name = name.substring(<span class="hljs-number">0</span>, <span class="hljs-number">8</span>);
    } <span class="hljs-keyword">else</span> {
        <span class="hljs-keyword">while</span> (name.length() &lt; LEN) {
            name = name + <span class="hljs-string">"\u0000"</span>;
        }
        <span class="hljs-built_in">this</span>.name = name;
        <span class="hljs-built_in">this</span>.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) {


<span class="hljs-type">RandomAccessFile</span> <span class="hljs-variable">tempRaf</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
<span class="hljs-type">FileChannel</span> <span class="hljs-variable">fileChannel</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
<span class="hljs-type">MappedByteBuffer</span> <span class="hljs-variable">mappedByteBuffer</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
<span class="hljs-keyword">try</span> {
  <span class="hljs-type">String</span> <span class="hljs-variable">uploadDirPath</span> <span class="hljs-operator">=</span> filePathUtil.getPath(param);
  <span class="hljs-type">File</span> <span class="hljs-variable">tmpFile</span> <span class="hljs-operator">=</span> <span class="hljs-built_in">super</span>.createTmpFile(param);
  tempRaf = <span class="hljs-keyword">new</span> <span class="hljs-title class_">RandomAccessFile</span>(tmpFile, <span class="hljs-string">"rw"</span>);
  fileChannel = tempRaf.getChannel();

  <span class="hljs-type">long</span> <span class="hljs-variable">chunkSize</span> <span class="hljs-operator">=</span> Objects.isNull(param.getChunkSize()) ? defaultChunkSize * <span class="hljs-number">1024</span> * <span class="hljs-number">1024</span>
      : param.getChunkSize();
  <span class="hljs-comment">//写入该分片数据</span>
  <span class="hljs-type">long</span> <span class="hljs-variable">offset</span> <span class="hljs-operator">=</span> chunkSize * param.getChunk();
  <span class="hljs-type">byte</span>[] fileData = param.getFile().getBytes();
  mappedByteBuffer = fileChannel
      .map(FileChannel.MapMode.READ_WRITE, offset, fileData.length);
  mappedByteBuffer.put(fileData);
  <span class="hljs-type">boolean</span> <span class="hljs-variable">isOk</span> <span class="hljs-operator">=</span> <span class="hljs-built_in">super</span>.checkAndSetUploadProgress(param, uploadDirPath);
  <span class="hljs-keyword">return</span> isOk;
} <span class="hljs-keyword">catch</span> (IOException e) {
  log.error(e.getMessage(), e);
} <span class="hljs-keyword">finally</span> {
  FileUtil.freedMappedByteBuffer(mappedByteBuffer);
  FileUtil.close(fileChannel);
  FileUtil.close(tempRaf);

}

<span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;



}
}

文件操作核心模板类代码

@Slf4j
public abstract class SliceUploadTemplate implements SliceUploadStrategy {

public abstract boolean upload(FileUploadRequestDTO param);


protected File createTmpFile(FileUploadRequestDTO param) {


<span class="hljs-type">FilePathUtil</span> <span class="hljs-variable">filePathUtil</span> <span class="hljs-operator">=</span> SpringContextHolder.getBean(FilePathUtil.class);
param.setPath(FileUtil.withoutHeadAndTailDiagonal(param.getPath()));
<span class="hljs-type">String</span> <span class="hljs-variable">fileName</span> <span class="hljs-operator">=</span> param.getFile().getOriginalFilename();
<span class="hljs-type">String</span> <span class="hljs-variable">uploadDirPath</span> <span class="hljs-operator">=</span> filePathUtil.getPath(param);
<span class="hljs-type">String</span> <span class="hljs-variable">tempFileName</span> <span class="hljs-operator">=</span> fileName + <span class="hljs-string">"_tmp"</span>;
<span class="hljs-type">File</span> <span class="hljs-variable">tmpDir</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">File</span>(uploadDirPath);
<span class="hljs-type">File</span> <span class="hljs-variable">tmpFile</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">File</span>(uploadDirPath, tempFileName);
<span class="hljs-keyword">if</span> (!tmpDir.exists()) {
  tmpDir.mkdirs();
}
<span class="hljs-keyword">return</span> tmpFile;



}


@Override
public FileUploadDTO sliceUpload(FileUploadRequestDTO param) {


<span class="hljs-type">boolean</span> <span class="hljs-variable">isOk</span> <span class="hljs-operator">=</span> <span class="hljs-built_in">this</span>.upload(param);
<span class="hljs-keyword">if</span> (isOk) {
  <span class="hljs-type">File</span> <span class="hljs-variable">tmpFile</span> <span class="hljs-operator">=</span> <span class="hljs-built_in">this</span>.createTmpFile(param);
  <span class="hljs-type">FileUploadDTO</span> <span class="hljs-variable">fileUploadDTO</span> <span class="hljs-operator">=</span> <span class="hljs-built_in">this</span>.saveAndFileUploadDTO(param.getFile().getOriginalFilename(), tmpFile);
  <span class="hljs-keyword">return</span> fileUploadDTO;
}
<span class="hljs-type">String</span> <span class="hljs-variable">md5</span> <span class="hljs-operator">=</span> FileMD5Util.getFileMD5(param.getFile());

Map&lt;Integer, String&gt; map = <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashMap</span>&lt;&gt;();
map.put(param.getChunk(), md5);
<span class="hljs-keyword">return</span> FileUploadDTO.builder().chunkMd5Info(map).build();



}


/**


    

  • 检查并修改文件上传进度
    */
    public boolean checkAndSetUploadProgress(FileUploadRequestDTO param, String uploadDirPath) {
    • 



<span class="hljs-type">String</span> <span class="hljs-variable">fileName</span> <span class="hljs-operator">=</span> param.getFile().getOriginalFilename();
<span class="hljs-type">File</span> <span class="hljs-variable">confFile</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">File</span>(uploadDirPath, fileName + <span class="hljs-string">".conf"</span>);
<span class="hljs-type">byte</span> <span class="hljs-variable">isComplete</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>;
<span class="hljs-type">RandomAccessFile</span> <span class="hljs-variable">accessConfFile</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
<span class="hljs-keyword">try</span> {
  accessConfFile = <span class="hljs-keyword">new</span> <span class="hljs-title class_">RandomAccessFile</span>(confFile, <span class="hljs-string">"rw"</span>);
  <span class="hljs-comment">//把该分段标记为 true 表示完成</span>
  System.out.println(<span class="hljs-string">"set part "</span> + param.getChunk() + <span class="hljs-string">" complete"</span>);
  <span class="hljs-comment">//创建conf文件文件长度为总分片数，每上传一个分块即向conf文件中写入一个127，那么没上传的位置就是默认0,已上传的就是Byte.MAX_VALUE 127</span>
  accessConfFile.setLength(param.getChunks());
  accessConfFile.seek(param.getChunk());
  accessConfFile.write(Byte.MAX_VALUE);

  <span class="hljs-comment">//completeList 检查是否全部完成,如果数组里是否全部都是127(全部分片都成功上传)</span>
  <span class="hljs-type">byte</span>[] completeList = FileUtils.readFileToByteArray(confFile);
  isComplete = Byte.MAX_VALUE;
  <span class="hljs-keyword">for</span> (<span class="hljs-type">int</span> <span class="hljs-variable">i</span> <span class="hljs-operator">=</span> <span class="hljs-number">0</span>; i &lt; completeList.length &amp;&amp; isComplete == Byte.MAX_VALUE; i++) {
    <span class="hljs-comment">//与运算, 如果有部分没有完成则 isComplete 不是 Byte.MAX_VALUE</span>
    isComplete = (<span class="hljs-type">byte</span>) (isComplete &amp; completeList[i]);
    System.out.println(<span class="hljs-string">"check part "</span> + i + <span class="hljs-string">" complete?:"</span> + completeList[i]);
  }

} <span class="hljs-keyword">catch</span> (IOException e) {
  log.error(e.getMessage(), e);
} <span class="hljs-keyword">finally</span> {
  FileUtil.close(accessConfFile);
}
<span class="hljs-type">boolean</span> <span class="hljs-variable">isOk</span> <span class="hljs-operator">=</span> setUploadProgress2Redis(param, uploadDirPath, fileName, confFile, isComplete);
<span class="hljs-keyword">return</span> isOk;



}


/**


    

  • 把上传进度信息存进 redis
    */
    private boolean setUploadProgress2Redis(FileUploadRequestDTO param, String uploadDirPath,
    String fileName, File confFile, byte isComplete)     {
    • 



<span class="hljs-type">RedisUtil</span> <span class="hljs-variable">redisUtil</span> <span class="hljs-operator">=</span> SpringContextHolder.getBean(RedisUtil.class);
<span class="hljs-keyword">if</span> (isComplete == Byte.MAX_VALUE) {
  redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), <span class="hljs-string">"true"</span>);
  redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
  confFile.delete();
  <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
} <span class="hljs-keyword">else</span> {
  <span class="hljs-keyword">if</span> (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {
    redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), <span class="hljs-string">"false"</span>);
    redisUtil.set(FileConstant.FILE_MD5_KEY + param.getMd5(),
        uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + <span class="hljs-string">".conf"</span>);
  }

  <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}



}


/**


    

  • 保存文件操作
    */
    public FileUploadDTO saveAndFileUploadDTO(String fileName, File tmpFile) {
    • 



<span class="hljs-type">FileUploadDTO</span> <span class="hljs-variable">fileUploadDTO</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;

<span class="hljs-keyword">try</span> {

  fileUploadDTO = renameFile(tmpFile, fileName);
  <span class="hljs-keyword">if</span> (fileUploadDTO.isUploadComplete()) {
    System.out
        .println(<span class="hljs-string">"upload complete !!"</span> + fileUploadDTO.isUploadComplete() + <span class="hljs-string">" name="</span> + fileName);
    <span class="hljs-comment">//TODO 保存文件信息到数据库</span>

  }

} <span class="hljs-keyword">catch</span> (Exception e) {
  log.error(e.getMessage(), e);
} <span class="hljs-keyword">finally</span> {

}
<span class="hljs-keyword">return</span> 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);

<span class="hljs-keyword">return</span> fileUploadDTO;



}


}

上传接口

@PostMapping(value = "/upload")
@ResponseBody
public Result<FileUploadDTO> upload(FileUploadRequestDTO fileUploadRequestDTO) throws IOException {

<span class="hljs-type">boolean</span> <span class="hljs-variable">isMultipart</span> <span class="hljs-operator">=</span> ServletFileUpload.isMultipartContent(request);
<span class="hljs-type">FileUploadDTO</span> <span class="hljs-variable">fileUploadDTO</span> <span class="hljs-operator">=</span> <span class="hljs-literal">null</span>;
<span class="hljs-keyword">if</span> (isMultipart) {

  <span class="hljs-type">StopWatch</span> <span class="hljs-variable">stopWatch</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">StopWatch</span>();
  stopWatch.start(<span class="hljs-string">"upload"</span>);
  <span class="hljs-keyword">if</span> (fileUploadRequestDTO.getChunk() != <span class="hljs-literal">null</span> &amp;&amp; fileUploadRequestDTO.getChunks() &gt; <span class="hljs-number">0</span>) {
    fileUploadDTO = fileService.sliceUpload(fileUploadRequestDTO);
  } <span class="hljs-keyword">else</span> {
    fileUploadDTO = fileService.upload(fileUploadRequestDTO);
  }
  stopWatch.stop();
  log.info(<span class="hljs-string">"{}"</span>,stopWatch.prettyPrint());

  <span class="hljs-keyword">return</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Result</span>&lt;FileUploadDTO&gt;().setData(fileUploadDTO);
}

<span class="hljs-keyword">throw</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">BizException</span>(<span class="hljs-string">"上传失败"</span>, <span class="hljs-number">406</span>);



}

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.<span class="hljs-keyword">class</span>);
<span class="hljs-keyword">if</span> (isComplete == <span class="hljs-built_in">Byte</span>.MAX_VALUE) {
  redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), <span class="hljs-string">"true"</span>);
  redisUtil.del(FileConstant.FILE_MD5_KEY + param.getMd5());
  confFile.delete();
  <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
} <span class="hljs-keyword">else</span> {
  <span class="hljs-keyword">if</span> (!redisUtil.hHasKey(FileConstant.FILE_UPLOAD_STATUS, param.getMd5())) {
    redisUtil.hset(FileConstant.FILE_UPLOAD_STATUS, param.getMd5(), <span class="hljs-string">"false"</span>);
    redisUtil.<span class="hljs-keyword">set</span>(FileConstant.FILE_MD5_KEY + param.getMd5(),
        uploadDirPath + FileConstant.FILE_SEPARATORCHAR + fileName + <span class="hljs-string">".conf"</span>);
  }

  <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
}



}

5、总结

在实现分片上传的过程，需要前端和后端配合，比如前后端的上传块号的文件大小，前后端必须得要一致，否则上传就会有问题。

其次文件相关操作正常都是要搭建一个文件服务器的，比如使用 fastdfs、hdfs 等。

版权声明：本文为 CSDN 博主「ZNineSun」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。原文链接：https://blog.csdn.net/zhiyikeji/article/details/128242775

近期热文推荐：

1.1,000+ 道 Java 面试题及答案整理 (2022 最新版)

2.劲爆！Java 协程要来了。。。

3.Spring Boot 2.x 教程，太全了！

4.别再写满屏的爆爆爆炸类了，试试装饰器模式，这才是优雅的方式！！

5.《Java 开发手册（嵩山版）》最新发布，速速下载！

觉得不错，别忘了随手点赞 + 转发哦！