sftp,ftp文件下载

一、sftp工具类

package com.ztesoft.iotcmp.util;

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpException;

import java.io.*;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import java.util.zip.GZIPInputStream;

public class SftpUtil implements AutoCloseable {
    private Session session = null;
    private ChannelSftp channel = null;

    private String userName = "bi";
    private String passWord = "bi";
    private String hostName = "10.40.197.41";
    private String port = "";
    private String workDir = "test/download";

    public SftpUtil(String hostName, String port, String userName
            , String passWord, String workDir) throws IOException, JSchException {
        this.hostName = hostName;
        this.port = port;
        this.userName = userName;
        this.passWord = passWord;
        this.workDir = workDir;
        connectServer(hostName, Integer.parseInt(port), userName, passWord);
    }

    /**
     * 连接sftp服务器
     *
     * @param serverIP 服务IP
     * @param port     端口
     * @param userName 用户名
     * @param password 密码
     * @throws SocketException SocketException
     * @throws IOException     IOException
     * @throws JSchException   JSchException
     */
    public void connectServer(String serverIP, int port, String userName, String password) throws JSchException {
        JSch jsch = new JSch();
        // 根据用户名,主机ip,端口获取一个Session对象
        session = jsch.getSession(userName, serverIP, port);
        // 设置密码
        session.setPassword(password);
        // 为Session对象设置properties
        Properties config = new Properties();
        config.put("StrictHostKeyChecking", "no");
        session.setConfig(config);
        // 通过Session建立链接
        session.connect();
        // 打开SFTP通道
        channel = (ChannelSftp) session.openChannel("sftp");
        // 建立SFTP通道的连接
        channel.connect();

    }

    /**
     * 自动关闭资源
     */
    public void close() {
        if (channel != null) {
            channel.disconnect();
        }
        if (session != null) {
            session.disconnect();
        }
    }

    /**
     * @param path
     * @throws SftpException
     * @return获取目录下文件名称
     */
    public List<String> getDirFileList(String path) throws SftpException {
        List<String> list = new ArrayList<>();
        if (channel != null) {
            Vector vv = channel.ls(path);
            if (vv == null && vv.size() == 0) {
                return list;
            } else {
                Object[] aa = vv.toArray();
                for (int i = 0; i < aa.length; i++) {
                    System.out.print(aa[i].toString());
                    ChannelSftp.LsEntry temp = (ChannelSftp.LsEntry) aa[i];
                    //获取文件名称
                    String fileName = temp.getFilename();
                    //判断文件名称是否为点
                    if (!fileName.equals(".") && !fileName.equals("..")) {
                        //判断文件是否为目录
                        if (!temp.getAttrs().isDir()) {
                            list.add(fileName);
                        }
                    }
                }
            }
        }
        return list;
    }

    /**
     * 下载文件
     *
     * @param remotePathFile 远程文件
     * @param localPathFile  本地文件[绝对路径]
     * @throws SftpException SftpException
     * @throws IOException   IOException
     */
    public void downloadFile(String remotePathFile, String localPathFile) throws SftpException, IOException {
        try (FileOutputStream os = new FileOutputStream(new File(localPathFile))) {
            if (channel == null)
                throw new IOException("sftp server not login");
            channel.get(remotePathFile, os);
        }
    }

    /**
     * 下载文件
     *
     * @param downloadFile 下载的文件
     * @param saveFile     存在本地的路径
     */
    public void download(String downloadFile, String saveFile) throws SftpException, FileNotFoundException {
        if (workDir != null && !"".equals(workDir)) {
            channel.cd(workDir);
        }
        File file = new File(saveFile);
        channel.get(downloadFile, new FileOutputStream(file));
        System.out.println("下载文件到"+saveFile+"目录完成!");
    }

