Commons Net 实现 FTP上传下载等常用操作

悠悠 2023-07-24 03:29 5阅读 0赞

> 本文引自[**大佬文章**][Link 1]，微调，仅作笔录使用，如有冒犯，留言即删！

直接上代码[（示例下载）][Link 2]：

## 1.Maven依赖 ##

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>2.2.1.RELEASE</version>
    		<relativePath/> 
    	</parent>
    	<groupId>com.lee.demo</groupId>
    	<artifactId>ftp</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>ftp</name>
    	<description>Demo project for Spring Boot</description>
    
    	<properties>
    		<java.version>1.8</java.version>
    	</properties>
    
    	<dependencies>
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter</artifactId>
    		</dependency>
    		<dependency>
    			<groupId>junit</groupId>
    			<artifactId>junit</artifactId>
    			<version>4.12</version>
    			<scope>test</scope>
    		</dependency>
    		<dependency>
    			<groupId>log4j</groupId>
    			<artifactId>log4j</artifactId>
    			<version>1.2.17</version>
    		</dependency>
    
    		<dependency>
    			<groupId>commons-net</groupId>
    			<artifactId>commons-net</artifactId>
    			<version>3.6</version>
    		</dependency>
    		<dependency>
    			<groupId>org.apache.commons</groupId>
    			<artifactId>commons-lang3</artifactId>
    			<version>3.9</version>
    		</dependency>
    		<dependency>
    			<groupId>commons-io</groupId>
    			<artifactId>commons-io</artifactId>
    			<version>2.4</version>
    		</dependency>
    		<dependency>
    			<groupId>javax.ws.rs</groupId>
    			<artifactId>jsr311-api</artifactId>
    			<version>1.1.1</version>
    		</dependency>
    
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-test</artifactId>
    			<scope>test</scope>
    			<exclusions>
    				<exclusion>
    					<groupId>org.junit.vintage</groupId>
    					<artifactId>junit-vintage-engine</artifactId>
    				</exclusion>
    			</exclusions>
    		</dependency>
    	</dependencies>
    
    	<build>
    		<plugins>
    			<plugin>
    				<groupId>org.springframework.boot</groupId>
    				<artifactId>spring-boot-maven-plugin</artifactId>
    			</plugin>
    		</plugins>
    	</build>
    
    </project>

## 2.FTP工具类 ##

