用FTPClient对ftp文件进行上传下载等操作

最新推荐文章于 2020-08-03 10:50:07 发布
dos_186
最新推荐文章于 2020-08-03 10:50:07 发布
阅读量665
点赞数
[java]view plaincopyprint? 
    
 package com.ad.util;  
   
 import org.apache.commons.net.ftp.FTP;  
 import org.apache.commons.net.ftp.FTPClient;  
 import org.apache.commons.net.ftp.FTPReply;  
 import org.apache.commons.net.ftp.FTPFile;  
 import org.apache.commons.net.ftp.FTPListParseEngine;  
   
 import com.ad.adweb.system.GlobalConst;  
   
 import java.io.InputStream;  
 import java.io.FileOutputStream;  
 import java.io.File;  
 import java.util.Calendar;  
   
 /** 
  * <p> 
  * Title: FTPUtil 
  * </p> 
  * <p> 
  * Description: FTP操作的工具类，通过此类可以完成文件到指定FTP服务器的上传和下载。 
  * </p> 
  * <p> 
  * Copyright: Copyright (c) 2007 
  * </p> 
  * <p> 
  * Company: Routon 
  * </p> 
  *  
  * @author zhihui zhou 
  * @version 1.0 InternalError-->Exception by jiangyl 
  * @2007.12.21 
  */  
 public class FTPUtil  
 {  
    
     /** 
      * 全局配置项: ftp传输模式: passive/active 
      */  
     //private static String ConfigFtpMode = null;  
   
     /** 
      * 全局配置项: applet ftp传输模式: passive/active 
      */  
     //private static String ConfigClientFtpMode = null;  
   
     /** 
      * ftp服务器的ip地址 
      */  
     private String              _ftpServer;  
   
     /** 
      * ftp端口 
      */  
     private int                     _ftpPort;  
   
     //   
     /** 
      * ftp服务器的有效登陆用户名 
      */  
     private String              _userName;  
   
     /** 
      * ftp服务器的有效登陆用户密码 
      */  
     private String              _password;  
   
     /** 
      * ftp客户端的对象实例 
      */  
     private FTPClient           _ftp;  
   
     /** 
      * ftp mode 
      */  
     private String              FtpMode = null;  
   
       
     // public FTPUtil(String ftpServer, String userName, String password) throws Exception  
     // {  
     // try  
     // {  
     // setFTPServer(ftpServer);  
     // setUserName(userName);  
     // setPassword(password);  
     //  
     // // 初始化ftp客户端对象实例  
     // _ftp = new FTPClient();  
     // }  
     // catch (Exception ex)  
     // {  
     // throw new Exception(ex.getMessage());  
     // }  
     // }  
     /** 
      * 构造器 
      *  
      * @param ftpServer FTP服务器 
      *          String 
      * @param userName 用户名 
      *          String 
      * @param password 密码 
      *          String 
      * @throws Exception 异常 
      */  
     public FTPUtil(String ftpServer, int port, String userName, String password) throws Exception  
     {  
         try  
         {  
             setFTPServer(ftpServer);  
             setUserName(userName);  
             setPassword(password);  
             this._ftpPort = port;  
   
             // 初始化ftp客户端对象实例  
             _ftp = new FTPClient();  
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
     }  
   
     /** 
      * 获取ftp服务器的ip地址 
      *  
      * @return ftpServerIP String 
      */  
     public String getFTPServer()  
     {  
         return _ftpServer;  
     }  
   
     /** 
      * 设置ftp服务器的ip地址 
      *  
      * @param ftpServerIP 
      *          String 
      * @throws Exception 
      */  
     public void setFTPServer(String ftpServer) throws Exception  
     {  
         // 检查输入的ftp服务器地址，不允许为空。  
         if (ftpServer == null || ftpServer.length() == 0)  
         {  
             throw new Exception("ftp服务器的IP地址不能够为空。");  
         }  
   
         _ftpServer = ftpServer;  
     }  
   
     /** 
      * 获取ftp服务器的用户名 
      *  
      * @return userName String 
      */  
     public String getUserName()  
     {  
         return _userName;  
     }  
   
     /** 
      * 设置ftp服务器的用户名 
      *  
      * @param userName 
      *          String 
      * @throws Exception 
      */  
     public void setUserName(String userName) throws Exception  
     {  
         // 检查输入的ftp服务器名称，不允许为空。  
         if (userName == null || userName.length() == 0)  
         {  
             throw new Exception("ftp服务器的登陆用户名不能够为空。");  
         }  
   
         _userName = userName;  
     }  
   
     /** 
      * 获取ftp服务器的用户登陆密码 
      *  
      * @return password String 
      */  
     public String getPassword()  
     {  
         return _password;  
     }  
   
     /** 
      * 设置ftp服务器的用户密码 
      *  
      * @param password 
      *          String 
      * @throws Exception 
      */  
     public void setPassword(String password) throws Exception  
     {  
         // 检查输入的ftp服务器用户登陆密码，不允许为空。  
         if (password == null || password.length() == 0)  
         {  
             throw new Exception("ftp服务器的登陆用户密码不能够为空。");  
         }  
   
         _password = password;  
     }  
   
     /** 
      * 上传文件到ftp服务器的指定路径 
      *  
      * @param ftpPath 
      *          文件上传到ftp的路径 
      * @param inputStream 
      *          待上传的文件流 
      * @return isUploadSuccessed ture表示上传成功，发了社表明上传失败。 
      * @throws Exception 
      */  
     public boolean UploadFile(String ftpPath, InputStream inputSteam) throws Exception  
     {  
         boolean isSuccessed = false;  
   
         // 通过指定的用户名和密码登陆ftp服务器  
         try  
         {  
             if (Login(_userName, _password))  
             {  
                 // 开始上传文件  
                 _ftp.setFileType(FTP.BINARY_FILE_TYPE);  
   
                 if (_ftp.storeFile(ftpPath, inputSteam))  
                 {  
                     isSuccessed = true;  
                 }  
                 else  
                 {  
                     throw new Exception("文件上传失败！");  
                 }  
             }  
             else  
             {  
                 // 登陆失败  
                 isSuccessed = false;  
                 throw new Exception("用户" + _userName + "登陆ftp服务器" + _password + "失败。");  
             }  
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
         finally  
         {  
             ftpDispose();  
         }  
   
         return isSuccessed;  
     }  
   
     /** 
      * 在ftp服务器上面创建一个目录 
      *  
      * @param folderName 
      *          目录名称 
      * @return boolean 创建结果true表示成功，false表示失败 
      * @throws Exception 
      */  
     public boolean CreateFolder(String folderName) throws Exception  
     {  
         boolean isSuccessed = false;  
   
         // 通过指定的用户名和密码登陆ftp服务器  
         try  
         {  
             if (Login(_userName, _password))  
             {  
                 // 开始创建指定的目录到ftp服务器上  
                 if (_ftp.makeDirectory(folderName))  
                 {  
                     isSuccessed = true;  
                 }  
                 else  
                 {  
                     throw new Exception("ftp文件夹创建失败！");  
                 }  
             }  
             else  
             {  
                 // 登陆ftp失败  
                 isSuccessed = false;  
                 throw new Exception("用户" + _userName + "登陆ftp服务器" + _password + "失败。");  
             }  
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
         finally  
         {  
             ftpDispose();  
         }  
   
         return isSuccessed;  
     }  
   
     /** 
      * 根据指定的用户名和密码登陆ftp服务器 
      *  
      * @param username 
      *          登陆用户名 
      * @param password 
      *          登陆用户密码 
      * @return isUploadSuccessed true表示登陆成功，false表示登陆失败 
      * @throws Exception 
      */  
     public boolean Login(String username, String password) throws Exception  
     {  
         boolean isSuccessed = false;  
   
         try  
         {  
             int reply = 0;  
   
             // 连接到指定的ftp服务器  
             _ftp.connect(_ftpServer, this._ftpPort);  
   
             // 检查ftp连接请求的响应码，确保本次连接请求是成功还是失败。  
             reply = _ftp.getReplyCode();  
             if (!FTPReply.isPositiveCompletion(reply))  
             {  
                 _ftp.disconnect();  
                 throw new Exception("FTP服务器拒绝了连接.");  
             }  
   
             // 根据指定的用户名和密码登陆ftp服务器  
             if (!_ftp.login(_userName, _password))  
             {  
                 throw new Exception("用户" + _userName + "登陆ftp服务器" + _password + "失败。");  
             }  
   
             // set ftp mode  
             setCurrentFtpMode();  
   
             isSuccessed = true;  
         }  
         catch (Exception e)  
         {  
             throw new Exception(e.getMessage());  
         }  
   
         return isSuccessed;  
     }  
   
     /** 
      * 设置ftp模式，优先顺序: 1. FtpMode 2. ConfigFtpMode 3. commons-net lib 默认 
      */  
     private void setCurrentFtpMode()  
     {  
         String tmpFtpMode = null;  
         if (FtpMode != null && FtpMode.length() > 0)  
         {  
             tmpFtpMode = FtpMode;  
         }  
         else if (GlobalConst.ConfigFtpMode != null && GlobalConst.ConfigFtpMode.length() > 0)  
         {  
             tmpFtpMode = GlobalConst.ConfigFtpMode;  
         }  
   
         if (tmpFtpMode != null && tmpFtpMode.length() > 0)  
         {  
             if (tmpFtpMode.equalsIgnoreCase("passive"))  
             {  
                 _ftp.enterLocalPassiveMode();  
             }  
             else if (tmpFtpMode.equalsIgnoreCase("active"))  
             {  
                 _ftp.enterLocalActiveMode();  
             }  
         }  
     }  
   
     /** 
      * 释放ftp客户端 
      */  
     public void ftpDispose()  
     {  
         try  
         {  
             // 注销FTP客户端  
             _ftp.logout();  
         }  
         catch (Exception e)  
         {  
             // 如果FTP注销失败什么也不做，忽略掉异常。  
         }  
   
         // 如果FTP客户端的连接还存在则断开连接。  
         if (_ftp.isConnected())  
         {  
             try  
             {  
                 _ftp.disconnect();  
             }  
             catch (Exception ex)  
             {  
                 // 如果断开FTP连接失败什么也不做，忽略掉异常。  
             }  
         }  
     }  
   
     /** 
      * 从ftp下载文件 
      *  
      * @param FtpFileName 
      *          来源文件名称 
      * @param LocaFileName 
      *          目的文件名称 
      * @return boolean true表示下载文件成功，false表示下载文件失败 
      * @throws Exception 
      */  
     public boolean DownFile(String FtpFileName, String LocaFileName) throws Exception  
     {  
         boolean isSuccessed = false;  
   
         try  
         {  
             if (Login(_userName, _password))  
             {  
                 File file = new File(LocaFileName);  
                 FileOutputStream fos = new FileOutputStream(file);  
   
                 // + by jiangyl @2008.7.6  
                 _ftp.setFileType(FTP.BINARY_FILE_TYPE);  
   
                 isSuccessed = _ftp.retrieveFile(FtpFileName, fos);  
                 fos.close();  
                 file = null;  
   
                 if (!isSuccessed)  
                 {  
                     throw new Exception("文件" + FtpFileName + "下载失败.");  
                 }  
             }  
             else  
             {  
                 isSuccessed = false;  
                 throw new Exception("用户" + _userName + "登陆ftp服务器" + _password + "失败。");  
             }  
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
         finally  
         {  
             ftpDispose();  
         }  
   
         return isSuccessed;  
     }  
   
     /** 
      * 提供一静态方法，由外部定时任务模块调用，对FTP服务器上的过期数据文件进行清理 
      *  
      * @return int 表示成功删除文件的个数 
      * @throws Exception 
      */  
     public static void ClearFTPExpiredFiles() throws Exception  
     {  
         com.ad.util.FtpServerInfo ftpServer = com.ad.util.FtpServerInfo.getInstance();  
         com.ad.util.FTPUtil ftpUtil = new com.ad.util.FTPUtil(ftpServer.getFtp().getFtpIntIP(),  
             ftpServer.getFtp().getPort(), ftpServer.getFtp().getUpName(), ftpServer.getFtp().getUpPWD());  
   
         ftpUtil.ClearExpiredFiles();  
     }  
   
     /** 
      * 根据web.xml中配置， 对FTP服务器上的过期数据文件进行清理，清理的目录有：playbill、terParam、theme、ThemePolicy 
      *  
      * @return int 表示成功删除文件的个数 
      * @throws Exception 
      */  
     public int ClearExpiredFiles() throws Exception  
     {  
           
         int deleteNum = 0;  
   
         try  
         {  
             if (Login(_userName, _password))  
             {  
                 deleteNum += DeleteExpiredFiles("playbill");  
                 deleteNum += DeleteExpiredFiles("terParam");  
                 deleteNum += DeleteExpiredFiles("theme");  
                 deleteNum += DeleteExpiredFiles("ThemePolicy");  
             }  
             else  
             {  
                   
                 throw new Exception("用户" + _userName + "登陆ftp服务器" + _password + "失败。");  
             }  
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
         finally  
         {  
             ftpDispose();  
         }  
   
         return deleteNum;  
     }  
   
     /** 
      * 根据web.xml中配置， 对FTP服务器上的过期数据文件进行清理 
      *  
      * @param FtpPathName 
      *          待清理的目录 
      * @return int 表示成功删除文件的个数 
      * @throws Exception 
      */  
     private int DeleteExpiredFiles(String FtpPathName) throws Exception  
     {  
         boolean isSuccessed = false;  
         int deleteNum = 0;  
         Calendar dtNow = Calendar.getInstance();  
         Calendar dt = null;  
         FTPFile[] files = null;  
         long t1 = System.currentTimeMillis();  
         long t2 = -1;  
           
         try  
         {  
             // _ftp.changeWorkingDirectory("ThemePolicy");  
             // String[] names = _ftp.listNames();  
   
             // Paged access, using a parser accessible by auto-detect:  
             FTPListParseEngine engine = _ftp.initiateListParsing(FtpPathName);  
               
             while (engine.hasNext())  
             {  
                 files = engine.getNext(25); // "page size" you want  
   
                 for (int i = 0; i < files.length; i++)  
                 {  
                     // System.out.println(files[i].getName()+" -- "+FastDateFormat.getInstance("yyyy-MM-dd  
                     // HH:mm:ss").format(files[i].getTimestamp()));  
                     dt = files[i].getTimestamp();  
                     dt.add(Calendar.MONTH, com.ad.adweb.system.ClearExpiredDataDao.ExpiredDataMonthDiff);  
                     // FTP服务器中保留最近多少个月的数据，默认为1个月  
                     if (dt.compareTo(dtNow) <= 0)  
                     {  
                         isSuccessed = _ftp.deleteFile(FtpPathName + "/" + files[i].getName());  
                           
                         if (isSuccessed)  
                         {  
                             deleteNum++;  
                             //System.out.println("deleteFile OK! -- " + files[i].getName() + " -- " + FastDateFormat.getInstance("yyyy-MM-dd HH:mm:ss").format(dt));  
                         }  
   
                     }  
                 }// for  
             }  
   
         }  
         catch (Exception ex)  
         {  
             throw new Exception(ex.getMessage());  
         }  
   
         t2 = System.currentTimeMillis();  
         System.out.println("FTP服务器过期数据文件清理 -- " + FtpPathName + " 目录，" + deleteNum + " 个文件已删除，用时 " + (t2 - t1) + " ms！");  
           
         return deleteNum;  
     }  
   
     /** 
      * 获取FtpMode 
      * @return String FtpMode 
      */  
     public String getFtpMode()  
     {  
         return FtpMode;  
     }  
   
     /** 
      * 设置FtpMode 
      * @param ftpMode FtpMode 
      */  
     public void setFtpMode(String ftpMode)  
     {  
         FtpMode = ftpMode;  
     }  
   
 //  /**  
 //   * 获取ConfigClientFtpMode  
 //   * @return String ConfigClientFtpMode  
 //   */  
 //  public static String getConfigClientFtpMode()  
 //  {  
 //      return ConfigClientFtpMode;  
 //  }  
 //  
 //  /**  
 //   * 设置ConfigClientFtpMode  
 //   * @param configClientFtpMode ConfigClientFtpMode  
 //   */  
 //  public static void setConfigClientFtpMode(String configClientFtpMode)  
 //  {  
 //      ConfigClientFtpMode = configClientFtpMode;  
 //  }  
 //  
 //  /**  
 //   * 获取ConfigFtpMode  
 //   * @return String ConfigFtpMode  
 //   */  
 //  public static String getConfigFtpMode()  
 //  {  
 //      return ConfigFtpMode;  
 //  }  
 //  
 //  /**  
 //   * 设置ConfigFtpMode  
 //   * @param configFtpMode ConfigFtpMode  
 //   */  
 //  public static void setConfigFtpMode(String configFtpMode)  
 //  {  
 //      ConfigFtpMode = configFtpMode;  
 //  }  
   
 }// END  