一.概述

FTP是用来传送文件的协议.使用FTP实现远程文件传输的同时,还可以保证数据传输的可靠性和高效性.
FTP是基于TCP传输的,所以数据在传输的过程中可靠性得到了保障,基于TCP20.21端口.

二.传输过程

image.png
客户端 服务器

image.png

三.搭建FTP服务器

1.导包

  1. <dependency>
  2.   <groupId>org.apache.ftpserver</groupId>
  3.   <artifactId>ftpserver-core</artifactId>
  4.   <version>1.1.1</version>
  5.   <scope>compile</scope>
  6. </dependency>

2.代码

  1. package com.example.demo.controller;
  3. import org.apache.ftpserver.FtpServer;
  4. import org.apache.ftpserver.FtpServerFactory;
  5. import org.apache.ftpserver.ftplet.Authority;
  6. import org.apache.ftpserver.ftplet.FtpException;
  7. import org.apache.ftpserver.listener.ListenerFactory;
  8. import org.apache.ftpserver.usermanager.impl.BaseUser;
  9. import org.apache.ftpserver.usermanager.impl.WritePermission;
  11. import java.util.ArrayList;
  12. import java.util.List;
  14. /**
  15. * @Author leaves
  16. * @Date 2022/5/6 19:34
  17. */
  18. public class FileUtilController {
  19.     public static void main(String[] args) throws FtpException {
  20.         FtpServerFactory serverFactory = new FtpServerFactory();
  22.         ListenerFactory factory = new ListenerFactory();
  23.         //设置监听端口
  24.         factory.setPort(2022);
  26.         //替换默认监听
  27.         serverFactory.addListener("default", factory.createListener());
  29.         //用户名
  30.         BaseUser user = new BaseUser();
  31.         user.setName("yourname");
  32.         //密码 如果不设置密码就是匿名用户
  33.         user.setPassword("yourpassword");
  34.         //用户主目录
  35.         user.setHomeDirectory("C:\\images");
  37.         List<Authority> authorities = new ArrayList<Authority>();
  38.         //增加写权限
  39.         authorities.add(new WritePermission());
  40.         user.setAuthorities(authorities);
  42.         //增加该用户
  43.         serverFactory.getUserManager().save(user);
  45.         FtpServer server = serverFactory.createServer();
  46.         server.start();
  47.     }
  48. }

四.连接FTP服务器

1.导包

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

