学成在线day06

上传视屏

断点续传

通常视频文件都比力大，所以对于媒资系统上传文件的需求要满足大文件的上传要求。http协议本身对上传文件大小没有限定，但是客户的网络环境质量、电脑硬件环境等参差不齐，假如一个大文件快上传完了网断了没有上传完成，须要客户重新上传，用户体验非常差，所以对于大文件上传的要求最基本的是断点续传。
什么是断点续传：
引用百度百科：断点续传指的是在下载或上传时，将下载或上传任务（一个文件或一个压缩包）人为的划分为几个部门，每一个部门采用一个线程进行上传或下载，假如遇到网络故障，可以从已经上传或下载的部门开始继续上传下载未完成的部门，而没有须要重新开始上传下载，断点续传可以进步节省操作时间，进步用户体验性。
断点续传流程如下图：

流程如下：
1、前端上传前先把文件分成块
2、一块一块的上传，上传停止后重新上传，已上传的分块则不用再上传
3、各分块上传完成末了在服务端归并文件

文件分块测试

1. package com.xuecheng.media;
6. import org.junit.jupiter.api.Test;
7. import org.springframework.util.DigestUtils;
8. import java.io.*;
9. import java.util.Arrays;
10. import java.util.Collections;
11. import java.util.Comparator;
12. import java.util.List;
14. public class TestBigFile {
16.     //文件分块
17.     @Test
18.     public void testChunkUpload() throws Exception{
19.         //源文件
20.         File sourceFile = new File("D:\\test\\1.mp4");
21.         //目标文件位置
22.         String ChunkFiles = "D:\\test\\chunk\";
23.         //设置分块大小
24.         int chunkSize = 1024 * 1024 * 10;
25.         //获取文件要分块的个数
26.         Integer size =(int) Math.ceil(sourceFile.length() * 1.0 / chunkSize);
27.         System.out.println(size);
28.         //使用RandomAccessFile访问文件
29.         RandomAccessFile raf_read = new RandomAccessFile(sourceFile, "r");
30.         //创建缓冲区
31.         byte[] b = new byte[1024*1024];
32.         for (Integer i = 0; i < size; i++) {
33.             //创建分块文件
34.             File chunkFile = new File(ChunkFiles+i);
35.             //判断该文件是否存在
36.             if (chunkFile.exists()) {
37.                 System.out.println("分块文件已存在");
38.                 //将该文件删除
39.                 chunkFile.delete();
40.             }
41.             //创建临时文件
42.             boolean newFile = chunkFile.createNewFile();
43.             if (newFile){
44.                 //用于记录本次读取的字节数
45.                 int len = -1;
46.                 //使用RandomAccessFile访问文件
47.                 RandomAccessFile raf_w = new RandomAccessFile(chunkFile, "rw");
48.                 while ((len = raf_read.read(b))!= -1){
49.                     //将分块文件写入到输出流
50.                     raf_w.write(b,0,len);
51.                     if (chunkFile.length() >= chunkSize){
52.                         break;
53.                     }
54.                 }
55.                 //关闭流
56.                 raf_w.close();
57.             }
58.         }
59.         raf_read.close();
60.     }
62.     //文件合并
63.     @Test
64.     public void testMerge() throws Exception{
65.         //源文件
66.         File sourceFile = new File("D:\\test\\1.mp4");
67.         //分块文件的文件夹
68.         File chunkFilesFolder = new File("D:\\test\\chunk");
69.         //合并文件位置
70.         File mergeFile = new File("D:\\test\\1_test.mp4");
72.         //根据文件夹获取该文件夹中的文件列表
73.         File[] files = chunkFilesFolder.listFiles();
74.         //将数组转化为list集合
75.         List<File> fileList = Arrays.asList(files);
76.         //集合排序
77.         Collections.sort(fileList, new Comparator<File>() {
78.             @Override
79.             public int compare(File o1, File o2) {
80.                 return Integer.parseInt(o1.getName()) - Integer.parseInt(o2.getName());
81.             }
82.         });
83.         //合并文件
84.         //创建临时文件
85.         mergeFile.createNewFile();
86.         //创建缓冲区
87.         byte[] b = new byte[1024];
88.         RandomAccessFile raf_write = new RandomAccessFile(mergeFile, "rw");
89.         for (File file : fileList) {
90.             //使用RandomAccessFile访问文件
91.             RandomAccessFile raf_read = new RandomAccessFile(file, "r");
92.             int len = -1;
93.             while ((len = raf_read.read(b)) != -1) {
94.                 //将分块文件写入到合并文件
95.                 raf_write.write(b, 0, len);
96.             }
97.             raf_read.close();
98.         }
99.         raf_write.close();
101.         //校验文件
102.         String mergeFileMd5 = DigestUtils.md5DigestAsHex(new FileInputStream(mergeFile));
103.         String sourceFileMd5 = DigestUtils.md5DigestAsHex(new FileInputStream(sourceFile));
104.         if (mergeFileMd5.equals(sourceFileMd5)){
105.             System.out.println("合并成功");
106.         }
107.     }
108. }

