1.引入依赖

  1. # 1.pom文件引入依赖
  2. <!--引入ftp的工具-->
  3. <dependency>
  4.     <groupId>commons-net</groupId>
  5.     <artifactId>commons-net</artifactId>
  6.     <version>3.7.2</version>
  7. </dependency>
  9. # 2.applicaiton.yml的配置中添加
  10. ftps:
  11.   connection:
  12.     server: 172.22.1.242
  13.     port: 10012
  14.     username: ftpuser
  15.     password: ftp123.,

2.工具类

  1. import cn.hutool.core.io.FileUtil;
  2. import cn.hutool.core.io.IoUtil;
  3. import com.qif.dsa.common.constant.StringConstant;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.apache.commons.compress.utils.IOUtils;
  6. import org.apache.commons.compress.utils.Lists;
  7. import org.apache.commons.lang3.StringUtils;
  8. import org.apache.commons.net.ftp.*;
  9. import org.springframework.beans.factory.annotation.Value;
  10. import org.springframework.stereotype.Component;
  12. import java.io.*;
  13. import java.nio.charset.StandardCharsets;
  14. import java.util.List;
  16. @Slf4j
  17. @Component
  18. public class FtpUtil {
  19.     private FTPSClient ftpsClient = null;
  20.     @Value(value = "${ftps.connection.server}")
  21.     private String server;
  22.     @Value(value = "${ftps.connection.port}")
  23.     private int port;
  24.     @Value(value = "${ftps.connection.username}")
  25.     private String username;
  26.     @Value(value = "${ftps.connection.password}")
  27.     private String password;
  29.     /**
  30.      * 链接到服务器
  31.      *
  32.      * @return boolean
  33.      */
  34.     public boolean connect() {
  35.         if (ftpsClient != null && ftpsClient.isConnected()) {
  36.             return true;
  37.         }
  38.         try {
  39.             ftpsClient = new FTPSClient("SSL", true);
  40.             ftpsClient.setAuthValue("SSL");
  41.             ftpsClient.setEnabledSessionCreation(true);
  42.             ftpsClient.connect(this.server, this.port);
  43.             ftpsClient.pasv();
  44.             ftpsClient.login(this.username, this.password);
  45.             ftpsClient.enterLocalPassiveMode();
  46.             ftpsClient.setUseEPSVwithIPv4(true);
  47.             ftpsClient.execAUTH("SSL");
  48.             ftpsClient.execPBSZ(0);
  49.             ftpsClient.execPROT("P");
  50.             // 检测连接是否成功
  51.             int reply = ftpsClient.getReplyCode();
  52.             if (!FTPReply.isPositiveCompletion(reply)) {
  53.                 this.close();
  54.             }
  55.             // 设置上传模式binary or ascii
  56.             ftpsClient.setFileType(FTP.BINARY_FILE_TYPE);
  57.             return true;
  58.         } catch (Exception ex) {
  59.             ex.printStackTrace();
  60.             // 关闭
  61.             this.close();
  62.             return false;
  63.         }
  64.     }
  66.     private boolean cd(String dir) throws IOException {
  67.         return ftpsClient.changeWorkingDirectory(dir);
  68.     }
  70.     /**
  71.      * 获取目录下所有的文件名称
  72.      *
  73.      * @param filePath 路径
  74.      * @return FTPFile
  75.      * @throws IOException
  76.      */
  78.     private FTPFile[] getFileList(String filePath) throws IOException {
  79.         return ftpsClient.listFiles(filePath);
  80.     }
  82.     /**
  83.      * 循环将设置工作目录
  84.      *
  85.      * @param ftpPath 文件路径
  86.      * @return boolean
  87.      * @author xu wen kai
  88.      * @create: 2021/3/31 18:49
  89.      */
  90.     public boolean changeDir(String ftpPath) {
  91.         if (!ftpsClient.isConnected()) {
  92.             return false;
  93.         }
  94.         try {
  95.             // 将路径中的斜杠统一
  96.             char[] chars = ftpPath.toCharArray();
  97.             StringBuffer sbStr = new StringBuffer(256);
  98.             for (char aChar : chars) {
  99.                 if ('\\' == aChar) {
  100.                     sbStr.append(StringConstant.SLASH);
  101.                 } else {
  102.                     sbStr.append(aChar);
  103.                 }
  104.             }
  105.             ftpPath = sbStr.toString();
  106.             if (!ftpPath.contains(StringConstant.SLASH)) {
  107.                 // 只有一层目录
  108.                 ftpsClient.changeWorkingDirectory(new String(ftpPath.getBytes(), StandardCharsets.UTF_8));
  109.             } else {
  110.                 // 多层目录循环创建
  111.                 String[] paths = ftpPath.split(StringConstant.SLASH);
  112.                 for (int i = 0; i < paths.length; i++) {
  113.                     ftpsClient.changeWorkingDirectory(new String(paths[i].getBytes(), StandardCharsets.UTF_8));
  114.                 }
  115.             }
  117.             return true;
  118.         } catch (Exception e) {
  119.             return false;
  120.         }
  121.     }
  123.     /**
  124.      * 循环创建目录,并且创建完目录后,设置工作目录为当前创建的目录下
  125.      */
  126.     public boolean mkDir(String ftpPath) {
  127.         if (!ftpsClient.isConnected()) {
  128.             return false;
  129.         }
  130.         try {
  131.             // 将路径中的斜杠统一
  132.             char[] chars = ftpPath.toCharArray();
  133.             StringBuffer sbStr = new StringBuffer(256);
  134.             for (char aChar : chars) {
  135.                 if ('\\' == aChar) {
  136.                     sbStr.append('/');
  137.                 } else {
  138.                     sbStr.append(aChar);
  139.                 }
  140.             }
  141.             ftpPath = sbStr.toString();
  143.             if (!ftpPath.contains(StringConstant.SLASH)) {
  144.                 // 只有一层目录
  145.                 ftpsClient.makeDirectory(new String(ftpPath.getBytes(), StandardCharsets.UTF_8));
  146.                 ftpsClient.changeWorkingDirectory(new String(ftpPath.getBytes(), StandardCharsets.UTF_8));
  147.             } else {
  148.                 // 多层目录循环创建
  149.                 String[] paths = ftpPath.split(StringConstant.SLASH);
  150.                 for (String path : paths) {
  151.                     ftpsClient.makeDirectory(new String(path.getBytes(), StandardCharsets.UTF_8));
  152.                     ftpsClient.changeWorkingDirectory(new String(path.getBytes(), StandardCharsets.UTF_8));
  153.                 }
  154.             }
  156.             return true;
  157.         } catch (Exception e) {
  158.             return false;
  159.         }
  160.     }
  162.     /**
  163.      * 上传文件到FTP服务器
  164.      *
  165.      * @param localDirectoryAndFileName 本地文件目录和文件名
  166.      * @param ftpFileName               上传后的文件名
  167.      * @param ftpDirectory              FTP目录如:/path1/path2/,如果目录不存在回自动创建目录
  168.      */
  169.     public boolean put(String localDirectoryAndFileName, String ftpFileName, String ftpDirectory) {
  170.         if (!ftpsClient.isConnected()) {
  171.             return false;
  172.         }
  173.         boolean flag = false;
  174.         if (ftpsClient != null) {
  175.             File srcFile = new File(localDirectoryAndFileName);
  176.             FileInputStream fis = null;
  177.             try {
  178.                 fis = new FileInputStream(srcFile);
  179.                 // 创建目录
  180.                 this.mkDir(ftpDirectory);
  181.                 ftpsClient.setBufferSize(1024);
  182.                 ftpsClient.setControlEncoding("UTF-8");
  183.                 // 设置文件类型(二进制)
  184.                 ftpsClient.setFileType(FTPClient.BINARY_FILE_TYPE);
  185.                 // 上传
  186.                 flag = ftpsClient.storeFile(new String(ftpFileName.getBytes(), StandardCharsets.UTF_8), fis);
  187.             } catch (Exception e) {
  188.                 this.close();
  189.                 return false;
  190.             } finally {
  191.                 IOUtils.closeQuietly(fis);
  192.             }
  193.         }
  194.         return flag;
  195.     }
  197.     public boolean uploadFile(InputStream inputStream, String ftpFileName, String ftpDirectory) {
  198.         this.connect();
  199.         if (!ftpsClient.isConnected()) {
  200.             return false;
  201.         }
  202.         boolean flag = false;
  203.         if (ftpsClient != null) {
  204.             try {
  205.                 // 创建目录
  206.                 this.mkDir(ftpDirectory);
  207.                 ftpsClient.setBufferSize(1024);
  208.                 ftpsClient.setControlEncoding("UTF-8");
  209.                 // 设置文件类型(二进制)
  210.                 ftpsClient.setFileType(FTPClient.BINARY_FILE_TYPE);
  211.                 // 上传
  212.                 flag = ftpsClient.storeFile(new String(ftpFileName.getBytes(), StandardCharsets.UTF_8), inputStream);
  213.             } catch (Exception e) {
  214.                 this.close();
  215.                 return false;
  216.             } finally {
  217.                 this.close();
  218.                 IOUtils.closeQuietly(inputStream);
  219.             }
  220.         }
  221.         return flag;
  222.     }
  224.     /**
  225.      * 复制ftp的文件到指定目录下，service与ftps在同一个服务器时使用
  226.      *
  227.      * @param srcFile
  228.      * @param targetFile
  229.      */
  230.     public void getFile(String srcFile, String targetFile) {
  231.         this.connect();
  232.         if (!ftpsClient.isConnected()) {
  233.             log.info("===>> ftps service is not connected ...");
  234.             return;
  235.         }
  236.         if (StringUtils.isEmpty(srcFile)) {
  237.             log.info("===>> FTP路径不存在.");
  238.             return;
  239.         }
  240.         if (StringUtils.isEmpty(targetFile)) {
  241.             log.info("===>> 目标路径不存在.");
  242.             return;
  243.         }
  244.         InputStream ins = null;
  245.         try {
  246.             log.info("===>> start copy ftps file");
  247.             ins = ftpsClient.retrieveFileStream(srcFile);
  248.             if (ins == null) {
  249.                 log.info("源文件未上传.file:{}", srcFile);
  250.                 return;
  251.             }
  252.             IOUtils.copy(ins, new FileOutputStream(new File(targetFile)));
  253.             log.info("===>> copy ftps file end");
  254.         } catch (Exception e) {
  255.             log.info("===>> download {} error: {}", srcFile, e);
  256.             e.printStackTrace();
  257.         } finally {
  258.             IoUtil.close(ins);
  259.         }
  260.     }
  262.     /**
  263.      * 从FTP服务器上下载文件并返回下载文件长度
  264.      *
  265.      * @param ftpFullName   路径加文件名称
  266.      * @param localFullName 本地路径名称
  267.      * @return long
  268.      */
  269.     public long downLoadFileToLocal(String ftpFullName, String localFullName) {
  270.         this.connect();
  271.         long result = 0;
  272.         if (!ftpsClient.isConnected()) {
  273.             return result;
  274.         }
  275.         if (StringUtils.isEmpty(ftpFullName)) {
  276.             log.info("FTP路径不存在.");
  277.             return result;
  278.         }
  279.         if (StringUtils.isEmpty(localFullName)) {
  280.             log.info("本地路径不存在.");
  281.             return result;
  282.         }
  284.         ftpsClient.enterLocalPassiveMode();
  285.         // 将路径中的斜杠统一
  286.         char[] chars = ftpFullName.toCharArray();
  287.         StringBuilder sbStr = new StringBuilder(256);
  288.         for (char aChar : chars) {
  289.             if ('\\' == aChar) {
  290.                 sbStr.append('/');
  291.             } else {
  292.                 sbStr.append(aChar);
  293.             }
  294.         }
  295.         String ftpFileName = sbStr.toString();
  296.         String filePath = ftpFileName.substring(0, ftpFileName.lastIndexOf(StringConstant.SLASH));
  297.         String fileName = ftpFileName.substring(ftpFileName.lastIndexOf(StringConstant.SLASH) + 1);
  298.         this.changeDir(filePath);
  299.         String localDirectory = localFullName.substring(0, localFullName.lastIndexOf(StringConstant.SLASH));
  300.         try (InputStream ins = ftpsClient.retrieveFileStream(new String(fileName.getBytes(), StandardCharsets.UTF_8))) {
  301.             log.info("===>> start download file[{}],[{}]", ftpFileName, fileName);
  302.             if (ins == null) {
  303.                 log.info("===>> 未读取到文件或者文件内容为空");
  304.                 return result;
  305.             }
  306.             File file = new File(localDirectory);
  307.             if (!file.isDirectory() || !file.exists()) {
  308.                 log.info("===>> file path not exist and created");
  309.                 if (!file.mkdirs()) {
  310.                     FileUtil.mkdir(file);
  311.                 }
  312.             }
  313.             this.changeDir(filePath);
  314.             if (IOUtils.copy(ins, new FileOutputStream(localFullName)) <= 0) {
  315.                 log.info("===>> 文件下载失败");
  316.             }
  317.             log.info("===>> download file from ftps end");
  318.             return 1;
  319.         } catch (IOException e) {
  320.             e.printStackTrace();
  321.         }
  322.         return result;
  323.     }
  325.     /**
  326.      * 从ftp上下载 指定目录下的 指定文件
  327.      * @param path -- 文件的保存路径
  328.      * @param filename -- 文件名称
  329.      * @return
  330.      */
  331.     public InputStream downLoadFile(String path, String filename) {
  332.         this.connect();
  333.         InputStream inputStream = null;
  334.         ByteArrayOutputStream bos = new ByteArrayOutputStream();
  335.         try {
  336.             ftpsClient.changeWorkingDirectory(path);
  337.             inputStream = ftpsClient.retrieveFileStream(filename);
  338.             if (inputStream == null) {
  339.                 log.info("FTPS服务不存在该文件.path:{},filename:{}", path, filename);
  340.                 return null;
  341.             }
  342.             byte[] receiveBuffer = new byte[2048];
  343.             int readBytesSize = inputStream.read(receiveBuffer);
  344.             while (readBytesSize != -1) {
  345.                 bos.write(receiveBuffer, 0, readBytesSize);
  346.                 readBytesSize = inputStream.read(receiveBuffer);
  347.             }
  348.         } catch (IOException e) {
  349.             log.error("切换目录失败。path:{},errMsg:{}", path, e);
  350.         } finally {
  351.             try {
  352.                 IoUtil.close(inputStream);
  353.                 if (inputStream != null) {
  354.                     ftpsClient.completePendingCommand();
  355.                 }
  356.                 IoUtil.close(bos);
  357.                 ftpsClient.disconnect();
  358.             } catch (IOException e) {
  359.                 log.error("获取FTP文件失败.path:{},errMsg:{}", path, e);
  360.             }
  361.         }
  362.         return new ByteArrayInputStream(bos.toByteArray());
  363.     }
  365.     /**
  366.      * 将远程的文件，保存到本地文件
  367.      * @param remoteFilePath --远程文件名称
  368.      * @param localFilePath -- 本地目录明湖曾
  369.      * @param fileName -- 文件名称
  370.      * @return
  371.      */
  372.     public boolean downloadFile(String remoteFilePath, String localFilePath, String fileName) {
  373.         this.connect();
  374.         boolean flag = false;
  375.         try {
  376.             ftpsClient.changeWorkingDirectory(remoteFilePath);
  377.             FTPFile[] fs = ftpsClient.listFiles();
  378.             for (FTPFile ff : fs) {
  379.                 if (ff.getName().equals(fileName)) {
  380.                     File localFile = new File(localFilePath + File.separator + fileName);
  381.                     OutputStream is = new FileOutputStream(localFile);
  382.                     ftpsClient.retrieveFile(ff.getName(), is);
  383.                     is.close();
  384.                     flag = true;
  385.                 }
  386.             }
  387.         } catch (Exception e) {
  388.             e.printStackTrace();
  389.         }
  390.         return flag;
  391.     }
  394.     /**
  395.      * 返回FTP目录下的文件列表
  396.      *
  397.      * @param ftpDirectory 路径
  398.      * @return List<String>
  399.      */
  400.     public List<String> getFileNameList(String ftpDirectory) {
  401.         this.connect();
  402.         List<String> list = Lists.newArrayList();
  403.         if (!connect()) {
  404.             return list;
  405.         }
  406.         try {
  407.             DataInputStream dis = new DataInputStream(ftpsClient.retrieveFileStream(ftpDirectory));
  408.             String filename;
  409.             while ((filename = dis.readLine()) != null) {
  410.                 list.add(filename);
  411.             }
  412.         } catch (Exception e) {
  413.             e.printStackTrace();
  414.         }
  415.         return list;
  416.     }
  418.     /**
  419.      * 删除FTP上的文件
  420.      *
  421.      * @param ftpDirAndFileName 路径名称
  422.      */
  423.     public boolean deleteFile(String ftpDirAndFileName) {
  424.         return ftpsClient.isConnected();
  425.     }
  427.     /**
  428.      * 删除FTP目录
  429.      *
  430.      * @param ftpDirectory 路径
  431.      */
  432.     public boolean deleteDirectory(String ftpDirectory) {
  433.         return ftpsClient.isConnected();
  434.     }
  436.     /**
  437.      * 关闭链接
  438.      */
  439.     public void close() {
  440.         try {
  441.             if (ftpsClient != null && ftpsClient.isConnected()) {
  442.                 ftpsClient.disconnect();
  443.             }
  444.         } catch (Exception e) {
  445.             e.printStackTrace();
  446.         }
  447.     }
  449.     public FTPSClient getFtpsClient() {
  450.         return ftpsClient;
  451.     }
  453.     public void setFtpsClient(FTPSClient ftpsClient) {
  454.         this.ftpsClient = ftpsClient;
  455.     }
  456. }