devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Windows10中搭建ftp服务器以实现文件传输_windows10配置ftp服务器

作者：你好赵伟 | 2024-03-08 00:54:38

赞

踩

windows10配置ftp服务器

开启ftp服务：

1、打开控制面板=====》程序和功能=====》 启用或关闭Windows功能

 

2、找到Internet Information Services，开启以下服务

 

 

 勾选之后，ftp服务开启成功。

配置IIS，搭建ftp

 1、Win+S键搜索iis，回车打开=====》右击网站 =====》添加FTP站点

 

在这里插入图片描述

填写FTP站点名称和物理路径，下一步。 

 

 填写IP地址（可直接填写0.0.0.0），选中无SSL，下一步

 全勾上，完成。

 ftp服务搭建完成！

使用文件传输工具测试是否可以连接ftp：

 填写ip地址和端口号，点击连接，弹出一个窗口的话点击确认

 如果能看到右下角的目录，且目录正确则表示连接成功，ftp可用

注意：如果要使用另一台电脑进行连接，则需要将两台电脑连在同一个局域网下，并且关闭作为ftp服务器主机的防火墙。 

如果无法连接，可以关闭防火墙和杀毒软件。

 

上面的全部关闭。

接着打开控制面板=====》Windows Defender防火墙=====》允许应用或功能通过防火墙

 

 更改设置=====》找到FTP服务器，勾选=====》允许其他应用

浏览=====》找到对应目录 

 

 点击打开，添加，确定。

 再试试能否连接ftp服务器。

