• Java连接FTP服务器，并使用ftp连接池进行文件操作

    使用Java连接FTP服务器进行文件相关操作，并且使用FTP连接池降低资源消耗，提高响应速率。

    1、导入Pom依赖

    1.          
    2.         
    3.             commons-net
    4.             commons-net
    5.             3.9.0
    6.

    2、创建FTP的配置

    1. ftp:
    2.     # 服务器地址
    3.     host: xx.xxx.xx.xxx
    4.     # 端口号
    5.     port: 21
    6.     # 用户名
    7.     userName: xxx
    8.     # 密码
    9.     password: xxxxxxx
    10.     # 工作目录
    11.     workingDirectory: /ftpTest
    12.     # 编码
    13.     encoding: utf-8
    14.     #被动模式
    15.     passiveMode: true
    16.     #连接超时时间
    17.     clientTimeout: 30000
    18.     # 线程数
    19.     threaNum: 1
    20.     # 0=ASCII_FILE_TYPE(ASCII格式)，1=EBCDIC_FILE_TYPE，2=LOCAL_FILE_TYPE(二进制文件)
    21.     transferFileType: 2
    22.     # 是否重命名
    23.     renameUploaded: true
    24.     # 重新连接时间
    25.     retryTimes: 1200
    26.     # 缓存大小
    27.     bufferSize: 8192
    28.  
    29.     # 最大数
    30.     maxTotal: 50
    31.     # 最小空闲
    32.     minldle: 10
    33.     # 最大空闲
    34.     maxldle: 50
    35.     # 最大等待时间
    36.     maxWait: 30000
    37.     # 池对象耗尽之后是否阻塞，maxWait < 0 时一直等待
    38.     blockWhenExhausted: true
    39.     # 取对象时验证
    40.     testOnBorrow: true
    41.     # 回收验证
    42.     testOnReturn: true
    43.     # 创建时验证
    44.     testOnCreate: true
    45.     # 空闲验证
    46.     testWhileldle: false
    47.     # 后进先出
    48.     lifo: false

    3、创建FTP配置类

    1. import lombok.Getter;
    2. import lombok.Setter;
    3. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
    4. import org.springframework.boot.context.properties.ConfigurationProperties;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.apache.commons.net.ftp.FTPClient;
    7.  
    8.  
    9. /**
    10.  * Ftp配置类
    11.  */
    12. @Configuration
    13. @ConfigurationProperties(prefix = "ftp")
    14. @Getter
    15. @Setter
    16. public class FtpConfig extends GenericObjectPoolConfig {
    17.  
    18.     /**
    19.      * FTP服务器地址
    20.      */
    21.     private String host;
    22.  
    23.     /**
    24.      * FTP服务器端口
    25.      */
    26.     private Integer port;
    27.  
    28.     /**
    29.      * FTP用户名
    30.      */
    31.     private String userName;
    32.  
    33.     /**
    34.      * FTP密码
    35.      */
    36.     private String password;
    37.  
    38.     /**
    39.      * FTP服务器根目录
    40.      */
    41.     private String workingDirectory;
    42.  
    43.     /**
    44.      * 传输编码
    45.      */
    46.     String encoding;
    47.  
    48.     /**
    49.      * 被动模式：在这种模式下，数据连接是由客户程序发起的
    50.      */
    51.     boolean passiveMode;
    52.  
    53.     /**
    54.      * 连接超时时间
    55.      */
    56.     int clientTimeout;
    57.  
    58.     /**
    59.      * 线程数
    60.      */
    61.     int threaNum;
    62.     /**
    63.      * 0=ASCII_FILE_TYPE(ASCII格式)，1=EBCDIC_FILE_TYPE，2=LOCAL_FILE_TYPE(二进制文件)
    64.      */
    65.     int transferFileType;
    66.  
    67.     /**
    68.      * 是否重命名
    69.      */
    70.     boolean renameUploaded;
    71.  
    72.     /**
    73.      * 重新连接时间
    74.      */
    75.     int retryTimes;
    76.  
    77.     /**
    78.      * 缓存大小
    79.      */
    80.     int bufferSize;
    81.  
    82.     /**
    83.      * 最大数
    84.      */
    85.     int maxTotal;
    86.  
    87.     /**
    88.      * 最小空闲
    89.      */
    90.     int minldle;
    91.  
    92.     /**
    93.      * 最大空闲
    94.      */
    95.     int maxldle;
    96.  
    97.     /**
    98.      * 最大等待时间
    99.      */
    100.     int maxWait;
    101.     /**
    102.      *  池对象耗尽之后是否阻塞，maxWait < 0 时一直等待
    103.      */
    104.     boolean blockWhenExhausted;
    105.     /**
    106.      * 取对象时验证
    107.      */
    108.     boolean testOnBorrow;
    109.     /**
    110.      * 回收验证
    111.      */
    112.     boolean testOnReturn;
    113.     /**
    114.      * 创建时验证
    115.      */
    116.     boolean testOnCreate;
    117.     /**
    118.      * 空闲验证
    119.      */
    120.     boolean testWhileldle;
    121.     /**
    122.      * 后进先出
    123.      */
    124.     boolean lifo;
    125. }

    4、创建工厂连接对象并注入配置

    1. import lombok.extern.slf4j.Slf4j;
    2. import org.apache.commons.lang3.StringUtils;
    3. import org.apache.commons.net.ftp.FTP;
    4. import org.apache.commons.net.ftp.FTPClient;
    5. import org.apache.commons.net.ftp.FTPReply;
    6. import org.apache.commons.pool2.PooledObject;
    7. import org.apache.commons.pool2.PooledObjectFactory;
    8. import org.apache.commons.pool2.impl.DefaultPooledObject;
    9. import org.springframework.beans.factory.annotation.Autowired;
    10. import org.springframework.stereotype.Component;
    11.  
    12. /**
    13.  * FtpClient 工厂连接对象
    14.  */
    15. @Component
    16. @Slf4j
    17. public class FTPClientFactory implements PooledObjectFactory {
    18.     /**
    19.      * 注入 ftp 连接配置
    20.      */
    21.     @Autowired
    22.     FtpConfig config;
    23.  
    24.     /**
    25.      * 创建连接到池中
    26.      *
    27.      * @return
    28.      * @throws Exception
    29.      */
    30.     @Override
    31.     public PooledObject makeObject() throws Exception {
    32.         FTPClient ftpClient = new FTPClient();
    33.         ftpClient.setConnectTimeout(config.getClientTimeout());
    34.         ftpClient.connect(config.getHost(), config.getPort());
    35.         int reply = ftpClient.getReplyCode();
    36.         if (!FTPReply.isPositiveCompletion(reply)) {
    37.             ftpClient.disconnect();
    38.             return null;
    39.         }
    40.         boolean success;
    41.         if (StringUtils.isBlank(config.getUserName())) {
    42.             success = ftpClient.login("anonymous", "anonymous");
    43.         } else {
    44.             success = ftpClient.login(config.getUserName(), config.getPassword());
    45.         }
    46.         if (!success) {
    47.             return null;
    48.         }
    49.         ftpClient.setFileType(config.getTransferFileType());
    50.         ftpClient.setBufferSize(1024);
    51.         ftpClient.setControlEncoding(config.getEncoding());
    52.         if (config.isPassiveMode()) {
    53.             ftpClient.enterLocalPassiveMode();
    54.         }
    55.         log.debug("创建ftp连接");
    56.         return new DefaultPooledObject<>(ftpClient);
    57.     }
    58.  
    59.     /**
    60.      * 链接状态检查
    61.      *
    62.      * @param pool
    63.      * @return
    64.      */
    65.     @Override
    66.     public boolean validateObject(PooledObject pool) {
    67.         FTPClient ftpClient = pool.getObject();
    68.         try {
    69.             return ftpClient != null && ftpClient.sendNoOp();
    70.         } catch (Exception e) {
    71.             return false;
    72.         }
    73.     }
    74.  
    75.     /**
    76.      * 销毁连接，当连接池空闲数量达到上限时，调用此方法销毁连接
    77.      *
    78.      * @param pool
    79.      * @throws Exception
    80.      */
    81.     @Override
    82.     public void destroyObject(PooledObject pool) throws Exception {
    83.         FTPClient ftpClient = pool.getObject();
    84.         if (ftpClient != null) {
    85.             try {
    86.                 ftpClient.disconnect();
    87.                 log.debug("销毁ftp连接");
    88.             } catch (Exception e) {
    89.                 log.error("销毁ftpClient异常，error：", e.getMessage());
    90.             }
    91.         }
    92.     }
    93.  
    94.     /**
    95.      * 钝化连接，是连接变为可用状态
    96.      *
    97.      * @param p
    98.      * @throws Exception
    99.      */
    100.     @Override
    101.     public void passivateObject(PooledObject p) throws Exception{
    102.         FTPClient ftpClient = p.getObject();
    103.         try {
    104.             ftpClient.changeWorkingDirectory(config.getWorkingDirectory());
    105.             ftpClient.logout();
    106.             if (ftpClient.isConnected()) {
    107.                 ftpClient.disconnect();
    108.             }
    109.         } catch (Exception e) {
    110.             throw new RuntimeException("Could not disconnect from server.", e);
    111.         }
    112.     }
    113.  
    114.     /**
    115.      * 初始化连接
    116.      *
    117.      * @param pool
    118.      * @throws Exception
    119.      */
    120.     @Override
    121.     public void activateObject(PooledObject pool) throws Exception {
    122.         FTPClient ftpClient = pool.getObject();
    123.         ftpClient.connect(config.getHost(),config.getPort());
    124.         ftpClient.login(config.getUserName(), config.getPassword());
    125.         ftpClient.setControlEncoding(config.getEncoding());
    126.         ftpClient.changeWorkingDirectory(config.getWorkingDirectory());
    127.         //设置上传文件类型为二进制，否则将无法打开文件
    128.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    129.     }
    130.  
    131.     /**
    132.      * 获取 FTP 连接配置
    133.      * @return
    134.      */
    135.     public FtpConfig getConfig(){
    136.         return config;
    137.     }
    138. }
    139.

    5、创建客户端对象service接口

    1. import com.aicut.monitor.config.FtpConfig;
    2. import org.apache.commons.net.ftp.FTPClient;
    3.  
    4. /**
    5.  * 获取 ftp 客户端对象的接口
    6.  */
    7. public interface FTPPoolService {
    8.     /**
    9.      * 获取ftpClient
    10.      * @return
    11.      */
    12.     FTPClient borrowObject();
    13.  
    14.     /**
    15.      * 归还ftpClient
    16.      * @param ftpClient
    17.      * @return
    18.      */
    19.     void returnObject(FTPClient ftpClient);
    20.  
    21.     /**
    22.      * 获取 ftp 配置信息
    23.      * @return
    24.      */
    25.     FtpConfig getFtpPoolConfig();
    26. }
    27.

    6、创建FTP接口实现类 

    1. import com.aicut.monitor.config.FTPClientFactory;
    2. import com.aicut.monitor.config.FtpConfig;
    3. import com.aicut.monitor.service.FTPPoolService;
    4. import lombok.extern.slf4j.Slf4j;
    5. import org.apache.commons.net.ftp.FTPClient;
    6. import org.apache.commons.pool2.impl.GenericObjectPool;
    7. import org.springframework.beans.factory.annotation.Autowired;
    8. import org.springframework.stereotype.Component;
    9.  
    10. import javax.annotation.PostConstruct;
    11.  
    12.  
    13. @Component
    14. @Slf4j
    15. public class FTPPoolServiceImpl implements FTPPoolService {
    16.  
    17.     /**
    18.      * ftp 连接池生成
    19.      */
    20.     private GenericObjectPool pool;
    21.  
    22.     /**
    23.      * ftp 客户端配置文件
    24.      */
    25.     @Autowired
    26.     private FtpConfig config;
    27.  
    28.     /**
    29.      * ftp 客户端工厂
    30.      */
    31.     @Autowired
    32.     private FTPClientFactory factory;
    33.  
    34.     /**
    35.      * 初始化pool
    36.      */
    37.     @PostConstruct
    38.     private void initPool() {
    39.         this.pool = new GenericObjectPool(this.factory, this.config);
    40.     }
    41.  
    42.     /**
    43.      * 获取ftpClient
    44.      */
    45.     @Override
    46.     public FTPClient borrowObject() {
    47.         if (this.pool != null) {
    48.             try {
    49.                 return this.pool.borrowObject();
    50.             } catch (Exception e) {
    51.                 log.error("获取 FTPClient 失败 ", e);
    52.             }
    53.         }
    54.         return null;
    55.     }
    56.  
    57.     /**
    58.      * 归还 ftpClient
    59.      */
    60.     @Override
    61.     public void returnObject(FTPClient ftpClient) {
    62.         if (this.pool != null && ftpClient != null) {
    63.             this.pool.returnObject(ftpClient);
    64.         }
    65.     }
    66.  
    67.     @Override
    68.     public FtpConfig getFtpPoolConfig() {
    69.         return config;
    70.     }
    71. }
    72.

    7、FTP工具类

    1. import cn.hutool.core.util.CharsetUtil;
    2. import com.aicut.monitor.enums.DownloadStatus;
    3. import com.aicut.monitor.enums.UploadStatus;
    4. import com.aicut.monitor.enums.uploadImageType;
    5. import com.aicut.monitor.service.FTPPoolService;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.apache.commons.compress.archivers.zip.ParallelScatterZipCreator;
    8. import org.apache.commons.compress.archivers.zip.UnixStat;
    9. import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
    10. import org.apache.commons.compress.archivers.zip.ZipArchiveOutputStream;
    11. import org.apache.commons.compress.parallel.InputStreamSupplier;
    12. import org.apache.commons.io.IOUtils;
    13. import org.apache.commons.io.input.NullInputStream;
    14. import org.apache.commons.net.ftp.FTP;
    15. import org.apache.commons.net.ftp.FTPClient;
    16. import org.apache.commons.net.ftp.FTPFile;
    17. import org.springframework.beans.factory.annotation.Autowired;
    18. import org.springframework.stereotype.Component;
    19.  
    20. import javax.servlet.http.HttpServletResponse;
    21. import java.io.*;
    22. import java.net.URLEncoder;
    23. import java.nio.file.Files;
    24. import java.text.ParseException;
    25. import java.text.SimpleDateFormat;
    26. import java.util.Arrays;
    27. import java.util.Date;
    28. import java.util.HashMap;
    29. import java.util.List;
    30. import java.util.Map;
    31. import java.util.concurrent.ExecutorService;
    32. import java.util.concurrent.LinkedBlockingQueue;
    33. import java.util.concurrent.ThreadPoolExecutor;
    34. import java.util.concurrent.TimeUnit;
    35. import java.util.stream.Collectors;
    36. import java.util.zip.ZipEntry;
    37. import java.util.zip.ZipOutputStream;
    38.  
    39. /**
    40.  * FTP工具类
    41.  *
    42.  * @author YJ2023085043
    43.  */
    44. @Component
    45. @Slf4j
    46. public class FtpUtil {
    47.  
    48.     /**
    49.      * ftp 连接池
    50.      */
    51.     @Autowired
    52.     FTPPoolService ftpPoolService;
    53.  
    54.     public static final String DIR_SPLIT = "/";
    55.  
    56.     public static final String HTTP_protocol = "http://";
    57.  
    58.  
    59.     /**
    60.      * 上传单个文件
    61.      *
    62.      * @param uploadPath 上传路径
    63.      * @param fileName   文件名
    64.      * @param input      文件输入流
    65.      * @return 上传结果
    66.      */
    67.     public UploadStatus upload(String uploadPath, String fileName, InputStream input) {
    68.         FTPClient ftpClient = ftpPoolService.borrowObject();
    69.         try {
    70.             // 切换到工作目录
    71.             if (!ftpClient.changeWorkingDirectory(uploadPath)) {
    72.                 ftpClient.makeDirectory(uploadPath);
    73.                 ftpClient.changeWorkingDirectory(uploadPath);
    74.             }
    75.             // 文件写入
    76.             boolean storeFile = ftpClient.storeFile(fileName, input);
    77.             if (storeFile) {
    78.                 log.info("文件:{}上传成功", fileName);
    79.                 return UploadStatus.UploadNewFileSuccess;
    80.             } else {
    81.                 throw new RuntimeException("ftp文件写入异常");
    82.             }
    83.         } catch (IOException e) {
    84.             log.error("文件:{}上传失败", fileName, e);
    85.             return UploadStatus.UploadNewFileFailed;
    86.         } finally {
    87.                 IOUtils.closeQuietly(input);
    88.                 ftpPoolService.returnObject(ftpClient);
    89.             }
    90.     }
    91.  
    92.     /**
    93.      * 从FTP服务器上下载文件,支持断点续传，下载百分比汇报
    94.      *
    95.      * @param ftpPath 远程文件路径
    96.      * @param fileName 远程文件名
    97.      * @param local  本地文件完整绝对路径
    98.      * @return 下载的状态
    99.      * @throws IOException
    100.      */
    101.     public DownloadStatus downloadFile(String ftpPath, String fileName, String local) throws IOException {
    102.         FTPClient ftpClient = ftpPoolService.borrowObject();
    103.         // 设置被动模式,由于Linux安全性考虑，端口没有全部放开，所有被动模式不能用
    104.         ftpClient.enterLocalPassiveMode();
    105.         // 设置以二进制方式传输
    106.         ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    107.         DownloadStatus result;
    108.         try {
    109.             // 检查远程文件是否存在
    110.             FTPFile[] files = ftpClient.listFiles(ftpPath,file -> file.getName().equals(fileName));
    111.             if (files.length != 1) {
    112.                 log.info("远程文件不存在");
    113.                 return DownloadStatus.RemoteFileNotExist;
    114.             }
    115.             long lRemoteSize = files[0].getSize();
    116.             File f = new File(local+DIR_SPLIT+fileName);
    117.             // 本地存在文件，进行断点下载
    118.             if (f.exists()) {
    119.                 long localSize = f.length();
    120.                 // 判断本地文件大小是否大于远程文件大小
    121.                 if (localSize >= lRemoteSize) {
    122.                     log.info("本地文件大于远程文件，下载中止");
    123.                     return DownloadStatus.LocalFileBiggerThanRemoteFile;
    124.                 }
    125.                 // 进行断点续传，并记录状态
    126.                 FileOutputStream out = new FileOutputStream(f, true);
    127.                 ftpClient.setRestartOffset(localSize);
    128.                 InputStream in = ftpClient.retrieveFileStream(ftpPath + DIR_SPLIT + fileName);
    129.                 byte[] bytes = new byte[1024];
    130.                 long step = lRemoteSize / 100;
    131.                 // 文件过小，step可能为0
    132.                 step = step == 0 ? 1 : step;
    133.                 long process = localSize / step;
    134.                 int c;
    135.                 while ((c = in.read(bytes)) != -1) {
    136.                     out.write(bytes, 0, c);
    137.                     localSize += c;
    138.                     long nowProcess = localSize / step;
    139.                     if (nowProcess > process) {
    140.                         process = nowProcess;
    141.                         if (process % 10 == 0) {
    142.                             log.info("下载进度：" + process);
    143.                         }
    144.                     }
    145.                 }
    146.                 in.close();
    147.                 out.close();
    148.                 boolean isDo = ftpClient.completePendingCommand();
    149.                 if (isDo) {
    150.                     result = DownloadStatus.DownloadFromBreakSuccess;
    151.                 } else {
    152.                     result = DownloadStatus.DownloadFromBreakFailed;
    153.                 }
    154.             } else {
    155.                 OutputStream out = new FileOutputStream(f);
    156.                 InputStream in = ftpClient.retrieveFileStream(ftpPath + DIR_SPLIT + fileName);
    157.                 byte[] bytes = new byte[1024];
    158.                 long step = lRemoteSize / 100;
    159.                 // 文件过小，step可能为0
    160.                 step = step == 0 ? 1 : step;
    161.                 long process = 0;
    162.                 long localSize = 0L;
    163.                 int c;
    164.                 while ((c = in.read(bytes)) != -1) {
    165.                     out.write(bytes, 0, c);
    166.                     localSize += c;
    167.                     long nowProcess = localSize / step;
    168.                     if (nowProcess > process) {
    169.                         process = nowProcess;
    170.                         if (process % 10 == 0) {
    171.                             log.info("下载进度：" + process);
    172.                         }
    173.                     }
    174.                 }
    175.                 in.close();
    176.                 out.close();
    177.                 boolean upNewStatus = ftpClient.completePendingCommand();
    178.                 if (upNewStatus) {
    179.                     result = DownloadStatus.DownloadNewSuccess;
    180.                 } else {
    181.                     result = DownloadStatus.DownloadNewFailed;
    182.                 }
    183.             }
    184.         } catch (Exception e) {
    185.             log.error("download error", e);
    186.         } finally {
    187.             ftpPoolService.returnObject(ftpClient);
    188.         }
    189.         return DownloadStatus.DownloadNewFailed;
    190.     }
    191.  
    192.     /**
    193.      * 下载文件到本地 *
    194.      *
    195.      * @param ftpPath     FTP服务器文件目录 *
    196.      * @param ftpFileName 文件名称 *
    197.      * @param localPath   下载后的文件路径 *
    198.      * @return
    199.      */
    200.     public boolean download(String ftpPath, String ftpFileName, String localPath) {
    201.         FTPClient ftpClient = ftpPoolService.borrowObject();
    202.         OutputStream outputStream = null;
    203.         try {
    204.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.isFile() && file.getName().equals(ftpFileName));
    205.             if (ftpFiles != null && ftpFiles.length > 0) {
    206.                 FTPFile ftpFile = ftpFiles[0];
    207.                 File localFile = new File(localPath + DIR_SPLIT + ftpFile.getName());
    208.                 // 判断本地路径目录是否存在，不存在则创建
    209.                 if (!localFile.getParentFile().exists()) {
    210.                     localFile.getParentFile().mkdirs();
    211.                 }
    212.                 outputStream = Files.newOutputStream(localFile.toPath());
    213.                 ftpClient.retrieveFile(ftpFile.getName(), outputStream);
    214.  
    215.                 log.info("fileName:{},size:{}", ftpFile.getName(), ftpFile.getSize());
    216.                 log.info("下载文件成功...");
    217.                 return true;
    218.             } else {
    219.                 log.info("文件不存在，filePathname:{},", ftpPath + DIR_SPLIT + ftpFileName);
    220.             }
    221.         } catch (Exception e) {
    222.             log.error("下载文件失败...",e);
    223.         } finally {
    224.             IOUtils.closeQuietly(outputStream);
    225.             ftpPoolService.returnObject(ftpClient);
    226.         }
    227.         return false;
    228.     }
    229.  
    230.     /**
    231.      * 下载文件到浏览器 *
    232.      *
    233.      * @param ftpPath     FTP服务器文件目录 *
    234.      * @param ftpFileName 文件名称 *
    235.      * @param response
    236.      * @return
    237.      */
    238.     public void download(HttpServletResponse response, String ftpPath, String ftpFileName)  {
    239.         FTPClient ftpClient = ftpPoolService.borrowObject();
    240.         OutputStream outputStream = null;
    241.         try {
    242.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.isFile() && file.getName().equals(ftpFileName));
    243.             response.setContentType("application/octet-stream");
    244.             response.setCharacterEncoding("utf8");
    245.             response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(ftpFileName,"UTF-8") );
    246.             outputStream = response.getOutputStream();
    247.             if (ftpFiles != null && ftpFiles.length > 0) {
    248.                 FTPFile ftpFile = ftpFiles[0];
    249.                 ftpClient.retrieveFile(ftpPath+DIR_SPLIT+ftpFile.getName(), outputStream);
    250.  
    251.                 log.info("fileName:{},size:{}", ftpFile.getName(), ftpFile.getSize());
    252.                 log.info("下载文件成功...");
    253.             } else {
    254.                 log.info("文件不存在，filePathname:{},", ftpPath + DIR_SPLIT + ftpFileName);
    255.             }
    256.         } catch (Exception e) {
    257.             log.error("下载文件失败...",e);
    258.         } finally {
    259.             IOUtils.closeQuietly(outputStream);
    260.             ftpPoolService.returnObject(ftpClient);
    261.         }
    262.     }
    263.  
    264.     public void ftpZipFileDownload (HttpServletResponse response,String ftpPath) {
    265.         //从FTP上下载文件并打成ZIP包给用户下载
    266.         ZipOutputStream zipOut = null;
    267.         try {
    268.             //文件名称
    269.             String zipFileName = "导出数据.zip";
    270.             response.reset();
    271.             // 设置导出文件头
    272.             response.setContentType("application/octet-stream");
    273.             response.setHeader("Content-disposition", "attachment;filename=" + URLEncoder.encode(zipFileName,"UTF-8") );
    274.             // 定义Zip输出流
    275.             zipOut = new ZipOutputStream(response.getOutputStream());
    276.             zipFTPFile(ftpPath,zipOut,"");
    277.         } catch (IOException e) {
    278.             log.error("当前："+ftpPath+"下载FTP文件--->下载文件失败："+e.getMessage());
    279.         } finally {
    280.             // 关闭zip文件输出流
    281.             if (null != zipOut) {
    282.                 try {
    283.                     zipOut.closeEntry();
    284.                     zipOut.close();
    285.                 } catch (IOException e) {
    286.                     log.error("当前："+ftpPath+"下载FTP文件--->关闭zip文件输出流出错："+e.getMessage());
    287.                 }
    288.             }
    289.         }
    290.     }
    291.  
    292.     public void zipFTPFile(String ftpPath, ZipOutputStream zipOut,String foldPath){
    293.         FTPClient ftpClient = ftpPoolService.borrowObject();
    294.         try {
    295.             // 切换到指定目录中，如果切换失败说明目录不存在
    296.             if(!ftpClient.changeWorkingDirectory(ftpPath)){
    297.                 log.error("切换目录失败");
    298.                 throw new RuntimeException("切换目录失败");
    299.             }
    300.             // 每次数据连接之前,ftp client告诉ftp server开通一个端口来传输数据
    301.             ftpClient.enterLocalPassiveMode();
    302.             // 遍历路径下的所有文件
    303.             FTPFile[] fileList = ftpClient.listFiles();
    304.             byte[] byteReader = new byte[1024];
    305.             ByteArrayOutputStream os = null;
    306.             for (FTPFile tempFile : fileList) {
    307.                 if (tempFile.isFile()) {
    308.                     os = new ByteArrayOutputStream();
    309.                     // 从FTP上下载downFileName该文件把该文件转化为字节数组的输出流
    310.                     ftpClient.retrieveFile(tempFile.getName(), os);
    311.                     byte[] bytes = os.toByteArray();
    312.                     InputStream ins = new ByteArrayInputStream(bytes);
    313.  
    314.                     int len;
    315.                     zipOut.putNextEntry(new ZipEntry(foldPath + tempFile.getName()));
    316.                     // 读入需要下载的文件的内容，打包到zip文件
    317.                     while ((len = ins.read(byteReader)) > 0) {
    318.                         zipOut.write(byteReader, 0, len);
    319.                     }
    320.                 }else{
    321.                     //如果是文件夹，则递归调用该方法
    322.                     zipOut.putNextEntry(new ZipEntry(tempFile.getName() + DIR_SPLIT));
    323.                     zipFTPFile(ftpPath + DIR_SPLIT + tempFile.getName(), zipOut, tempFile.getName() + DIR_SPLIT);
    324.                 }
    325.             }
    326.             zipOut.flush();
    327.         } catch (IOException e) {
    328.             e.printStackTrace();
    329.         } finally {
    330.             ftpPoolService.returnObject(ftpClient);
    331.         }
    332.     }
    333.  
    334.     /**
    335.      * 得到某个目录下的文件名列表
    336.      *
    337.      * @param ftpDirPath FTP上的目标文件路径
    338.      * @return
    339.      * @throws IOException
    340.      */
    341.     public List getFileList(String ftpDirPath) {
    342.         FTPClient ftpClient = ftpPoolService.borrowObject();
    343.         try {
    344.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpDirPath);
    345.             if (ftpFiles != null && ftpFiles.length > 0) {
    346.                 return Arrays.stream(ftpFiles).map(FTPFile::getName).collect(Collectors.toList());
    347.             }
    348.             log.error(String.format("路径有误，或目录【%s】为空", ftpDirPath));
    349.         } catch (Exception e) {
    350.             log.error("获取目录下文件列表失败", e);
    351.         } finally {
    352.             ftpPoolService.returnObject(ftpClient);
    353.         }
    354.         return null;
    355.     }
    356.  
    357.     /**
    358.      * 删除文件
    359.      *
    360.      * @param ftpPath 服务器文件存储路径
    361.      * @param fileName 文件名
    362.      * @return
    363.      * @throws IOException
    364.      */
    365.     public boolean deleteFile(String ftpPath, String fileName) {
    366.         FTPClient ftpClient = ftpPoolService.borrowObject();
    367.         try {
    368.             // 在 ftp 目录下获取文件名与 fileName 匹配的文件信息
    369.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.getName().equals(fileName));
    370.             // 删除文件
    371.             if (ftpFiles != null && ftpFiles.length > 0) {
    372.                 boolean del;
    373.                 String deleteFilePath = ftpPath + DIR_SPLIT + fileName;
    374.                 FTPFile ftpFile = ftpFiles[0];
    375.                 if (ftpFile.isDirectory()) {
    376.                     //递归删除该目录下的所有文件后删除目录
    377.                     FTPFile[] files = ftpClient.listFiles(ftpPath + DIR_SPLIT + fileName);
    378.                     for (FTPFile file : files) {
    379.                         if(file.isDirectory()){
    380.                             deleteFile(ftpPath + DIR_SPLIT + fileName,file.getName());
    381.                         }else{
    382.                             del = ftpClient.deleteFile(deleteFilePath + DIR_SPLIT + file.getName());
    383.                             log.info(del ? "文件:{}删除成功" : "文件:{}删除失败", file.getName());
    384.                         }
    385.                     }
    386.                     del = ftpClient.removeDirectory(deleteFilePath);
    387.                 } else {
    388.                     del = ftpClient.deleteFile(deleteFilePath);
    389.                 }
    390.                 log.info(del ? "文件:{}删除成功" : "文件:{}删除失败", fileName);
    391.                 return del;
    392.             } else {
    393.                 log.warn("文件:{}未找到", fileName);
    394.             }
    395.         } catch (IOException e) {
    396.             e.printStackTrace();
    397.         } finally {
    398.             ftpPoolService.returnObject(ftpClient);
    399.         }
    400.         return false;
    401.     }
    402.  
    403.     /**
    404.      * 上传文件到FTP服务器，支持断点续传
    405.      * @param uploadPath 远程文件存放路径
    406.      * @param fileName 上传文件名
    407.      * @param input 文件输入流
    408.      * @return 上传结果
    409.      * @throws IOException
    410.      */
    411.     public UploadStatus uploadFile(String uploadPath, String fileName, InputStream input) {
    412.         FTPClient ftpClient = ftpPoolService.borrowObject();
    413.         UploadStatus result = UploadStatus.UploadNewFileFailed;
    414.         try {
    415.             // 设置PassiveMode传输
    416.             ftpClient.enterLocalPassiveMode();
    417.             // 设置以二进制流的方式传输
    418.             ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
    419.             ftpClient.setControlEncoding(CharsetUtil.UTF_8);
    420.             //切换到工作目录
    421.             if(!ftpClient.changeWorkingDirectory(uploadPath)){
    422.                 ftpClient.makeDirectory(uploadPath);
    423.                 ftpClient.changeWorkingDirectory(uploadPath);
    424.             }
    425.             // 检查远程是否存在文件
    426.             FTPFile[] files = ftpClient.listFiles(uploadPath,file -> file.getName().equals(fileName));
    427.             if (files.length == 1) {
    428.                 long remoteSize = files[0].getSize();
    429.                 //根据文件输入流获取文件对象
    430.                 File f = getFileFromInputStream(input);
    431.                 long localSize = f.length();
    432.                 // 文件存在
    433.                 if (remoteSize == localSize) {
    434.                     return UploadStatus.FileExits;
    435.                 } else if (remoteSize > localSize) {
    436.                     return UploadStatus.RemoteFileBiggerThanLocalFile;
    437.                 }
    438.                 // 尝试移动文件内读取指针,实现断点续传
    439.                 result = uploadFile(fileName, f, ftpClient, remoteSize);
    440.                 // 如果断点续传没有成功，则删除服务器上文件，重新上传
    441.                 if (result == UploadStatus.UploadFromBreakFailed) {
    442.                     if (!ftpClient.deleteFile(fileName)) {
    443.                         return UploadStatus.DeleteRemoteFaild;
    444.                     }
    445.                     result = uploadFile(fileName, f, ftpClient, 0);
    446.                 }
    447.             } else {
    448.                 result = uploadFile(fileName, getFileFromInputStream(input), ftpClient, 0);
    449.             }
    450.         } catch (Exception e) {
    451.             log.error("上传文件失败", e);
    452.         } finally {
    453.             ftpPoolService.returnObject(ftpClient);
    454.         }
    455.         return result;
    456.     }
    457.  
    458.     /**
    459.      * 从输入流中获取文件对象
    460.      * @param inputStream
    461.      * @return
    462.      */
    463.     public static File getFileFromInputStream(InputStream inputStream) {
    464.         File file = null;
    465.         try {
    466.             // 创建临时文件
    467.             file = File.createTempFile("temp", null);
    468.  
    469.             // 将输入流写入临时文件
    470.             byte[] buffer = new byte[1024];
    471.             int bytesRead;
    472.             try (FileOutputStream outputStream = new FileOutputStream(file)) {
    473.                 while ((bytesRead = inputStream.read(buffer)) != -1) {
    474.                     outputStream.write(buffer, 0, bytesRead);
    475.                 }
    476.             }
    477.         } catch (IOException e) {
    478.             e.printStackTrace();
    479.         }
    480.         return file;
    481.     }
    482.  
    483.     /**
    484.      * 递归创建远程服务器目录
    485.      *
    486.      * @param remote    远程服务器文件绝对路径
    487.      * @param ftpClient FTPClient对象
    488.      * @return 目录创建是否成功
    489.      * @throws IOException
    490.      */
    491.  
    492.     public UploadStatus createDirectory(String remote, FTPClient ftpClient) throws IOException {
    493.         UploadStatus status = UploadStatus.CreateDirectorySuccess;
    494.         String directory = remote.substring(0, remote.lastIndexOf("/") + 1);
    495.         if (!directory.equalsIgnoreCase("/") && !ftpClient.changeWorkingDirectory(new String(directory.getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1))) {
    496.             // 如果远程目录不存在，则递归创建远程服务器目录
    497.             int start = 0;
    498.             int end = 0;
    499.             if (directory.startsWith("/")) {
    500.                 start = 1;
    501.             } else {
    502.                 start = 0;
    503.             }
    504.             end = directory.indexOf("/", start);
    505.             while (true) {
    506.                 String subDirectory = new String(remote.substring(start, end).getBytes(CharsetUtil.UTF_8), CharsetUtil.ISO_8859_1);
    507.                 if (!ftpClient.changeWorkingDirectory(subDirectory)) {
    508.                     if (ftpClient.makeDirectory(subDirectory)) {
    509.                         ftpClient.changeWorkingDirectory(subDirectory);
    510.                     } else {
    511.                         log.info("创建目录失败");
    512.                         return UploadStatus.CreateDirectoryFail;
    513.                     }
    514.                 }
    515.                 start = end + 1;
    516.                 end = directory.indexOf("/", start);
    517.                 // 检查所有目录是否创建完毕
    518.                 if (end <= start) {
    519.                     break;
    520.                 }
    521.             }
    522.         }
    523.         return status;
    524.     }
    525.  
    526.     /**
    527.      * 上传文件到服务器,新上传和断点续传
    528.      *
    529.      * @param remoteFileName 远程文件名，在上传之前已经将服务器工作目录做了改变，一定要注意这里的 remoteFile 已经别被编码 ISO-8859-1
    530.      * @param localFile  本地文件File句柄，绝对路径
    531.      * @param ftpClient  FTPClient引用
    532.      * @return
    533.      * @throws IOException
    534.      */
    535.     public UploadStatus uploadFile(String remoteFileName, File localFile, FTPClient ftpClient, long remoteSize) {
    536.         if (null == ftpClient) {
    537.             ftpClient = ftpPoolService.borrowObject();
    538.         }
    539.         if (null == ftpClient) {
    540.             return null;
    541.         }
    542.         UploadStatus status = UploadStatus.UploadNewFileFailed;
    543.  
    544.         try (RandomAccessFile raf = new RandomAccessFile(localFile, "r");
    545.              OutputStream out = ftpClient.appendFileStream(remoteFileName);) {
    546.             // 显示进度的上传
    547.             log.info("localFile.length():" + localFile.length());
    548.             long step = localFile.length() / 100;
    549.             // 文件过小，step可能为0
    550.             step = step == 0 ? 1 : step;
    551.             long process = 0;
    552.             long localreadbytes = 0L;
    553.  
    554.             // 断点续传
    555.             if (remoteSize > 0) {
    556.                 ftpClient.setRestartOffset(remoteSize);
    557.                 process = remoteSize / step;
    558.                 raf.seek(remoteSize);
    559.                 localreadbytes = remoteSize;
    560.             }
    561.             byte[] bytes = new byte[1024];
    562.             int c;
    563.             while ((c = raf.read(bytes)) != -1) {
    564.                 out.write(bytes, 0, c);
    565.                 localreadbytes += c;
    566.                 if (localreadbytes / step != process) {
    567.                     process = localreadbytes / step;
    568.                     if (process % 10 == 0) {
    569.                         log.info("上传进度：" + process);
    570.                     }
    571.                 }
    572.             }
    573.             out.flush();
    574.             raf.close();
    575.             out.close();
    576.             // FTPUtil的upload方法在执行ftpClient.completePendingCommand()之前应该先关闭OutputStream，否则主线程会在这里卡死执行不下去。
    577.             // 原因是completePendingCommand()会一直在等FTP Server返回226 Transfer complete，但是FTP Server只有在接受到OutputStream执行close方法时，才会返回。
    578.             boolean result = ftpClient.completePendingCommand();
    579.             if (remoteSize > 0) {
    580.                 status = result ? UploadStatus.UploadFromBreakSuccess : UploadStatus.UploadFromBreakFailed;
    581.             } else {
    582.                 status = result ? UploadStatus.UploadNewFileSuccess : UploadStatus.UploadNewFileFailed;
    583.             }
    584.         } catch (Exception e) {
    585.             log.error("uploadFile error ", e);
    586.         }
    587.         return status;
    588.     }
    589.  
    590.     /**
    591.      * 获取FTP某一特定目录下的文件数量
    592.      *
    593.      * @param ftpDirPath FTP上的目标文件路径
    594.      */
    595.     public Integer getFileNum(String ftpDirPath) {
    596.         FTPClient ftpClient = ftpPoolService.borrowObject();
    597.         try {
    598.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpDirPath);
    599.             if (ftpFiles != null && ftpFiles.length > 0) {
    600.                 return Arrays.stream(ftpFiles).map(FTPFile::getName).collect(Collectors.toList()).size();
    601.             }
    602.             log.error(String.format("路径有误，或目录【%s】为空", ftpDirPath));
    603.         } catch (IOException e) {
    604.             log.error("文件获取异常:", e);
    605.         } finally {
    606.             ftpPoolService.returnObject(ftpClient);
    607.         }
    608.         return null;
    609.     }
    610.  
    611.     /**
    612.      * 获取文件夹下文件数量
    613.      * @param ftpPath
    614.      * @return
    615.      */
    616.     public Map getDirFileNum(String ftpPath) {
    617.         FTPClient ftpClient = ftpPoolService.borrowObject();
    618.         try {
    619.             Integer sum  = 0;
    620.             Map map = new HashMap<>();
    621.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath);
    622.             if (ftpFiles != null && ftpFiles.length > 0) {
    623.                 for (FTPFile file : ftpFiles) {
    624.                     if (file.isDirectory()) {
    625.                         sum += getFileNum(ftpPath + DIR_SPLIT + file.getName());
    626.                         map.put(file.getName(), String.valueOf(getFileNum(ftpPath + DIR_SPLIT + file.getName())));
    627.                     }
    628.                 }
    629.             }else {
    630.                 log.error(String.format("路径有误，或目录【%s】为空", ftpPath));
    631.             }
    632.             map.put("sum", String.valueOf(sum));
    633.             return map;
    634.         } catch (IOException e) {
    635.             log.error("文件获取异常:", e);
    636.         } finally {
    637.             ftpPoolService.returnObject(ftpClient);
    638.         }
    639.         return null;
    640.     }
    641.  
    642.  
    643.     /**
    644.      * 下载指定文件夹到本地
    645.      * @param ftpPath FTP服务器文件目录
    646.      * @param localPath 下载后的文件路径
    647.      * @param dirName 文件夹名称
    648.      * @return
    649.      */
    650.     public void downloadDir(String ftpPath, String localPath, String dirName){
    651.         FTPClient ftpClient = ftpPoolService.borrowObject();
    652.         OutputStream outputStream = null;
    653.         try {
    654.             //判断是否存在该文件夹
    655.             FTPFile[] ftpFiles = ftpClient.listFiles(ftpPath, file -> file.getName().equals(dirName));
    656.             if (ftpFiles != null && ftpFiles.length > 0) {
    657.                 if(ftpFiles[0].isDirectory()) {
    658.                     // 判断本地路径目录是否存在，不存在则创建
    659.                     File localFile = new File(localPath + DIR_SPLIT + dirName);
    660.                     if (!localFile.exists()) {
    661.                         localFile.mkdirs();
    662.                     }
    663.                     for (FTPFile file : ftpClient.listFiles(ftpPath + DIR_SPLIT + dirName)) {
    664.                         if (file.isDirectory()) {
    665.                             downloadDir(ftpPath + DIR_SPLIT + dirName, localPath + dirName + DIR_SPLIT, file.getName());
    666.                         } else {
    667.                             outputStream = Files.newOutputStream(new File(localPath + DIR_SPLIT + dirName + DIR_SPLIT + file.getName()).toPath());
    668.                             ftpClient.retrieveFile(ftpPath + DIR_SPLIT + dirName + DIR_SPLIT + file.getName(), outputStream);
    669.                             log.info("fileName:{},size:{}", file.getName(), file.getSize());
    670.                             outputStream.close();
    671.                         }
    672.                     }
    673.                 }
    674.             }
    675.         }catch (Exception e){
    676.             log.error("下载文件夹失败，filePathname:{},", ftpPath + DIR_SPLIT + dirName, e);
    677.         }finally {
    678.             IOUtils.closeQuietly(outputStream);
    679.             ftpPoolService.returnObject(ftpClient);
    680.         }
    681.     }
    682.  
    683.         /**
    684.      * 从本地上传文件夹
    685.      * @param uploadPath ftp服务器地址
    686.      * @param localPath 本地文件夹地址
    687.      * @param dirName  文件夹名称
    688.      * @return
    689.      */
    690.     public boolean uploadDir(String uploadPath, String localPath, String dirName){
    691.         FTPClient ftpClient = ftpPoolService.borrowObject();
    692.         try{
    693.             // 切换到工作目录
    694.             if (!ftpClient.changeWorkingDirectory(uploadPath)) {
    695.                 ftpClient.makeDirectory(uploadPath);
    696.                 ftpClient.changeWorkingDirectory(uploadPath);
    697.             }
    698.             //创建文件夹
    699.             ftpClient.makeDirectory(uploadPath + DIR_SPLIT + dirName);
    700.             File src = new File(localPath);
    701.             //获取该目录下的所有文件
    702.             File[] files = src.listFiles();
    703.             FileInputStream input = null;
    704.             for(File file : files) {
    705.                 if (file.isDirectory()) {
    706.                     uploadDir(uploadPath + DIR_SPLIT + dirName, file.getAbsolutePath(), file.getName());
    707.                 } else {
    708.                     input = new FileInputStream(file);
    709.                     boolean storeFile = ftpClient.storeFile(uploadPath + DIR_SPLIT + dirName + DIR_SPLIT + file.getName(), input);
    710.                     if (storeFile) {
    711.                         log.info("文件:{}上传成功", file.getName());
    712.                     } else {
    713.                         throw new RuntimeException("ftp文件写入异常");
    714.                     }
    715.                 }
    716.             }
    717.             if(input != null){
    718.                 input.close();
    719.             }
    720.         }catch (Exception e){
    721.             log.error("文件夹上传失败",e);
    722.         }finally {
    723.             ftpPoolService.returnObject(ftpClient);
    724.         }
    725.         return false;
    726.     }
    727. }
    728.
  • 相关阅读:
    「技术人生」第9篇：如何设定业务目标
    动态链接库(扩展)--实际开发时的注意事项
    【ESD专题】金属外壳连接器的信号PIN脚需要进行ESD测试吗？
    史上最全，最详细SQL基础
    微服务拆分
    MySql的初识感悟，以及sql语句中的DDL和DML和DQL的基本语法
    STM32CubeMX串口通讯
    自行更换内存条的操作规范
    【java多种方式实现计时器】时分秒毫秒，附带代码+运行截图
    408 | 大纲知识点考点冲刺 复习整理 ——【计组】第一二三章
  • 原文地址：https://blog.csdn.net/qq_41481924/article/details/138192937