复制代码

文件分块上传minio，归并文件，利用minio接口来归并文件：

1.     //文件上传minio
2.     @org.junit.jupiter.api.Test
3.     public void testUploadminio() throws Exception {
4. //        D:\test\chunk
5.         for (int i = 0; i < 7; i++) {
6.             //准备数据
7.             UploadObjectArgs testbucket = UploadObjectArgs.builder()
8.                     .bucket("testbucket")
9.                     .object("chunk/"+i)//文件要存放的路径和文件名
10.                     .filename("D:\\test\\chunk\"+i)
11.                     .build();
12.             minioClient.uploadObject(testbucket);
13.         }
14.     }
16.     //将minio中的文件合并,minio默认文件分块大小要超过5mb
17.     @org.junit.jupiter.api.Test
18.     public void testMerge() throws Exception{
19.         List<ComposeSource> sources = new ArrayList<>();
20.         for (int i = 0; i < 7; i++) {
21.             ComposeSource source = ComposeSource.builder().bucket("testbucket").object("chunk/"+i).build();
22.             sources.add(source);
23.         }
25. //        sources = (List<ComposeSource>) Stream.iterate(0, i -> ++i).limit(7).map(i -> ComposeSource.builder().bucket("testbucket").object("chunk/" + i).build());
27.         ComposeObjectArgs testbucket = ComposeObjectArgs.builder().bucket("testbucket").object("1.mp4").sources(sources).build();
28.         minioClient.composeObject(testbucket);
29.     }
30.    

复制代码

文件上传相关接口

文件上传前查抄

1.     @ApiOperation(value = "文件上传前检查文件")
2.     @PostMapping("/upload/checkfile")
3.     public RestResponse<Boolean> checkfile(
4.             @RequestParam("fileMd5") String fileMd5
5.     ) throws Exception {
6.         RestResponse<Boolean> booleanRestResponse = mediaFileService.checkFile(fileMd5);
7.         return booleanRestResponse;
8.     }
11.     @ApiOperation(value = "分块文件上传前的检测")
12.     @PostMapping("/upload/checkchunk")
13.     public RestResponse<Boolean> checkchunk(@RequestParam("fileMd5") String fileMd5,
14.                                             @RequestParam("chunk") int chunk) throws Exception {
15.         RestResponse<Boolean> booleanRestResponse = mediaFileService.checkChunk(fileMd5, chunk);
16.        return booleanRestResponse;
17.     }

复制代码

service层

1. /**
2.   * @description 检查文件是否存在
3.   * @param fileMd5 文件的md5
4.   * @return com.xuecheng.base.model.RestResponse<java.lang.Boolean> false不存在，true存在
5.   * @author Mr.M
6.   * @date 2022/9/13 15:38
7.   */
8. public RestResponse<Boolean> checkFile(String fileMd5);
10. /**
11.   * @description 检查分块是否存在
12.   * @param fileMd5  文件的md5
13.   * @param chunkIndex  分块序号
14.   * @return com.xuecheng.base.model.RestResponse<java.lang.Boolean> false不存在，true存在
15.   * @author Mr.M
16.   * @date 2022/9/13 15:39
17.   */
18. public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex);

复制代码