ftpUtil工具类：

  1. package com.kgc.ymw.util;
  2.  
  3. import org.apache.commons.net.ftp.*;
  4.  
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.util.ArrayList;
  10. import java.util.Collections;
  11. import java.util.List;
  12. import java.util.StringTokenizer;
  13.  
  14. /**
  15.  * @author： BruceYoung
  16.  * @date: 2023/5/23
  17.  */
  18. @SuppressWarnings({"all"})
  19. public class FtpUtil {
  20.  
  21.     private String Control_Encoding = "UTF-8";
  22.  
  23.     private FTPClient client = null;
  24.  
  25.     private String host = "";
  26.     private int port = 21;
  27.     private String user = "";
  28.     private String password = "";
  29.     private String ftpPath = "/";
  30.  
  31.     @SuppressWarnings("unused")
  32.     private FtpUtil() {
  33.     }
  34.  
  35.     public FtpUtil(String host, int port, String user, String pwd) {
  36.         this.host = host;
  37.         this.port = port;
  38.         this.user = user;
  39.         this.password = pwd;
  40.     }
  41.  
  42.     /**
  43.      * 获取当前FTP所在目录位置
  44.      *
  45.      * @return
  46.      */
  47.     public String getHome() {
  48.         return this.ftpPath;
  49.     }
  50.  
  51.     /**
  52.      * 连接FTP Server
  53.      *
  54.      * @throws IOException
  55.      */
  56.     public static final String ANONYMOUS_USER = "anonymous";
  57.  
  58.     public void connect() throws Exception {
  59.         if (client == null) {
  60.             client = new FTPClient();
  61.         }
  62.         // 已经连接
  63.         if (client.isConnected()) {
  64.             return;
  65.         }
  66.  
  67.         // 编码
  68.         client.setControlEncoding(Control_Encoding);
  69.  
  70.         try {
  71.             // 连接FTP Server
  72.             client.connect(this.host, this.port);
  73.             // 登陆
  74.             if (this.user == null || "".equals(this.user)) {
  75.                 // 使用匿名登陆
  76.                 client.login(ANONYMOUS_USER, ANONYMOUS_USER);
  77.             } else {
  78.                 client.login(this.user, this.password);
  79.             }
  80.             // 设置文件格式
  81.             client.setFileType(FTPClient.BINARY_FILE_TYPE);
  82.             // 获取FTP Server 应答
  83.             int reply = client.getReplyCode();
  84.             if (!FTPReply.isPositiveCompletion(reply)) {
  85.                 client.disconnect();
  86.                 throw new Exception("connection FTP fail!");
  87.             }
  88.  
  89.             FTPClientConfig config = new FTPClientConfig(client.getSystemType().split(" ")[0]);
  90.             config.setServerLanguageCode("zh");
  91.             client.configure(config);
  92.             // 使用被动模式设为默认
  93.             client.enterLocalPassiveMode();
  94.             // 二进制文件支持
  95.             client.setFileType(FTP.BINARY_FILE_TYPE);
  96.             // 设置模式
  97.             client.setFileTransferMode(FTP.STREAM_TRANSFER_MODE);
  98.  
  99.         } catch (IOException e) {
  100.             throw new Exception("connection FTP fail! " + e);
  101.         }
  102.     }
  103.  
  104.     /**
  105.      * 断开FTP连接
  106.      *
  107.      * @param ftpClient
  108.      * @throws IOException
  109.      */
  110.     public void close() {
  111.         if (client != null && client.isConnected()) {
  112.             try {
  113.                 client.logout();
  114.                 client.disconnect();
  115.             } catch (IOException e) {
  116.                 e.printStackTrace();
  117.             }
  118.         }
  119.     }
  120.  
  121.     /**
  122.      * 获取文件列表
  123.      *
  124.      * @return
  125.      */
  126.     public List<FTPFile> list() {
  127.         List<FTPFile> list = null;
  128.         try {
  129.             FTPFile ff[] = client.listFiles(ftpPath);
  130.             if (ff != null && ff.length > 0) {
  131.                 list = new ArrayList<FTPFile>(ff.length);
  132.                 Collections.addAll(list, ff);
  133.             } else {
  134.                 list = new ArrayList<FTPFile>(0);
  135.             }
  136.         } catch (IOException e) {
  137.             e.printStackTrace();
  138.         }
  139.         return list;
  140.     }
  141.  
  142.     /**
  143.      * 切换目录
  144.      *
  145.      * @param path
  146.      *            需要切换的目录
  147.      * @param forcedIncrease
  148.      *            如果目录不存在，是否增加
  149.      */
  150.     public void switchDirectory(String path, boolean forcedIncrease) {
  151.         try {
  152.             if (path != null && !"".equals(path)) {
  153.                 boolean ok = client.changeWorkingDirectory(path);
  154.                 if (ok) {
  155.                     this.ftpPath = path;
  156.                 } else if (forcedIncrease) {
  157.                     // ftpPath 不存在，手动创建目录
  158.                     StringTokenizer token = new StringTokenizer(path, "\\//");
  159.                     while (token.hasMoreTokens()) {
  160.                         String npath = token.nextToken();
  161.                         client.makeDirectory(npath);
  162.                         client.changeWorkingDirectory(npath);
  163.                         if (ok) {
  164.                             this.ftpPath = path;
  165.                         }
  166.                     }
  167.                 }
  168.             }
  169.         } catch (Exception e) {
  170.             e.printStackTrace();
  171.         }
  172.     }
  173.  
  174.     /**
  175.      * 创建目录
  176.      *
  177.      * @param path
  178.      */
  179.     public void createDirectory(String path) {
  180.         try {
  181.             if (path != null && !"".equals(path)) {
  182.                 boolean ok = client.changeWorkingDirectory(path);
  183.                 if (!ok) {
  184.                     // ftpPath 不存在，手动创建目录
  185.                     StringTokenizer token = new StringTokenizer(path, "\\//");
  186.                     while (token.hasMoreTokens()) {
  187.                         String npath = token.nextToken();
  188.                         client.makeDirectory(npath);
  189.                         client.changeWorkingDirectory(npath);
  190.                     }
  191.                 }
  192.             }
  193.             client.changeWorkingDirectory(this.ftpPath);
  194.         } catch (Exception e) {
  195.             e.printStackTrace();
  196.         }
  197.     }
  198.  
  199.     /**
  200.      * 删除目录，如果目录中存在文件或者文件夹则删除失败
  201.      *
  202.      * @param path
  203.      * @return
  204.      */
  205.     public boolean deleteDirectory(String path) {
  206.         boolean flag = false;
  207.         try {
  208.             flag = client.removeDirectory(path);
  209.         } catch (IOException e) {
  210.             e.printStackTrace();
  211.         }
  212.         return flag;
  213.     }
  214.  
  215.     /**
  216.      * 删除文件
  217.      *
  218.      * @param path
  219.      * @return
  220.      */
  221.     public boolean deleteFile(String path) {
  222.         boolean flag = false;
  223.         try {
  224.             flag = client.deleteFile(path);
  225.         } catch (IOException e) {
  226.             e.printStackTrace();
  227.         }
  228.         return flag;
  229.     }
  230.  
  231.     /**
  232.      * 上传文件，上传文件只会传到当前所在目录
  233.      *
  234.      * @param localFile
  235.      *            本地文件
  236.      * @return
  237.      */
  238.     public boolean upload(File localFile) {
  239.         return this.upload(localFile, "");
  240.     }
  241.  
  242.     /**
  243.      * 上传文件，会覆盖FTP上原有文件
  244.      *
  245.      * @param localFile
  246.      *            本地文件
  247.      * @param reName
  248.      *            重名
  249.      * @return
  250.      */
  251.     public boolean upload(File localFile, String reName) {
  252.         boolean flag = false;
  253.         String targetName = reName;
  254.         // 设置上传后文件名
  255.         if (reName == null || "".equals(reName)) {
  256.             targetName = localFile.getName();
  257.         }
  258.         FileInputStream fis = null;
  259.         try {
  260.             // 开始上传文件
  261.             fis = new FileInputStream(localFile);
  262.             client.setControlEncoding(Control_Encoding);
  263.             client.setFileType(FTPClient.BINARY_FILE_TYPE);
  264.             boolean ok = client.storeFile(targetName, fis);
  265.             if (ok) {
  266.                 flag = true;
  267.             }
  268.         } catch (IOException e) {
  269.             e.printStackTrace();
  270.         }
  271.         return flag;
  272.     }
  273.  
  274.     /**
  275.      * 下载文件，如果存在会覆盖原文件
  276.      *
  277.      * @param ftpFileName
  278.      *            文件名称，FTP上的文件名称
  279.      * @param savePath
  280.      *            保存目录，本地保存目录
  281.      * @return
  282.      */
  283.     public boolean download(String ftpFileName, String savePath) {
  284.         boolean flag = false;
  285.  
  286.         File dir = new File(savePath);
  287.  
  288.         if (!dir.exists()) {
  289.             dir.mkdirs();
  290.         }
  291.  
  292.         FileOutputStream fos = null;
  293.         try {
  294.             String saveFile = dir.getAbsolutePath() + File.separator + ftpFileName;
  295.             fos = new FileOutputStream(new File(saveFile));
  296.             boolean ok = client.retrieveFile(ftpFileName, fos);
  297.             if (ok) {
  298.                 flag = true;
  299.             }
  300.         } catch (IOException e) {
  301.             e.printStackTrace();
  302.         }
  303.         return flag;
  304.     }
  305.  
  306.     public static void main(String args[]) {
  307.  
  308.         // 创建FTP对象
  309.         FtpUtil ftp = new FtpUtil("127.0.0.1", 21, "myftp", "myftp@2020");
  310.         try {
  311.             // 连接FTP
  312.             ftp.connect();
  313.  
  314.             // 移动工作空间、切换目录
  315.             System.out.println("当前位置：" + ftp.getHome());
  316.             ftp.switchDirectory("/test", true);
  317.             System.out.println("当前位置：" + ftp.getHome());
  318.  
  319.             // 查询目录下的所有文件夹以及文件
  320.             List<FTPFile> list = ftp.list();
  321.             System.out.println("|-- " + ftp.getHome());
  322.             for (FTPFile f : list) {
  323.                 System.out.println(" |-- [" + (f.getType() == 0 ? "文件" : "文件夹") + "]" + f.getName());
  324.             }
  325.  
  326.             // 上传文件
  327.             boolean r1 = ftp.upload(new File("C:\\Users\\joymt\\Documents\\ftp\\测试文件1.txt"), "测试文件2.txt");
  328.             System.out.println("上传文件：" + r1);
  329.  
  330.             // 下载文件
  331.             boolean r2 = ftp.download("测试文件2.txt", "C:\\Users\\joymt\\Documents\\ftp");
  332.             System.out.println("下载文件：" + r2);
  333.  
  334.             // 删除文件
  335.             boolean r3 = ftp.deleteFile("/test/测试文件2.txt");
  336.             System.out.println("删除文件：" + r3);
  337.  
  338.             // 删除目录
  339.             boolean r4 = ftp.deleteDirectory("/test");
  340.             System.out.println("删除目录：" + r4);
  341.  
  342.         } catch (Exception e) {
  343.             e.printStackTrace();
  344.         }
  345.  
  346.         ftp.close();
  347.     }
  348.  
  349. }

