FTP工具类开发

正所谓工欲善其事必先利其器，熟悉了下一套流程，以此铭记。

1.FTP服务搭建

由于本人使用wondiow系统，所以针对window的童鞋们可以查看。至于windowX这里配置类似，所以不要纠结于window系统不同。经过以上操作我们可以获取到ftp的用户名，密码，以及IP地址，端口号（ps：默认端口号，搭建时可以设置）

2.FTP编码集问题

由于FTP使用编码集为ISO-8859-1，所以在中文文件夹以及文件名称上传，获取服务器文件等会出现问题。有以下2中解决方案：

1.将目录、文件转码，这样就造成跟目录、文件相关的都要转码，以至于

　　　　　　ftpClient.changeWorkingDirectory(new String(onepath.getBytes("GBK"),"iso-8859-1"));
　　　　　　ftpClient.storeFile(new String(fileName.getBytes("GBK"),"iso-8859-1"), in);
　　　　　　ftpClient.listFiles(new String(remotePath.getBytes("GBK"),"iso-8859-1"));

那这样岂不是很麻烦，而且每次使用都需要转码，有没有更简单的呢？有，请看第2中

2.设置相应编码集等信息

　　　　　　ftpClient = new FTPClient();
　　　　　　ftpClient.setControlEncoding("GBK");
　　　　　　FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);//系统类型   这表示window系统
　　　　　　conf.setServerLanguageCode("zh"); 
　　　　　　ftpClient.configure(conf);
　　　　　　ftpClient.connect(this.ip, this.port);

这边需要注意的是顺序必须这么写

3.工具类相关

1.Jar包问题

由于本人使用maven，pom中的配置

　　　　　　<dependency>
    　　　　　　<groupId>commons-net</groupId>
   　　　　　　 <artifactId>commons-net</artifactId>
    　　　　　　<version>3.5</version>
   　　　　　　 <classifier>ftp</classifier>
　　　　　　</dependency>