1.     /**
2.      * 检查文件是否存在
3.      * @param fileMd5 文件的md5
4.      * @return
5.      */
6.     @Override
7.     public RestResponse<Boolean> checkFile(String fileMd5) {
8.         //检查数据库中是否存在该文件
9.         MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
10.         if(mediaFiles != null){
11.             //数据库存在则检查minio中是否存在
12.             //初始化数据
13.             //存储目录
14.             String filePath = mediaFiles.getFilePath();
15.             //文件流
16.             InputStream stream = null;
17.             try {
18.                 GetObjectArgs testbucket = GetObjectArgs.builder()
19.                         .bucket(bucket_video)
20.                         .object(filePath)
21.                         .build();
22.                 //读取数据获取到输入流
23.                 stream = minioClient.getObject(testbucket);
24.                 //判断是否获取到流
25.                 if (stream != null){
26.                     return RestResponse.success(true);
28.                 }
29.             } catch (Exception e) {
30.                 throw new RuntimeException(e);
31.             }
32.         }
33.         return RestResponse.success(false);
34.     }
36.     /**
37.      * 检查分块是否存在
38.      * @param fileMd5  文件的md5
39.      * @param chunkIndex  分块序号
40.      * @return
41.      */
42.     @Override
43.     public RestResponse<Boolean> checkChunk(String fileMd5, int chunkIndex) {
44.         //得到分块文件目录
45.         String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
46.         //得到分块文件的路径
47.         String chunkFilePath = chunkFileFolderPath + chunkIndex;
49.         //文件流
50.         InputStream fileInputStream = null;
51.         try {
52.             fileInputStream = minioClient.getObject(
53.                     GetObjectArgs.builder()
54.                             .bucket(bucket_video)
55.                             .object(chunkFilePath)
56.                             .build());
58.             if (fileInputStream != null) {
59.                 //分块已存在
60.                 return RestResponse.success(true);
61.             }
62.         } catch (Exception e) {
64.         }
65.         //分块未存在
66.         return RestResponse.success(false);
67.     }
70.     //获取分块路径
71.     //得到分块文件的目录
72.     private String getChunkFileFolderPath(String fileMd5) {
73.         return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
74.     }

复制代码

文件上传和归并

接口层

2.     @ApiOperation(value = "上传分块文件")
3.     @PostMapping("/upload/uploadchunk")
4.     public RestResponse uploadchunk(@RequestParam("file") MultipartFile file,
5.                                     @RequestParam("fileMd5") String fileMd5,
6.                                     @RequestParam("chunk") int chunk) throws Exception {
7.         //创建临时文件,用来存储分块文件
8.         File tempFile = File.createTempFile("minio", "temp");
9.         //上传的文件拷贝到临时文件
10.         file.transferTo(tempFile);
11.         //文件路径
12.         String absolutePath = tempFile.getAbsolutePath();
13.         log.error("上传文件路径：{}",absolutePath);
14.         log.error("上传文件md5：{}",fileMd5);
15.         return mediaFileService.uploadChunk(fileMd5, chunk,absolutePath);
16.     }
18.     @ApiOperation(value = "合并文件")
19.     @PostMapping("/upload/mergechunks")
20.     public RestResponse mergechunks(@RequestParam("fileMd5") String fileMd5,
21.                                     @RequestParam("fileName") String fileName,
22.                                     @RequestParam("chunkTotal") int chunkTotal) throws Exception {
23.         Long companyId = 1232141425L;
24.         UploadFileParamsDto uploadFileParamsDto = new UploadFileParamsDto();
25.         uploadFileParamsDto.setFilename(fileName);
26.         uploadFileParamsDto.setFileType("001002");
27.         uploadFileParamsDto.setTags("课程视频");
28.         uploadFileParamsDto.setRemark("");
29.         return mediaFileService.mergechunks(companyId, fileMd5, chunkTotal, uploadFileParamsDto);
31.     }

复制代码

service层

1. /**
2.   * 分块上传文件
3.   * @param fileMd5 文件md5
4.   * @param chunk 分块序号
5.   * @param localChunkFilePath 文件的本地路径
6.   * @return
7.   */
8. public RestResponse uploadChunk(String fileMd5,int chunk,String localChunkFilePath);
10. /**
11.   * @description 合并分块
12.   * @param companyId  机构id
13.   * @param fileMd5  文件md5
14.   * @param chunkTotal 分块总和
15.   * @param uploadFileParamsDto 文件信息
16.   * @return com.xuecheng.base.model.RestResponse
17.   * @author Mr.M
18.   * @date 2022/9/13 15:56
19.   */
20. public RestResponse mergechunks(Long companyId,String fileMd5,int chunkTotal,UploadFileParamsDto uploadFileParamsDto);

复制代码

实现：

