主要演示Java整合FTP后的一些常用基本操作；
    为方便操作，直接使用Maven运行测试；
    在配置文件中引入FTP操作依赖（FTPClient）：

    1.     <dependency>
    2.       <groupId>commons-net</groupId>
    3.       <artifactId>commons-net</artifactId>
    4.       <version>3.6</version>
    5.     </dependency>

    然后直接上代码吧，
    运行类：

    1. import org.apache.commons.net.ftp.FTPClient;
    2. import org.springframework.boot.autoconfigure.SpringBootApplication;
    3. import org.springframework.stereotype.Component;
    5. import java.io.IOException;
    6. import java.util.Scanner;
    8. @Component
    9. @SpringBootApplication
    10. public class App {
    11.     public static void main(String[] args) {
    12.         FTPClient ftpClient = new FTPClient();
    14.         InitFTP initFTP = new InitFTP();
    15.         System.out.println("退出请输入exit，输入其他字符继续操作");
    16.         while (!"exit".equals(new Scanner(System.in).next())) {
    17.             initFTP.initFtpClient(ftpClient);
    18.             System.out.println("请输入操作（上传、下载、删除、移动、读取、写入）：");
    19.             Scanner scanner = new Scanner(System.in);
    20.             String next = scanner.next();
    21.             if ("上传".equals(next)) {
    22.                 UploadFTP uploadFTP = new UploadFTP();
    23.                 String fileName = "ahzoo.txt";
    24.                 String pathName = "\\ftpPath";
    25.                 String originFilename = "E:\\ouo\\ouo.txt";
    26.                 uploadFTP.uploadFile(pathName, fileName, originFilename, ftpClient);
    27.             } else if ("下载".equals(next)) {
    28.                 DownloadFTP downloadFTP = new DownloadFTP();
    29. //            String fileName = "ahzoo.md";
    30.                 String fileName = null;
    31.                 String pathName = "\\ftpPath";
    32.                 String downloadPath = "E:\\ahzoo";
    33.                 downloadFTP.downLoadFTP(pathName, fileName, downloadPath, ftpClient);
    34.             } else if ("删除".equals(next)) {
    35.                 DeleteFTP deleteFTP = new DeleteFTP();
    36. //            String fileName = "ahzoo.md";
    37.                 String fileName = null;
    38.                 String pathName = "\\test";
    39.                 deleteFTP.deleteFTP(pathName, fileName, ftpClient);
    40.             } else if ("移动".equals(next)) {
    41.                 MoveFTP moveFTP = new MoveFTP();
    42.                 String fileName = "ahzoo.txt";
    43.                 String pathName = "\\ftpPath";
    44.                 String moveName = "move.txt";
    45.                 String movePath = "\\ouo";
    46.                 moveFTP.moveFTP(pathName, fileName, movePath, moveName, ftpClient);
    47.             } else if ("读取".equals(next)) {
    48.                 ReadFTP readFTP = new ReadFTP();
    49.                 String fileName = "ahzoo.txt";
    50.                 String pathName = "\\ftpPath";
    51.                 readFTP.readFTP(pathName, fileName, ftpClient);
    52.             } else if ("写入".equals(next)) {
    53.                 WriteFTP writeFTP = new WriteFTP();
    54.                 String fileName = "测试.txt";
    55.                 String pathName = "\\ftpPath";
    56.                 String contentText = "十玖八柒654321";
    57.                 writeFTP.writeFile(pathName, fileName, contentText, ftpClient);
    58.             } else {
    59.                 System.out.println("输入有误");
    60.                 //关闭连接
    61.                 if (ftpClient.isConnected()) {
    62.                     try {
    63.                         ftpClient.disconnect();
    64.                     } catch (IOException e) {
    65.                         e.printStackTrace();
    66.                     }
    67.                 }
    69.             }
    70.             System.out.println("退出请输入exit，输入其他字符继续操作");
    73.         }
    75.     }
    76. }

    FTP连接类：

    1. import org.apache.commons.net.ftp.FTPClient;
    2. import org.apache.commons.net.ftp.FTPReply;
    4. import java.io.IOException;
    5. import java.net.MalformedURLException;
    6. /**
    7.  * 连接FTP服务链接
    8.  */
    9. public class InitFTP {
    11.     //ftp服务器IP
    12.     private static final String host = "192.168.6.125";
    13.     //ftp服务器端口号默认为21
    14.     private static final Integer port = 21;
    15.     //ftp登录账号
    16.     private static final String username = "ahzoo";
    17.     //ftp登录密码
    18.     private static final String password = "123";
    20.     public void initFtpClient(FTPClient ftpClient) {
    21.         ftpClient.setControlEncoding("utf-8"); //设置编码
    22.         try {
    23.             System.out.println("正在连接FTP服务器:" + host + ":" + port);
    24.             ftpClient.connect(host, port); //连接ftp服务器
    25.             ftpClient.login(username, password); //登录ftp服务器
    26.             int replyCode = ftpClient.getReplyCode(); //是否成功登录服务器
    27.             if(!FTPReply.isPositiveCompletion(replyCode)){
    28.                 System.out.println("FTP服务器连接失败:" + host + ":" + port);
    29.             }
    30.             System.out.println("FTP服务器连接成功:" + host + ":" + port);
    31.         }catch (MalformedURLException e) {
    32.             e.printStackTrace();
    33.         }catch (IOException e) {
    34.             e.printStackTrace();
    35.         }
    36.     }
    37. }

    操作相关类：

    上传文件：

    1. import org.apache.commons.net.ftp.FTPClient;
    3. import java.io.File;
    4. import java.io.FileInputStream;
    5. import java.io.IOException;
    6. import java.io.InputStream;
    9. public class UploadFTP {
    10.     /**
    11.      * 文件上传
    12.      * @param pathName 文件上传到ftp服务器的路径
    13.      * @param fileName 文件上传到ftp服务器的名称
    14.      * @param originPath 要上传文件所在的路径（绝对路径）
    15.      **/
    16.     public void uploadFile(String pathName, String fileName, String originPath, FTPClient ftpClient){
    17.         InputStream inputStream = null;
    18.         try{
    19.             System.out.println("文件传输中");
    20.             inputStream = new FileInputStream(new File(originPath));//将文本数据转换为输入流
    22.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    23.             ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);//以二进制文件形式输入
    24.             ftpClient.makeDirectory(pathName);//在ftp服务器创建目标路径
    25.             ftpClient.changeWorkingDirectory(pathName);//切换到目标路径
    26.             ftpClient.enterLocalPassiveMode();//开启端口
    27.             ftpClient.storeFile(fileName, inputStream);//开始上传，inputStream表示数据源。
    28.             //ftpClient.storeFile(new String(fileName.getBytes("UTF-8"),"ISO-8859-1") inputStream);
    31.             System.out.println("文件上传操作完成");
    32.         }catch (Exception e) {
    33.             System.out.println("文件上传失败");
    34.             e.printStackTrace();
    35.         }finally{
    36.             //关闭连接
    37.             if(ftpClient.isConnected()){
    38.                 try{
    39.                     ftpClient.disconnect();
    40.                 }catch(IOException e){
    41.                     e.printStackTrace();
    42.                 }
    43.             }
    44.             if(null != inputStream){
    45.                 try {
    46.                     inputStream.close();
    47.                 } catch (IOException e) {
    48.                     e.printStackTrace();
    49.                 }
    50.             }
    51.         }
    52.     }
    53. }

    下载文件：

    2. import java.io.File;
    3. import java.io.FileOutputStream;
    4. import java.io.IOException;
    5. import java.io.OutputStream;
    7. public class DownloadFTP {
    8.     /**
    9.      * 文件下载（暂未实现下载路径内子文件中文件功能）
    10.      * @param pathName     要下载文件所在ftp路径
    11.      * @param fileName     要下载文件所在ftp的文件名
    12.      * @param downloadPath 文件下载后保存的路径
    13.      * @param ftpClient    FTPClient对象
    14.      */
    15.     public void downLoadFTP(String pathName, String fileName, String downloadPath, FTPClient ftpClient) {
    17.         OutputStream outputStream = null;
    18.         try {
    19.             ftpClient.changeWorkingDirectory(pathName);// 跳转到文件目录
    20.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    22.             if (fileName != null && fileName != "") {
    23.                 //文件名不为空，下载指定文件
    24.                 File filePath = new File(downloadPath);
    25.                 if (!filePath.exists()) {
    26.                     filePath.mkdir();//目录不存在，创建目录
    27.                 }
    28.                 outputStream = new FileOutputStream(new File(downloadPath + File.separator + fileName));
    29.                 ftpClient.retrieveFile(fileName, outputStream);
    30.                 System.out.println("下载操作完成");
    31.             } else {
    32.                 FTPFile[] files = ftpClient.listFiles();//获取目录下文件集合
    33.                 //文件名为空，下载路径下所有文件（不包含文件夹）
    34.                 for (FTPFile file : files) {
    35.                     File filePath = new File(downloadPath);
    36.                     if (!filePath.exists()) {
    37.                         filePath.mkdir();//目录不存在，创建目录
    38.                     }
    39.                     File downloadFile = new File(downloadPath + File.separator + file.getName());
    40.                     outputStream = new FileOutputStream(downloadFile);
    41.                     ftpClient.retrieveFile(file.getName(), outputStream);
    43.                     System.out.println("下载操作完成：" + downloadFile);
    44.                 }
    45.             }
    47.         } catch (Exception e) {
    48.             System.out.println("下载失败");
    49.             e.printStackTrace();
    50.         } finally {
    51.             //关闭连接
    52.             if(ftpClient.isConnected()){
    53.                 try{
    54.                     ftpClient.disconnect();
    55.                 }catch(IOException e){
    56.                     e.printStackTrace();
    57.                 }
    58.             }
    59.             if(null != outputStream){
    60.                 try {
    61.                     outputStream.close();
    62.                 } catch (IOException e) {
    63.                     e.printStackTrace();
    64.                 }
    65.             }
    66.         }
    68.     }
    70. }

    删除：

    2. import org.apache.commons.net.ftp.FTPClient;
    3. import org.apache.commons.net.ftp.FTPFile;
    5. import java.io.File;
    6. import java.io.IOException;
    8. public class DeleteFTP {
    9.     /**
    10.      * 文件删除 （暂未实现删除路径内子文件夹功能）
    11.      * @param pathName     要删除文件/目录所在ftp路径
    12.      * @param fileName     要删除文件所在ftp的文件名
    13.      * @param ftpClient    FTPClient对象
    14.      */
    15.     public void deleteFTP(String pathName, String fileName, FTPClient ftpClient) {
    17.         try {
    18.             ftpClient.changeWorkingDirectory(pathName);// 跳转到文件目录
    19.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    20.             if (fileName != null && fileName != "") {
    21.                 //文件名不为空，删除指定文件
    22.                 ftpClient.deleteFile(pathName + File.separator + fileName);
    23.                 System.out.println("删除成功");
    24.             } else {
    25.                 //文件名为空，删除路径下所有文件
    26.                 System.out.println("正在删除");
    27.                 //删除文件
    28.                 FTPFile[] files = ftpClient.listFiles();//获取目录下文件集合
    29.                 for (FTPFile file : files) {
    31.                     if (file.isFile()) {
    32.                         //判断为文件，直接删除
    33.                         ftpClient.deleteFile(pathName + File.separator + file.getName());
    34.                         System.out.println(file + "：已完成删除操作");
    35.                     }
    36.                     if (file.isDirectory()) {
    37.                         /*有点问题，建议使用线程优化
    39.                         //判断是文件夹，递归删除子文件夹内文件
    40.                         deleteFTP(pathName + File.separator + file.getName(), null, ftpClient);
    41.                         */
    42.                     }
    43.                 }
    44.                 //删除文件夹
    45.                 ftpClient.removeDirectory(pathName);
    46.                 System.out.println("删除操作完成");
    47.             }
    48.         } catch (Exception e) {
    49.             System.out.println("删除失败");
    50.             e.printStackTrace();
    51.         } finally {
    52.             //关闭连接
    53.             if(ftpClient.isConnected()){
    54.                 try{
    55.                     ftpClient.disconnect();
    56.                 }catch(IOException e){
    57.                     e.printStackTrace();
    58.                 }
    59.             }
    60.         }
    62.     }
    63. }

    移动：

    1. import org.apache.commons.net.ftp.FTPClient;
    2. import org.apache.commons.net.ftp.FTPFile;
    4. import java.io.File;
    5. import java.io.IOException;
    7. public class MoveFTP {
    8.     /**
    9.      * 文件移动/重命名
    10.      * @param pathName     要移动文件所在ftp路径
    11.      * @param fileName     要移动文件所在ftp的文件名
    12.      * @param movePath     文件移动后的路径
    13.      * @param moveName     文件移动后的文件名（与源文件一致时实现只移动不重命名，不一致则实现了移动+重命名）
    14.      * @param ftpClient    FTPClient对象
    15.      */
    16.     public void moveFTP(String pathName, String fileName, String movePath, String moveName, FTPClient ftpClient) {
    17.         try {
    18.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    19.             if (!ftpClient.changeWorkingDirectory(movePath)) {
    20.                 //跳转到目标路径失败时创建目标目录
    21.                 ftpClient.makeDirectory(movePath);
    22.             }
    23.             if (moveName != null && moveName != "") {
    24.                 ftpClient.changeWorkingDirectory(pathName);// 跳转回需要进行操作的目录
    25.                 //移动后的文件名不为空，移动目标文件
    26.                 //ftpClient.rename(旧文件名, 新路径)
    27.                 ftpClient.rename(fileName, movePath + File.separator + moveName);
    28.                 System.out.println("文件移动操作已完成：" + movePath + File.separator + moveName);
    29.             } else {
    30.                 //移动后的文件名为空，移动目标路径所有文件
    32.                 ftpClient.changeWorkingDirectory(pathName);// 跳转回需要进行操作的目录
    33.                 FTPFile[] files = ftpClient.listFiles();//获取目录下文件集合
    35.                 for (FTPFile file : files) {
    36.                     ftpClient.rename(file.getName(), movePath + File.separator + file.getName());
    37.                     System.out.println("移动操作完成：" + file.getName());
    38.                 }
    39.             }
    41.         } catch (Exception e) {
    42.             System.out.println("移动失败");
    43.             e.printStackTrace();
    44.         } finally {
    45.             //关闭连接
    46.             if(ftpClient.isConnected()){
    47.                 try{
    48.                     ftpClient.disconnect();
    49.                 }catch(IOException e){
    50.                     e.printStackTrace();
    51.                 }
    52.             }
    53.         }
    55.     }
    57. }
    60. import org.apache.commons.net.ftp.FTPClient;
    61. import org.apache.commons.net.ftp.FTPFile;
    63. import java.io.File;
    64. import java.io.IOException;
    66. public class MoveFTP {
    67.     /**
    68.      * 文件移动/重命名
    69.      * @param pathName     要移动文件所在ftp路径
    70.      * @param fileName     要移动文件所在ftp的文件名
    71.      * @param movePath     文件移动后的路径
    72.      * @param moveName     文件移动后的文件名（与源文件一致时实现只移动不重命名，不一致则实现了移动+重命名）
    73.      * @param ftpClient    FTPClient对象
    74.      */
    75.     public void moveFTP(String pathName, String fileName, String movePath, String moveName, FTPClient ftpClient) {
    76.         try {
    77.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    78.             if (!ftpClient.changeWorkingDirectory(movePath)) {
    79.                 //跳转到目标路径失败时创建目标目录
    80.                 ftpClient.makeDirectory(movePath);
    81.             }
    82.             if (moveName != null && moveName != "") {
    83.                 ftpClient.changeWorkingDirectory(pathName);// 跳转回需要进行操作的目录
    84.                 //移动后的文件名不为空，移动目标文件
    85.                 //ftpClient.rename(旧文件名, 新路径)
    86.                 ftpClient.rename(fileName, movePath + File.separator + moveName);
    87.                 System.out.println("文件移动操作已完成：" + movePath + File.separator + moveName);
    88.             } else {
    89.                 //移动后的文件名为空，移动目标路径所有文件
    91.                 ftpClient.changeWorkingDirectory(pathName);// 跳转回需要进行操作的目录
    92.                 FTPFile[] files = ftpClient.listFiles();//获取目录下文件集合
    94.                 for (FTPFile file : files) {
    95.                     ftpClient.rename(file.getName(), movePath + File.separator + file.getName());
    96.                     System.out.println("移动操作完成：" + file.getName());
    97.                 }
    98.             }
    100.         } catch (Exception e) {
    101.             System.out.println("移动失败");
    102.             e.printStackTrace();
    103.         } finally {
    104.             //关闭连接
    105.             if(ftpClient.isConnected()){
    106.                 try{
    107.                     ftpClient.disconnect();
    108.                 }catch(IOException e){
    109.                     e.printStackTrace();
    110.                 }
    111.             }
    112.         }
    114.     }
    116. }

    读取：

    1. import org.apache.commons.net.ftp.FTPClient;
    2. import org.apache.commons.net.ftp.FTPFile;
    4. import java.io.*;
    6. public class ReadFTP {
    7.     /**
    8.      * 文件读取（暂未实现读取路径内子文件中文件功能）
    9.      * @param pathName     要解析文件所在ftp路径
    10.      * @param fileName     要下载文件所在ftp的文件名
    11.      * @param ftpClient    FTPClient对象
    12.      */
    13.     public void readFTP(String pathName, String fileName, FTPClient ftpClient) {
    15.         InputStream inputStream = null;
    16.         BufferedReader reader = null;
    17.         try {
    18.             ftpClient.changeWorkingDirectory(pathName);// 跳转到文件目录
    19.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    21.             if (fileName != null && fileName != "") {
    22.                 //文件名不为空，读取指定文件
    23.                 inputStream = ftpClient.retrieveFileStream(fileName);
    24.                 reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
    25.                 String fileL;
    26.                 StringBuffer buffer = new StringBuffer();
    27.                 while(((fileL=reader.readLine()) != null)){
    28.                     buffer.append(fileL);
    29.                 }
    30.                 System.out.println(fileName + ":" + buffer.toString());
    32.             } else {
    33.                 FTPFile[] files = ftpClient.listFiles();//获取目录下文件集合
    34.                 //文件名为空，下载路径下所有文件（不包含文件夹）
    35.                 for (FTPFile file : files) {
    36.                     inputStream = ftpClient.retrieveFileStream(fileName);
    37.                     reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
    38.                     String fileL;
    39.                     StringBuffer buffer = new StringBuffer();
    41.                     while(((fileL=reader.readLine()) != null)){
    42.                         buffer.append(fileL + "\n");
    43.                     }
    44.                     System.out.println(file + ":" + buffer.toString());
    45.                 }
    46.             }
    48.         } catch (Exception e) {
    49.             System.out.println("读取失败");
    50.             e.printStackTrace();
    51.         } finally {
    52.             //关闭连接
    53.             if(ftpClient.isConnected()){
    54.                 try{
    55.                     ftpClient.disconnect();
    56.                 }catch(IOException e){
    57.                     e.printStackTrace();
    58.                 }
    59.             }
    60.             if(null != inputStream){
    61.                 try {
    62.                     inputStream.close();
    63.                 } catch (IOException e) {
    64.                     e.printStackTrace();
    65.                 }
    66.             }
    67.             if(null != reader) {
    68.                 try {
    69.                     reader.close();
    70.                 } catch (IOException e) {
    71.                     e.printStackTrace();
    72.                 }
    73.             }
    74.         }
    76.     }
    78. }

    写入：

    写入操作与上传操作基本一致，唯一不同的就是写入操作是将文本转换为流，上传是读取文件后转换为流

    1. import org.apache.commons.net.ftp.FTPClient;
    3. import java.io.*;
    5. public class WriteFTP {
    6.     /**
    7.      * 文本写入
    8.      * @param pathName 文本写入到ftp服务器的路径
    9.      * @param fileName 文本写入到ftp服务器的名称
    10.      * @param contentText 要写入的文本数据
    11.      **/
    12.     public void writeFile(String pathName, String fileName, String contentText, FTPClient ftpClient){
    13.         InputStream inputStream = null;
    14.         try{
    15.             System.out.println("开始写入操作");
    16.             inputStream = new ByteArrayInputStream(contentText.getBytes());//将文本数据转换为输入流，通过getBytes()方法避免中文乱码
    18.             ftpClient.enterLocalPassiveMode(); //设置被动模式传输
    19.             ftpClient.setFileType(ftpClient.BINARY_FILE_TYPE);//以二进制文件形式输入
    20.             ftpClient.makeDirectory(pathName);//在ftp服务器创建目标路径
    21.             ftpClient.changeWorkingDirectory(pathName);//切换到目标路径
    22.             ftpClient.enterLocalPassiveMode();//开启端口
    23.             ftpClient.storeFile(fileName, inputStream);//开始写入，inputStream表示数据源。
    25.             System.out.println("文本写入操作完成");
    26.         }catch (Exception e) {
    27.             System.out.println("文本写入失败");
    28.             e.printStackTrace();
    29.         }finally{
    30.             //关闭连接
    31.             if(ftpClient.isConnected()){
    32.                 try{
    33.                     ftpClient.disconnect();
    34.                 }catch(IOException e){
    35.                     e.printStackTrace();
    36.                 }
    37.             }
    38.             if(null != inputStream){
    39.                 try {
    40.                     inputStream.close();
    41.                 } catch (IOException e) {
    42.                     e.printStackTrace();
    43.                 }
    44.             }
    45.         }
    46.     }
    47. }