Java实现Fast DFS、服务器、OSS上传

支持Fast DFS、服务器、OSS等上传方式

先容

在实际的业务中，可以根据客户的需求设置差别的文件上传需求，支持普通服务器上传+分布式上传（Fast DFS）+云服务上传OSS（OSS）
软件架构

为了方便演示使用，本项目使用的是前后端不分离的架构

前端：Jquery.uploadFile
后端：SpringBoot
前期准备：FastDFS、OSS（华为）、服务器
实现逻辑

通过 application 配置对上传文件举行一个自定义配置，从而摆设在差别客户环境可以自定义选择方式。
优点：

• 一键切换；
  
• 支持当前主流方式；
  

缺点：

• 迁移数据难度增长：因为体现FileID在对象存储和服务器上传都是天生的UUID，而FastDFS是返回存取ID，当需要迁移的时间，通过脚本可以快速将FastDFS的数据迁移上云，因为存储ID可以共用。但是对象存储和服务器上传的UUID无法被FastDFS使用，增长迁移成本
  

核心代码

1. package com.example.file.util;
3. import com.example.file.common.ResultBean;
4. import com.github.tobato.fastdfs.domain.StorePath;
5. import com.github.tobato.fastdfs.proto.storage.DownloadByteArray;
6. import com.github.tobato.fastdfs.service.FastFileStorageClient;
7. import com.obs.services.ObsClient;
8. import com.obs.services.exception.ObsException;
9. import com.obs.services.model.DeleteObjectRequest;
10. import com.obs.services.model.GetObjectRequest;
11. import com.obs.services.model.ObsObject;
12. import com.obs.services.model.PutObjectResult;
13. import io.micrometer.common.util.StringUtils;
14. import jakarta.servlet.http.HttpServletResponse;
15. import lombok.extern.slf4j.Slf4j;
16. import org.springframework.mock.web.MockMultipartFile;
17. import org.springframework.web.multipart.MultipartFile;
19. import java.io.*;
20. import java.util.Objects;
21. import java.util.UUID;
23. @Slf4j
24. public class FileUtil {
26.     /**
27.      *
28.      * @param file 文件
29.      * @param uploadFlag 标识
30.      * @param uploadPath 上传路径
31.      * @param endPoint 域名
32.      * @param ak    ak
33.      * @param sk sk
34.      * @param bucketName 桶名字
35.      * @return fileId 用于下载
36.      */
37.     public static ResultBean uploadFile(MultipartFile file, String uploadFlag, String uploadPath,
38.                                         FastFileStorageClient fastFileStorageClient,
39.                                         String endPoint, String ak, String sk,
40.                                         String bucketName) {
42.         if (StringUtils.isBlank(uploadFlag)){
43.             ResultBean.error("uploadFlag is null");
44.         }
45.         switch (uploadFlag){
46.             case "fastDFS":
47.                 return uploadFileByFastDFS(file,fastFileStorageClient);
48.             case "huaweiOOS":
49.                 return uploadFileByHuaweiObject(file, endPoint, ak, ak, bucketName);
50.             case "server":
51.             default:
52.                 return uploadFileByOrigin(file,uploadPath);
53.         }}
55.     /**
56.      * 上传文件fastDFS
57.      * @param file 文件名
58.      * @return
59.      */
60.     private static ResultBean uploadFileByFastDFS(MultipartFile file,FastFileStorageClient fastFileStorageClient){
61.         Long size=file.getSize();
62.         String fileName=file.getOriginalFilename();
63.         String extName=fileName.substring(fileName.lastIndexOf(".")+1);
64.         InputStream inputStream=null;
65.         try {
66.             inputStream=file.getInputStream();
67.             //1-上传的文件流 2-文件的大小 3-文件的后缀 4-可以不管他
68.             StorePath storePath=fastFileStorageClient.uploadFile(inputStream,size,extName,null);
69.             log.info("[uploadFileByFastDFS][FullPath]"+storePath.getFullPath());
70.             return ResultBean.success(storePath.getPath());
71.         }catch (Exception e){
72.             log.info("[ERROR][uploadFileByFastDFS]"+e.getMessage());
73.             return ResultBean.error(e.getMessage());
74.         }finally {
75.             if (inputStream != null) {
76.                 try {
77.                     inputStream.close();
78.                 } catch (IOException e) {
79.                     e.printStackTrace();
80.                 }
81.             }
82.         }
83.     }
85.     /**
86.      * 对象存储上传
87.      * @param file 文件名
88.      * @return
89.      */
90.     private static ResultBean uploadFileByHuaweiObject(MultipartFile file, String huaweiEndPoint,String huaweiobsAk,String huaweiobsSk,
91.                                                    String bucketName){
92.         String fileName = file.getOriginalFilename();
93.         fileName = renameToUUID(fileName);
94.         InputStream inputStream=null;
95.         try {
96.             inputStream=file.getInputStream();
97.             // 创建ObsClient实例
98.             ObsClient obsClient = new ObsClient(huaweiobsAk, huaweiobsSk, huaweiEndPoint);
99.             PutObjectResult result = obsClient.putObject(bucketName, fileName, inputStream);
100.             obsClient.close();
101.             return ResultBean.success(fileName);
102.         }catch (ObsException e){
103.             log.info("[ERROR][uploadFileByHuaweiObject]"+e.getErrorMessage());
104.             return ResultBean.error(e.getErrorMessage());
105.         }catch (Exception e){
106.             log.info("[ERROR][uploadFileByHuaweiObject]"+e.getMessage());
107.             return ResultBean.error(e.getMessage());
108.         }finally {
109.             if (inputStream != null) {
110.                 try {
111.                     inputStream.close();
112.                 } catch (IOException e) {
113.                     e.printStackTrace();
114.                 }
115.             }
116.         }
117.     }
119.     /**
120.      * 上传文件原本方法
121.      * @param file 文件名
122.      * @return
123.      */
124.     private static ResultBean uploadFileByOrigin(MultipartFile file,String uploadPath){
125.         String fileName = file.getOriginalFilename();
126.         fileName = renameToUUID(fileName);
127.         File targetFile = new File(uploadPath);
128.         if (!targetFile.exists()) {
129.             targetFile.mkdirs();
130.         }
131.         FileOutputStream out = null;
132.         try {
133.             out = new FileOutputStream(uploadPath + fileName);
134.             out.write(file.getBytes());
135.         } catch (IOException e) {
136.             log.info("[ERROR][uploadFileByOrigin]"+e.getMessage());
137.             return ResultBean.error(e.getMessage());
138.         }finally {
139.             try {
140.                 out.flush();
141.             } catch (IOException e) {
142.                 e.printStackTrace();
143.             }
144.             try {
145.                 out.close();
146.             } catch (IOException e) {
147.                 e.printStackTrace();
148.             }
149.         }
150.         return ResultBean.success(fileName);
151.     }
152.     /**
153.      * 下载
154.      * @return
155.      */
156.     public static byte[] downloadFile(String fileId,String uploadFlag,String uploadPath
157.             ,FastFileStorageClient fastFileStorageClient, String group,
158.                                       String endPoint,String ak,String sk,
159.                                       String bucketName) {
160.         byte[] result=null;
161.         switch (uploadFlag){
162.             case "fastDFS":
163.                 result =downloadFileByFastDFS(fileId,fastFileStorageClient,group);
164.                 break;
165.             case "huaweiOOS":
166.                 result =downloadFileByHuaweiObject(fileId, endPoint, ak, sk, bucketName);
167.                 break;
168.             case "server":
169.             default:
170.                 String path2 = uploadPath + fileId;
171.                 path2 = path2.replace("//", "/");
172.                 result=downloadFileByOrigin(path2);
173.                 break;
174.         }
175.         return result;
177.     }
179.     /**
180.      * 下载文件fastDFS
181.      * @param fileId 文件名
182.      * @return
183.      */
184.     private static byte[] downloadFileByFastDFS(String fileId,FastFileStorageClient fastFileStorageClient,
185.                                                 String group){
186.         DownloadByteArray callback=new DownloadByteArray();
187.         byte[] group1s=null;
188.         try {
189.             group1s = fastFileStorageClient.downloadFile(group, fileId, callback);
190.         }catch (Exception e){
191.             log.info("[ERROR][downloadFileByFastDFS]"+e.getMessage());
193.         }
194.         return group1s;
195.     }
197.     /**
198.      * 下载文件对象存储
199.      * @param fileId 文件名
200.      * @return
201.      */
202.     private static byte[] downloadFileByHuaweiObject(String fileId, String huaweiEndPoint,String huaweiobsAk,String huaweiobsSk,
203.                                                      String bucketName){
204.         byte[] bytes =null;
205.         try {
206.             // 创建ObsClient实例
207.             ObsClient obsClient = new ObsClient(huaweiobsAk, huaweiobsSk, huaweiEndPoint);
208.             // 构造GetObjectRequest请求
209.             GetObjectRequest getObjectRequest = new GetObjectRequest(bucketName, fileId);
210.             // 执行下载操作
211.             ObsObject obsObject = obsClient.getObject(getObjectRequest);
212.             bytes = inputStreamToByteArray(obsObject.getObjectContent());
213.             // 关闭OBS客户端
214.             obsClient.close();
215.             return bytes;
216.         }catch (ObsException e){
217.             log.info("[ERROR][downloadFileByHuaweiObject]"+e.getErrorMessage());
218.         }catch (Exception e) {
219.             log.info("[ERROR][downloadFileByHuaweiObject]"+e.getMessage());
220.         }
221.         return bytes;
222.     }
224.     /**
225.      *
226.      * @param input
227.      * @return
228.      * @throws IOException
229.      */
230.     private static byte[] inputStreamToByteArray(InputStream input) throws IOException {
231.         ByteArrayOutputStream output = new ByteArrayOutputStream();
232.         byte[] buffer = new byte[4096];
233.         int n = 0;
234.         while (-1 != (n = input.read(buffer))) {
235.             output.write(buffer, 0, n);
236.         }
237.         return output.toByteArray();
238.     }
240.     /**
241.      * 下载文件
242.      * @param fileId 文件名
243.      * @return
244.      */
245.     private static byte[] downloadFileByOrigin(String fileId){
246.         File file  =new File(fileId);
247.         InputStream inputStream=null;
248.         byte[] buff = new byte[1024];
249.         byte[] result=null;
250.         BufferedInputStream bis = null;
251.         ByteArrayOutputStream os = null;
252.         try {
253.             os=new ByteArrayOutputStream();
254.             bis = new BufferedInputStream(new FileInputStream(file));
255.             int i = bis.read(buff);
256.             while (i != -1) {
257.                 os.write(buff, 0, buff.length);
258.                 i = bis.read(buff);
259.             }
260.             result=os.toByteArray();
261.             os.flush();
262.         } catch (Exception e) {
263.             log.info("[ERROR][downloadFile]"+e.getMessage());
264.         }finally {
265.             if (inputStream != null) {
266.                 try {
267.                     inputStream.close();
268.                 } catch (IOException e) {
269.                     e.printStackTrace();
270.                 }
271.             }
272.         }
273.         return result;
274.     }
276.     /**
277.      * 删除文件
278.      * @param fileId 文件ID
279.      * @return 删除失败返回-1，否则返回0
280.      */
281.     public static boolean deleteFile(String fileId,String fastDFSFlag,FastFileStorageClient fastFileStorageClient,
282.                                      String group,String uploadPath) {
283.         boolean result=false;
284.         if (StringUtils.isNotBlank(fastDFSFlag)&&
285.                 fastDFSFlag.trim().equalsIgnoreCase("true")){
286.             result =deleteFileByFastDFS(fileId,fastFileStorageClient,group);
287.         }else {
288.             String path2 = uploadPath + fileId;
289.             path2 = path2.replace("//", "/");
290.             result=deleteByOrigin(path2);
291.         }
292.         return result;
293.     }
294.     private static boolean deleteByOrigin(String fileName) {
295.         File file = new File(fileName);
296.         // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
297.         if (file.exists() && file.isFile()) {
298.             if (file.delete()) {
299.                 return true;
300.             } else {
301.                 return false;
302.             }
303.         } else {
304.             return false;
305.         }
306.     }
308.     private static boolean deleteFileByFastDFS(String fileId,FastFileStorageClient fastFileStorageClient,
309.                                                String group) {
310.         try {
311.             String groupFieId=group+"/"+fileId;
312.             StorePath storePath = StorePath.praseFromUrl(groupFieId);
313.             fastFileStorageClient.deleteFile(storePath.getGroup(), storePath.getPath());
314.         } catch (Exception e) {
315.             log.info("[ERROR][deleteFileByFastDFS]"+e.getMessage());
316.             return false;
317.         }
318.         return true;
319.     }
321.     /**
322.      * 生成fileId
323.      * @param fileName
324.      * @return
325.      */
326.     private static String renameToUUID(String fileName) {
327.         return UUID.randomUUID() + "." + fileName.substring(fileName.lastIndexOf(".") + 1);
328.     }
330.     /**
331.      * 删除文件对象存储
332.      * @param fileId 文件名
333.      * @return
334.      */
335.     private static boolean deleteFileByHuaweiObject(String fileId, String huaweiEndPoint,String huaweiobsAk,String huaweiobsSk,
336.                                                     String bucketName){
337.         try {
338.             // 创建ObsClient实例
339.             ObsClient obsClient = new ObsClient(huaweiobsAk, huaweiobsSk, huaweiEndPoint);
340.             // 构造GetObjectRequest请求
341.             DeleteObjectRequest getObjectRequest = new DeleteObjectRequest(bucketName, fileId);
343.             // 执行删除操作
344.             obsClient.deleteObject(getObjectRequest);
345.             // 关闭OBS客户端
346.             obsClient.close();
347.         }catch (ObsException e){
348.             log.info("[ERROR][deleteFileByHuaweiObject]"+e.getErrorMessage());
349.         }catch (Exception e) {
350.             log.info("[ERROR][downloadFileByHuaweiObject]"+e.getMessage());
351.         }
352.         return true;
353.     }
355.     /**
356.      * 文件数据输出(image)
357.      * @param fileId
358.      * @param bytes
359.      * @param res
360.      */
361.     public static void fileDataOut(String fileId, byte[] bytes, HttpServletResponse res){
363.         String[] prefixArray = fileId.split("\\.");
364.         String prefix=prefixArray[1];
365.         File file  =new File(fileId);
367.         res.reset();
368.         res.setCharacterEncoding("utf-8");
369. //        res.setHeader("content-type", "");
370.         res.addHeader("Content-Length", "" + bytes.length);
371.         if(prefix.equals("svg"))
372.             prefix ="svg+xml";
373.         res.setContentType("image/"+prefix);
374.         res.setHeader("Accept-Ranges","bytes");
375.         OutputStream os = null;
377.         try {
378. //            os = res.getOutputStream();
379. //            os.write(bytes);
380. //            os.flush();
381.             res.getOutputStream().write(bytes);
382.         } catch (IOException e) {
383.             System.out.println("not find img..");
384.         } finally {
385.             if (os != null) {
386.                 try {
387.                     os.close();
388.                 } catch (IOException e) {
389.                     e.printStackTrace();
390.                 }
391.             }
392.         }
393.     }
395. }

复制代码

参考资料

假设个人实战使用可以采用docker快速安装，但是未安装过FastDFS建议普通安装摆设，了解一下tracker和storage的使用，以及摆设搭建集群。
FastDFS普通安装摆设：https://www.cnblogs.com/chenliugou/p/15322389.html
FasdDFS docker安装摆设：https://blog.csdn.net/weixin_44621343/article/details/117825755?utm_medium=distribute.pc_relevant.none-task-blog-2defaultbaidujs_baidulandingword~default-0-117825755-blog-127896984.235v43pc_blog_bottom_relevance_base6&spm=1001.2101.3001.4242.1&utm_relevant_index=3
OpenFeign和FastDFS的类冲突：https://www.cnblogs.com/chenliugou/p/18113183
Gitee地址：https://gitee.com/chen-liugou/file/new/master?readme=true

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