1.   /**
2.      * 上传分块文件到minio
3.      * @param fileMd5 文件md5
4.      * @param chunk 分块序号
5.      * @param localChunkFilePath 文件的本地路径
6.      * @return
7.      */
8.     @Override
9.     public RestResponse uploadChunk(String fileMd5, int chunk, String localChunkFilePath) {
10.         //获取文件的保存父路径
11.         String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
12.         //获取文件保存路径
13.         String chunkFilePath = chunkFileFolderPath + chunk;
14.         //获取文件的mimeType
15.         String mimeType = getMimeType(null);
16.         try {
17.             //上传分块文件到minio
18.             boolean b = updataFile(mimeType, bucket_video, chunkFilePath, localChunkFilePath);
19.             if (!b){
20.                 log.debug("上传分块文件失败:{}",chunkFilePath);
21.                 return RestResponse.validfail(false,"上传分块文件失败");
22.             }
23.         }catch (Exception e){
24.             e.printStackTrace();
25.         }
26.         log.debug("上传分块文件成功:{}",chunkFilePath);
27.         return RestResponse.success(true);
28.     }
31.     /**
32.      * @description 合并分块
33.      * @param companyId  机构id
34.      * @param fileMd5  文件md5
35.      * @param chunkTotal 分块总和
36.      * @param uploadFileParamsDto 文件信息
37.      * @return com.xuecheng.base.model.RestResponse
38.      * @author Mr.M
39.      * @date 2022/9/13 15:56
40.      */
41.     @Override
42.     public RestResponse mergechunks(Long companyId, String fileMd5, int chunkTotal, UploadFileParamsDto uploadFileParamsDto) {
43.         //合并分块
44.         //获取分块文件路径
45. //        fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
46.         String chunkFileFolderPath = getChunkFileFolderPath(fileMd5);
47.         List<ComposeSource> sources = new ArrayList<>();
48.         for (int i = 0; i < chunkTotal; i++) {
49.             ComposeSource source = ComposeSource.builder().bucket(bucket_video).object(chunkFileFolderPath+i).build();
50.             sources.add(source);
51.         }
52.         //准备合并后文件保存位置
53.         //文件名称
54.         String fileName = uploadFileParamsDto.getFilename();
55.         //文件扩展名
56.         String extName = fileName.substring(fileName.lastIndexOf("."));
57.         //合并文件路径
58.         String mergeFilePath = getFilePathByMd5(fileMd5, extName);
59.         ComposeObjectArgs testbucket = ComposeObjectArgs.builder().bucket(bucket_video).object(mergeFilePath).sources(sources).build();
60.         try {
61.             minioClient.composeObject(testbucket);
62.         } catch (Exception e) {
63.             log.error("合并文件失败",e);
64.             return RestResponse.validfail(false,"合并文件失败");
65.         }
66.         //校验文件是否完整
67.         //下载已经合并完成的文件
68.         File file = downloadFileFromMinIO(bucket_video, mergeFilePath);
69.         if(file == null){
70.             log.debug("下载合并后文件失败,mergeFilePath:{}",mergeFilePath);
71.             return RestResponse.validfail(false, "下载合并后文件失败。");
72.         }
73. //        try {
74. //            //获取合并后文件的md5
75. //            String mergeFile_md5 = getFileMd5(file.getAbsolutePath());
76. //            if (!fileMd5.equals(mergeFile_md5)){
77. //                //合并后文件的md5与源文件的md5不一致
78. //                return RestResponse.validfail(false,"文件合并校验失败");
79. //            }
80. //        } catch (Exception e) {
81. //            e.printStackTrace();
82. //        }
83.         try (InputStream newFileInputStream = new FileInputStream(file)) {
84.             //minio上文件的md5值
85.             String md5Hex = DigestUtils.md5DigestAsHex(newFileInputStream);
86.             //比较md5值，不一致则说明文件不完整
87.             if(!fileMd5.equals(md5Hex)){
88.                 return RestResponse.validfail(false, "文件合并校验失败，最终上传失败。");
89.             }
90.             //文件大小
91.             uploadFileParamsDto.setFileSize(file.length());
92.         }catch (Exception e){
93.             log.debug("校验文件失败,fileMd5:{},异常:{}",fileMd5,e.getMessage(),e);
94.             return RestResponse.validfail(false, "文件合并校验失败，最终上传失败。");
95.         }finally {
96.             if(file!=null){
97.                 file.delete();
98.             }
99.         }
100.         //将文件信息保存到数据库
101.         currentProxy.addMediaFilesToDb(companyId,fileMd5,uploadFileParamsDto,bucket_video,mergeFilePath);
102.         //删除分块文件
103. //        removeChunkFiles(chunkFileFolderPath,chunkTotal);
104.         clearChunkFiles(chunkFileFolderPath,chunkTotal);
105.         return RestResponse.success(true);
106.     }
108.     /**
109.      * 删除分块文件
110.      * @param chunkFileFolderPath 分块文件的位置
111.      * @param chunkTotal 分块文件的数量
112.      */
113.     private void clearChunkFiles(String chunkFileFolderPath, int chunkTotal) {
114.         List<DeleteObject> sources = new ArrayList<>();
115.         for (int i = 0; i < chunkTotal; i++) {
116.             DeleteObject source = new DeleteObject(chunkFileFolderPath.concat(Integer.toString(i)));
117.                 sources.add(source);
118.         }
120.         //这个方法要真正删除要遍历一下
121.         Iterable<Result<DeleteError>> results = minioClient.removeObjects(RemoveObjectsArgs.builder().bucket(bucket_video).objects(sources).build());
122.         results.forEach(r->{
123.             DeleteError deleteError = null;
124.             try {
125.                 deleteError = r.get();
126.             } catch (Exception e) {
127.                 e.printStackTrace();
128.                 log.error("清楚分块文件失败,objectname:{}",deleteError.objectName(),e);
129.             }
130.         });
131.     }
133.     /**
134.      * 从minio中下载文件
135.      * @param bucket
136.      * @param objectName
137.      * @return
138.      */
139.     public File downloadFileFromMinIO(String bucket,String objectName){
140.         //创建临时文件
141.         File minioFile = null;
142.         FileOutputStream  outputStream = null;
143.         try {
144.             GetObjectArgs testbucket = GetObjectArgs.builder()
145.                     .bucket(bucket)
146.                     .object(objectName)
147.                     .build();
148.             //读取数据获取到输入流
149.             InputStream  stream = minioClient.getObject(testbucket);
150.             //创建临时文件
151.             minioFile=File.createTempFile("minio", ".merge");
152.             outputStream = new FileOutputStream(minioFile);
153.             IOUtils.copy(stream,outputStream);
154.             return minioFile;
155.         }catch (Exception e){
156.             e.printStackTrace();
157.         }finally {
158.             //关闭资源
159.             if (outputStream != null){
160.                 try {
161.                     outputStream.close();
162.                 } catch (IOException e) {
163.                     throw new RuntimeException(e);
164.                 }
165.             }
166.         }
167.         return null;
168.     }
170.     //获取分块路径
171.     //得到分块文件的目录
172.     private String getChunkFileFolderPath(String fileMd5) {
173.         return fileMd5.substring(0, 1) + "/" + fileMd5.substring(1, 2) + "/" + fileMd5 + "/" + "chunk" + "/";
174.     }
176.     /**
177.      * 得到合并后的文件的地址
178.      * @param fileMd5 文件id即md5值
179.      * @param fileExt 文件扩展名
180.      * @return
181.      */
182.     private String getFilePathByMd5(String fileMd5,String fileExt){
183.         return   fileMd5.substring(0,1) + "/" + fileMd5.substring(1,2) + "/" + fileMd5 + "/" +fileMd5 +fileExt;
184.     }
188.     /**
189.      * @description 将文件信息添加到文件表
190.      * @param companyId  机构id
191.      * @param fileMd5  文件md5值
192.      * @param uploadFileParamsDto  上传文件的信息
193.      * @param bucket  桶
194.      * @param objectName 对象名称
195.      * @return com.xuecheng.media.model.po.MediaFiles
196.      * @author Mr.M
197.      * @date 2022/10/12 21:22
198.      */
199.     @Transactional
200.     public MediaFiles addMediaFilesToDb(Long companyId,String fileMd5,UploadFileParamsDto uploadFileParamsDto,String bucket,String objectName){
201.         //从数据库查询文件
202.         MediaFiles mediaFiles = mediaFilesMapper.selectById(fileMd5);
203.         if (mediaFiles == null) {
204.             mediaFiles = new MediaFiles();
205.             //拷贝基本信息
206.             BeanUtils.copyProperties(uploadFileParamsDto, mediaFiles);
207.             mediaFiles.setId(fileMd5);
208.             mediaFiles.setFileId(fileMd5);
209.             mediaFiles.setCompanyId(companyId);
210.             mediaFiles.setUrl("/" + bucket + "/" + objectName);
211.             mediaFiles.setBucket(bucket);
212.             mediaFiles.setFilePath(objectName);
213.             mediaFiles.setCreateDate(LocalDateTime.now());
214.             mediaFiles.setAuditStatus("002003");
215.             mediaFiles.setStatus("1");
216.             //保存文件信息到文件表
217.             int insert = mediaFilesMapper.insert(mediaFiles);
218.             if (insert < 0) {
219.                 log.error("保存文件信息到数据库失败,{}",mediaFiles.toString());
220.                 XueChengPlusException.cast("保存文件信息失败");
221.             }
222.             log.debug("保存文件信息到数据库成功,{}",mediaFiles.toString());
224.         }
225.         return mediaFiles;
226.     }

