JAVA使用FTPClient类读写FTP

雨点打透心脏的1/2处 2022-05-30 00:29 261阅读 0赞

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