FTP工具上传下载类

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;
import org.apache.log4j.Logger;









public class FtpUtil {
    
    
        
       /**
         * 上传文件（可供Action/Controller层使用）
         * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器保存目录
         * @param fileName   上传到FTP服务器后的文件名称
         * @param inputStream 输入文件流
         * @return
         */
        public static boolean uploadFile(String hostname, int port, String username, String password, String pathname, String fileName, InputStream inputStream){
            boolean flag = false;
            FTPClient ftpClient = new FTPClient();
            ftpClient.setControlEncoding("UTF-8");
            try {
                
                //连接FTP服务器
                ftpClient.setControlEncoding("UTF-8");
                ftpClient.connect(hostname, port);
                //设置传输时间
                ftpClient.setDataTimeout(30000);
                //设置默认的全局超时时间
                ftpClient.setDefaultTimeout(6000);
                //登录FTP服务器
                ftpClient.login(username, password);
                //是否成功登录FTP服务器
                int replyCode = ftpClient.getReplyCode();
                if(!FTPReply.isPositiveCompletion(replyCode)){
                    ftpClient.disconnect();
                    return flag;
                }
                ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
                ftpClient.makeDirectory(pathname);
                ftpClient.changeWorkingDirectory(pathname);
                ftpClient.storeFile(fileName, inputStream);
                inputStream.close();
                ftpClient.logout();
                flag = true;
            } catch (Exception e) {
                e.printStackTrace();
            } finally{
                if(ftpClient.isConnected()){
                    try {
                        //断开连接
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        logger1.error("FtpUtil:uploadFile-->FTP断开连接异常:!"+e.getMessage());
                        
                    }
                }
            }
            return flag;
        }
         
         
        /**
         * 上传文件（可对文件进行重命名）
         * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器保存目录
         * @param filename   上传到FTP服务器后的文件名称
         * @param originfilename 待上传文件的名称（绝对地址）
         * @return
         */
        public static boolean uploadFileFromProduction(String hostname, int port, String username, String password, String pathname, String filename, String originfilename){
            boolean flag = false;
            try {
                InputStream inputStream = new FileInputStream(new File(originfilename));
                flag = uploadFile(hostname, port, username, password, pathname, filename, inputStream);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return flag;
        }
         
        /**
         * 上传文件（不可以进行文件的重命名操作）
         * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器保存目录
         * @param originfilename 待上传文件的名称（绝对地址）
         * @return
         */
        public static boolean uploadFileFromProduction(String hostname, int port, String username, String password, String pathname, String originfilename){
            boolean flag = false;
            try {
                String fileName = new File(originfilename).getName();
                InputStream inputStream = new FileInputStream(new File(originfilename));
                flag = uploadFile(hostname, port, username, password, pathname, fileName, inputStream);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return flag;
        }
         
         
        /**
         * 删除文件
         * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器保存目录
         * @param filename   要删除的文件名称
         * @return
         */
        public static boolean deleteFile(String hostname, int port, String username, String password, String pathname, String filename,String date){
    
            boolean flag = false;
            FTPClient ftpClient = new FTPClient();
            try {
                //连接FTP服务器
                ftpClient.connect(hostname, port);
                //设置传输时间
                ftpClient.setDataTimeout(35000);
                //设置默认的全局超时时间
                
                //登录FTP服务器
                ftpClient.login(username, password);
                //验证FTP服务器是否登录成功
                int replyCode = ftpClient.getReplyCode();
                
                if(!FTPReply.isPositiveCompletion(replyCode)){
                    return flag;
                }
                ftpClient.enterLocalPassiveMode(); // 使用被动模式
                //切换FTP目录
                ftpClient.changeWorkingDirectory(filename);
                FTPFile[] ftpFiles= ftpClient.listFiles();
                if (ftpFiles.length>0) {
                    for(FTPFile file:ftpFiles ){
                        String name=file.getName();
                        if(date.equals(name)){
                        
                             long currTime = System.currentTimeMillis();
                             String deleteName="../"+filename+"/"+name;
                           
                             String bb= removeDirectoryALLFile(deleteName,ftpClient);
                       
                             long lastTime = System.currentTimeMillis();
                   
                             flag = true;
                        }
                        /*int index=name.lastIndexOf(".");
                        String suffix=name.substring(index+1);
                        String name1=fileName.get(suffix);  //获取要移动的文件名
                        if (name.equalsIgnoreCase(name1)) {
                            
                            long currTime = System.currentTimeMillis();
                          
                            ftpClient.deleteFile(file.getName());
                            long lastTime = System.currentTimeMillis();
                        
                            flag = true;
                                                    
                        }*/
                        
                     }
                    ftpClient.logout();    
                }else{
                    System.out.println("deleteFile未进行删除文件，遍历文件大小为0");
                }   
            } catch (Exception e) {
                
            } finally{
                if(ftpClient.isConnected()){
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        
                    }
                }
            }
            return flag;
        }
         
        /**
         * 下载文件
         * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器文件目录
         * @param filename   文件名称
         * @param localpath 下载后的文件路径
         * @return
         */
        
        public static List<Map<String, String>> downloadFile(String hostname, int port, String username, String password, String pathname, String filename, String localpath){
            
            /*System.out.println("hostname="+hostname+" port="+port+" username="+username+" password="+password+" pathname="+pathname);
            System.out.println(" filename="+filename+" localpath="+localpath);*/
            List<Map<String, String>> list=new ArrayList<Map<String,String>>();
            
            FTPClient ftpClient = new FTPClient();
            try {
                //连接FTP服务器
                ftpClient.connect(hostname, port);
               
                //设置传输时间
                ftpClient.setDataTimeout(1200000);
                //设置默认的全局超时时间；
                ftpClient.setDefaultTimeout(3600000);
                //登录FTP服务器
                ftpClient.login(username, password);
               
                //验证FTP服务器是否登录成功
                int replyCode = ftpClient.getReplyCode();
                System.out.println(" downloadFile-->验证服务器是否成功登陆："+replyCode);
                //判断返回是否合法
                if(!FTPReply.isPositiveCompletion(replyCode)){
                    //断开连接
                    ftpClient.disconnect();
                    System.out.println(" downloadFile-->连接服务器失败!");
                    return null;
                }
               ftpClient.enterLocalPassiveMode();  //被动模式
              /* ftpClient.enterLocalActiveMode();   //主动模式*/               
               //转移到FTP服务器目录 下文件
               
                boolean bb= ftpClient.changeWorkingDirectory(filename);
               System.out.println("成功转移到目录下filename:"+bb+"-"+"filename:"+filename);
                 if(bb){
                       FTPFile[] ftpFiles= ftpClient.listFiles();
                     
                       if(ftpFiles.length>0){
                           long currTime = System.currentTimeMillis();   
                           for(FTPFile file : ftpFiles){
                               String name=file.getName();
                               try{
                                   File localFile = new File(localpath + "//" + name);
                                   OutputStream os = new FileOutputStream(localFile);
                                   ftpClient.retrieveFile(name, os);
                                   os.flush();
                                   os.close();
                              //用来记录ftp文件下载的chk文件
                                   int index=name.lastIndexOf(".");
                                   String suffix=name.substring(index+1);
                                   if("chk".equalsIgnoreCase(suffix)){
                                    Map<String, String> map=new HashMap<String, String>();
                                      map.put("chk", name);
                                      System.out.println("downloadFile-->map="+map);
                                      list.add(map);
                                    }
                               }catch(Exception e){
                                  
                               }
                           }
                           
                         long lasttime = System.currentTimeMillis();
                            System.out.println("(lasttime-currTime:)"+(lasttime-currTime));
                   }      
               }else{
                System.out.println("hunanBSS downloadFile-->成功连接服务器,未有文件下载!");
               }
                ftpClient.logout();
            } catch (Exception e) {
                logger1.error("hunanBSS downloadFile-->连接服务器异常!"+e.getMessage(),e);
                    
            } finally{
                if(ftpClient.isConnected()){
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                        logger1.error("[hunanBSS.FtpUtil] downloadFile-->FTP断开连接异常:!",e);
                    }
                }
            }
            
            return list;
           
        }
      /**
       * 移动文件  
       * @param hostname FTP服务器地址
         * @param port   FTP服务器端口号
         * @param username   FTP登录帐号
         * @param password   FTP登录密码
         * @param pathname   FTP服务器文件目录
         * @param filename   文件名称
         * @param newfilename 下载后的文件路径
         * @return
         */
     public static void removeName(String hostname, int port, String username, String password, String filename,String newfilename,String date){
         FTPClient ftpClient = new FTPClient();
            try {
                //连接FTP服务器
                ftpClient.connect(hostname, port);
               
                //设置传输时间
                ftpClient.setDataTimeout(1200000);
                //设置默认的全局超时时间；
                ftpClient.setDefaultTimeout(3600000);
                //登录FTP服务器
                ftpClient.login(username, password);
               
                //验证FTP服务器是否登录成功
                int replyCode = ftpClient.getReplyCode();
                System.out.println("hunanBSS removeName-->验证服务器是否成功登陆："+replyCode);
                //判断返回是否合法
                if(!FTPReply.isPositiveCompletion(replyCode)){
                    //断开连接
                    ftpClient.disconnect();
                    System.out.println("hunanBSS removeName-->连接服务器失败!");
                }
               ftpClient.enterLocalPassiveMode();  //被动模式
               boolean bb= ftpClient.changeWorkingDirectory(filename);
               System.out.println("成功转移到目录下filename:"+bb+"-"+"filename:"+filename);
               FTPFile[] ftpFiles= ftpClient.listFiles();
               System.out.println("ftpFiles.length:"+ftpFiles.length);
               if(ftpFiles.length>0){
                   for(FTPFile file : ftpFiles){
                       String name=file.getName();
                       System.out.println("hunanBSS removeName name="+name);
                       if(date.equals(name)){                                   //修改根据时间转移文件夹
                           String newfilename1="../"+newfilename+"/"+date;
                           System.out.println("newfilename1="+newfilename1);
                           ftpClient.rename(name, newfilename1);
                       }
                       /*int index=name.lastIndexOf(".");
                       String suffix=name.substring(index+1);
                       String name1=map.get(suffix);  //获取要移动的文件名
                       String newfilename1="../"+newfilename+"/"+name;
                       System.out.println("removeName-->newfilename="+newfilename1+" filename="+name+" downloadFilename="+name1);
                       if(name1.equalsIgnoreCase(name)){
                           ftpClient.rename(name, newfilename1);
                       }*/
                       
                   }
               }else {
                 System.out.println("----空文件----");
               }
            }catch (Exception e) {
                
                    
            } finally{
                if(ftpClient.isConnected()){
                    try {
                        ftpClient.disconnect();
                    } catch (IOException e) {
                    
                    }
                }
            }
     }
    
