java 简单实现FtpClient

1. 引入喜闻乐见的maven地址

 <dependency>
       <groupId>commons-net</groupId>
       <artifactId>commons-net</artifactId>
       <version>3.6</version>
 </dependency>

2. 代码实现

 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.net.ftp.FTPClient;
 import org.apache.commons.net.ftp.FTPFile;
 import org.apache.commons.net.ftp.FTPReply;

 import java.io.*;
 import java.time.LocalDate;
 import java.util.Objects;

 /**
  * @author <a herf="mailto:yanwu0527@163.com">XuBaofeng</a>
  * @date 2019-08-26 14:22.
  * <p/>
  * description: 简单操作FTP工具类
  */
 @Slf4j
 public class FtpUtil {

     private static final String DEFAULT_PATH = "test";
     private static final String SEPARATOR = "/";

     private static final String FTP_HOST = "192.168.1.158";
     private static final Integer FTP_PORT = 21;
     private static final String USERNAME = "hoolink";
     private static final String PASSWORD = "hoolink123";

     private static FTPClient ftpClient;
     private static FtpUtil instance;

     private FtpUtil() {
     }

     static {
         instance = new FtpUtil();
         ftpClient = new FTPClient();
     }

     /**
      * 获取工具类示例
      *
      * @return FtpUtil
      */
     public static FtpUtil getInstance() {
         return instance;
     }

     /**
      * 初始化FTP
      */
     private void initClient(String host, Integer port, String username, String password) {
         if (StringUtils.isBlank(host)) {
             throw new RuntimeException("init ftp client failed, host is null");
         }
         // ----- 当端口为空时使用默认端口
         port = port == null ? FTP_PORT : port;
         try {
             ftpClient.setControlEncoding("UTF-8");
             // ----- 连接
             ftpClient.connect(host, port);
             ftpClient.login(username, password);
             // ----- 检测连接是否成功
             if (FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {
                 log.info(" ----- connect success ftp server host: {}, post: {}, user: {}", host, port, username);
                 return;
             }
             log.error(" ----- connect failed ftp server host: {}, post: {}, user: {}", host, port, username);
         } catch (Exception e) {
             log.error(" ----- connect failed ftp server, ", e);
         }
         instance.close();
     }

     /**
      * ftp上传文件
      *
      * @param file      文件
      * @param projectId 项目ID
      * @return true||false
      */
     public String upload(File file, Long projectId, String filePath) {
         return instance.upload(FTP_HOST, FTP_PORT, USERNAME, PASSWORD, file, projectId, filePath);
     }

     /**
      * 上传文件
      *
      * @param host       ftp服务器地址
      * @param port       ftp端口
      * @param username   ftp用户
      * @param password   ftp密码
      * @param file       文件
      * @param projectId  项目ID
      * @param targetPath 文件存放目录
      * @return true||false
      */
     public String upload(String host, Integer port, String username, String password,
                          File file, Long projectId, String targetPath) {
         instance.initClient(host, port, username, password);
         if (Objects.isNull(ftpClient) || Objects.isNull(file)) {
             return null;
         }
         String filePath = getFilePath(projectId, targetPath);
         StringBuilder sb = new StringBuilder();
         try (FileInputStream fis = new FileInputStream(file)) {
             // ----- 切换到对应目录
             changeDirectory(filePath.split(SEPARATOR));
             ftpClient.setBufferSize(1024);
             ftpClient.setControlEncoding("GBK");
             // ----- 设置文件类型
             ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
             // ----- 上传
             if (!ftpClient.storeFile(file.getName(), fis)) {
                 log.error(" ----- upload file failed, projectId: {}, file: {}", projectId, file.getName());
                 return null;
             } else {
                 sb.append(filePath).append(SEPARATOR).append(file.getName());
                 log.info(" ----- upload file success, file: {}", sb.toString());
             }
         } catch (Exception e) {
             log.error(" ----- upload file failed, ", e);
         } finally {
             instance.close();
         }
         return sb.toString();
     }

     /**
      * 删除ftp上的文件
      *
      * @param target 资源文件
      * @return true || false
      */
     public boolean remove(String target) {
         return instance.remove(FTP_HOST, FTP_PORT, USERNAME, PASSWORD, target);
     }

     /**
      * 删除ftp上的文件
      *
      * @param host     ftp服务器地址
      * @param port     ftp端口
      * @param username ftp用户
      * @param password ftp密码
      * @param target   资源文件
      * @return true || false
      */
     public boolean remove(String host, Integer port, String username, String password, String target) {
         instance.initClient(host, port, username, password);
         if (Objects.isNull(ftpClient) || StringUtils.isBlank(target)) {
             return false;
         }
         boolean flag = false;
         try {
             changeDirectory(splitFtpFilePath(target));
             flag = ftpClient.deleteFile(target.substring(target.lastIndexOf(SEPARATOR) + 1));
             log.info(" ----- remove file {}, file: {}", flag ? "success" : "failed", target);
         } catch (Exception e) {
             log.error(" ----- remove file failed, ", e);
         } finally {
             instance.close();
         }
         return flag;
     }

     /**
      * @param filePath   资源路径
      * @param targetPath 目标路径
      * @return 文件
      */
     public File download(String filePath, String targetPath) {
         return download(FTP_HOST, FTP_PORT, USERNAME, PASSWORD, filePath, targetPath);
     }

     /**
      * @param host       ftp服务器地址
      * @param port       ftp端口
      * @param username   ftp用户
      * @param password   ftp密码
      * @param filePath   资源路径
      * @param targetPath 目标路径
      * @return 文件
      */
     public File download(String host, Integer port, String username, String password, String filePath, String targetPath) {
         instance.initClient(host, port, username, password);
         if (Objects.isNull(ftpClient) || StringUtils.isBlank(filePath)) {
             return null;
         }
         File file = null;
         try {
             // ----- 切换到对应目录
             changeDirectory(splitFtpFilePath(filePath));
             // ----- 获取文件名和文件
             String fileName = filePath.substring(filePath.lastIndexOf(SEPARATOR) + 1);
             FTPFile ftpFile = ftpClient.mdtmFile(fileName);
             if (Objects.nonNull(ftpFile)) {
                 file = new File(targetPath + SEPARATOR + fileName);
                 // ----- 下载
                 try (OutputStream out = new FileOutputStream(file)) {
                     ftpClient.retrieveFile(fileName, out);
                 }
             }
             log.info(" ----- download file {}, filePath: {}, targetPath: {}", file != null ? "success" : "failed", filePath, targetPath);
         } catch (Exception e) {
             log.error(" ----- download file failed, ", e);
         } finally {
             instance.close();
         }
         return file;
     }

     /**
      * 释放资源
      *
      * @author tangw 2010-12-26
      */
     public void close() {
         if (Objects.isNull(ftpClient)) {
             return;
         }
         if (ftpClient.isConnected()) {
             try {
                 ftpClient.logout();
                 ftpClient.disconnect();
             } catch (IOException e) {
                 log.error(" ----- close ftp server failed, ", e);
             }
         }
     }

     /**
      * 切换到对应的目录，当目录不存在时，创建目录
      *
      * @param filePath 文件目录
      */
     private void changeDirectory(String[] filePath) throws Exception {
         for (String path : filePath) {
             if (StringUtils.isBlank(path) || ftpClient.changeWorkingDirectory(path)) {
                 continue;
             }
             ftpClient.makeDirectory(path);
             ftpClient.changeWorkingDirectory(path);
         }
     }

     /**
      * 根据FTP文件地址切割出FTP文件目录
      *
      * @param filePath 文件地址
      * @return 文件所在目录
      */
     private String[] splitFtpFilePath(String filePath) {
         if (StringUtils.isBlank(filePath)) {
             throw new NullPointerException("file path is null");
         }
         // ----- 去掉尾[文件名]
         filePath = filePath.substring(0, filePath.lastIndexOf(SEPARATOR));
         return filePath.split(SEPARATOR);
     }

     /**
      * 根据项目ID获取目录
      *
      * @param projectId 项目ID
      * @return 目录
      */
     private static String getFilePath(Long projectId, String targetPath) {
         StringBuilder sb = new StringBuilder();
         targetPath = targetPath == null ? DEFAULT_PATH : targetPath;
         LocalDate now = LocalDate.now();
         return sb.append(targetPath).append(SEPARATOR)
                 .append(projectId).append(SEPARATOR)
                 .append(now.getYear()).append(SEPARATOR)
                 .append(now.getMonthValue()).append(SEPARATOR)
                 .append(now.getDayOfMonth()).toString();
     }

     public static void main(String[] args) {
         FtpUtil instance = FtpUtil.getInstance();
         String filePath = "F:\\document\\协议文档\\02 HOOLINK协议\\文档\\HOOLINK传输协议.docx";
         String targetPath = "F:\\file";
         Long projectId = 269L;
         String file = instance.upload(new File(filePath), projectId, DEFAULT_PATH);
         instance.download(file, targetPath);
         instance.remove(file);
     }

 }