工具类最后有测试代码。

ftp依赖：

  1.         <!-- ftp文件上传依赖 -->
  2.         <dependency>
  3.             <groupId>commons-net</groupId>
  4.             <artifactId>commons-net</artifactId>
  5.             <version>3.6</version>
  6.         </dependency>

文件上传代码：

  1. public Map<String, Object> insertSelective(Product product, MultipartFile file, HttpServletRequest request) throws Exception {
  2.         HashMap<String, Object> map = new HashMap<>();
  3.         String filename = file.getOriginalFilename();
  4.         String extension = FilenameUtils.getExtension(filename);
  5.         if (!(extension.equals("png") || extension.equals("pneg") || extension.equals("jpg") || extension.equals("jpeg"))) {
  6.             map.put("msg", "文件格式不正确");
  7.             return map;
  8.         }
  9.         if (file.getSize() == 0) {
  10.             map.put("msg", "文件不能为空");
  11.             return map;
  12.         }
  13.         if (file.getSize() > 5 * 1024 * 1024) {
  14.             map.put("msg", "文件大小超过5M");
  15.             return map;
  16.         }
  17.         String newFilename = UUID.randomUUID().toString() + "." + extension;
  18.  
  19.         // 创建FTP对象
  20.         FtpUtil ftp = new FtpUtil("127.0.0.1", 21, null , null);
  21.         // 连接FTP
  22.         ftp.connect();
  23.         System.out.println("当前位置：" + ftp.getHome());
  24.         String path = request.getSession().getServletContext().getRealPath("upload");
  25.         File file1 = new File(path, newFilename);
  26.         if (!file1.exists()){
  27.             file1.mkdirs();
  28.         }
  29.         file.transferTo(new File(path, newFilename));
  30.         // 上传文件
  31.         boolean r1 = ftp.upload(file1, newFilename);
  32.         System.out.println("上传文件：" + r1);
  33.         //关闭连接
  34.         ftp.close();
  35.  
  36.         if (StringUtils.isEmpty(product.getCategorylevel2id())) {
  37.             product.setCategorylevel2id(0);
  38.         }
  39.         if (StringUtils.isEmpty(product.getCategorylevel3id())) {
  40.             product.setCategorylevel3id(0);
  41.         }
  42.         product.setId(UUID.randomUUID().toString());
  43.         product.setIsdelete(0);
  44.         product.setFilename(newFilename);
  45.         product.setCreatedate(new Date());
  46.  
  47.         if (productMapper.insertSelective(product) != 1) {
  48.             throw new Exception("数据库添加失败！");
  49.         }
  50.         solrClient.addBean(product);
  51.         solrClient.commit();
  52.  
  53.         return map;
  54.     }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/208414
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号