JAVA使用FTPClient类读写FTP

public class FTPFactory {

    /**
     * 1、创建FTP连接
     * @param ip
     * @param user
     * @param password
     * @return
     */
    public static FTPClient obtainFTPClient(String ip, String user, String password) {

        FTPClient ftpClient = new FTPClient();  
        try {  
            //连接服务器ip
            ftpClient.connect(ip);  
            //登录用户
            ftpClient.login(user, password);
            if (!FTPReply.isPositiveCompletion(ftpClient.getReplyCode())) {  
                System.out.println("未连接到FTP，用户名或密码错误。");
                ftpClient.disconnect();  
            } else {
                System.out.println("FTP连接成功。");  
            }  
        } catch (SocketException e) {
            e.printStackTrace();  
            System.out.println("FTP的IP地址可能错误，请正确配置。"+e.getMessage());
        } catch (IOException e) {  
            e.printStackTrace(); 
            System.out.println("FTP的端口错误,请正确配置。"+e.getMessage());
        }  

        if (!ftpClient.isConnected()) { 
            System.out.println("--------------FTP连接失败----------------");
            ftpClient = null;  
        }  

        return ftpClient;  
    }


    /**
     * 2、关闭ftp连接  
     * @param ftpClient
     */
    public static void closeFtp(FTPClient ftpClient){  

        if (ftpClient!=null && ftpClient.isConnected()) {  
            try {  
                //登出用户
                ftpClient.logout(); 
                //关闭连接
                ftpClient.disconnect();
                System.out.println("FTP远程连接关闭成功");
            } catch (IOException e) {  
                e.printStackTrace(); 
                System.out.println("FTP远程连接关闭失败"+e.getMessage());
            }  
        }  
    }  


    /**
     * 根据文件所在的本地   目录和文件名,下载单个文件
     * @param ftpClient     客户端对象
     * @param localFilePath 下载到本地的文件路径
     * @param fileName      文件名
     */
    public static void downloadFile(FTPClient ftpClient,String downloadFilePath,
                                    String localFilePath,String fileName){


        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持  
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);//文件类型为二进制文件
            ftpClient.enterLocalPassiveMode();  //ftp client告诉ftp server开通一个端口来传输数据
            //进入服务器指定的目录（更改当前工作目录）：不然在这个目录找不到需要下载的文件
            boolean isDiretory=ftpClient.changeWorkingDirectory(downloadFilePath);
            if(isDiretory){
                System.out.println("进入服务器目录："+downloadFilePath+",成功");
            }else {
                System.out.println("进入服务器目录："+downloadFilePath+",失败");
            }


            //创建本地目录
            File dir=new File(localFilePath);
            if(!dir.exists()){
                dir.mkdirs();
                System.out.println("下载目录已创建!");
            }else{
                System.out.println("下载目录已存在!"); 
            }


            //创建本地文件的输出流：声明下载后的本地路径和文件名
            File localFile = new File(localFilePath + File.separatorChar + fileName);  
            //创建本地文件
            if(!localFile.exists()){
                localFile.createNewFile();
             }
            OutputStream os = new FileOutputStream(localFile);  