2.配置工具类

  1. package com.example.demo.ftp;
  3. import org.apache.commons.net.ftp.FTP;
  4. import org.apache.commons.net.ftp.FTPClient;
  5. import org.apache.commons.net.ftp.FTPFile;
  6. import org.apache.commons.net.ftp.FTPReply;
  8. import java.io.*;
  9. import java.net.MalformedURLException;
  11. /**
  12.  * @Auther: hrabbit
  13.  * @Date: 2018-04-21 下午12:35
  14.  * @Description:
  15.  */
  16. public class FTPUtils {
  18.     public static FTPClient ftpClient = null;
  20.     /**
  21.      * 初始化ftp服务器
  22.      */
  23.     public static void initFtpClient(String hostname,String username,String password,Integer port) {
  24.         ftpClient = new FTPClient();
  25.         /**
  26.          * 在上传文件的时候，我们的文件名称有时候需要被保留，但是有时候如果文件名称为中文的话，会产生保存失败的现象，因此只需要将FTPClient的编码方式更改为UTF-8模式即可解决
  27.          */
  28.         ftpClient.setControlEncoding("UTF-8");
  29.         try {
  30.             //连接ftp服务器
  31.             ftpClient.connect(hostname, port);
  32.             //登录ftp服务器
  33.             ftpClient.login(username, password);
  34.             //是否成功登录服务器
  35.             int replyCode = ftpClient.getReplyCode();
  36.             if(FTPReply.isPositiveCompletion(replyCode)){
  37.                 System.out.println("ftp服务器登录成功");
  38.             }
  39.         }catch (MalformedURLException e) {
  40.             e.printStackTrace();
  41.         }catch (IOException e) {
  42.             e.printStackTrace();
  43.         }
  44.     }
  46.     /**
  47.      * 上传文件
  48.      * @param pathname ftp服务保存地址
  49.      * @param fileName 上传到ftp的文件名
  50.      * @param inputStream 输入文件流
  51.      * @return
  52.      */
  53.     public static boolean uploadFile(String hostname,String username,String password,Integer port, String pathname, String fileName,InputStream inputStream){
  54.         boolean flag = false;
  55.         try{
  56.             System.out.println("开始上传文件");
  57.             initFtpClient(hostname,username,password,port);
  58.             /**
  59.              * 二进制形式上传文件
  60.              */
  61.             ftpClient.setFileType(FTP.BINARY_FILE_TYPE);
  62.             /**
  63.              * 主动模式和被动模式的不同简单概述为： 主动模式传送数据时是“服务器”连接到“客户端”的端口；被动模式传送数据是“客户端”连接到“服务器”的端口。
  65.                 主动模式需要客户端必须开放端口给服务器，很多客户端都是在防火墙内，开放端口给FTP服务器访问比较困难。
  67.                 被动模式只需要服务器端开放端口给客户端连接就行了。
  69.                 因此只需要将模式改为被动模式即可:
  70.              */
  71.             ftpClient.enterLocalPassiveMode();
  72.             CreateDirecroty(pathname);
  73. //            ftpClient.makeDirectory(pathname);
  74.             ftpClient.setControlEncoding("utf-8");
  75.             ftpClient.storeFile(fileName, inputStream);
  76.             System.out.println("上传结束");
  77.             inputStream.close();
  78.             ftpClient.logout();
  79.             flag = true;
  80.             System.out.println("上传文件成功");
  82.         }catch (Exception e) {
  83.             System.out.println("上传文件失败");
  84.             e.printStackTrace();
  85.         }finally{
  86.             if(ftpClient.isConnected()){
  87.                 try{
  88.                     ftpClient.disconnect();
  89.                 }catch(IOException e){
  90.                     e.printStackTrace();
  91.                 }
  92.             }
  93.             if(null != inputStream){
  94.                 try {
  95.                     inputStream.close();
  96.                 } catch (IOException e) {
  97.                     e.printStackTrace();
  98.                 }
  99.             }
  100.         }
  101.         return true;
  102.     }
  103.     //改变目录路径
  104.     public static boolean changeWorkingDirectory(String directory) {
  105.         boolean flag = true;
  106.         try {
  107.             flag = ftpClient.changeWorkingDirectory(directory);
  108.             if (flag) {
  109.                 System.out.println("进入文件夹" + directory + " 成功！");
  110.             } else {
  111.                 System.out.println("进入文件夹" + directory + " 失败！开始创建文件夹");
  112.             }
  113.         } catch (IOException ioe) {
  114.             ioe.printStackTrace();
  115.         }
  116.         return flag;
  117.     }
  119.     //创建多层目录文件，如果有ftp服务器已存在该文件，则不创建，如果无，则创建
  120.     public static boolean CreateDirecroty(String remote) throws IOException {
  121.         boolean success = true;
  122.         String directory = remote + "/";
  123.         // 如果远程目录不存在，则递归创建远程服务器目录
  124.         if (!directory.equalsIgnoreCase("/") && !changeWorkingDirectory(new String(directory))) {
  125.             int start = 0;
  126.             int end = 0;
  127.             if (directory.startsWith("/")) {
  128.                 start = 1;
  129.             } else {
  130.                 start = 0;
  131.             }
  132.             end = directory.indexOf("/", start);
  133.             String path = "";
  134.             String paths = "";
  135.             while (true) {
  136.                 String subDirectory = new String(remote.substring(start, end).getBytes("UTF-8"), "iso-8859-1");
  137.                 path = path + "/" + subDirectory;
  138.                 if (!existFile(path)) {
  139.                     if (makeDirectory(subDirectory)) {
  140.                         changeWorkingDirectory(subDirectory);
  141.                     } else {
  142.                         System.out.println("创建目录[" + subDirectory + "]失败");
  143.                         changeWorkingDirectory(subDirectory);
  144.                     }
  145.                 } else {
  146.                     changeWorkingDirectory(subDirectory);
  147.                 }
  149.                 paths = paths + "/" + subDirectory;
  150.                 start = end + 1;
  151.                 end = directory.indexOf("/", start);
  152.                 // 检查所有目录是否创建完毕
  153.                 if (end <= start) {
  154.                     break;
  155.                 }
  156.             }
  157.         }
  158.         return success;
  159.     }
  161.     //判断ftp服务器文件是否存在
  162.     public static boolean existFile(String path) throws IOException {
  163.         boolean flag = false;
  164.         FTPFile[] ftpFileArr = ftpClient.listFiles(path);
  165.         if (ftpFileArr.length > 0) {
  166.             flag = true;
  167.         }
  168.         return flag;
  169.     }
  170.     //创建目录
  171.     public static boolean makeDirectory(String dir) {
  172.         boolean flag = true;
  173.         try {
  174.             flag = ftpClient.makeDirectory(dir);
  175.             if (flag) {
  176.                 System.out.println("创建文件夹" + dir + " 成功！");
  178.             } else {
  179.                 System.out.println("创建文件夹" + dir + " 失败！");
  180.             }
  181.         } catch (Exception e) {
  182.             e.printStackTrace();
  183.         }
  184.         return flag;
  185.     }
  187.     /** * 下载文件 *
  188.      * @param pathname FTP服务器文件目录 *
  189.      * @param filename 文件名称 *
  190.      * @param localpath 下载后的文件路径 *
  191.      * @return */
  192.     public static  boolean downloadFile(String hostname,String username,String password,Integer port,String pathname, String filename, String localpath){
  193.         boolean flag = false;
  194.         OutputStream os=null;
  195.         try {
  196.             System.out.println("开始下载文件");
  197.             initFtpClient(hostname,username,password,port);
  198.             //切换FTP目录
  199.             ftpClient.changeWorkingDirectory(pathname);
  200.             FTPFile[] ftpFiles = ftpClient.listFiles();
  201.             for(FTPFile file : ftpFiles){
  202.                 if(filename.equalsIgnoreCase(file.getName())){
  203.                     File localFile = new File(localpath + "/" + file.getName());
  204.                     os = new FileOutputStream(localFile);
  205.                     ftpClient.retrieveFile(file.getName(), os);
  206.                     os.close();
  207.                 }
  208.             }
  209.             ftpClient.logout();
  210.             flag = true;
  211.             System.out.println("下载文件成功");
  212.         } catch (Exception e) {
  213.             System.out.println("下载文件失败");
  214.             e.printStackTrace();
  215.         } finally{
  216.             if(ftpClient.isConnected()){
  217.                 try{
  218.                     ftpClient.disconnect();
  219.                 }catch(IOException e){
  220.                     e.printStackTrace();
  221.                 }
  222.             }
  223.             if(null != os){
  224.                 try {
  225.                     os.close();
  226.                 } catch (IOException e) {
  227.                     e.printStackTrace();
  228.                 }
  229.             }
  230.         }
  231.         return flag;
  232.     }
  234.     /** * 删除文件 *
  235.      * @param pathname FTP服务器保存目录 *
  236.      * @param filename 要删除的文件名称 *
  237.      * @return */
  238.     public static boolean deleteFile(String hostname,String username,String password,Integer port,String pathname, String filename){
  239.         boolean flag = false;
  240.         try {
  241.             System.out.println("开始删除文件");
  242.             initFtpClient(hostname,username,password,port);
  243.             //切换FTP目录
  244.             ftpClient.changeWorkingDirectory(pathname);
  245.             ftpClient.dele(filename);
  246.             ftpClient.logout();
  247.             flag = true;
  248.             System.out.println("删除文件成功");
  249.         } catch (Exception e) {
  250.             System.out.println("删除文件失败");
  251.             e.printStackTrace();
  252.         } finally {
  253.             if(ftpClient.isConnected()){
  254.                 try{
  255.                     ftpClient.disconnect();
  256.                 }catch(IOException e){
  257.                     e.printStackTrace();
  258.                 }
  259.             }
  260.         }
  261.         return flag;
  262.     }
  263. }