2.工具类开发

 import org.apache.commons.net.ftp.*;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;

 import java.io.*;
 import java.util.Arrays;
 import java.util.List;

 /**
  * FTP上传工具类
  */
 public class FtpUtil {
     private static Logger log = LoggerFactory.getLogger(FtpUtil.class);
     private final static String FILE_SEPARATOR = System.getProperties().getProperty("file.separator");
     private String ip;
     private String username;
     private String password;
     private int port = 21;
     private FTPClient ftpClient = null;

     public FtpUtil(String serverIP, String username, String password) {
         this.ip = serverIP;
         this.username = username;
         this.password = password;
     }

     public FtpUtil(String serverIP, int port, String username, String password) {
         this.ip = serverIP;
         this.username = username;
         this.password = password;
         this.port = port;
     }

     /**
      * 连接ftp服务器
      */
     public boolean connectServer() {
         boolean result = true;
         try {
             ftpClient = new FTPClient();
             ftpClient.setControlEncoding("GBK");
             FTPClientConfig conf = new FTPClientConfig(FTPClientConfig.SYST_NT);
             conf.setServerLanguageCode("zh");
             ftpClient.configure(conf);
             ftpClient.connect(this.ip, this.port);
             ftpClient.login(this.username, this.password);
             ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
             int reply = ftpClient.getReplyCode();
             if (!FTPReply.isPositiveCompletion(reply)) {
                 ftpClient.disconnect();
                 result = false;
             }
         } catch (IOException e) {
             e.printStackTrace();
             log.error("连接ftp服务器失败", e);
             result = false;
         }
         return result;
     }

     /**
      * 断开与ftp服务器连接
      */
     public boolean closeServer() {
         try {
             if (ftpClient != null && ftpClient.isConnected()) {
                 ftpClient.logout();
                 ftpClient.disconnect();
             }
             return true;
         } catch (IOException e) {
             log.error("断开与ftp服务器连接失败", e);
             return false;
         }
     }

     /**
      * 向FTP根目录上传文件
      *
      * @param localFile
      * @param newName   文件名称
      * @throws Exception
      */
     public boolean uploadFile(String localFile, String newName) {
         boolean success = false;
         InputStream input = null;
         try {
             File file = null;
             if (checkFileExist(localFile)) {
                 file = new File(localFile);
             }
             input = new FileInputStream(file);
             success = ftpClient.storeFile(newName, input);
         } catch (Exception e) {
             log.error("FTP根目录上传文件上传失败（ps：传入文件名）", e);
         } finally {
             if (input != null) {
                 try {
                     input.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                     log.error("FTP根目录上传文件上传（ps：传入文件名）,输入流关闭失败", e);
                 }
             }
         }
         return success;
     }

     /**
      * 向FTP根目录上传文件
      *
      * @param input
      * @param newName 新文件名
      * @throws Exception
      */
     public boolean uploadFile(InputStream input, String newName) {
         boolean success = false;
         try {
             success = ftpClient.storeFile(newName, input);
         } catch (Exception e) {
             log.error("FTP根目录上传文件上传失败（ps：传入文件流）", e);
         } finally {
             if (input != null) {
                 try {
                     input.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                     log.error("FTP根目录上传文件上传（ps：传入文件流）,输入流关闭失败", e);
                 }
             }
         }
         return success;
     }

     /**
      * 向FTP指定路径上传文件
      *
      * @param localFile
      * @param newName        新文件名
      * @param remoteFoldPath
      * @throws Exception
      */
     public boolean uploadFile(String localFile, String newName, String remoteFoldPath) {
         InputStream input = null;
         boolean success = false;
         try {
             // 改变当前路径到指定路径
             if (!this.changeDirectory(remoteFoldPath)) {
                 return false;
             }
             File file = null;
             if (checkFileExist(localFile)) {
                 file = new File(localFile);
             }
             input = new FileInputStream(file);
             success = ftpClient.storeFile(newName, input);
         } catch (Exception e) {
             log.error("FTP指定路径上传文件失败（ps：本地文件路径以及ftp服务器中文件名）", e);
         } finally {
             if (input != null) {
                 try {
                     input.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                     log.error("FTP指定路径上传文件失败（ps：本地文件路径以及ftp服务器中文件名）,输入流关闭失败", e);
                 }
             }
         }
         return success;
     }

     /**
      * 向FTP指定路径上传文件
      *
      * @param input
      * @param newName        新文件名
      * @param remoteFoldPath
      * @throws Exception
      */
     public boolean uploadFile(InputStream input, String newName, String remoteFoldPath) throws Exception {
         boolean success = false;
         try {
             // 改变当前路径到指定路径
             if (!this.changeDirectory(remoteFoldPath)) {
                 return false;
             }
             success = ftpClient.storeFile(newName, input);
         } catch (Exception e) {
             log.error("FTP指定路径上传文件失败（ps：本地文件流及ftp服务器中文件名）", e);
         } finally {
             if (input != null) {
                 try {
                     input.close();
                 } catch (IOException e) {
                     log.error("FTP指定路径上传文件失败（ps：本地文件流及ftp服务器中文件名）,输入流关闭失败", e);
                 }
             }
         }
         return success;
     }

     /**
      * 从FTP服务器下载文件
      *
      * @param remotePath FTP路径(不包含文件名)
      * @param fileName   下载文件名
      * @param localPath  本地路径
      */
     public boolean downloadFile(String remotePath, String fileName, String localPath) {
         BufferedOutputStream output = null;
         boolean success = false;
         try {
             // 检查本地路径
             if (!this.checkFileExist(localPath)) {
                 return false;
             }
             // 改变工作路径
             if (!this.changeDirectory(remotePath)) {
                 return false;
             }
             // 列出当前工作路径下的文件列表
             List<FTPFile> fileList = this.getFileList();
             if (fileList == null || fileList.size() == 0) {
                 return false;
             }
             for (FTPFile ftpfile : fileList) {
                 if (ftpfile.getName().equals(fileName)) {
                     File localFilePath = new File(localPath + File.separator + ftpfile.getName());
                     output = new BufferedOutputStream(new FileOutputStream(localFilePath));
                     success = ftpClient.retrieveFile(ftpfile.getName(), output);
                 }
             }
         } catch (Exception e) {
             log.error("FTP服务器下载文件失败", e);
         } finally {
             if (output != null) {
                 try {
                     output.close();
                 } catch (IOException e) {
                     log.error("FTP服务器下载文件,输出流关闭失败", e);
                 }
             }
         }
         return success;
     }

     /**
      * 从FTP服务器获取文件流
      *
      * @param remoteFilePath
      * @return
      * @throws Exception
      */
     public InputStream downloadFile(String remoteFilePath) {
         try {
             return ftpClient.retrieveFileStream(remoteFilePath);
         } catch (IOException e) {
             log.error("FTP服务器获取文件流失败", e);
         }
         return null;
     }

     /**
      * 获取FTP服务器上[指定路径]下的文件列表
      *
      * @param remotePath
      * @return
      */
     public List<FTPFile> getFtpServerFileList(String remotePath) {
         try {
             FTPListParseEngine engine = ftpClient.initiateListParsing(remotePath);
             return Arrays.asList(engine.getNext(25));
         } catch (IOException e) {
             log.error("获取FTP服务器上[指定路径]下的文件列表(getFtpServerFileList)失败", e);
         }
         return null;
     }

     /**
      * 获取FTP服务器上[指定路径]下的文件列表
      *
      * @param remotePath
      * @return
      */
     public List<FTPFile> getFileList(String remotePath) {
         List<FTPFile> ftpfiles = null;
         try {
             ftpfiles = Arrays.asList(ftpClient.listFiles(remotePath));
         } catch (IOException e) {
             log.error("获取FTP服务器上[指定路径]下的文件列表(getFileList)失败", e);
         }
         return ftpfiles;
     }

     /**
      * 获取FTP服务器[当前工作路径]下的文件列表
      *
      * @return
      */
     public List<FTPFile> getFileList() {
         List<FTPFile> ftpfiles = null;
         try {
             ftpfiles = Arrays.asList(ftpClient.listFiles());
         } catch (IOException e) {
             log.error("获取FTP服务器[当前工作路径]下的文件列表失败", e);
         }
         return ftpfiles;
     }

     /**
      * 改变FTP服务器工作路径
      *
      * @param remoteFoldPath
      */
     public boolean changeDirectory(String remoteFoldPath) {
         boolean result = false;
         try {
             result = ftpClient.changeWorkingDirectory(new String(remoteFoldPath));
         } catch (IOException e) {
             log.error("改变FTP服务器工作路径失败", e);
         }
         return result;
     }

     /**
      * 删除文件
      *
      * @param remoteFilePath
      * @return
      * @throws Exception
      */
     public boolean deleteFtpServerFile(String remoteFilePath) {
         boolean result = false;
         try {
             result = ftpClient.deleteFile(remoteFilePath);
         } catch (IOException e) {
             log.error("FTP服务器删除文件失败", e);
         }
         return result;
     }

     /**
      * 删除目录
      *
      * @param remoteFoldPath
      * @return
      * @throws Exception
      */
     public boolean deleteFold(String remoteFoldPath) {
         boolean result = false;
         try {
             result = ftpClient.removeDirectory(remoteFoldPath);
         } catch (IOException e) {
             log.error("FTP服务器删除目录失败", e);
         }
         return result;
     }

     /**
      * 删除目录以及文件
      *
      * @param remoteFoldPath
      * @return
      */
     public boolean deleteFoldAndsubFiles(String remoteFoldPath) {
         boolean success = false;
         List<FTPFile> list = this.getFileList(remoteFoldPath);
         if (list == null || list.size() == 0) {
             return deleteFold(remoteFoldPath);
         }
         for (FTPFile ftpFile : list) {
             String name = ftpFile.getName();
             if (ftpFile.isDirectory()) {
                 success = deleteFoldAndsubFiles(remoteFoldPath + FILE_SEPARATOR + name);
             } else {
                 success = deleteFtpServerFile(remoteFoldPath + FILE_SEPARATOR + name);
             }
             if (!success) {
                 break;
             }
         }
         if (!success) {
             return false;
         }
         success = deleteFold(remoteFoldPath);
         return success;
     }

     /**
      * 创建目录
      *
      * @param remoteFoldPath
      * @return
      */
     public boolean createFold(String remoteFoldPath) {
         boolean result = false;
         try {
             result = ftpClient.makeDirectory(remoteFoldPath);
         } catch (IOException e) {
             log.error("FTP服务器创建目录失败", e);
         }
         return result;
     }

     /**
      * 检查本地路径是否存在
      *
      * @param filePath
      * @return
      * @throws Exception
      */
     public boolean checkFileExist(String filePath) {
         return new File(filePath).exists();
     }

     /**
      * 把文件移动到特定目录下
      *
      * @param remoteFile
      * @param remoteNewPath
      * @return
      */
     public boolean moveFtpServerFile(String remoteFile, String remoteNewPath) {
         boolean result = false;
         try {
             result = ftpClient.rename(remoteFile, remoteNewPath);
         } catch (IOException e) {
             log.error("FTP服务器文件移动失败", e);
         }
         return result;
     }

     /**
      * 判断是文件还是目录
      *
      * @param remoteOldPath
      * @return
      */
     public boolean isContents(String remoteOldPath) {
         return changeDirectory(remoteOldPath);
     }

     /**
      * 递归创建远程服务器目录
      *
      * @param dirpath 远程服务器文件绝对路径
      * @return 目录创建是否成功
      */
     public void createDirecroty(String dirpath) {
         String directory = dirpath.substring(0, dirpath.lastIndexOf("/") + 1);
         try {
             if (!directory.equalsIgnoreCase("/") && !ftpClient.changeWorkingDirectory(new String(directory))) {
                 // 如果远程目录不存在，则递归创建远程服务器目录
                 int start = 0;
                 int end = 0;
                 if (directory.startsWith("/")) {
                     start = 1;
                 } else {
                     start = 0;
                 }
                 end = directory.indexOf("/", start);
                 while (true) {
                     String subDirectory = new String(dirpath.substring(start, end));
                     if (!ftpClient.changeWorkingDirectory(subDirectory)) {
                         if (ftpClient.makeDirectory(subDirectory)) {
                             ftpClient.changeWorkingDirectory(subDirectory);
                         }
                     }
                     start = end + 1;
                     end = directory.indexOf("/", start);
                     // 检查所有目录是否创建完毕
                     if (end <= start) {
                         break;
                     }
                 }
             }
         } catch (IOException e) {
             log.error("递归生成目录失败", e);
         }
     }

     /**
      * 复制
      *
      * @param remoteOldPath
      * @param remoteNewPath
      * @return
      */
     public boolean copyFtpServerFile(String remoteOldPath, String remoteNewPath) {
         boolean copyFalg = false;
         List<FTPFile> filelist;
         try {
             ftpClient.enterLocalPassiveMode();
             filelist = this.getFileList(remoteOldPath);
             int length = filelist == null || filelist.isEmpty() ? 0 : filelist.size();
             String category = null;
             ByteArrayOutputStream fos = null;
             ByteArrayInputStream in = null;
             if (length > 0) {
                 boolean flage = false;
                 if (this.isContents(remoteOldPath)) {
                     flage = true;
                 }
                 changeDirectory("/");
                 for (FTPFile ftpFile : filelist) {
                     category = ftpFile.getName();
                     if (ftpFile.isFile()) {
                         // 如果是文件则复制文件
                         ftpClient.setBufferSize(1024);
                         fos = new ByteArrayOutputStream();
                         copyFalg = ftpClient.retrieveFile(flage ? remoteOldPath + FILE_SEPARATOR + category : remoteOldPath, fos);
                         if (!copyFalg) {
                             return copyFalg;
                         }
                         // 如果读取的文件流不为空则复制文件
                         if (fos != null) {
                             in = new ByteArrayInputStream(fos.toByteArray());
                             copyFalg = ftpClient.storeFile(remoteNewPath + FILE_SEPARATOR + category, in);
                             // 关闭文件流
                             fos.close();
                             in.close();
                             if (!copyFalg) {
                                 return copyFalg;
                             }
                         }
                     } else if (ftpFile.isDirectory()) {
                         // 如果是目录则先创建该目录
                         copyFalg = this.createFold(remoteNewPath + FILE_SEPARATOR + category);
                         // 再进入子目录进行递归复制
                         copyFtpServerFile(remoteOldPath + FILE_SEPARATOR + category, remoteNewPath + FILE_SEPARATOR + category);
                     }
                 }
             }
         } catch (IOException e) {
             log.error("文件复制失败", e);
             copyFalg = false;
         }
         return copyFalg;
     }

     public static void main(String[] args) {
         FtpUtil ftpUtil = new FtpUtil("", "", "");
         //执行文件移动
         /*if (ftpUtil.connectServer()) {
             if (ftpUtil.changeDirectory("load")) {
                 ftpUtil.moveFtpServerFile("xlsj_h1_v0.7.apk", ".." + FILE_SEPARATOR + "down" + FILE_SEPARATOR + "1.apk");
                 ftpUtil.closeServer();
             }
         }*/
         //复制  xlsj_h1_v0.8.apk是目录   xlsj_h1_v0.7.apk是文件
        /* if (ftpUtil.connectServer()) {
             ftpUtil.copyFtpServerFile("load/xlsj_h1_v0.8.apk", "down");
             ftpUtil.copyFtpServerFile("load/xlsj_h1_v0.8.apk/xlsj_h1_v0.7.apk", "down");
             ftpUtil.closeServer();
         }*/

         if (ftpUtil.connectServer()) {
             ftpUtil.copyFtpServerFile("load/安卓上传包/安卓开发包.apk", "down");
             ftpUtil.closeServer();
         }
     }
 }

　参考：

　　http://blog.csdn.net/iheng_scau/article/details/41682511

　　http://blog.163.com/biangji_and/blog/static/3382923020102491050525/

　　http://bbs.csdn.net/topics/390373219

　　http://commons.apache.org/proper/commons-net/javadocs/api-1.4.1/org/apache/commons/net/ftp/FTPClient.html

　　http://yangyangmyself.iteye.com/blog/1299997