复制代码

面试

5.6面试
1、什么情况Spring事件会失效
1)在方法中捕捉非常没有抛出去
2)非事件方法调用事件方法
3)事件方法部调用事件方法
4)@Transactional标记的方法不是public
5)抛出的非常与rollbackFor指定的非常不匹配，默认rollbackFor指定的非常为RuntimeException
6)数据库表不支持事件，好比MySQL的MyISAM
7)Spring的传播举动导致事件失效，好比：PROPAGATION_NEVER、PROPAGATION_NOT_SUPPORTED
PROPAGATION REQUIRED-支持当前事件，假如当前没有事件，就新建一个事件。这是最常见的选择。
PROPAGATION SUPPORTS-支持当前事件，假如当前没有事件，就以非事件方式执行。
PROPAGATION MANDATORY-支持当前事件，假如当前没有事件，就抛出非常。
PROPAGATION REQUIRES NEW-新建事件，假如当前存在事件，把当前事件挂起。
PROPAGATION NOT_SUPPORTED-以非事件方式执行操作，假如当前存在事件，就把当前事件挂起。
PROPAGATION_NEVER-以非事件方式执行，假如当前存在事件，则抛出非常。
PROPAGATION NESTED-假如当前存在事件，则在嵌套事件内执行。假如当前没有事件，则与
PROPAGATION REQUIRED类似的操作。