    /**
     * 下载文件
     *
     * @param downloadFile 下载的文件
     */
    public InputStream download(String downloadFile) {
        InputStream in = null;
        try {
            channel.cd(workDir);
            in = channel.get(downloadFile);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
        return in;
    }


    /**
     * 上传文件
     *
     * @param remoteFile 远程文件
     * @param localFile
     * @throws SftpException
     * @throws IOException
     */
    public void uploadFile(String remoteFile, String localFile) throws SftpException, IOException {
        try (FileInputStream in = new FileInputStream(new File(localFile))) {
            if (channel == null)
                throw new IOException("sftp server not login");
            channel.put(in, remoteFile);
        }
    }

    /**
     * 下载流文件
     *
     * @param remoteFileName
     * @return
     * @throws SftpException
     * @throws IOException
     */
    public BufferedReader downloadGZFile(String remoteFileName) throws SftpException, IOException {
        BufferedReader returnValue = null;

        //跳转目录
        Boolean state = openDir(this.workDir, channel);

        //判断是否跳转到指定目录
        if (state) {
            InputStream in = new GZIPInputStream(channel.get(remoteFileName));
            if (in != null) {
                returnValue = new BufferedReader(new InputStreamReader(in));
                System.out.println("<----------- INFO: download " + this.workDir + "/" + remoteFileName + " from ftp : succeed! ----------->");
            } else {
                System.out.println("<----------- ERR : download " + this.workDir + "/" + remoteFileName + " from ftp : failed! ----------->");
            }
        }

        return returnValue;
    }


    /**
     * 跳转到指定的目录
     *
     * @param directory
     * @param sftp
     * @return
     */
    public static boolean openDir(String directory, ChannelSftp sftp) {
        try {
            sftp.cd(directory);
            return true;
        } catch (SftpException e) {
            return false;
        }
    }

    public String getWorkDir() {
        return this.workDir;
    }
}

 

二、文件处理思想流程

获取sftp连接

SftpUtil sftpUtil = new SftpUtil(host,port,userName,passWord,dir);

 

根据路径获取文件列表

List<String> fileList = sftpUtil.getDirFileList(sftpUtil.getWorkDir());
if (fileList == null || fileList.isEmpty()) {
     throw new RuntimeException("没有文件要处理!");
}

 

判断文件是否处理过

boolean flag = SftpConfigUtil.checkFileIsDeal(fileName);//此处是根据表数据查询

 

未处理,进行处理过程

if (!flag){
    BufferedReader reader = sftpUtil.downloadGZFile(fileName);//下载压缩文件并转化为流

    List<TempPaymentDayAuditFileDTO> dataList = paseReader(reader, fileName);//解析文件字段,注意关闭文件流reader.close();
tempPaymentDayAuditService.insertPaymentDayAudits(dataList);//插入数据库 SftpConfigUtil.insertFileIsDeal(fileName);//插入文件已处理标记到数据表中 }

 

关闭sftp连接

 sftpUtil.close();

 

三、ftp工具类

package com.ztesoft.iotcmp.util;

import org.apache.commons.io.IOUtils;
import org.apache.commons.net.ftp.FTP;
import org.apache.commons.net.ftp.FTPClient;
import org.apache.commons.net.ftp.FTPFile;
import org.apache.commons.net.ftp.FTPReply;

import java.io.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.zip.GZIPInputStream;

/**
 * Ftp操作工具类
 * 
 * @author easonwu 
 *
 */
public class FtpUtil {

    private  String userName = "bi";
    private  String passWord = "bi";
    private  String hostName = "10.40.197.41" ;
    private  String port = "" ;
    private  String workDir = "test/download" ;
    private  FTPClient ftpClient = new FTPClient();
    

    public FtpUtil() throws IOException {
        initailCheck() ;
    }
    
    public FtpUtil(String hostName , String port , String userName 
            , String passWord , String workDir) throws IOException {
        this.hostName = hostName ;
        this.port = port ;
        this.userName = userName ;
        this.passWord = passWord ;
        this.workDir = workDir ;
        initailCheck() ;
    }
    
    private void initailCheck() throws IOException {
        connectToServer();
        if( this.workDir != null && !"".endsWith(this.workDir )){
            checkPathExist(this.workDir);
        }
        closeConnect();
    }

    /** 
     * 查找指定目录是否存在 
     * @param  filePath 要查找的目录
     * @return boolean:存在:true,不存在:false 
     * @throws IOException 
     */
    private  boolean checkPathExist(String filePath) throws IOException {
        boolean existFlag = false;
        try {
            if (!ftpClient.changeWorkingDirectory(filePath)) {
                ftpClient.makeDirectory(filePath);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return existFlag;
    }

    /** 
     * 连接到ftp服务器 
     */
    private void connectToServer() throws IOException{
        if(!ftpClient.isConnected()){
            int reply;
            try{
                ftpClient = new FTPClient();
                ftpClient.enterLocalPassiveMode();
                
                if(this.port == null || "".equals(this.port)){
                    ftpClient.connect(this.hostName);
                }
                else{
                    ftpClient.connect(this.hostName, Integer.parseInt(this.port));
                }
                
                ftpClient.login(userName, passWord);
                reply = ftpClient.getReplyCode();
                
                if(!FTPReply.isPositiveCompletion(reply)){
                    ftpClient.disconnect();
                    System.err.println("FTP server refused connection.");
                }
            }
            catch(IOException e){
//                System.err.println("登录ftp服务器【" + this.hostName + "】失败");
                e.printStackTrace();
                throw new IOException("登录ftp服务器【" + this.hostName + "】失败");
            }
        }
    }

    /** 
     * 关闭连接 
     */
    private  void closeConnect() {
        try {
            if (ftpClient != null) {
                ftpClient.logout();
                ftpClient.disconnect();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /** 
     * 转码[GBK ->  ISO-8859-1] 
     * 不同的平台需要不同的转码 
     * @param obj 
     * @return 
     */
    private static String gbkToIso8859(Object obj) {
        try {
            if (obj == null)
                return "";
            else
                return new String(obj.toString().getBytes("GBK"), "iso-8859-1");
        } catch (Exception e) {
            return "";
        }
    }

    /** 
     * 转码[ISO-8859-1 ->  GBK] 
     * 不同的平台需要不同的转码 
     * @param obj 
     * @return 
     */
    private static String iso8859ToGbk(Object obj) {
        try {
            if (obj == null)
                return "";
            else
                return new String(obj.toString().getBytes("iso-8859-1"), "GBK");
        } catch (Exception e) {
            return "";
        }
    }

    /** 
     * 设置传输文件的类型[文本文件或者二进制文件] 
     * @param fileType--BINARY_FILE_TYPE、ASCII_FILE_TYPE 
     */
    private  void setFileType(int fileType) {
        try {
            ftpClient.setFileType(fileType);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private void changeDir(String filePath) throws IOException {
//        跳转到指定的文件目录 
        if (filePath != null && !filePath.equals("")) {
            if (filePath.indexOf("/") != -1) {
                int index = 0;
                while ((index = filePath.indexOf("/")) != -1) {
                    System.out.println("P:"+ filePath.substring(0,
                            index)) ;
                    ftpClient.changeWorkingDirectory(filePath.substring(0,
                            index));

                    filePath = filePath.substring(index + 1, filePath.length());
                }
                if (!filePath.equals("") && !"/".equals(filePath)) {
                    ftpClient.changeWorkingDirectory(filePath);
                }
            } else {
                ftpClient.changeWorkingDirectory(filePath);
            }
        }
    }
    /**
     * check file 
     * @param filePath
     * @param fileName
     * @return
     * @throws IOException
     */
    private  boolean checkFileExist(String filePath, String fileName)
            throws IOException {
        boolean existFlag = false;
        changeDir( filePath )  ;
        String[] fileNames = ftpClient.listNames();
        if (fileNames != null && fileNames.length > 0) {
            for (int i = 0; i < fileNames.length; i++) {
                System.out.println("File:" + iso8859ToGbk(fileNames[i])) ;
                if (fileNames[i] != null
                        && iso8859ToGbk(fileNames[i]).equals(fileName)) {
                    existFlag = true;
                    break;
                }
            }
        }
        ftpClient.changeToParentDirectory();
        return existFlag;
    }

    /**
     * download ftp file as inputstream 
     * @param remoteFileName
     * @return
     * @throws IOException
     */
    public  InputStream downloadFile(
            String remoteFileName) throws IOException {
        InputStream returnValue = null;
        //下载文件 
        BufferedOutputStream buffOut = null;
        try {
            //连接ftp服务器 
            connectToServer();
            if (!checkFileExist(this.workDir, remoteFileName)) {
                System.out.println("<----------- ERR : file  " + this.workDir    + "/" + remoteFileName+ " does not exist, download failed!----------->");
                return null;
            } else {
                changeDir( this.workDir )  ;
                String[] fileNames = ftpClient.listNames();
                
                //设置传输二进制文件 
                setFileType(FTP.BINARY_FILE_TYPE);
                //获得服务器文件 
                InputStream in = ftpClient.retrieveFileStream(remoteFileName);
                //输出操作结果信息 
                if (in != null) {
                    returnValue = new ByteArrayInputStream(IOUtils.toByteArray(in));
                    in.close();
                    System.out.println("<----------- INFO: download "+ this.workDir + "/" + remoteFileName+ " from ftp : succeed! ----------->");
                } else {
                    System.out.println("<----------- ERR : download "+ this.workDir + "/" + remoteFileName+ " from ftp : failed! ----------->");
                }
            }
            //关闭连接 
            closeConnect();
        } catch (Exception e) {
            e.printStackTrace();
            returnValue = null;
            //输出操作结果信息 
            System.out.println("<----------- ERR : download " +  this.workDir + "/" + remoteFileName+ " from ftp : failed! ----------->");
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    closeConnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return returnValue;
    }
    
    /**
     * 
     * @param remoteFilePath
     * @param remoteFileName
     * @param localFileName
     * @return
     * @throws IOException
     */
    public  boolean downloadFile(String remoteFilePath,
            String remoteFileName, String localFileName) throws IOException {
        boolean returnValue = false;
        //下载文件 
        BufferedOutputStream buffOut = null;
        try {
            //连接ftp服务器 
            connectToServer();
            File localFile = new File(localFileName.substring(0, localFileName
                    .lastIndexOf("/")));
            if (!localFile.exists()) {
                localFile.mkdirs();
            }
            if (!checkFileExist(remoteFilePath, remoteFileName)) {
                System.out.println("<----------- ERR : file  " + remoteFilePath    + "/" + remoteFileName+ " does not exist, download failed!----------->");
                return false;
            } else {
                changeDir( remoteFilePath )  ;
                String[] fileNames = ftpClient.listNames();
                
                //设置传输二进制文件 
                setFileType(FTP.BINARY_FILE_TYPE);
                //获得服务器文件 
                buffOut = new BufferedOutputStream(new FileOutputStream(
                        localFileName));
                returnValue = ftpClient.retrieveFile(
                        remoteFileName, buffOut);
                //输出操作结果信息 
                if (returnValue) {
                    System.out.println("<----------- INFO: download "+ remoteFilePath + "/" + remoteFileName+ " from ftp : succeed! ----------->");
                } else {
                    System.out.println("<----------- ERR : download "+ remoteFilePath + "/" + remoteFileName+ " from ftp : failed! ----------->");
                }
            }
            //关闭连接 
            closeConnect();
        } catch (Exception e) {
            e.printStackTrace();
            returnValue = false;
            //输出操作结果信息 
            System.out.println("<----------- ERR : download " + remoteFilePath+ "/" + remoteFileName+ " from ftp : failed! ----------->");
        } finally {
            try {
                if (buffOut != null) {
                    buffOut.close();
                }
                if (ftpClient.isConnected()) {
                    closeConnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return returnValue;
    }
    
    /**
     * 
     * @param remoteFileNameList
     * @return
     * @throws IOException
     */
    public  List batchDownloadFile(
            List remoteFileNameList) throws IOException {
        InputStream resultIs = null ;
        List inputStreamList = null ;
        String remoteFileName = null ;
        
        if( remoteFileNameList == null ||remoteFileNameList.isEmpty() ) return null ;
            
        inputStreamList = new ArrayList() ;
        for( Iterator it = remoteFileNameList.iterator() ; it.hasNext() ; ) {
            remoteFileName = (String)it.next() ;
            resultIs = this.downloadFile(remoteFileName);
            if (resultIs != null ) {
                inputStreamList.add(resultIs) ;
            } 
        }
        return inputStreamList;
    }
    
    
    /**
     * 删除服务器上文件
     * 
     * @param fileDir
     *            文件路径
     * @param fileName
     *            文件名称
     * @throws IOException
     */
    public boolean delFile(String fileDir, String fileName) throws IOException {
        boolean returnValue = false;
        try {
            //连接ftp服务器 
            connectToServer();
            //跳转到指定的文件目录 
            if (fileDir != null) {
                if (fileDir.indexOf("/") != -1) {
                    int index = 0;
                    while ((index = fileDir.indexOf("/")) != -1) {
                        ftpClient.changeWorkingDirectory(fileDir.substring(0,
                                index));
                        fileDir = fileDir
                                .substring(index + 1, fileDir.length());
                    }
                    if (!fileDir.equals("")) {
                        ftpClient.changeWorkingDirectory(fileDir);
                    }
                } else {
                    ftpClient.changeWorkingDirectory(fileDir);
                }
            }
            //设置传输二进制文件 
            setFileType(FTP.BINARY_FILE_TYPE);
            //获得服务器文件 
            returnValue = ftpClient.deleteFile(fileName);
            //关闭连接 
            closeConnect();
            //输出操作结果信息 
            if (returnValue) {
                System.out.println("<----------- INFO: delete " + fileDir + "/"
                        + fileName + " at ftp:succeed! ----------->");
            } else {
                System.out.println("<----------- ERR : delete " + fileDir + "/"
                        + fileName + " at ftp:failed! ----------->");
            }
        } catch (Exception e) {
            e.printStackTrace();
            returnValue = false;
            //输出操作结果信息 
            System.out.println("<----------- ERR : delete " + fileDir + "/"
                    + fileName + " at ftp:failed! ----------->");
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    closeConnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return returnValue;
    }

    /**
     * upload file to ftp 
     * @param uploadFile
     * @param fileName
     * @return
     * @throws IOException
     */
    public boolean uploadFile(String uploadFile , String fileName ) throws IOException{
        if(uploadFile == null || "".equals(uploadFile.trim())){
            System.out.println("<----------- ERR :  uploadFile:" + uploadFile
                    + " is null , upload failed! ----------->");
            return false ;
        }
        return this.uploadFile(new File(uploadFile) , fileName ) ;
    }
    
    
    /**
     * batch upload files 
     * @param uploadFileList
     * @return
     * @throws IOException
     */
    public boolean batchUploadFile(List uploadFileList ) throws IOException{
        if(uploadFileList == null || uploadFileList.isEmpty()){
            System.out.println("<----------- ERR :  batchUploadFile failed! because the file list is empty ! ----------->");
            return false ;
        }
        
        for( Iterator it = uploadFileList.iterator() ; it.hasNext() ;){
            File uploadFile = (File)it.next() ;
            if( !uploadFile(uploadFile , uploadFile.getName() ) ){
                System.out.println("<----------- ERR :  upload file【"+uploadFile.getName()+"】  failed! ----------->") ;
                return false ;
            }
        }
        return true ;
    }
    
    /**
     * upload file to ftp 
     * @param uploadFile
     * @param fileName
     * @return
     * @throws IOException
     */
    public  boolean uploadFile(File uploadFile, String fileName)
            throws IOException {
        if (!uploadFile.exists()) {
            System.out.println("<----------- ERR : an named " + fileName
                    + " not exist, upload failed! ----------->");
            return false;
        } 
        return this.uploadFile(new FileInputStream(uploadFile) , fileName ) ;
    }

    /**
     * upload file to ftp 
     * @param is
     * @param fileName
     * @return
     * @throws IOException
     */
    public boolean uploadFile(InputStream is , String fileName ) throws IOException {
        boolean returnValue = false;
        // 上传文件
        BufferedInputStream buffIn = null;
        try {
        
                // 建立连接
                connectToServer();
                // 设置传输二进制文件
                setFileType(FTP.BINARY_FILE_TYPE);
                // 获得文件
                buffIn = new BufferedInputStream(is);
                // 上传文件到ftp
                ftpClient.enterLocalPassiveMode();
                returnValue = ftpClient.storeFile(gbkToIso8859(this.workDir + "/"
                        + fileName), buffIn);
                // 输出操作结果信息
                if (returnValue) {
                    System.out.println("<----------- INFO: upload file  to ftp : succeed! ----------->");
                } else {
                    System.out.println("<----------- ERR : upload file  to ftp : failed! ----------->");
                }
                // 关闭连接
                closeConnect();
            
        } catch (Exception e) {
            e.printStackTrace();
            returnValue = false;
            System.out.println("<----------- ERR : upload file  to ftp : failed! ----------->");
        } finally {
            try {
                if (buffIn != null) {
                    buffIn.close();
                }
                if (ftpClient.isConnected()) {
                    closeConnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return returnValue ;
    }
    
    
      public boolean changeDirectory(String path) throws IOException {   
          return ftpClient.changeWorkingDirectory(path);   
        }   
        public boolean createDirectory(String pathName) throws IOException {   
            return ftpClient.makeDirectory(pathName);   
        }   
        public boolean removeDirectory(String path) throws IOException {   
            return ftpClient.removeDirectory(path);   
        } 
        // delete all subDirectory and files.   
        public boolean removeDirectory(String path, boolean isAll)   
                throws IOException {   
               
            if (!isAll) {   
                return removeDirectory(path);   
            }   
      
            FTPFile[] ftpFileArr = ftpClient.listFiles(path);   
            if (ftpFileArr == null || ftpFileArr.length == 0) {   
                return removeDirectory(path);   
            }   
            //    
            for (int i=ftpFileArr.length ; i>0 ; i-- ) {   
                FTPFile ftpFile = ftpFileArr[i-1] ; 
                String name = ftpFile.getName();   
                if (ftpFile.isDirectory()) {   
    System.out.println("* [sD]Delete subPath ["+path + "/" + name+"]");                
                    removeDirectory(path + "/" + name, true);   
                } else if (ftpFile.isFile()) {   
    System.out.println("* [sF]Delete file ["+path + "/" + name+"]");                           
                    deleteFile(path + "/" + name);   
                }
//                else if (ftpFile.isSymbolicLink()) {   
//      
//                } else if (ftpFile.isUnknown()) {   
//      
//                }   
            }   
            return ftpClient.removeDirectory(path);   
        }   

        public boolean deleteFile(String pathName) throws IOException {   
            return ftpClient.deleteFile(pathName);   
        }   
        
        public List getFileList(String path) throws IOException {   
            FTPFile[] ftpFiles= ftpClient.listFiles(path);   
               
            List retList = new ArrayList();   
            if (ftpFiles == null || ftpFiles.length == 0) {   
                return retList;   
            }   
            for (int i=ftpFiles.length ; i>0 ; i-- ) {   
                FTPFile ftpFile = ftpFiles[i-1] ;
                  if (ftpFile.isFile()) {   
                        retList.add(ftpFile.getName());   
                    }   
            }
               
            return retList;   
        } 
        
        private void changeWordDir(String wd) throws IOException{
            if(wd != null && wd != ""){
                if(!ftpClient.changeWorkingDirectory(wd)){
                    ftpClient.makeDirectory(wd);
                    ftpClient.changeWorkingDirectory(wd);
                }
            }
        }
        
        /**
         * 上传文件到服务器上
         * @param is 文件流
         * @param filepath FTP服务器上文件路径
         * @param filename 文件名称
         * @return
         * @throws Exception
         */
        public boolean uploadFile(InputStream is,String filepath,String filename) throws Exception{
            if(!ftpClient.isConnected()){
                connectToServer();
            }
            changeWordDir(this.workDir);
            changeWordDir(filepath);
            ftpClient.setFileType(FTP.BINARY_FILE_TYPE); 
            ftpClient.enterLocalPassiveMode();
            boolean isSuccess = ftpClient.storeFile(filename, is);
            if(isSuccess){
                System.out.println("<-- INFO:upload "+workDir+"/"+filepath+"/"+filename+" from ftp: succeed -->");
            }else{
                System.out.println("<-- INFO:upload "+workDir+"/"+filepath+"/"+filename+" from ftp: failed -->");
            }
            is.close();
            closeConnect();
            return isSuccess;
        }
        
        /**
         * 从FTP服务器上下载文件
         * @param filepath FTP服务器文件路径
         * @param filename 文件名称
         * @param localPath 本机文件路径
         * @return
         * @throws IOException
         */
        public boolean downLoadFile(String filepath,String filename,String localPath) throws IOException{
            if(!ftpClient.isConnected()){
                connectToServer();
            }
            changeWordDir(this.workDir);
            changeWordDir(filepath);
            if(ftpClient.listNames(filename).length > 0){
                setFileType(FTP.BINARY_FILE_TYPE);
                File localFile = new File(localPath+"/"+filename);
                OutputStream os = new FileOutputStream(localFile);   
                boolean isSuccess = ftpClient.retrieveFile(filename, os);
                if(isSuccess){
                    System.out.println("<-- INFO:download "+workDir+"/"+filepath+"/"+filename+" from ftp: succeed -->");
                }else{
                    System.out.println("<-- INFO:download "+workDir+"/"+filepath+"/"+filename+" from ftp: failed -->");
                }
                os.close();
                closeConnect();
                return isSuccess;
            }else{
                System.out.println("<-- INFO:download "+workDir+"/"+filepath+"/"+filename+" from ftp: failed, file is not exist -->");
            }
            closeConnect();
            return false;
        }
        
        /**
         * 删除FTP服务器上的文件
         * @param filepath 文件路径
         * @param filename 文件名称
         * @throws IOException
         */
        public boolean deleteFile(String filepath,String filename) throws IOException{
            if(!ftpClient.isConnected()){
                connectToServer();
            }
            changeWordDir(this.workDir);
            changeWordDir(filepath);
            boolean isSuccess = false;
            if(ftpClient.listNames(filename).length > 0){
                isSuccess = ftpClient.deleteFile(filename);
                if(isSuccess){
                    System.out.println("<-- INFO:delete "+workDir+"/"+filepath+"/"+filename+" from ftp: succeed -->");
                }else{
                    System.out.println("<-- INFO:delete "+workDir+"/"+filepath+"/"+filename+" from ftp: failed -->");
                }
            }else{
                System.out.println("<-- INFO:delete "+workDir+"/"+filepath+"/"+filename+" from ftp: failed, file is not exist -->");
            }
            closeConnect();
            return isSuccess;
        }


    /**
     * download ftp .gz file as BufferedReader
     * @param remoteFileName
     * @return
     * @throws IOException
     */
    public  BufferedReader downloadGZFile(
            String remoteFileName, String filePath) throws IOException {
        BufferedReader returnValue = null;
        //下载文件
        BufferedOutputStream buffOut = null;
        try {
            //连接ftp服务器
            connectToServer();
            if (!checkFileExist(filePath, remoteFileName)) {
                System.out.println("<----------- ERR : file  " + filePath    + "/" + remoteFileName+ " does not exist, download failed!----------->");
                return null;
            } else {
                changeDir( filePath )  ;
                String[] fileNames = ftpClient.listNames();

                //设置传输二进制文件
                setFileType(FTP.BINARY_FILE_TYPE);
                //获得服务器文件
                InputStream in = new GZIPInputStream(ftpClient.retrieveFileStream(remoteFileName));
                //输出操作结果信息
                if (in != null) {
                    returnValue = new BufferedReader(new InputStreamReader(in));
                    in.close();
                    System.out.println("<----------- INFO: download "+ filePath + "/" + remoteFileName+ " from ftp : succeed! ----------->");
                } else {
                    System.out.println("<----------- ERR : download "+ filePath + "/" + remoteFileName+ " from ftp : failed! ----------->");
                }
            }
            //关闭连接
            closeConnect();
        } catch (Exception e) {
            e.printStackTrace();
            returnValue = null;
            //输出操作结果信息
            System.out.println("<----------- ERR : download " +  filePath + "/" + remoteFileName+ " from ftp : failed! ----------->");
        } finally {
            try {
                if (ftpClient.isConnected()) {
                    closeConnect();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return returnValue;
    }

    public String getWorkDir()
    {
        return this.workDir;
    }
}

 

reader.close();
posted @ 2018-10-19 11:10  子渝渝渝  阅读(866)  评论(0编辑  收藏  举报