• FastDFS基础学习(三)之使用FastDFS

    Java上传文件

    首先拉取最新的FastDFS代码

    GitHub - wangwei216/fastdfs-client-java-master

    打包到本地

    mvn clean install

    更换jdk版本  

            

            1.6

            

            1.8

    新建一个springboot项目

     创建一个controller用来进行测试

    1. @RestController
    2. @RequestMapping("/fdfs")
    3. public class FdfsController {
    4.     @GetMapping(value = "/hello")
    5.     public String hello(){
    6.         return "桃李不言下";
    7.     }
    8.  
    9. }
    配置文件启动端口修改一下
    server.port=8090
    pom.xml文件
    1. <properties>
    2.         <java.version>1.8java.version>
    3.         <fastjson.version>1.2.75fastjson.version>
    4.         <hutool.version>5.5.2hutool.version>
    5.         <generator.version>1.1.2generator.version>
    6.         <commons-io.version>2.8.0commons-io.version>
    7.         <commons-lang3.version>3.11commons-lang3.version>
    8.     properties>
    9.     <dependencies>
    10.         <dependency>
    11.             <groupId>org.springframework.bootgroupId>
    12.             <artifactId>spring-boot-starter-webartifactId>
    13.         dependency>
    14.         <dependency>
    15.             <groupId>org.springframework.bootgroupId>
    16.             <artifactId>spring-boot-starter-webfluxartifactId>
    17.         dependency>
    18.         <dependency>
    19.             <groupId>org.springframework.sessiongroupId>
    20.             <artifactId>spring-session-coreartifactId>
    21.         dependency>
    22.         <dependency>
    23.             <groupId>org.springframework.bootgroupId>
    24.             <artifactId>spring-boot-devtoolsartifactId>
    25.             <scope>runtimescope>
    26.             <optional>trueoptional>
    27.         dependency>
    28.         <dependency>
    29.             <groupId>org.springframework.bootgroupId>
    30.             <artifactId>spring-boot-configuration-processorartifactId>
    31.             <optional>trueoptional>
    32.         dependency>
    33.         <dependency>
    34.             <groupId>org.projectlombokgroupId>
    35.             <artifactId>lombokartifactId>
    36.             <optional>trueoptional>
    37.         dependency>
    38.         <dependency>
    39.             <groupId>org.springframework.bootgroupId>
    40.             <artifactId>spring-boot-starter-tomcatartifactId>
    41.             <scope>providedscope>
    42.         dependency>
    43.         <dependency>
    44.             <groupId>org.springframework.bootgroupId>
    45.             <artifactId>spring-boot-starter-testartifactId>
    46.             <scope>testscope>
    47.         dependency>
    48.         <dependency>
    49.             <groupId>io.projectreactorgroupId>
    50.             <artifactId>reactor-testartifactId>
    51.             <scope>testscope>
    52.         dependency>
    53.  
    54.         <dependency>
    55.             <groupId>cn.hutoolgroupId>
    56.             <artifactId>hutool-allartifactId>
    57.             <version>${hutool.version}version>
    58.         dependency>
    59.  
    60.         <dependency>
    61.             <groupId>com.github.binarywanggroupId>
    62.             <artifactId>java-testdata-generatorartifactId>
    63.             <version>${generator.version}version>
    64.         dependency>
    65.  
    66.         <dependency>
    67.             <groupId>commons-iogroupId>
    68.             <artifactId>commons-ioartifactId>
    69.             <version>${commons-io.version}version>
    70.         dependency>
    71.  
    72.         <dependency>
    73.             <groupId>com.alibabagroupId>
    74.             <artifactId>fastjsonartifactId>
    75.             <version>${fastjson.version}version>
    76.         dependency>
    77.  
    78.         <dependency>
    79.             <groupId>org.apache.commonsgroupId>
    80.             <artifactId>commons-lang3artifactId>
    81.             <version>${commons-lang3.version}version>
    82.         dependency>
    83.  
    84.             
    85.         <dependency>
    86.             <groupId>org.csourcegroupId>
    87.             <artifactId>fastdfs-client-javaartifactId>
    88.             <version>1.29-SNAPSHOTversion>
    89.         dependency>
    90.              <exclusions>
    91.                 <exclusion>
    92.                     <groupId>org.slf4jgroupId>
    93.                     <artifactId>slf4j-log4j12artifactId>
    94.                 exclusion>
    95.             exclusions>
    96.     dependencies>
    97.  
    98.     <build>
    99.         <plugins>
    100.             <plugin>
    101.                 <groupId>org.springframework.bootgroupId>
    102.                 <artifactId>spring-boot-maven-pluginartifactId>
    103.                 <version>2.5.10version>
    104.             plugin>
    105.         plugins>
    106.     build>

     resources下fastdfs-client.properties

    1. #连接超时时间，单位为秒。
    2. fastdfs.connect_timeout_in_seconds = 5
    3. #通信超时时间，单位为秒。发送或接收数据时。假设在超时时间后还不能发送或接收数据，则本次网络通信失败
    4. fastdfs.network_timeout_in_seconds = 30
    5. #charset： 字符集
    6. fastdfs.charset = UTF-8
    7. fastdfs.http_anti_steal_token = false
    8. fastdfs.http_secret_key = FastDFS1234567890
    9. #tracker的http端口
    10. fastdfs.http_tracker_http_port = 28083
    11. #tracker服务器IP和端口设置
    12. fastdfs.tracker_servers = 39.97.100.141:22122
    13.  
    14. fastdfs.connection_pool.enabled = true
    15. fastdfs.connection_pool.max_count_per_entry = 500
    16. fastdfs.connection_pool.max_idle_time = 3600
    17. fastdfs.connection_pool.max_wait_time_in_ms = 1000

    application.yml

    1. server:
    2.     port: 8090
    3. spring:
    4.   servlet:
    5.     multipart:
    6.       max-file-size: 50MB #文件上传大小限制为
    7.       max-request-size: 200MB #请求大小限制为
    8. #查看图片的端口号
    9.  
    10. fdfs_storage_proxy:
    11.   protocol: http://
    12.   domain: 192.168.178.130
    13.   port: 8888

     测试

    1. import org.springframework.beans.factory.annotation.Value;
    2. import org.springframework.web.bind.annotation.GetMapping;
    3. import org.springframework.web.bind.annotation.RequestMapping;
    4. import org.springframework.web.bind.annotation.RestController;
    5.  
    6. @RestController
    7. @RequestMapping("/fdfs")
    8. public class FdfsController {
    9.     @Value("${fdfs_storage_proxy.protocol}")
    10.     private String fdfs_storage_proxy_protocol;
    11.     @Value("${fdfs_storage_proxy.domain}")
    12.     private String fdfs_storage_proxy_domain;
    13.     @Value("${fdfs_storage_proxy.port}")
    14.     private String fdfs_storage_proxy_port;
    15.  
    16.     @GetMapping("/proxy")
    17.     public String proxy(){
    18.         return fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port;
    19.     }
    20.  
    21.     @GetMapping(value = "/hello")
    22.     public String hello(){
    23.         return "桃李不言下";
    24.     }
    25. }

    返回值状态枚举

    ResultCode.enum
    1. /*
    2. * 返回值状态枚举
    3. * */
    4. public enum ResultCode {
    5.     /*
    6.      * 操作成功 请求成功
    7.      * */
    8.     SUCCESS("200","操作成功","请求成功"),
    9.     /*
    10.      * 上传失败
    11.      * */
    12.     UPLOAD_FAILED("700","上传失败","上传失败");
    13.  
    14. /*
    15. * 状态码
    16. * */
    17. private String code;
    18. /*
    19. * 状态码含义
    20. * */
    21.  private String msg;
    22.  /*
    23.  * 状态码含义描述
    24.  * */
    25.  private String desc;
    26.  
    27.  ResultCode(String code,String msg,String desc){
    28.      this.code=code;
    29.      this.msg=msg;
    30.      this.desc=desc;
    31.  }
    32.  
    33.     public String getCode() {
    34.         return code;
    35.     }
    36.  
    37.     public String getMsg() {
    38.         return msg;
    39.     }
    40.  
    41.     public String getDesc() {
    42.         return desc;
    43.     }
    44.  
    45.     public void setCode(String code) {
    46.         this.code = code;
    47.     }
    48.  
    49.     public void setMsg(String msg) {
    50.         this.msg = msg;
    51.     }
    52.  
    53.     public void setDesc(String desc) {
    54.         this.desc = desc;
    55.     }
    56. }
    R.java
    1. /*
    2. * 统一返回数据格式
    3. * */
    4. @NoArgsConstructor
    5. @AllArgsConstructor
    6. @Getter
    7. @Setter
    8. public class R{
    9.     /*
    10.      * 状态码
    11.      * */
    12.     private String code;
    13.     /*
    14.      * 状态码含义
    15.      * */
    16.     private String msg;
    17.     /*
    18.      * 状态码含义描述
    19.      * */
    20.     private T data;
    21. }
    FdfsController.java
    1. @RestController
    2. @RequestMapping("/fdfs")
    3. public class FdfsController {
    4.     @Value("${fdfs_storage_proxy.protocol}")
    5.     private String fdfs_storage_proxy_protocol;
    6.     @Value("${fdfs_storage_proxy.domain}")
    7.     private String fdfs_storage_proxy_domain;
    8.     @Value("${fdfs_storage_proxy.port}")
    9.     private String fdfs_storage_proxy_port;
    10.  
    11.     @GetMapping("/proxy")
    12.     public String proxy(){
    13.         return fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port;
    14.     }
    15.  
    16.     @GetMapping(value = "/hello")
    17.     public String hello(){
    18.         return "桃李不言下";
    19.     }
    20.  
    22.  
    23.     @RequestMapping("/upload1")
    24.     public R<String>update01(@RequestParam("header")MultipartFile multipartFile){
    25.         //封装返回数据 默认为上传失败
    26.         R<String> response = new R<>(ResultCode.UPLOAD_FAILED.getCode(), ResultCode.UPLOAD_FAILED.getMsg(), null);
    27.         //获取原文件的名字
    28.         String originalFilename = multipartFile.getOriginalFilename();
    29.         //获取源文件后缀名
    30.         String suffix = FilenameUtils.getExtension(originalFilename);
    31.         //文件上传
    32.         try {
    33.             //加载fastdfs-client.properties配置文件
    34.             ClientGlobal.initByProperties("fastdfs-client.properties");
    35.             //获取tracker和storage客户端对象
    36.             TrackerClient client = new TrackerClient();
    37.             //获取tracker地址
    38.             TrackerServer trackerServer = client.getTrackerServer();
    39.             StorageServer storageServer=null;
    40.             //获取storage地址
    41.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    42.             //文件上传字节数组
    43.             InputStream inputStream = multipartFile.getInputStream();
    44.             int length = inputStream.available();
    45.             byte[] bytes = new byte[length];
    46.             //文件上传成功后重新封装返回数据
    47.             inputStream.read(bytes);
    48.             String[] result = storageClient.upload_file(bytes, suffix, null);
    49.             System.out.println(JSON.toJSONString(result));
    50.             //文件上传后,重新封装返回数据
    51.             response.setCode(ResultCode.SUCCESS.getCode());
    52.             response.setMsg(ResultCode.SUCCESS.getMsg());
    53.             String url =fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port+"/" +result[0]+"/"+result[1];
    54.             response.setData(url);
    55.         } finally {
    56.             //向用户响应上传成功的访问地址
    57.             return response;
    58.         }
    59.     }
    60.  
    61. }

     封装成Utils工具类

    BaseFastDFSUtil.java
    1. /*
    2. * FastDFS工具类
    3. * */
    4. public class BaseFastDFSUtil {
    5.     /*
    6.     * 配置文件
    7.     * */
    8.     private final static String propFilePath="fastdfs-client.properties";
    9.  
    10.     static {
    11.         //加载fastdfs-client.properties配置文件
    12.         try {
    13.             ClientGlobal.initByProperties(propFilePath);
    14.         } catch (IOException  | MyException e) {
    15.             e.printStackTrace();
    16.         }
    17.     }
    18.  
    19.     /*
    20.     *文件上传到fastdfs
    21.     *fdfs_storage_proxy_url storage web服务地址
    22.     * inputStream 上传文件的自己输入流
    23.     * file_etx_name 上传文件的后缀名
    24.     *  上传成功后的web地址
    25.     *  */
    26.     public static String upload(String fdfs_storage_proxy_url, InputStream inputStream,String file_ext_name) throws Exception {
    27.         //获取tracker和storage客户端对象
    28.         TrackerClient client = new TrackerClient();
    29.         //获取tracker地址
    30.         TrackerServer trackerServer = client.getTrackerServer();
    31.         StorageServer storageServer=null;
    32.         //获取storage地址
    33.         StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    34.         int length = inputStream.available();
    35.         byte[] bytes = new byte[length];
    36.         //文件上传成功后重新封装返回数据
    37.         inputStream.read(bytes);
    38.         String[] result = storageClient.upload_file(bytes, file_ext_name, null);
    39.         System.out.println(JSON.toJSONString(result));
    40.         //断开连接
    41.         storageClient.close();
    42.         return fdfs_storage_proxy_url+"/" +result[0]+"/"+result[1];
    43.     }
    44. }
    FdfsController.java
    1. @RestController
    2. @RequestMapping("/fdfs")
    3. public class FdfsController {
    4.     @Value("${fdfs_storage_proxy.protocol}")
    5.     private String fdfs_storage_proxy_protocol;
    6.     @Value("${fdfs_storage_proxy.domain}")
    7.     private String fdfs_storage_proxy_domain;
    8.     @Value("${fdfs_storage_proxy.port}")
    9.     private String fdfs_storage_proxy_port;
    10.  
    11.     @GetMapping("/proxy")
    12.     public String proxy(){
    13.         return fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port;
    14.     }
    15.  
    16.     @GetMapping(value = "/hello")
    17.     public String hello(){
    18.         return "桃李不言下";
    19.     }
    20.  
    22.     @RequestMapping("/upload1")
    23.     public R<String>update01(@RequestParam("header")MultipartFile multipartFile){
    24.         //封装返回数据 默认为上传失败
    25.         R<String> response = new R<>(ResultCode.UPLOAD_FAILED.getCode(), ResultCode.UPLOAD_FAILED.getMsg(), null);
    26.         //获取原文件的名字
    27.         String originalFilename = multipartFile.getOriginalFilename();
    28.         //获取源文件后缀名
    29.         String suffix = FilenameUtils.getExtension(originalFilename);
    30.         //文件上传
    31.         try {
    32.             //加载fastdfs-client.properties配置文件
    33.             ClientGlobal.initByProperties("fastdfs-client.properties");
    34.             //获取tracker和storage客户端对象
    35.             TrackerClient client = new TrackerClient();
    36.             //获取tracker地址
    37.             TrackerServer trackerServer = client.getTrackerServer();
    38.             StorageServer storageServer=null;
    39.             //获取storage地址
    40.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    41.             //文件上传字节数组
    42.             InputStream inputStream = multipartFile.getInputStream();
    43.             int length = inputStream.available();
    44.             byte[] bytes = new byte[length];
    45.             //文件上传成功后重新封装返回数据
    46.             inputStream.read(bytes);
    47.             String[] result = storageClient.upload_file(bytes, suffix, null);
    48.             System.out.println(JSON.toJSONString(result));
    49.             //文件上传后,重新封装返回数据
    50.             response.setCode(ResultCode.SUCCESS.getCode());
    51.             response.setMsg(ResultCode.SUCCESS.getMsg());
    52.             //断开连接
    53.             storageClient.close();
    54.             String url =fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port+"/" +result[0]+"/"+result[1];
    55.             response.setData(url);
    56.         } finally {
    57.             //向用户响应上传成功的访问地址
    58.             return response;
    59.         }
    60.     }
    61.  
    63.     @RequestMapping("/upload2")
    64.     public R<String>update02(@RequestParam("header")MultipartFile multipartFile){
    65.         //封装返回数据 默认为上传失败
    66.         R<String> response = new R<>(ResultCode.UPLOAD_FAILED.getCode(), ResultCode.UPLOAD_FAILED.getMsg(), null);
    67.         //获取原文件的名字
    68.         String originalFilename = multipartFile.getOriginalFilename();
    69.         //获取源文件后缀名
    70.         String suffix = FilenameUtils.getExtension(originalFilename);
    71.         //文件上传
    72.         try {
    73.             String proxy=fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port;
    74.             String url = BaseFastDFSUtil.upload(proxy, multipartFile.getInputStream(), suffix);
    75.             //文件上传后,重新封装返回数据
    76.             response.setCode(ResultCode.SUCCESS.getCode());
    77.             response.setMsg(ResultCode.SUCCESS.getMsg());
    78.             response.setData(url);
    79.         } finally {
    80.             //向用户响应上传成功的访问地址
    81.             return response;
    82.         }
    83.     }
    84. }

    下载图片

    utils层

    1. /**
    2.      * 文件下载
    3.      *
    4.      * @param groupName      组/卷名，默认值：group1
    5.      * @param remoteFileName 文件名，例如："M00/00/00/wKgKZl9tkTCAJAanAADhaCZ_RF0495.jpg"
    6.      * @return 文件的字节输入流
    7.      */
    8.     public static InputStream downloadFile(String groupName, String remoteFileName) {
    9.         try {
    10.             // 链接FastDFS服务器，创建tracker和Stroage
    11.             TrackerClient trackerClient = new TrackerClient();
    12.             TrackerServer trackerServer = trackerClient.getTrackerServer();
    13.             StorageServer storageServer=trackerClient.getStoreStorage(trackerServer);
    14.             //定义Stroage客户端对象，需要使用这个对象来完成具体的文件上传，下载和删除操作
    15.             StorageClient storageClient = new StorageClient(trackerServer,storageServer);
    16.             // 根据组名和文件名通过 Storage 客户端获取文件的字节数组
    17.             byte[] bytes = storageClient.download_file(groupName == null ? "group1" : groupName, remoteFileName);
    18.             // 返回字节流对象
    19.             InputStream inputStream = new ByteArrayInputStream(bytes);
    20.             return inputStream;
    21.         } catch (IOException e) {
    22.             e.printStackTrace();
    23.         } catch (MyException e) {
    24.             e.printStackTrace();
    25.         }
    26.         return null;
    27.     }
    Controller层
    1.     /**
    2.          * 文件下载
    3.          */
    4.     @PostMapping("/downloadFile")
    5.      public R downloadFile(@RequestParam("groupName")String groupName,@RequestParam("remoteFileName") String remoteFileName) throws Exception {
    6.  
    7.                     //封装返回数据 默认为上传失败
    8.                     R response = new R<>(ResultCode.SUCCESS.getCode(), ResultCode.SUCCESS.getMsg(), "下载成功");
    9.                      //调用下载接口
    10.                       InputStream is = BaseFastDFSUtil
    11.                               .downloadFile(groupName, remoteFileName);
    12.  
    13.                     File file = new File("D:/" + remoteFileName);
    14.                     //判断目录是否存在如果不存在则存在
    15.                     //getParent()——得到路径的父级及以上的目录，String类型。
    16.                     //getParentFile()——得到路径的父级及以上的目录实例化的File对象。
    17.                     //createNewFile()创建文件
    18.                     //mkdir()——仅创建一层目录,返回true或false.
    19.                     //mkdirs()——创建一层或多层目录,返回true或false.
    20.                     if (!file.exists()){
    21.                         boolean dr = file.getParentFile().mkdirs(); //创建目录
    22.                     }
    23.                     OutputStream os = new FileOutputStream(new File("D:/" + remoteFileName));
    24.  
    25.                       int index = 0 ;
    26.                        while((index = is.read())!=-1){
    27.                          os.write(index);
    28.                      }
    29.                          os.flush();
    30.                          os.close();
    31.                          is.close();
    32.            return response;
    33.     }

    删除图片

    Utils层

    1.  /**
    2.      * 文件删除
    3.      *
    4.      * @param groupName      组/卷名，默认值：group1
    5.      * @param remoteFileName 文件名，例如："M00/00/00/wKgKZl9tkTCAJAanAADhaCZ_RF0495.jpg"
    6.      * @return 0为成功，非0为失败
    7.      */
    8.     public static int deleteFile(String groupName, String remoteFileName) {
    9.         int result = -1;
    10.         try {
    11.             // 链接FastDFS服务器，创建tracker和Stroage
    12.             TrackerClient trackerClient = new TrackerClient();
    13.             TrackerServer trackerServer = trackerClient.getTrackerServer();
    14.             StorageServer storageServer=trackerClient.getStoreStorage(trackerServer);
    15.             //定义Stroage客户端对象，需要使用这个对象来完成具体的文件上传，下载和删除操作
    16.             StorageClient storageClient = new StorageClient(trackerServer,storageServer);
    17.             // 根据组名和文件名通过 Storage 客户端删除文件
    18.             result = storageClient.delete_file(groupName == null ? "group1" : groupName, remoteFileName);
    19.         } catch (IOException e) {
    20.             e.printStackTrace();
    21.         } catch (MyException e) {
    22.             e.printStackTrace();
    23.         }
    24.         return result;
    25.     }

    Controller层

    1.     // 文件删除
    2.     @PostMapping("/testDeleteFile")
    3.     public void testDeleteFile(@RequestParam("groupName")String groupName,@RequestParam("remoteFileName") String remoteFileName) {
    4.         int result = BaseFastDFSUtil.deleteFile(groupName, remoteFileName);
    5.         System.out.println("result = " + result);
    6.     }

    修改文件

    Utils工具类层

    1. /**
    2.      * 修改一个已经存在的文件
    3.      *
    4.      * @param oldGroupName 旧组名
    5.      * @param oldFileName  旧文件名
    6.      * @param file         新文件
    7.      * @param fileName     新文件名
    8.      * @return
    9.      */
    10.     public static String modifyFile(String oldGroupName, String oldFileName, MultipartFile file) throws Exception {
    11.         // 先上传
    12.        String stringR = update01(file);
    13.         // 再删除
    14.         int delResult = deleteFile(oldGroupName, oldFileName);
    15.         if (delResult != 0) {
    16.             return null;
    17.         }
    18.         return stringR;
    19.     }
    20.  
    21.     /*
    22.      *文件上传到fastdfs
    23.      *fdfs_storage_proxy_url storage web服务地址
    24.      * inputStream 上传文件的自己输入流
    25.      * file_etx_name 上传文件的后缀名
    26.      *  上传成功后的web地址
    27.      *  */
    28.     public static String  update01(MultipartFile multipartFile) throws Exception {
    29.         //获取原文件的名字
    30.         String originalFilename = multipartFile.getOriginalFilename();
    31.         //获取源文件后缀名
    32.         String suffix = FilenameUtils.getExtension(originalFilename);
    33.         //文件上传
    34.         //加载fastdfs-client.properties配置文件
    35.         ClientGlobal.initByProperties("fastdfs-client.properties");
    36.         //获取tracker和storage客户端对象
    37.         TrackerClient client = new TrackerClient();
    38.         //获取tracker地址
    39.         TrackerServer trackerServer = client.getTrackerServer();
    40.         StorageServer storageServer = null;
    41.         //获取storage地址
    42.         StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    43.         //文件上传字节数组
    44.         InputStream inputStream = multipartFile.getInputStream();
    45.         int length = inputStream.available();
    46.         byte[] bytes = new byte[length];
    47.         //文件上传成功后重新封装返回数据
    48.         inputStream.read(bytes);
    49.         String[] result = storageClient.upload_file(bytes, suffix, null);
    50.         System.out.println(JSON.toJSONString(result));
    51.         String url = "http://" + "39.97.100.141" + ":" + "8888" + "/" + result[0] + "/" + result[1];
    52.         return url;
    53.     }
    54.     /*
    55.      *文件上传到fastdfs
    56.      *fdfs_storage_proxy_url storage web服务地址
    57.      * inputStream 上传文件的自己输入流
    58.      * file_etx_name 上传文件的后缀名
    59.      *  上传成功后的web地址
    60.      *  */
    61.     public static String upload(String fdfs_storage_proxy_url, InputStream inputStream, String file_ext_name) throws Exception {
    62.         //获取tracker和storage客户端对象
    63.         TrackerClient client = new TrackerClient();
    64.         //获取tracker地址
    65.         TrackerServer trackerServer = client.getTrackerServer();
    66.         StorageServer storageServer=null;
    67.         //获取storage地址
    68.         StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    69.         int length = inputStream.available();
    70.         byte[] bytes = new byte[length];
    71.         //文件上传成功后重新封装返回数据
    72.         inputStream.read(bytes);
    73.         String[] result = storageClient.upload_file(bytes, file_ext_name, null);
    74.         System.out.println(JSON.toJSONString(result));
    75.         //断开连接
    76.         storageClient.close();
    77.         return fdfs_storage_proxy_url+"/" +result[0]+"/"+result[1];
    78.     }

    Controller层

    1.   // 文件替换
    2.     @PostMapping("/testModifyFile")
    3.     public String testModifyFile(@RequestParam("groupName")String groupName,@RequestParam("remoteFileName") String remoteFileName,@RequestParam("header")MultipartFile file) throws Exception {
    4.         //封装返回数据 默认为上传失败
    5.         String fileids = BaseFastDFSUtil.modifyFile(groupName, remoteFileName,file);
    6.         return fileids;
    7.     }

    FastDFS校验文件类型

    配置yaml

    1. upload:
    2.   base-url: http://116.62.44.5/
    3.   allow-types:
    4.     - image/jpeg
    5.     - image/png
    6.     - image/bmp
    7.     - image/gif

    创建配置类UploadProperties

    1. package com.coydone.config;
    2.  
    3. import org.springframework.boot.context.properties.ConfigurationProperties;
    4.  
    5. import java.util.List;
    6.  
    7. @ConfigurationProperties(prefix = "upload")
    8. public class UploadProperties {
    9.  
    10.     private String baseUrl;
    11.  
    12.     private List<String> allowTypes;
    13.  
    14.     public String getBaseUrl() {
    15.         return baseUrl;
    16.     }
    17.  
    18.     public void setBaseUrl(String baseUrl) {
    19.         this.baseUrl = baseUrl;
    20.     }
    21.  
    22.     public List<String> getAllowTypes() {
    23.         return allowTypes;
    24.     }
    25.  
    26.     public void setAllowTypes(List<String> allowTypes) {
    27.         this.allowTypes = allowTypes;
    28.     }
    29. }

    在Controller使用

    1.  
    2. @RestController
    3. @Component
    4. @EnableConfigurationProperties(UploadProperties.class)
    5. @RequestMapping("/fdfs")
    6. public class FdfsController {
    7.  
    8.     @Autowired
    9.     private UploadProperties prop;
    10.     @RequestMapping("/upload1")
    11.     public R update01(@RequestParam("header") MultipartFile multipartFile){
    12.         //封装返回数据 默认为上传失败
    13.         R response = new R<>(ResultCode.UPLOAD_FAILED.getCode(), ResultCode.UPLOAD_FAILED.getMsg(), null);
    14.  
    15.         //获取原文件的名字
    16.         String originalFilename = multipartFile.getOriginalFilename();
    17.         //获取源文件后缀名
    18.         String suffix = FilenameUtils.getExtension(originalFilename);
    19.         System.out.println("获取源文件后缀名"+suffix);
    20.         // 1、校验文件类型
    21.         String contentType = multipartFile.getContentType();
    22.         if (!prop.getAllowTypes().contains(contentType)) {
    23.             throw new RuntimeException("文件类型不支持");
    24.         }
    25.         // 2、校验文件内容
    26.         try {
    27.             BufferedImage image = ImageIO.read(multipartFile.getInputStream());
    28.             if (image == null || image.getWidth() == 0 || image.getHeight() == 0) {
    29.                 throw new RuntimeException("上传文件有问题");
    30.             }
    31.         } catch (IOException e) {
    32.             throw new RuntimeException("校验文件内容失败"+e.getMessage());
    33.         }
    34.         try {
    35.             //加载fastdfs-client.properties配置文件
    36.             ClientGlobal.initByProperties("fastdfs-client.properties");
    37.             //获取tracker和storage客户端对象
    38.             TrackerClient client = new TrackerClient();
    39.             //获取tracker地址
    40.             TrackerServer trackerServer = client.getTrackerServer();
    41.             StorageServer storageServer=null;
    42.             //获取storage地址
    43.             StorageClient storageClient = new StorageClient(trackerServer, storageServer);
    44.             //文件上传字节数组
    45.             InputStream inputStream = multipartFile.getInputStream();
    46.             int length = inputStream.available();
    47.             byte[] bytes = new byte[length];
    48.             //文件上传成功后重新封装返回数据
    49.             inputStream.read(bytes);
    50.             String[] result = storageClient.upload_file(bytes, suffix, null);
    51.             System.out.println(JSON.toJSONString(result));
    52.             //文件上传后,重新封装返回数据
    53.             response.setCode(ResultCode.SUCCESS.getCode());
    54.             response.setMsg(ResultCode.SUCCESS.getMsg());
    55.             String url =fdfs_storage_proxy_protocol+fdfs_storage_proxy_domain+":"+fdfs_storage_proxy_port+"/" +result[0]+"/"+result[1];
    56.             response.setData(url);
    57.         } finally {
    58.             //向用户响应上传成功的访问地址
    59.             return response;
    60.         }
    61.     }
    62. }

  • 相关阅读:
    CorelDRAW2022标准专业订阅版下载及功能介绍
    【Ubuntu上使用git链接私人仓库】
    shell编程基础
    SQL SERVER EXEC 、SP_EXECUTESQL
    AIGC程序员效能提升之道
    modbusRTU【codesys】
    MySQL报错：json_contains: “The document is empty.“ at position 0.
    Redis缓存
    自制操作系统日志——第九天
    简易实现通讯录3.0 (实现文件操作)
  • 原文地址：https://blog.csdn.net/weixin_53998054/article/details/126104560