4、断点续传是怎么做的？
我们是基于分块上传的模式实现断点续传的需求，当文件上传一部门断网后前边已经上传过的不再上传。
1)前端对文件分块。
2)前端利用多线程一块一块上传，上传前给服务端发一个消息校验该分块是否上传，假如已上传则不再上传。
3)等全部分块上传完毕，服务端归并全部分块，校验文件的完整性。
因为分块全部上传到了服务器，服务器将全部分块按顺序进行归并，就是写每个分块文件内容按顺序依次写入一个
文件中。利用字节流去读写文件。
4)前端给服务传了一个md5值，服务端归并文件后计算归并后文件的md5是否和前端传的一样，假如一样则说文
件完整，假如不一样说明可能由于网络丢包导致文件不完整，这时上传失败须要重新上传。
5、分块文件清算题目？
上传一个文件进行分块上传，上传一半不传了，之前上传到miio的分块文件要清算吗？怎么做的？
1、在数据库中有一张文件表记载minio中存储的文件信息。
2、文件开始上传时会写入文件表，状态为上传中，上传完成会更新状态为上传完成。
3、当一个文件传了一半不再上传了说明该文件没有上传完成，会有定时任务去查询文件表中的记载，假如文件未
上传完成则删除minio中没有上传成功的文件目录。

视频处理

视频编码

视频上传成功后须要对视频进行转码处理。
什么是视频编码？查阅百度百科如下：

详情参考 ：视频编码_百度百科
首先我们要分清文件格式和编码格式：
文件格式：是指.mp4、.avi、.rmvb等 这些不同扩展名的视频文件的文件格式 ，视频文件的内容重要包罗视频和音频，其文件格式是按照一 定的编码格式去编码，并且按照该文件所规定的封装格式将视频、音频、字幕等信息封装在一起，播放器会根据它们的封装格式去提取出编码，然后由播放器解码，最终播放音视频。
音视频编码格式：通过音视频的压缩技术，将视频格式转换成另一种视频格式，通过视频编码实现流媒体的传输。好比：一个.avi的视频文件原来的编码是a，通过编码后编码格式变为b，音频原来为c，通过编码后变为d。
音视频编码格式各类繁多，重要有几下几类：
MPEG系列
（由ISO[国际标准构造机构]部属的MPEG[运动图象专家组]开发 ）视频编码方面重要是Mpeg1（vcd用的就是它）、Mpeg2（DVD利用）、Mpeg4（的DVDRIP利用的都是它的变种，如：divx，xvid等）、Mpeg4 AVC（正热门）；音频编码方面重要是MPEG Audio Layer 1/2、MPEG Audio Layer 3（台甫鼎鼎的mp3）、MPEG-2 AAC 、MPEG-4 AAC等等。留意：DVD音频没有采用Mpeg的。
H.26X系列
（由ITU[国际电传视讯联盟]主导，偏重网络传输，留意：只是视频编码）
包罗H.261、H.262、H.263、H.263+、H.263++、H.264（就是MPEG4 AVC-合作的结晶）
目前最常用的编码标准是视频H.264，音频AAC。
提问：
H.264是编码格式照旧文件格式？
mp4是编码格式照旧文件格式？
FFmpeg 的基本利用