     /**
         * 删除Ftp上的文件夹 包括其中的文件 <功能详细描述>
         *
         * @param client Ftp对象
         * @param pathName 文件夹路径
         * @return SUCCESS:成功 其他:失败
         * @see [类、类#方法、类#成员] Create Author:<> Time:<Aug 18, 2014> Ver:< >
         */
        public static String removeDirectoryALLFile(String pathName,FTPClient ftpClient)
        {
            try
            {
            
                FTPFile[] files = ftpClient.listFiles(pathName);
                if (null != files && files.length > 0)
                {
                    for (FTPFile file : files)
                    {
                        if (file.isDirectory())
                        {
                            removeDirectoryALLFile(pathName + "/" + file.getName(),ftpClient );
                            
                            // 切换到父目录，不然删不掉文件夹
                            ftpClient.changeWorkingDirectory(pathName.substring(0,pathName.lastIndexOf("/")));
                            ftpClient.removeDirectory(pathName);
                        }
                        else
                        {
                            if (!ftpClient.deleteFile(pathName+ "/" + file.getName()))
                            {
                                return "删除指定文件" + pathName + "/" + file.getName() + "失败!";
                            }
                        }
                    }
                }
                // 切换到父目录，不然删不掉文件夹
                ftpClient.changeWorkingDirectory(pathName.substring(0,pathName.lastIndexOf("/")));
                ftpClient.removeDirectory(pathName);
            }
            catch (IOException e)
            {
                logger1.error("删除指定文件夹" + pathName + "失败：" + e.getMessage(),e);
            
                return "删除指定文件夹" + pathName + "失败：" + e;
            }
            
            return "删除成功";
        }
        
        /**
         * 删除指定文件
         *
         * @param filePath 文件路径(含文件名)
         * @see [类、类#方法、类#成员]
         * @return SUCCESS:成功 其他:失败信息
         */
        public String removeFile(String filePath)
        {
            try
            {
                FTPClient ftpClient = new FTPClient();
                if (StringUtils.isNotEmpty(filePath))
                {
                    if (!ftpClient.deleteFile(filePath))
                    {
                        return "删除文件" + filePath + "失败！";
                    }
                }
            }
            catch (IOException e)
            {
                logger1.error("删除文件失败："+e.getMessage(),e);
                return "删除文件" + filePath + "失败！" + e;
            }
            return "success";
        }

    
}