package com.lee.demo.ftp.util;
    
    import org.apache.commons.io.FileUtils;
    import org.apache.commons.io.filefilter.TrueFileFilter;
    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 org.apache.log4j.Logger;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    
    
    /** * 创建人:Jimmy * 创建时间:2019年11月11日23:24 * 描述: FTP工具类 */
    public class FtpUtil { 
    
        private static Logger logger = Logger.getLogger(FtpUtil.class.getName());
    
        /** * 连接 FTP 服务器 * * @param addr FTP 服务器 IP 地址 * @param port FTP 服务器端口号 * @param username 登录用户名 * @param password 登录密码 * @return * @throws Exception */
        public static FTPClient connectFtpServer(String addr, int port, String username, String password, String controlEncoding) { 
            FTPClient ftpClient = new FTPClient();
            try { 
                /**设置文件传输的编码*/
                ftpClient.setControlEncoding(controlEncoding);
    
                /**连接 FTP 服务器 * 如果连接失败，则此时抛出异常，如ftp服务器服务关闭时，抛出异常： * java.net.ConnectException: Connection refused: connect*/
                ftpClient.connect(addr, port);
                /**登录 FTP 服务器 * 1）如果传入的账号为空，则使用匿名登录，此时账号使用 "Anonymous"，密码为空即可*/
                if (StringUtils.isBlank(username)) { 
                    ftpClient.login("", "");
                } else { 
                    ftpClient.login(username, password);
                }
    
                /** 设置传输的文件类型 * BINARY_FILE_TYPE：二进制文件类型 * ASCII_FILE_TYPE：ASCII传输方式，这是默认的方式 * .... */
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
    
                /** * 确认应答状态码是否正确完成响应 * 凡是 2开头的 isPositiveCompletion 都会返回 true，因为它底层判断是： * return (reply >= 200 && reply < 300); */
                int reply = ftpClient.getReplyCode();
                ftpClient.enterLocalPassiveMode();
                if (!FTPReply.isPositiveCompletion(reply)) { 
                    /** * 如果 FTP 服务器响应错误 中断传输、断开连接 * abort：中断文件正在进行的文件传输，成功时返回 true,否则返回 false * disconnect：断开与服务器的连接，并恢复默认参数值 */
                    ftpClient.abort();
                    ftpClient.disconnect();
                } else { 
                }
            } catch (IOException e) { 
                e.printStackTrace();
                System.out.println(">>>>>FTP服务器连接登录失败，请检查连接参数是否正确，或者网络是否通畅*********");
            }
            return ftpClient;
        }
    
        /** * 下载 FTP 服务器上指定的单个文件，而且本地存放的文件相对部分路径 会与 FTP 服务器结构保持一致 * * @param ftpClient ：连接成功有效的 FTP客户端连接 * @param absoluteLocalDirectory ：本地存储文件的绝对路径，如 E:\gxg\ftpDownload * @param relativeRemotePath ：ftpFile 文件在服务器所在的绝对路径，此方法强制路径使用右斜杠"\"，如 "\video\2018.mp4" * @return */
        public static void downloadSingleFile(FTPClient ftpClient, String absoluteLocalDirectory, String relativeRemotePath) { 
            /**如果 FTP 连接已经关闭，或者连接无效，则直接返回*/
            if (!ftpClient.isConnected() || !ftpClient.isAvailable()) { 
                System.out.println(">>>>>FTP服务器连接已经关闭或者连接无效*********");
                return;
            }
            if (StringUtils.isBlank(absoluteLocalDirectory) || StringUtils.isBlank(relativeRemotePath)) { 
                System.out.println(">>>>>下载时遇到本地存储路径或者ftp服务器文件路径为空，放弃...*********");
                return;
            }
            try { 
                /**没有对应路径时，FTPFile[] 大小为0，不会为null*/
                FTPFile[] ftpFiles = ftpClient.listFiles(relativeRemotePath);
                FTPFile ftpFile = null;
                if (ftpFiles.length >= 1) { 
                    ftpFile = ftpFiles[0];
                }
                if (ftpFile != null && ftpFile.isFile()) { 
                    /** ftpFile.getName():获取的是文件名称，如 123.mp4 * 必须保证文件存放的父目录必须存在，否则 retrieveFile 保存文件时报错 */
                    File localFile = new File(absoluteLocalDirectory, relativeRemotePath);
                    if (!localFile.getParentFile().exists()) { 
                        localFile.getParentFile().mkdirs();
                    }
    
                    OutputStream outputStream = new FileOutputStream(localFile);
    
                    String workDir = relativeRemotePath.substring(0, relativeRemotePath.lastIndexOf("/"));
                    if (StringUtils.isBlank(workDir)) { 
                        workDir = "/";
                    }
                    /**文件下载前，FTPClient工作目录必须切换到文件所在的目录，否则下载失败 * "/" 表示用户根目录*/
                    ftpClient.changeWorkingDirectory(workDir);
                    /**下载指定的 FTP 文件 到本地 * 1)注意只能是文件，不能直接下载整个目录 * 2)如果文件本地已经存在，默认会重新下载 * 3)下载文件之前，ftpClient 工作目录必须是下载文件所在的目录 * 4)下载成功返回 true，失败返回 false */
                    ftpClient.retrieveFile(ftpFile.getName(), outputStream);
    
                    outputStream.flush();
                    outputStream.close();
                    System.out.println(">>>>>FTP服务器文件下载完毕*********" + ftpFile.getName());
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        /** * 遍历 FTP 服务器指定目录下的所有文件(包含子孙文件) * * @param ftpClient ：连接成功有效的 FTP客户端连接 * @param remotePath ：查询的 FTP 服务器目录，如果文件，则视为无效，使用绝对路径，如"/"、"/video"、"/"、"/video" * @param relativePathList ：返回查询结果，其中为服务器目录下的文件相对路径，如：\1.png、\docs\overview-tree.html 等 * @return */
        public static List<String> loopServerPath(FTPClient ftpClient, String remotePath, List<String> relativePathList) { 
            /**如果 FTP 连接已经关闭，或者连接无效，则直接返回*/
            if (!ftpClient.isConnected() || !ftpClient.isAvailable()) { 
                System.out.println("ftp 连接已经关闭或者连接无效......");
                return relativePathList;
            }
            try { 
                /**转移到FTP服务器根目录下的指定子目录 * 1)"/"：表示用户的根目录，为空时表示不变更 * 2)参数必须是目录，当是文件时改变路径无效 * */
                ftpClient.changeWorkingDirectory(remotePath);
                /** listFiles：获取FtpClient连接的当前下的一级文件列表(包括子目录) * 1）FTPFile[] ftpFiles = ftpClient.listFiles("/docs/info"); * 获取服务器指定目录下的子文件列表(包括子目录)，以 FTP 登录用户的根目录为基准，与 FTPClient 当前连接目录无关 * 2）FTPFile[] ftpFiles = ftpClient.listFiles("/docs/info/springmvc.txt"); * 获取服务器指定文件，此时如果文件存在时，则 FTPFile[] 大小为 1，就是此文件 * */
                FTPFile[] ftpFiles = ftpClient.listFiles();
                if (ftpFiles != null && ftpFiles.length > 0) { 
                    for (FTPFile ftpFile : ftpFiles) { 
                        if (ftpFile.isFile()) { 
                            String relativeRemotePath = remotePath + "/" + ftpFile.getName();
                            relativePathList.add(relativeRemotePath);
                        } else { 
                            loopServerPath(ftpClient, remotePath + "/" + ftpFile.getName(), relativePathList);
                        }
                    }
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return relativePathList;
        }
    
        /** * 同步本地目录与 FTP 服务器目录 * 1）约定：FTP 服务器有，而本地没有的，则下载下来；本地有，而ftp服务器没有的，则将本地多余的删除 * 2）始终确保本地与 ftp 服务器内容一致 * 2）让 FTP 服务器与 本地目录保持结构一致，如 服务器上是 /docs/overview-tree.html，则本地也是 localDir/docs/overview-tree.html * * @param ftpClient 连接成功有效的 FTPClinet * @param localSyncFileDir ：与 FTP 目录进行同步的本地目录 */
        public static void syncLocalDir(FTPClient ftpClient, String localSyncFileDir) throws IOException { 
            /**如果 FTP 连接已经关闭，或者连接无效，则直接返回*/
            if (!ftpClient.isConnected() || !ftpClient.isAvailable() || StringUtils.isBlank(localSyncFileDir)) { 
                System.out.println(">>>>>FTP服务器连接已经关闭或者连接无效*********");
                return;
            }
    
            /** 获取本地存储目录下的文件*/
            Collection<File> fileCollection = localListFiles(new File(localSyncFileDir));
            System.out.println(">>>>>本地存储目录共有文件数量*********" + fileCollection.size());
    
            /**获取 FTP 服务器下的相对路径*/
            List<String> relativePathList = new ArrayList<>();
            relativePathList = loopServerPath(ftpClient, "", relativePathList);
            System.out.println(">>>>>FTP 服务器端共有文件数量*********" + relativePathList.size());
    
            /** * 遍历 本地存储目录下的文件 * 1）如果本地文件在 FTP 服务器上不存在，则删除它 * 2）如果本地文件在 FTP 服务器上存在，则比较两种大小 * 如果大小不一致，则重新下载 */
            for (File localFile : fileCollection) { 
                String localFilePath = localFile.getPath();
                String localFileSuffi = localFilePath.replace(localSyncFileDir, "");
                if (relativePathList.contains(localFileSuffi)) { 
                    /**本地此文件在 FTP 服务器存在 * 1)比较大小，如果本地文件与服务器文件大小一致，则跳过 * 2）如果大小不一致，则删除本地文件，重新下载 * 3）最后都要删除relativePathList中的此元素，减轻后一次循环的压力*/
                    FTPFile[] ftpFiles = ftpClient.listFiles(localFileSuffi);
                    System.out.println(">>>>>本地文件 在 FTP 服务器已存在*********" + localFile.getPath());
                    if (ftpFiles.length >= 1 && localFile.length() != ftpFiles[0].getSize()) { 
                        downloadSingleFile(ftpClient, localSyncFileDir, localFileSuffi);
                        System.out.println(">>>>>本地文件与 FTP 服务器文件大小不一致，重新下载*********" + localFile.getPath());
                    }
                    relativePathList.remove(localFileSuffi);
                } else { 
                    System.out.println(">>>>>本地文件在 FTP 服务器不存在，删除本地文件*********" + localFile.getPath());
                    /**本地此文件在 FTP 服务器不存在 * 1)删除本地文件 * 2）如果当前文件所在目录下文件已经为空，则将此父目录也一并删除*/
                    localFile.delete();
                    File parentFile = localFile.getParentFile();
                    while (parentFile.list().length == 0) { 
                        parentFile.delete();
                        parentFile = parentFile.getParentFile();
                    }
                }
            }
            for (int i = 0; i < relativePathList.size(); i++) { 
                System.out.println(">>>>> FTP 服务器存在新文件，准备下载*********" + relativePathList.get(i));
                downloadSingleFile(ftpClient, localSyncFileDir, relativePathList.get(i));
            }
        }
    
        /** * 遍历目录下的所有文件--方式1 * * @param targetDir */
        public static Collection<File> localListFiles(File targetDir) { 
            Collection<File> fileCollection = new ArrayList<>();
            if (targetDir != null && targetDir.exists() && targetDir.isDirectory()) { 
                /** * targetDir：不要为 null、不要是文件、不要不存在 * 第二个 文件过滤 参数如果为 FalseFileFilter.FALSE ，则不会查询任何文件 * 第三个 目录过滤 参数如果为 FalseFileFilter.FALSE , 则只获取目标文件夹下的一级文件，而不会迭代获取子文件夹下的文件 */
                fileCollection = FileUtils.listFiles(targetDir, TrueFileFilter.INSTANCE, TrueFileFilter.INSTANCE);
            }
            return fileCollection;
        }
    
    
        /** * 上传本地文件 或 目录 至 FTP 服务器----保持 FTP 服务器与本地 文件目录结构一致 * * @param ftpClient 连接成功有效的 FTPClinet * @param uploadFile 待上传的文件 或 文件夹(此时会遍历逐个上传) * @throws Exception */
        public static void uploadFiles(FTPClient ftpClient, File uploadFile) { 
            /**如果 FTP 连接已经关闭，或者连接无效，则直接返回*/
            if (!ftpClient.isConnected() || !ftpClient.isAvailable()) { 
                System.out.println(">>>>>FTP服务器连接已经关闭或者连接无效*****放弃文件上传****");
                return;
            }
            if (uploadFile == null || !uploadFile.exists()) { 
                System.out.println(">>>>>待上传文件为空或者文件不存在*****放弃文件上传****");
                return;
            }
            try { 
                if (uploadFile.isDirectory()) { 
                    /**如果被上传的是目录时 * makeDirectory：在 FTP 上创建目录(方法执行完，服务器就会创建好目录，如果目录本身已经存在，则不会再创建) * 1）可以是相对路径，即不以"/"开头，相对的是 FTPClient 当前的工作路径，如 "video"、"视频" 等，会在当前工作目录进行新建目录 * 2）可以是绝对路径，即以"/"开头，与 FTPCLient 当前工作目录无关，如 "/images"、"/images/2018" * 3）注意多级目录时，必须确保父目录存在，否则创建失败， * 如 "video/201808"、"/images/2018" ，如果 父目录 video与images不存在，则创建失败 * */
                    ftpClient.makeDirectory(uploadFile.getName());
                    /**变更 FTPClient 工作目录到新目录 * 1)不以"/"开头表示相对路径，新目录以当前工作目录为基准，即当前工作目录下不存在此新目录时，变更失败 * 2)参数必须是目录，当是文件时改变路径无效*/
                    ftpClient.changeWorkingDirectory(uploadFile.getName());
    
                    File[] listFiles = uploadFile.listFiles();
                    for (File loopFile:listFiles) { 
                        if (loopFile.isDirectory()) { 
                            /**如果有子目录，则迭代调用方法进行上传*/
                            uploadFiles(ftpClient, loopFile);
                            /**changeToParentDirectory：将 FTPClient 工作目录移到上一层 * 这一步细节很关键，子目录上传完成后，必须将工作目录返回上一层，否则容易导致文件上传后，目录不一致 * */
                            ftpClient.changeToParentDirectory();
                        } else { 
                            /**如果目录中全是文件，则直接上传*/
                            FileInputStream input = new FileInputStream(loopFile);
                            ftpClient.storeFile(loopFile.getName(), input);
                            input.close();
                            System.out.println(">>>>>文件上传成功****" + loopFile.getPath());
                        }
                    }
                } else { 
                    /**如果被上传的是文件时*/
                    FileInputStream input = new FileInputStream(uploadFile);
                    /** storeFile:将本地文件上传到服务器 * 1）如果服务器已经存在此文件，则不会重新覆盖,即不会再重新上传 * 2）如果当前连接FTP服务器的用户没有写入的权限，则不会上传成功，但是也不会报错抛异常 * */
                    ftpClient.storeFile(uploadFile.getName(), input);
                    input.close();
                    System.out.println(">>>>>文件上传成功****" + uploadFile.getPath());
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        /*** * @上传文件夹 * @param localDirectory 当地文件夹 * @param remoteDirectoryPath Ftp 服务器路径 以目录"/"结束 * */
        public static boolean uploadDirectory(FTPClient ftpClient,String localDirectory,String remoteDirectoryPath) { 
            File src = new File(localDirectory);
            try { 
                remoteDirectoryPath = remoteDirectoryPath + src.getName() + "/";
                ftpClient.makeDirectory(remoteDirectoryPath);
            } catch (IOException e) { 
                e.printStackTrace();
                logger.info(remoteDirectoryPath + "目录创建失败");
            }
            File[] allFile = src.listFiles();
            for (File file:allFile) { 
                if (file.isDirectory()) { 
                    // 递归
                    uploadDirectory(ftpClient,file.getPath(),remoteDirectoryPath);
                }else { 
                    String srcName = file.getPath();
                    uploadFile(ftpClient,new File(srcName),remoteDirectoryPath);
                }
            }
            return true;
        }
    
    
        /*** * 上传Ftp文件 * @param localFile 当地文件 * @param romotUpLoadePath 上传服务器路径 - 应该以/结束 * */
        public static boolean uploadFile(FTPClient ftpClient,File localFile,String romotUpLoadePath) { 
            BufferedInputStream inStream = null;
            boolean success = false;
            try { 
                ftpClient.changeWorkingDirectory(romotUpLoadePath);// 改变工作路径
                inStream = new BufferedInputStream(new FileInputStream(localFile));
                logger.info(localFile.getName() + "开始上传.....");
                success = ftpClient.storeFile(localFile.getName(), inStream);
                if (success == true) { 
                    logger.info(localFile.getName() + "上传成功");
                    return success;
                }
            } catch (FileNotFoundException e) { 
                e.printStackTrace();
                logger.error(localFile + "未找到");
            } catch (IOException e) { 
                e.printStackTrace();
            } finally { 
                if (inStream != null) { 
                    try { 
                        inStream.close();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }
            return success;
        }
    
        /*** * @下载文件夹 * @param localDirectoryPath 本地地址 * @param remoteDirectory 远程文件夹 * */
        public static boolean downLoadDirectory(FTPClient ftpClient, String localDirectoryPath,String remoteDirectory) { 
            try { 
                String fileName = new File(remoteDirectory).getName();
                localDirectoryPath = localDirectoryPath + fileName + "/";
                new File(localDirectoryPath).mkdirs();
                FTPFile[] allFile = ftpClient.listFiles(remoteDirectory);
                for (FTPFile file:allFile) { 
                    if (file.isDirectory()) { 
                        String strremoteDirectoryPath = remoteDirectory + "/" + file.getName();
                        downLoadDirectory(ftpClient, localDirectoryPath, strremoteDirectoryPath);
                    }else { 
                        downloadFile(ftpClient,file.getName(), localDirectoryPath, remoteDirectory);
                    }
                }
            } catch (IOException e) { 
                e.printStackTrace();
                logger.info("下载文件夹失败");
                return false;
            }
            return true;
        }
    
        /*** * 下载文件 * @param remoteFileName 待下载文件名称 * @param localDires 下载到当地那个路径下 * @param remoteDownLoadPath remoteFileName所在的路径 */
    
        public static boolean downloadFile(FTPClient ftpClient, String remoteFileName, String localDires,
                                    String remoteDownLoadPath) { 
            String strFilePath = localDires + remoteFileName;
            BufferedOutputStream outStream = null;
            boolean success = false;
            try { 
                ftpClient.changeWorkingDirectory(remoteDownLoadPath);
                outStream = new BufferedOutputStream(new FileOutputStream(strFilePath));
                logger.info(remoteFileName + "开始下载....");
                success = ftpClient.retrieveFile(remoteFileName, outStream);
                if (success == true) { 
                    logger.info(remoteFileName + "成功下载到" + strFilePath);
                    return success;
                }
            } catch (Exception e) { 
                e.printStackTrace();
                logger.error(remoteFileName + "下载失败");
            } finally { 
                if (null != outStream) { 
                    try { 
                        outStream.flush();
                        outStream.close();
                    } catch (IOException e) { 
                        e.printStackTrace();
                    }
                }
            }
            if (success == false) { 
                logger.error(remoteFileName + "下载失败!!!");
            }
            return success;
        }
    
    
        /** * 删除服务器的文件 * * @param ftpClient 连接成功且有效的 FTP客户端 * @param deleteFiles 待删除的文件或者目录，为目录时，会逐个删除， * 路径必须是绝对路径，如 "/1.png"、"/video/3.mp4"、"/images/2018" * "/" 表示用户根目录,则删除所有内容 */
        public static void deleteServerFiles(FTPClient ftpClient, String deleteFiles) { 
            /**如果 FTP 连接已经关闭，或者连接无效，则直接返回*/
            if (!ftpClient.isConnected() || !ftpClient.isAvailable()) { 
                System.out.println(">>>>>FTP服务器连接已经关闭或者连接无效*****放弃文件上传****");
                return;
            }
            try { 
                /** 尝试改变当前工作目录到 deleteFiles * 1）changeWorkingDirectory：变更FTPClient当前工作目录，变更成功返回true，否则失败返回false * 2）如果变更工作目录成功，则表示 deleteFiles 为服务器已经存在的目录 * 3）否则变更失败，则认为 deleteFiles 是文件，是文件时则直接删除 */
                boolean changeFlag = ftpClient.changeWorkingDirectory(deleteFiles);
                if (changeFlag) { 
                    /**当被删除的是目录时*/
                    FTPFile[] ftpFiles = ftpClient.listFiles();
                    for (FTPFile ftpFile : ftpFiles) { 
                        System.out.println("----------------::::" + ftpClient.printWorkingDirectory());
                        if (ftpFile.isFile()) { 
                            boolean deleteFlag = ftpClient.deleteFile(ftpFile.getName());
                            if (deleteFlag) { 
                                System.out.println(">>>>>删除服务器文件成功****" + ftpFile.getName());
                            } else { 
                                System.out.println(">>>>>删除服务器文件失败****" + ftpFile.getName());
                            }
                        } else { 
                            /**printWorkingDirectory：获取 FTPClient 客户端当前工作目录 * 然后开始迭代删除子目录 */
                            String workingDirectory = ftpClient.printWorkingDirectory();
                            deleteServerFiles(ftpClient, workingDirectory + "/" + ftpFile.getName());
                        }
                    }
                    /**printWorkingDirectory：获取 FTPClient 客户端当前工作目录 * removeDirectory：删除FTP服务端的空目录，注意如果目录下存在子文件或者子目录，则删除失败 * 运行到这里表示目录下的内容已经删除完毕，此时再删除当前的为空的目录，同时将工作目录移动到上移层级 * */
                    String workingDirectory = ftpClient.printWorkingDirectory();
                    ftpClient.removeDirectory(workingDirectory);
                    ftpClient.changeToParentDirectory();
                } else { 
                    /**deleteFile：删除FTP服务器上的文件 * 1）只用于删除文件而不是目录，删除成功时，返回 true * 2）删除目录时无效,方法返回 false * 3）待删除文件不存在时，删除失败，返回 false * */
                    boolean deleteFlag = ftpClient.deleteFile(deleteFiles);
                    if (deleteFlag) { 
                        System.out.println(">>>>>删除服务器文件成功****" + deleteFiles);
                    } else { 
                        System.out.println(">>>>>删除服务器文件失败****" + deleteFiles);
                    }
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        /** * 使用完毕，应该及时关闭连接 * 终止 ftp 传输 * 断开 ftp 连接 * * @param ftpClient * @return */
        public static FTPClient closeFTPConnect(FTPClient ftpClient) { 
            try { 
                if (ftpClient != null && ftpClient.isConnected()) { 
                    ftpClient.abort();
                    ftpClient.disconnect();
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
            return ftpClient;
        }
    
    }

## 3.FTP测试类 ##

package com.lee.demo.ftp;
    
    import com.lee.demo.ftp.util.FtpUtil;
    import org.apache.commons.net.ftp.FTPClient;
    import org.apache.commons.net.ftp.FTPFile;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import javax.ws.rs.core.Application;
    import java.io.*;
    
    import static com.lee.demo.ftp.util.FtpUtil.*;
    
    
    /** * 创建人:Jimmy * 创建时间:2019年11月11日23:23 * 描述:FTP测试类 */
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = Application.class)
    public class FtpTest { 
    
        /** * FTP查询文件信息 * @throws IOException */
        @Test
        public void ftpQuery() throws IOException { 
            String ftpHost = "192.168.0.222";
            int ftpPort = 21;
            String ftpUserName = "test";
            String ftpPassword = "123456";
            String ftpEncoding = "gbk";
    
            System.out.println("=========应用启动==========");
            FTPClient ftpClient = FtpUtil.connectFtpServer(ftpHost, ftpPort, ftpUserName, ftpPassword, ftpEncoding);
            System.out.println("FTP 连接是否成功：" + ftpClient.isConnected());
            System.out.println("FTP 连接是否有效：" + ftpClient.isAvailable());
    
            FTPFile[] ftpFiles = ftpClient.listFiles();
            for (FTPFile ftpFile : ftpFiles) { 
                System.out.println("文件名：" + ftpFile.getName());
            }
    
            closeFTPConnect(ftpClient);
            System.out.println("=========应用关闭==========");
        }
    
        /** * FTP文件上传 */
        @Test
        public void ftpUpdate() { 
            String ftpHost = "192.168.0.222";
            int ftpPort = 21;
            String ftpUserName = "test";
            String ftpPassword = "123456";
            String ftpEncoding = "gbk";
            String localPath = "C:/Users/liqiu/Desktop/pic/1.jpg";
    
            System.out.println("=========应用启动==========");
            FTPClient ftpClient = FtpUtil.connectFtpServer(ftpHost, ftpPort, ftpUserName, ftpPassword, ftpEncoding);
    
            uploadFiles(ftpClient, new File(localPath));
    
            closeFTPConnect(ftpClient);
            System.out.println("=========应用关闭==========");
    
        }
    
        /** * FTP单文件下载 */
        @Test
        public void ftpSingleDownload() { 
            String ftpHost = "192.168.0.222";
            int ftpPort = 21;
            String ftpUserName = "test";
            String ftpPassword = "123456";
            String ftpEncoding = "gbk";
    
            System.out.println("=========应用启动==========");
            FTPClient ftpClient = FtpUtil.connectFtpServer(ftpHost, ftpPort, ftpUserName, ftpPassword, ftpEncoding);
            downloadSingleFile(ftpClient, "F:/ftp/ftpDownload", "/home/test/1.jpg");
            closeFTPConnect(ftpClient);
            System.out.println("=========应用关闭==========");
        }
    
        /** * 文件源FTP服务器转存文件至目标FTP服务器（存本地==》再上传==》删除本地文件） * @throws Exception */
        @Test
        public void task() throws Exception { 
            System.out.println("=========连接文件源FTP服务器==========");
            String sourceFtpHost = "192.168.0.222";
            int sourceFtpPort = 21;
            String sourceFtpUserName = "test";
            String sourceFtpPassword = "123456";
            String sourceFtpEncoding = "gbk";
            String localPath = "F:/ftp/ftpDownload";
            String remotePath = "/home/test/1.jpg";
            FTPClient sourceFtpClient = FtpUtil.connectFtpServer(sourceFtpHost, sourceFtpPort, sourceFtpUserName, sourceFtpPassword, sourceFtpEncoding);
    
            System.out.println("=========获取文件==========");
            downloadSingleFile(sourceFtpClient, localPath, remotePath);
            closeFTPConnect(sourceFtpClient);
    
            System.out.println("=========连接转存目标FTP服务器==========");
            String targetFtpHost = "192.168.0.102";
            int targetFtpPort = 21;
            String targetFtpUserName = "ftpUser";
            String targetFtpPassword = "123456";
            String targetFtpEncoding = "gbk";
            FTPClient targetFtpClient = FtpUtil.connectFtpServer(targetFtpHost, targetFtpPort, targetFtpUserName, targetFtpPassword, targetFtpEncoding);
    
            System.out.println("=========转存文件至目标FTP服务器==========");
            String localFinalPath = localPath + remotePath;
            uploadFiles(targetFtpClient, new File(localFinalPath));
            closeFTPConnect(targetFtpClient);
    
            //删除本地临时文件
            File folder= new File(localPath + "/" + remotePath.split("/")[1]);
            delFolder(folder);
        }
    
        private void delFolder(File folder) throws Exception { 
            if (!folder.exists()) { 
                throw new Exception("文件不存在");
            }
            File[] files = folder.listFiles();
            if (files != null) { 
                for (File file : files) { 
                    if (file.isDirectory()) { 
                        //递归直到目录下没有文件
                        delFolder(file);
                    } else { 
                        //删除
                        file.delete();
                    }
                }
            }
            //删除
            folder.delete();
        }
    
        /** * FTP下载文件夹 * @throws Exception */
        @Test
        public void downloadDir() throws Exception { 
            System.out.println("=========连接文件源FTP服务器==========");
            String sourceFtpHost = "192.168.0.222";
            int sourceFtpPort = 21;
            String sourceFtpUserName = "test";
            String sourceFtpPassword = "123456";
            String sourceFtpEncoding = "gbk";
            String localDirectoryPath = "F:/ftp/ftpDownload/";
            String remoteDirectory = "/home/test/dir001/";
            FTPClient sourceFtpClient = FtpUtil.connectFtpServer(sourceFtpHost, sourceFtpPort, sourceFtpUserName, sourceFtpPassword, sourceFtpEncoding);
    
            downLoadDirectory(sourceFtpClient, localDirectoryPath, remoteDirectory);
            closeFTPConnect(sourceFtpClient);
        }
    
        /** * 上传文件夹 * @throws Exception */
        @Test
        public void uploadDir() throws Exception { 
            System.out.println("=========连接文件源FTP服务器==========");
            String sourceFtpHost = "192.168.0.222";
            int sourceFtpPort = 21;
            String sourceFtpUserName = "test";
            String sourceFtpPassword = "123456";
            String sourceFtpEncoding = "gbk";
            String localDirectory = "F:/ftp/ftpDownload/dir001/";
            String remoteDirectoryPath = "/home/test/";
            FTPClient sourceFtpClient = FtpUtil.connectFtpServer(sourceFtpHost, sourceFtpPort, sourceFtpUserName, sourceFtpPassword, sourceFtpEncoding);
    
            uploadDirectory(sourceFtpClient, localDirectory, remoteDirectoryPath);
            closeFTPConnect(sourceFtpClient);
    
        }
    
    }

[Link 1]: https://blog.csdn.net/wangmx1993328/article/details/82150290#FTP%20%E8%BF%9E%E6%8E%A5
[Link 2]: https://download.csdn.net/download/yuxielea/12317434