我们将视频录制完成后，利用视频编码软件对视频进行编码，本项目 利用FFmpeg对视频进行编码 。

FFmpeg被许多开源项目采用，QQ影音、暴风影音、VLC等。
下载：FFmpeg Download FFmpeg
请从常用工具软件目录找到ffmpeg.exe，并将ffmpeg.exe加入环境变量path中。
测试是否正常：cmd运行 ffmpeg -version

安装成功，作下简单测试
将一个.avi文件转成mp4、mp3、gif等。
好比我们将nacos.avi文件转成mp4，运行如下下令：
D:\soft\ffmpeg\ffmpeg.exe -i 1.avi 1.mp4
可以将ffmpeg.exe配置到环境变量path中，进入视频目录直接运行：ffmpeg.exe -i 1.avi 1.mp4
转成mp3：ffmpeg -i nacos.avi nacos.mp3
转成gif：ffmpeg -i nacos.avi nacos.gif
官方文档（英文）：ffmpeg Documentation

视频处理工具类

将课程资料的工具类中的util拷贝至base工程。

其中Mp4VideoUtil类是用于将视频转为mp4格式，是我们项目要利用的工具类。
对Mp4VideoUtil类须要学习利用方法，下边代码将一个avi视频转为mp4视频，如下：

1.     public static void main(String[] args) throws IOException {
3.         //ffmpeg的路径
4.         String ffmpeg_path = "D:\\yingyong\\tool\\ffmpeg\\ffmpeg.exe";//ffmpeg的安装位置
5.         //源avi视频的路径
6.         String video_path = "D:\\test\\1.avi";
7.         //转换后mp4文件的名称
8.         String mp4_name = "test1.mp4";
9.         //转换后mp4文件的路径
10.         String mp4_path = "D:\\test\\1a.mp4";
11.         //创建工具类对象
12.         Mp4VideoUtil videoUtil = new Mp4VideoUtil(ffmpeg_path,video_path,mp4_name,mp4_path);
13.         //开始视频转换，成功将返回success
14.         String s = videoUtil.generateMp4();
15.         System.out.println(s);
16.     }

复制代码

执行main方法，最终在控制台输出 success 表示执行成功。

分布式任务处理

什么是分布式任务调度

对一个视频的转码可以明白为一个任务的执行，假如视频的数目比力多，如何去高效处理一批任务呢？
1、多线程
多线程是充实利用单机的资源。
2、分布式加多线程
充实利用多台计算机，每台计算机利用多线程处理。
方案2可扩展性更强。
方案2是一种分布式任务调度的处理方案。
什么是分布式任务调度？
我们可以先思考一下下面业务场景的解决方案：
每隔24小时执行数据备份任务。
12306网站会根据车次不同，设置几个时间点分批次放票。
某财务系统须要在每天上午10点前结算前一天的账单数据，统计汇总。
商品成功发货后，须要向客户发送短信提示。
类似的场景另有很多，我们该如何实现？
多线程方式实现：

学过多线程的同学，可能会想到，我们可以开启一个线程，每sleep一段时间，就去查抄是否已到预期执行时间。
以下代码简单实现了任务调度的功能：

1. public static void main(String[] args) {   
2.     //任务执行间隔时间
3.     final long timeInterval = 1000;
4.     Runnable runnable = new Runnable() {
5.         public void run() {
6.             while (true) {
7.                 //TODO：something
8.                 try {
9.                     Thread.sleep(timeInterval);
10.                 } catch (InterruptedException e) {
11.                     e.printStackTrace();
12.                 }
13.             }
14.         }
15.     };
16.     Thread thread = new Thread(runnable);
17.     thread.start();
18. }

复制代码

上面的代码实现了按一定的间隔时间执行任务调度的功能。
Jdk也为我们提供了相关支持，如Timer、ScheduledExecutor，下边我们了解下。
Timer方式实现：

1. public static void main(String[] args){  
2.     Timer timer = new Timer();  
3.     timer.schedule(new TimerTask(){
4.         @Override  
5.         public void run() {  
6.            //TODO：something
7.         }  
8.     }, 1000, 2000);  //1秒后开始调度，每2秒执行一次
9. }

复制代码

Timer 的优点在于简单易用，每个Timer对应一个线程，因此可以同时启动多个Timer并行执行多个任务，同一个Timer中的任务是串行执行。
ScheduledExecutor方式实现：

