FTPClient相关

最新推荐文章于 2023-05-27 22:47:32 发布
最新推荐文章于 2023-05-27 22:47:32 发布
阅读量2.5k 收藏
点赞数
分类专栏： ftp 文章标签： FTPClient ftp java

首先，你需要安装Ftp服务器：
http://jingyan.baidu.com/article/574c5219d466c36c8d9dc138.html
接下来看代码：

使用Apache Commons Net包实现javaFTP来上传目录

复杂的地方体现在文件夹的上传。

在前面层用Apache Commons Net工具包实现了Java FTP单个文件的上传下载功能，这次，实现的是对一个本地目录的上传，实现费了很大劲，虽然实现了 ，但是感觉还是对此封装不是非常满意，改用了其他的FTP客户端工具。将这个半成品放出来供各位研究吧。

ftpconfig.properties
username=admin 
password=123 
ip=192.168.14.117 
port=21

package comftp; 

import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
import org.apache.commons.net.ftp.FTP; 
import org.apache.commons.net.ftp.FTPClient; 
import org.apache.commons.net.ftp.FTPClientConfig; 
import org.apache.commons.net.ftp.FTPReply; 

import java.io.*; 
import java.net.SocketException; 
import java.text.SimpleDateFormat; 
import java.util.Properties; 

/** 
* Created by IntelliJ IDEA. 
* 
* @author leizhimin 2008-9-12 10:32:39 
*/ 
public class FtpTest { 
        public static Log logger = LogFactory.getLog(FtpTest.class); 

        private static String userName;         //FTP 登录用户名 
        private static String password;         //FTP 登录密码 
        private static String ip;                     //FTP 服务器地址IP地址 
        private static int port;                        //FTP 端口 
        private static Properties property = null;    //属性集 
        private static String configFile = "E:\\test\\comftp\\ftpconfig.properties";    //配置文件的路径名 
        private static FTPClient ftpClient = null; //FTP 客户端代理 
        //时间格式化 
        private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm"); 
        //FTP状态码 
        public static int i = 1; 

        public static void main(String[] args) { 
                connectServer(); 
                setFileType(FTP.BINARY_FILE_TYPE);// 设置传输二进制文件 
                uploadManyFile(new File("C:\\ooo\\upx"), new File("C:\\ooo\\upx"), "/admin/ttt"); 
                closeConnect();// 关闭连接 
        } 

