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

使用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;
        }

}

 

运行结果表名，上传文件夹成功！

下载文件夹还没有实现。

 

另外，我将我用的新开发包也放出来，参看 [url]http://www.enterprisedt.com/[/url]

 

 

本文出自 “熔 岩” 博客，转载请与作者联系！