1. public static void main(String [] agrs){
2.     ScheduledExecutorService service = Executors.newScheduledThreadPool(10);
3.     service.scheduleAtFixedRate(
4.             new Runnable() {
5.                 @Override
6.                 public void run() {
7.                     //TODO：something
8.                     System.out.println("todo something");
9.                 }
10.             }, 1,
11.             2, TimeUnit.SECONDS);
12. }

复制代码

Java 5 推出了基于线程池设计的 ScheduledExecutor，其设计思想是，每一个被调度的任务都会由线程池中一个线程去执行，因此任务是并发执行的，相互之间不会受到干扰。
Timer 和 ScheduledExecutor 都仅能提供基于开始时间与重复间隔的任务调度，不能胜任更加复杂的调度需求。好比，设置每月第一天凌晨1点执行任务、复杂调度任务的管理、任务间传递数据等等。

第三方Quartz方式实现，项目地址：https://github.com/quartz-scheduler/quartz
Quartz 是一个功能强大的任务调度框架，它可以满足更多更复杂的调度需求，Quartz 设计的焦点类包罗 Scheduler, Job 以及 Trigger。其中，Job 负责定义须要执行的任务，Trigger 负责设置调度计谋，Scheduler 将二者组装在一起，并触发任务开始执行。Quartz支持简单的按时间间隔调度、还支持按日历调度方式，通过设置CronTrigger表达式（包罗：秒、分、时、日、月、周、年）进行任务调度。
下边是一个例子代码

1. public static void main(String [] agrs) throws SchedulerException {
2.     //创建一个Scheduler
3.     SchedulerFactory schedulerFactory = new StdSchedulerFactory();
4.     Scheduler scheduler = schedulerFactory.getScheduler();
5.     //创建JobDetail
6.     JobBuilder jobDetailBuilder = JobBuilder.newJob(MyJob.class);
7.     jobDetailBuilder.withIdentity("jobName","jobGroupName");
8.     JobDetail jobDetail = jobDetailBuilder.build();
9.     //创建触发的CronTrigger 支持按日历调度
10.         CronTrigger trigger = TriggerBuilder.newTrigger()
11.                 .withIdentity("triggerName", "triggerGroupName")
12.                 .startNow()
13.                 .withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
14.                 .build();
15.     scheduler.scheduleJob(jobDetail,trigger);
16.     scheduler.start();
17. }
19. public class MyJob implements Job {
20.     @Override
21.     public void execute(JobExecutionContext jobExecutionContext){
22.         System.out.println("todo something");
23.     }
24. }

复制代码

通过以上内容我们学习了什么是任务调度，任务调度所解决的题目，以及任务调度的多种实现方式。
任务调度顾名思义，就是对任务的调度，它是指系统为了完成特定业务，基于给定时间点，给定时间间隔或者给定执行次数自动执行任务。
什么是分布式任务调度？
通常任务调度的步伐是集成在应用中的，好比：优惠卷服务中包罗了定时发放优惠卷的的调度步伐，结算服务中包罗了定期生成报表的任务调度步伐，由于采用分布式架构，一个服务往往会部署多个冗余实例来运行我们的业务，在这种分布式系统环境下运行任务调度，我们称之为分布式任务调度，如下图：

分布式调度要实现的目的：
不管是任务调度步伐集成在应用步伐中，照旧单独构建的任务调度系统，假如采用分布式调度任务的方式就相当于将任务调度步伐分布式构建，如许就可以具有分布式系统的特点，并且进步任务的调度处理能力：
1、并行任务调度
并行任务调度实现靠多线程，假如有大量任务须要调度，此韶光靠多线程就会有瓶颈了，因为一台计算机CPU的处理能力是有限的。
假如将任务调度步伐分布式部署，每个结点还可以部署为集群，如许就可以让多台计算机共同去完成任务调度，我们可以将任务分割为若干个分片，由不同的实例并行执行，来进步任务调度的处理效率。
2、高可用
若某一个实例宕机，不影响其他实例来执行任务。
3、弹性扩容
当集群中增长实例就可以进步并执行任务的处理效率。
4、任务管理与监测
对系统中存在的全部定时任务进行统一的管理及监测。让开发人员及运维人员可以或许时刻了解任务执行情况，从而做出快速的应急处理响应。
5、克制任务重复执行
当任务调度以集群方式部署，同一个任务调度可能会执行多次，好比在上面提到的电商系统中到点发优惠券的例子，就会发放多次优惠券，对公司造成很多损失，所以我们须要控制雷同的任务在多个运行实例上只执行一次。

XXL-JOB介绍

XXL-JOB配置详情：https://mx67xggunk5.feishu.cn/wiki/SiQAwJ99MiP7w9kZWaicTacKn0g














































































免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。