        /** 
         * 上传单个文件，并重命名 
         * 
         * @param localFile--本地文件路径 
         * @param distFolder--新的文件名,可以命名为空"" 
         * @return true 上传成功，false 上传失败 
         */ 
        public static boolean uploadFile(File localFile, final File localRootFile, final String distFolder) { 
                System.out.println("                    -------------------------"); 
                boolean flag = true; 
                try { 
                        connectServer(); 
                        ftpClient.setFileType(FTP.BINARY_FILE_TYPE); 
                        ftpClient.enterLocalPassiveMode(); 
                        ftpClient.setFileTransferMode(FTP.STREAM_TRANSFER_MODE); 
                        InputStream input = new FileInputStream(localFile); 
//                        if (input == null) { 
//                                System.out.println("本地文件"+localFile.getPath()+"不存在!"); 
//                        } 
//                        if (newFileName.trim().equals("")) { 
//                                newFileName = localFile.getName(); 
//                        } 

                        String furi1 = localFile.getParentFile().getAbsoluteFile().toURI().toString(); 
                        String furi2 = localRootFile.getParentFile().getAbsoluteFile().toURI().toString(); 

                        String objFolder = distFolder + File.separator + furi1.substring(furi2.length()); 

                        ftpClient.changeWorkingDirectory("/"); 
                        ftpClient.makeDirectory(objFolder); 
                        System.out.println("a>>>>>>> : " + distFolder + File.separator + localFile.getParent()); 
                        System.out.println("x>>>>>>> : " + objFolder); 
                        ftpClient.changeWorkingDirectory(objFolder); 

                        System.out.println("b>>>>>>> : " + localFile.getPath() + " " + ftpClient.printWorkingDirectory()); 
                        flag = ftpClient.storeFile(localFile.getName(), input); 
                        if (flag) { 
                                System.out.println("上传文件成功！"); 
                        } else { 
                                System.out.println("上传文件失败！"); 
                        } 
                        input.close(); 
                } catch (IOException e) { 
                        e.printStackTrace(); 
                        logger.debug("本地文件上传失败！", e); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
                return flag; 
        } 

        /** 
         * 上传多个文件 
         * 
         * @param localFile--本地文件夹路径 
         * @return true 上传成功，false 上传失败 
         */ 
        public static String uploadManyFile(String localFile) { 
                boolean flag = true; 
                StringBuffer strBuf = new StringBuffer(); 
                try { 
                        connectServer(); 
                        File file = new File(localFile);        // 在此目录中找文件 
                        File fileList[] = file.listFiles(); 
                        for (File f : fileList) { 
                                if (f.isDirectory()) {            // 文件夹中还有文件夹 
                                        uploadManyFile(f.getAbsolutePath()); 
                                } else { 
                                } 
                                if (!flag) { 
                                        strBuf.append(f.getName() + "\r\n"); 
                                } 
                        } 
                        System.out.println(strBuf.toString()); 
                } catch (NullPointerException e) { 
                        e.printStackTrace(); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        logger.debug("本地文件上传失败！", e); 
                } 
                return strBuf.toString(); 
        } 

        /** 
         * 上传多个文件 
         * 
         * @param localFile,--本地文件夹路径 
         * @param distFolder--目标路径 
         * @return true 上传成功，false 上传失败 
         */ 
        public static String uploadManyFile(File localFile, final File localRootFile, final String distFolder) { 
                System.out.println("-------------------------"); 
                boolean flag = true; 
                StringBuffer strBuf = new StringBuffer(); 
                int n = 0; 
                try { 
                        connectServer(); 
                        ftpClient.makeDirectory(distFolder + File.separator + localFile.getParent()); 
                        File fileList[] = localFile.listFiles(); 
                        for (File upfile : fileList) { 
                                if (upfile.isDirectory()) {// 文件夹中还有文件夹 
                                        uploadManyFile(upfile, localRootFile, distFolder); 
                                } else { 
                                        flag = uploadFile(upfile, localRootFile, distFolder); 
                                } 
                                if (!flag) { 
                                        strBuf.append(upfile.getName() + "\r\n"); 
                                } 
                        } 
                        System.out.println(strBuf.toString()); 
                } catch (NullPointerException e) { 
                        e.printStackTrace(); 
                        logger.debug("本地文件上传失败！找不到上传文件！", e); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        logger.debug("本地文件上传失败！", e); 
                } 
                return strBuf.toString(); 
        } 

        /** 
         * 下载文件 
         * 
         * @param remoteFileName             --服务器上的文件名 
         * @param localFileName--本地文件名 
         * @return true 下载成功，false 下载失败 
         */ 
        public static boolean loadFile(String remoteFileName, String localFileName) { 
                boolean flag = true; 
                connectServer(); 
                // 下载文件 
                BufferedOutputStream buffOut = null; 
                try { 
                        buffOut = new BufferedOutputStream(new FileOutputStream(localFileName)); 
                        flag = ftpClient.retrieveFile(remoteFileName, buffOut); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                        logger.debug("本地文件下载失败！", e); 
                } finally { 
                        try { 
                                if (buffOut != null) 
                                        buffOut.close(); 
                        } catch (Exception e) { 
                                e.printStackTrace(); 
                        } 
                } 
                return flag; 
        } 

        /** 
         * 删除一个文件 
         */ 
        public static boolean deleteFile(String filename) { 
                boolean flag = true; 
                try { 
                        connectServer(); 
                        flag = ftpClient.deleteFile(filename); 
                        if (flag) { 
                                System.out.println("删除文件成功！"); 
                        } else { 
                                System.out.println("删除文件失败！"); 
                        } 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
                return flag; 
        } 

        /** 
         * 删除目录 
         */ 
        public static void deleteDirectory(String pathname) { 
                try { 
                        connectServer(); 
                        File file = new File(pathname); 
                        if (file.isDirectory()) { 
                                File file2[] = file.listFiles(); 
                        } else { 
                                deleteFile(pathname); 
                        } 
                        ftpClient.removeDirectory(pathname); 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
        } 

        /** 
         * 删除空目录 
         */ 
        public static void deleteEmptyDirectory(String pathname) { 
                try { 
                        connectServer(); 
                        ftpClient.removeDirectory(pathname); 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
        } 

        /** 
         * 列出服务器上文件和目录 
         * 
         * @param regStr --匹配的正则表达式 
         */ 
        public static void listRemoteFiles(String regStr) { 
                connectServer(); 
                try { 
                        String files[] = ftpClient.listNames(regStr); 
                        if (files == null || files.length == 0) 
                                System.out.println("没有任何文件!"); 
                        else { 
                                for (int i = 0; i < files.length; i++) { 
                                        System.out.println(files[i]); 
                                } 
                        } 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
        } 

        /** 
         * 列出Ftp服务器上的所有文件和目录 
         */ 
        public static void listRemoteAllFiles() { 
                connectServer(); 
                try { 
                        String[] names = ftpClient.listNames(); 
                        for (int i = 0; i < names.length; i++) { 
                                System.out.println(names[i]); 
                        } 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
        } 

        /** 
         * 关闭连接 
         */ 
        public static void closeConnect() { 
                try { 
                        if (ftpClient != null) { 
                                ftpClient.logout(); 
                                ftpClient.disconnect(); 
                        } 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
        } 

        /** 
         * 设置配置文件 
         * 
         * @param configFile 
         */ 
        public static void setConfigFile(String configFile) { 
                FtpTest.configFile = configFile; 
        } 

        /** 
         * 设置传输文件的类型[文本文件或者二进制文件] 
         * 
         * @param fileType--BINARY_FILE_TYPE、ASCII_FILE_TYPE 
         * 
         */ 
        public static void setFileType(int fileType) { 
                try { 
                        connectServer(); 
                        ftpClient.setFileType(fileType); 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
        } 

        /** 
         * 扩展使用 
         * 
         * @return ftpClient 
         */ 
        protected static FTPClient getFtpClient() { 
                connectServer(); 
                return ftpClient; 
        } 

        /** 
         * 设置参数 
         * 
         * @param configFile --参数的配置文件 
         */ 
        private static void setArg(String configFile) { 
                property = new Properties(); 
                BufferedInputStream inBuff = null; 
                try { 
                        File file = new File(configFile); 
                        inBuff = new BufferedInputStream(new FileInputStream(file)); 
                        property.load(inBuff); 
                        userName = property.getProperty("username"); 
                        password = property.getProperty("password"); 
                        ip = property.getProperty("ip"); 
                        port = Integer.parseInt(property.getProperty("port")); 
                } catch (FileNotFoundException e1) { 
                        System.out.println("配置文件 " + configFile + " 不存在！"); 
                } catch (IOException e) { 
                        System.out.println("配置文件 " + configFile + " 无法读取！"); 
                } 
        } 

        /** 
         * 连接到服务器 
         * 
         * @return true 连接服务器成功，false 连接服务器失败 
         */ 
        public static boolean connectServer() { 
                boolean flag = true; 
                if (ftpClient == null) { 
                        int reply; 
                        try { 
                                setArg(configFile); 
                                ftpClient = new FTPClient(); 
                                ftpClient.setControlEncoding("GBK"); 
                                ftpClient.setDefaultPort(port); 
                                ftpClient.configure(getFtpConfig()); 
                                ftpClient.connect(ip); 
                                ftpClient.login(userName, password); 
                                ftpClient.setDefaultPort(port); 
                                //System.out.print(ftpClient.getReplyString()); 
                                reply = ftpClient.getReplyCode(); 
                                ftpClient.setDataTimeout(120000); 

                                if (!FTPReply.isPositiveCompletion(reply)) { 
                                        ftpClient.disconnect(); 
                                        System.err.println("FTP server refused connection."); 
                                        // logger.debug("FTP 服务拒绝连接！"); 
                                        flag = false; 
                                } 
//                                System.out.println(i); 
                                i++; 
                        } catch (SocketException e) { 
                                flag = false; 
                                e.printStackTrace(); 
                                System.err.println("登录ftp服务器 " + ip + " 失败,连接超时！"); 
                        } catch (IOException e) { 
                                flag = false; 
                                e.printStackTrace(); 
                                System.err.println("登录ftp服务器 " + ip + " 失败，FTP服务器无法打开！"); 
                        } 
                } 
                return flag; 
        } 

        /** 
         * 进入到服务器的某个目录下 
         * 
         * @param directory 
         */ 
        public static void changeWorkingDirectory(String directory) { 
                try { 
                        connectServer(); 
                        ftpClient.changeWorkingDirectory(directory); 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
        } 

        /** 
         * 返回到上一层目录 
         */ 
        public static void changeToParentDirectory() { 
                try { 
                        connectServer(); 
                        ftpClient.changeToParentDirectory(); 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
        } 

        /** 
         * 重命名文件 
         * 
         * @param oldFileName --原文件名 
         * @param newFileName --新文件名 
         */ 
        public static void renameFile(String oldFileName, String newFileName) { 
                try { 
                        connectServer(); 
                        ftpClient.rename(oldFileName, newFileName); 
                } catch (IOException ioe) { 
                        ioe.printStackTrace(); 
                } 
        } 

        /** 
         * 设置FTP客服端的配置--一般可以不设置 
         * 
         * @return ftpConfig 
         */ 
        private static FTPClientConfig getFtpConfig() { 
                FTPClientConfig ftpConfig = new FTPClientConfig(FTPClientConfig.SYST_UNIX); 
                ftpConfig.setServerLanguageCode(FTP.DEFAULT_CONTROL_ENCODING); 
                return ftpConfig; 
        } 

        /** 
         * 转码[ISO-8859-1 -> GBK] 不同的平台需要不同的转码 
         * 
         * @param obj 
         * @return "" 
         */ 
        private static String iso8859togbk(Object obj) { 
                try { 
                        if (obj == null) 
                                return ""; 
                        else 
                                return new String(obj.toString().getBytes("iso-8859-1"), "GBK"); 
                } catch (Exception e) { 
                        return ""; 
                } 
        } 

        /** 
         * 在服务器上创建一个文件夹 
         * 
         * @param dir 文件夹名称，不能含有特殊字符，如 \ 、/ 、: 、* 、?、 "、 <、>... 
         */ 
        public static boolean makeDirectory(String dir) { 
                connectServer(); 
                boolean flag = true; 
                try { 
                        // System.out.println("dir=======" dir); 
                        flag = ftpClient.makeDirectory(dir); 
                        if (flag) { 
                                System.out.println("make Directory " + dir + " succeed"); 

                        } else { 

                                System.out.println("make Directory " + dir + " false"); 
                        } 
                } catch (Exception e) { 
                        e.printStackTrace(); 
                } 
                return flag; 
        } 

}
界二
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FTPClient jar
09-20
FTPClient.jar 帮助你完成FTP的有关开发。 FTPClient.jar 帮助你完成FTP的有关开发。 FTPClient.jar 帮助你完成FTP的有关开发。
FTP工具类一
andyjery的博客
08-22 910
public class FTPClientUtils { public static String FTPCONFIG = "config/ftpConfig.properties"; private static String LOCAL_CHARSET = "GBK"; private static FTPClient ftpClient = null; // FTP 客户端代理 ...
FTP的主动模式和被动模式，你造吗？
动哒APP—运动健康科技提供商
07-03 748
本文由动哒公众号（tongmi5g），QQ群（58621899）提供，欢迎关注获取技术支持，有任何问题群里都会回复。 问题描述 在开发的本地电脑向服务器上传文件没问题，但是，部署之后，在服务器之间上传文件，ftp连接没问题，但是上传死活不成功，ftpClient.storeFile一直返回失败。 解决 原因： 网上找资料原因可能是防火墙策略阻止了java测试服务的端口连接，FTP服务器使用的有可能是被动模式； 注意： FTP的PORT（主动模式）和PASV（被动模式） (1) PORT（主动模式） PORT
Windows10中搭建ftp服务器以实现文件传输
qq_59125846的博客
05-27 6201
注意：如果要使用另一台电脑进行连接，则需要将两台电脑连在同一个局域网下，并且关闭作为ftp服务器主机的防火墙。如果能看到右下角的目录，且目录正确则表示连接成功，ftp可用。填写ip地址和端口号，点击连接，弹出一个窗口的话点击确认。填写IP地址（可直接填写0.0.0.0），选中无SSL。如果无法连接，可以关闭防火墙和杀毒软件。填写FTP站点名称和物理路径，下一步。浏览=====》找到对应目录。再试试能否连接ftp服务器。点击打开，添加，确定。ftp服务搭建完成！找到FTP服务器，勾选。搜索iis，回车打开。
FTPClient设置多级目录
xxdw1992的博客
02-19 1643
/** * 上传文件之前初始化相关参数 * * @param remotePath FTP目录 * @param listener 监听器 * @throws IOException */ private void uploadBeforeOperate(String remotePath, UploadProgressListener listener) throws IOException { // 打开F...
FTPClient的简要使用示例
hellwhisper的专栏
03-03 1341
ftpclient简要使用示例
Java使用FTPClient类读写FTP
08-30
主要为大家详细介绍了Java使用FTPClient类读写FTP的相关资料，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Apache的FTPClient相关jar包
04-28
commons-net-1.4.1.jar，jakarta-oro.jar，commons-net-2.0-javadoc.jar以及相关帮助
详解JAVA中使用FTPClient工具类上传下载
08-29
主要介绍了JAVA中使用FTPClient工具类上传下载的相关资料,java 使用FTP服务器上传文件、下载文件，需要的朋友可以参考下
Java FTPClient实现文件上传下载
09-02
主要为大家详细介绍了Java FTPClient实现文件上传下载的相关资料,需要的朋友可以参考下
apache的ftpClient.listFiles()为空
huiy的专栏
11-25 935
客户端连接FTP服务器，执行到ftpClient.listFiles()总是为空，但是同样的代码却可以连接另外一台FTP服务器。连接方式都是被动模式。经跟踪源码发现执行到socket.connect(...)这个方法时就报connection time out。发现这两台FTP服务器是出于不同的网段，其中客户端与一台服务器在同一个网段，得出在跨网段访问时中间存在防火墙，阻隔了客户端连接访问。 ...
FTPClient 上传
LUANJIESHI的专栏
04-18 476
public boolean uploadFile(String remoteFile,File localFile) throws IOException { ftpClient.setFileTransferMode(FTP.BINARY_FILE_TYPE); FileInputStream fis = new FileInputStream(localFile); boolea
Java使用FTPClient 上传文件、下载文件、删除文件
abc_xian的博客
03-16 2636
在连接ftp服务器时，刚开始密码弄错了，使用工具FlashFXP修改密码后就能连上， FileZilla连接时，报证书过期，选择信任该证书并继续登录，登录不上，修改密码后报同样的错误，后来在编辑中选择清除个人信息，全部选中（包括快速连接栏历史，重新连接信息，站点管理器条目和传输队列）后删除，重新添加新站点后可以连接。 import org.apache.commons.net.ftp.*; import org.slf4j.Logger; import org.slf4j.LoggerFactory.
ftpClient.makeDirectory(path) 一直返回false，无法创建目录的问题
热门推荐
超级八卦达人的博客
11-17 2万+
问题：         使用FTPClient的makeDirectory(path)在ftp服务器端创建目录，一直返回fale，无法创建 原因：         由于我使用的是普通账号登录，所以一开始就设置chroot_local_user=YES，将用户禁锢在了宿主目录，导致始终无法创建目录。但是可以上传文件，不过，上传的文件最终也只能存放在宿主目录下，即 /home/test/xx
FtpClient.makeDirectory(s);方法返回false
tian5753的博客
01-07 1260
链接地址
关于FTPClient无法执行logout()直到断开连接的问题
WM_55555的博客
03-22 824
今天遇到一个问题，做个记录，当我们在使用ftp下载文件时会获取到一个输入流，这个输入流必须在关闭ftpclient或者退出之前先close掉，否则ftp认为你还在获取文件中，导致无法关闭客户端链接；--------------------->卡在这不不能动直到失去链接。这个is在代码中没有提前close;
FtpClient获取数据实例
高考我军的博客
11-23 1581
实际项目中有一个需求：将远程服务器上的文件转存到本地服务器，开发中遇到很多问题，总结出一个可行的代码实例。
FTP ftp.printWorkingDirectory() 乱码问题以及FTP浏览效果实例
xg_54的专栏
04-29 932
乱码问题 获取项目当前路径ftp.printWorkingDirectory() 乱码，因为已经是转码的了，再转回来即可 new String(ftp.printWorkingDirectory().getBytes("iso8859-1"), "UTF-8") 下载文件返回为false，文件大小为0： ftp.retrieveFile(ftp.printWorkingDirectory()+"/" +new String((fileName).getBytes(LOCAL_CHARSET.
ftpClient.disconnect() 和 ftpClient.logout()区别
最新发布
07-23
1. ftpClient.disconnect(): 这个方法用于断开与FTP服务器的连接，它会关闭与服务器的连接，并释放相关的资源。调用disconnect()方法后，不能再执行其他的FTP操作，因为连接已经关闭。 2. ftpClient.logout(): 这个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值