            //将服务器上的文件内容通过输出流fos写到本地文件中:fileName服务器上待下载的文件名
            boolean flag=ftpClient.retrieveFile(fileName, os);  //下载文件
            if(flag){
                System.out.println("下载成功。");
            }else {
                System.out.println("下载失败。");
            }
            os.close();  
        }catch (FileNotFoundException e) {  
            System.out.println("没有找到" + localFilePath+ File.separatorChar+ fileName+ "文件");  
            e.printStackTrace();  
        } catch (IOException e) {
            System.out.println("读取文件错误");
            e.printStackTrace();
        }finally{
            //每次做完一次操作后，关闭连接，避免连接超时问题（当然，每次操作都要重新连接）
            closeFtp(ftpClient);
        }

    }


    /**
     * 批量下载某个文件夹下的所有文件
     * 
     * @param ftpClient
     * @param downloadFilePath
     * @param localFilePath
     */
    public static void batchDownloadFile(FTPClient ftpClient,String downloadFilePath,String localFilePath){

        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持  
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);//文件类型为二进制文件
            ftpClient.enterLocalPassiveMode();  //ftp client告诉ftp server开通一个端口来传输数据
            //进入服务器指定的目录（更改当前工作目录）：不然在这个目录找不到需要下载的文件
            boolean isDiretory=ftpClient.changeWorkingDirectory(downloadFilePath);
            if(isDiretory){
                System.out.println("进入服务器目录："+downloadFilePath+",成功");
                //获得该目录downloadFilePath下的所有文件
            }else {
                System.out.println("进入服务器目录："+downloadFilePath+",失败");
            }           

            //遍历当前目录
            FTPFile[] fileDic = ftpClient.listFiles();
            if(fileDic.length>0){

                for(FTPFile f: fileDic){
                    //创建本地目录
                     File dir=new File(localFilePath);
                     if(!dir.exists()){
                        dir.mkdirs();
                        System.out.println("下载目录已创建!");                 
                     }else{
                        System.out.println("下载目录已存在!");
                     }
                     //创建本地文件
                     File localFile = new File(localFilePath +File.separator+ f.getName());
                     if(!localFile.exists()){
                        localFile.createNewFile();
                     }
                     //创建本地文件的输出流
                     FileOutputStream fos = new FileOutputStream(localFile);
                     //将服务器上的文件内容通过输出流fos写到本地文件中
                     boolean flag=ftpClient.retrieveFile(f.getName(), fos);
                     //如果下载成功就删除服务器上的文件
                     if(flag){
                         System.out.println("文件下载成功："+f.getName());
                     }
                     //关闭流
                     fos.close();
                 }
            }else {
                System.out.println("待下载目录为空");
            }

        }catch (FileNotFoundException e) {  
            System.out.println("没有找到文件");  
            e.getMessage();
            e.printStackTrace();  
        } catch (IOException e) {
            System.out.println("读取文件错误");
            e.getMessage();
            e.printStackTrace();
        }finally{
            //每次做完一次操作后，关闭连接，避免连接超时问题（当然，每次操作都要重新连接）
            closeFtp(ftpClient);
        }
    }






    /**
     * 上传单个文件
     * @param ftpClient
     * @param uploadPath   上传到服务器的目录
     * @param fileName     上传到服务器的文件名称
     * @param file         待上传的文件
     */
    public static void uploadFile(FTPClient ftpClient,String uploadPath,File file){

        FileInputStream fis = null;
        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持  
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);//文件类型为二进制文件
            //ftp client告诉ftp server开通一个端口来传输数据
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE);


            //进入服务器指定的目录（更改当前工作目录）：不然在这个目录找不到需要下载的文件
            if(ftpClient.changeWorkingDirectory(uploadPath)){
                System.out.println("进入服务器目录："+uploadPath+",成功");
            }else {
                System.out.println("进入服务器目录："+uploadPath+",失败");
                //创建该目录
                if(ftpClient.makeDirectory(uploadPath)){                
                    System.out.println("创建"+uploadPath+",目录成功");
                    ftpClient.changeWorkingDirectory(uploadPath);
                }else {
                    System.out.println("创建"+uploadPath+",目录失败");
                }
            }


            fis = new FileInputStream(file);
            //fileName：上传到服务器的文件名    fis：待上传的文件
            boolean flag=ftpClient.storeFile(file.getName(), fis);
            //boolean flag=ftpClient.storeFile(new String(file.getName().getBytes("UTF-8"),"iso-8859-1"), fis);
            if(flag){
                System.out.println("文件上传成功");
            }else {
                System.out.println("文件上传失败");
            }
            //关闭流
            fis.close();
        }catch (FileNotFoundException e) {  
            System.out.println("没有找到" + file+"这个文件");  
            e.printStackTrace();  
        } catch (IOException e) {
            System.out.println("读取文件错误");
            e.printStackTrace();
        }catch(Exception e){
            System.out.println(e.getMessage());
            e.printStackTrace();
        }finally{
            //每次做完一次操作后，关闭连接，避免连接超时问题（当然，每次操作都要重新连接）
            closeFtp(ftpClient);    
        }

    }


    /**
     * 删除单个文件
     * 
     * @param ftpClient
     * @param targetFilePath
     * @param targetFileName
     */
    public static void deleteFile(FTPClient ftpClient,String targetFilePath,String targetFileName){

        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持  
            //文件类型为二进制文件
            ftpClient.enterLocalPassiveMode();  //ftp client告诉ftp server开通一个端口来传输数据
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //进入服务器指定的目录（更改当前工作目录）：不然在这个目录找不到需要下载的文件
            boolean isDiretory=ftpClient.changeWorkingDirectory(targetFilePath);
            if(isDiretory){
                System.out.println("进入服务器目录："+targetFilePath+",成功");
            }else {
                System.out.println("进入服务器目录："+targetFilePath+",失败");
            }


            //ftpClient.removeDirectory(pathname): 删除目录
            boolean flag=ftpClient.deleteFile(targetFileName);
            if(flag){
                System.out.println(targetFileName+":文件删除成功。");
            }else {
                System.out.println(targetFileName+":文件删除失败。");
            }
        } catch (IOException e) {
            System.out.println("删除文件失败。");
            e.printStackTrace();
        }finally{
            //每次做完一次操作后，关闭连接，避免连接超时问题（当然，每次操作都要重新连接）
            closeFtp(ftpClient);    
        }


    }



    /**
     * 读取FTP服务器上的某个文件内容
     * @param ftpClient      客户端
     * @param fileDirectory  服务器文件目录
     * @param fileName       文件名
     */
    @SuppressWarnings("finally")
    public static String readFileFromFTP(FTPClient ftpClient,String fileDirectory,String fileName){


        StringBuffer resultBuffer = new StringBuffer();   
        InputStream in = null;  
        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //ftp client告诉ftp server开通一个端口来传输数据
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE);

            if(ftpClient.changeWorkingDirectory(fileDirectory)){
                System.out.println("进入目录："+fileDirectory+",成功");
            }else {
                System.out.println("进入目录："+fileDirectory+",失败");
            }

            //将文本转化为InputStream流
            in = ftpClient.retrieveFileStream(fileName);
            BufferedReader br = new BufferedReader(new InputStreamReader(in));
            String data = null;
            if(in!=null){
                while ((data = br.readLine()) != null) {  
                    resultBuffer.append(data + "\r\n");  
                }
            }

            System.out.println("文本内容："+resultBuffer.toString());
            in.close();
            br.close();

        }catch (FileNotFoundException e) {  
            System.out.println("没有找到文件："+fileName);  
            e.getMessage();
            e.printStackTrace();  
        } catch (IOException e) {
            e.getMessage();
            e.printStackTrace();
        }finally{
            closeFtp(ftpClient);
            return resultBuffer.toString();
        }

    }


    /**
     * 将某段文本写到服务器指定目录的指定文件中
     * 
     * @param ftpClient
     * @param fileDirectory
     * @param fileName
     * @param fileContext
     */
    public static void writeContextToFTPFile(FTPClient ftpClient,String fileDirectory,String fileName,String fileContext){

        OutputStream out=null;
        try {
            ftpClient.setControlEncoding("UTF-8"); // 中文支持
            ftpClient.setFileType(FTPClient.BINARY_FILE_TYPE);
            //ftp client告诉ftp server开通一个端口来传输数据
            ftpClient.enterLocalPassiveMode();
            ftpClient.setFileTransferMode(FTPClient.STREAM_TRANSFER_MODE);

            if(ftpClient.changeWorkingDirectory(fileDirectory)){
                System.out.println("进入目录："+fileDirectory+",成功");
            }else {
                System.out.println("进入目录："+fileDirectory+",失败");
            }

            //将文本转化为OutputStream流
            out = ftpClient.storeFileStream(fileName);
            PrintWriter pw = new PrintWriter(new OutputStreamWriter(out));
            //将文本写入
            pw.println(fileContext);
            pw.close();

        }catch (FileNotFoundException e) {  
            System.out.println("没有找到文件："+fileName);  
            e.getMessage();
            e.printStackTrace();  
        } catch (IOException e) {
            e.getMessage();
            e.printStackTrace();
        }finally{
            closeFtp(ftpClient);
        }
    }


       /** 
        * 循环切换目录 
        * @param dir 
        * @return 
        */  
       public boolean cd(FTPClient ftpClient,String dir){  
            boolean stat = true;  
            try {  
                   String[] dirs = dir.split("/");  
                   //只有一级目录
                   if(dirs.length == 0){  
                       return ftpClient.changeWorkingDirectory(dir);  
                   }  
                   //多级目录
                   stat = ftpClient.changeToParentDirectory();  
                    for(String dirss : dirs){  
                        stat = stat && ftpClient.changeWorkingDirectory(dirss);  
                    }  

                    stat = true;  
               } catch (IOException e) {  
                    stat = false;  
               }  
               return stat;  
       }  


       /*** 
        * 创建目录 
        * @param dir 
        * @return 
        */  
       public boolean mkdir(FTPClient ftpClient,String dir){  
           boolean stat = false;  
           try {  
               ftpClient.changeToParentDirectory();  
               ftpClient.makeDirectory(dir);  
               stat = true;  
           } catch (IOException e) {  
                stat = false;  
           }  
           return stat;  
       }  

       /*** 
        * 创建多个层级目录 
        * @param dir dong/zzz/ddd/ewv 
        * @return 
        */  
       public boolean mkdirs(FTPClient ftpClient,String dir){  
           String[] dirs = dir.split("/");  
           if(dirs.length == 0){  
               return false;  
           }  
           boolean stat = false;  
           try {  
               ftpClient.changeToParentDirectory();  
                for(String dirss : dirs){  
                    ftpClient.makeDirectory(dirss);  
                    ftpClient.changeWorkingDirectory(dirss);  
                }  

                ftpClient.changeToParentDirectory();  
                stat = true;  
           } catch (IOException e) {  
                stat = false;  
           }  
           return stat;  
       }  

       /** 
        * 删除文件夹 
        * @param pathname 
        * @return 
        */  
       public boolean rmdir(FTPClient ftpClient,String pathname){  
           try{  
               return ftpClient.removeDirectory(pathname);  
           }catch(Exception e){  
               return false;  
           }  
       }  

       /** 
        * 删除文件 
        * @param pathname 
        * @return 
        */  
       public boolean remove(FTPClient ftpClient,String pathname){  
           boolean stat = false;  
           try{  
               stat = ftpClient.deleteFile(pathname);   
           }catch(Exception e){  
               stat = false;  
           }  
           return stat;  
       }  

}