3.代码

  1. package com.example.demo;
  3. import com.example.demo.ftp.FTPUtils;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.boot.test.context.SpringBootTest;
  7. import java.io.File;
  8. import java.io.FileInputStream;
  9. import java.io.IOException;
  11. /**
  12. * @author zhangyixuan
  13. * @version 2022.4
  14. * @date 2022/5/6 8:51
  15. */
  16. @SpringBootTest
  17. public class FtpTest {
  19.     /**
  20.     * FTP登录
  21.     */
  22.     @Test
  23.     public void test01(){
  24.         FTPUtils.initFtpClient("localhost", "user", "12345", 2022);
  25.     }
  27.     /**
  28.     * 文件上传
  29.     * @throws IOException
  30.     */
  31.     @Test
  32.     public void test02() throws IOException {
  33.         FTPUtils.uploadFile("localhost", "user", "12345", 2022,"ftp",
  34.                             "test001.jpg",new FileInputStream("D:\\dog.jpg"));
  35.     }
  37.     /**
  38.     * 文件下载
  39.     *
  40.     */
  41.     @Test
  42.     public void test03(){
  43.         FTPUtils.downloadFile("localhost", "user", "12345", 2022,"ftp",
  44.                               "test001.jpg","D:\\Desktop\\ftp");
  45.     }
  47.     /**
  48.     * 删除文件
  49.     * @throws IOException
  50.     */
  51.     @Test
  52.     public void test05() {
  53.         FTPUtils.deleteFile("localhost", "user", "12345", 2022, "ftp","test001.jpg");
  54.     }
  56.     /**
  57.     * 创建文件夹
  58.     */
  59.     @Test
  60.     public void test06(){
  61.         FTPUtils.initFtpClient("localhost", "user", "12345", 2022);
  62.         FTPUtils.makeDirectory("/ftp/666");
  63.     }
  65.     /**
  66.     * 文件夹是否存在
  67.     * @throws IOException
  68.     */
  69.     @Test
  70.     public void test04() throws IOException {
  71.         FTPUtils.initFtpClient("localhost", "user", "12345", 2022);
  72.         System.out.println(FTPUtils.existFile("dog.jpg"));
  73.     }
  74. }