Sftp工具类

末蓝、 2022-04-12 06:22 175阅读 0赞

import java.io.ByteArrayInputStream;
    import java.io.ByteArrayOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.util.Properties;
    import java.util.Vector;
    
    import org.apache.log4j.Logger;
    
    import com.aspire.prm.app.iodd.common.remoteclient.RemoteClient;
    import com.aspire.prm.dmplt.basic.domain.FtpConfig;
    import com.jcraft.jsch.Channel;
    import com.jcraft.jsch.ChannelSftp;
    import com.jcraft.jsch.JSch;
    import com.jcraft.jsch.Session;
    import com.jcraft.jsch.SftpATTRS;
    import com.jcraft.jsch.SftpException;
    
    /**
     * name：SFTPClient
     * <p>
     * </p>
     * 
     * @author：lipeng
     * @data：2014-9-22 下午04:29:45
     * @version 1.0
     */
    public class SftpClient implements RemoteClient {
        
        private static final Logger logger = Logger.getLogger(SftpClient.class);
        
        private ChannelSftp sftp;
        
        private boolean isReady = false;
        
        private FtpConfig config;
        
        /** 当前工作目录，每次关闭连接要回复到null，因为当前类是单例类 */
        private String directory = null;
        
        private Session sshSession;
        
        /**
         * 连接sftp服务器
         * 
         * @param host 主机
         * @param port 端口
         * @param username 用户名
         * @param password 密码
         * @return
         */
        public SftpClient(FtpConfig config) {
            this.config = config;
            // 设置当前工作目录
            directory = config.getRootPath();
        }
        
        private void setReady() throws Exception {
            try {
                if (!isReady) {
                    JSch jsch = new JSch();
                    sshSession =
                        jsch.getSession(config.getUsername(), config.getServer(), Integer.parseInt(config.getPort()));
                    System.out.println("Session created.");
                    sshSession.setPassword(config.getPassword());
                    Properties sshConfig = new Properties();
                    sshConfig.put("StrictHostKeyChecking", "no");
                    sshSession.setConfig(sshConfig);
                    isReady = true;
                }
                if (sshSession != null && !sshSession.isConnected()) {
                    sshSession.connect();
                    Channel channel = sshSession.openChannel("sftp");
                    channel.connect();
                    sftp = (ChannelSftp) channel;
                }
                
            } catch (Exception e) {
                this.close();
                logger.error("sftp连接服务器出错,host:" + config.getServer(), e);
                throw e;
            }
        }
        
        /**
         * 上传文件
         * 
         * @param directory 上传的目录
         * @param uploadFile 要上传的文件
         * @throws Exception 
         */
        public boolean uploadFile(String uploadFile, String remoteName) throws Exception {
            try {
                setReady();
                if (remoteName.contains("/")) {
                    String remotePath = remoteName.substring(0,remoteName.lastIndexOf("/"));
                    try {
                        sftp.cd(directory);
                        sftp.mkdir(remotePath);
                    } catch (Exception e) {
                    }
                    sftp.cd(directory+"/"+remotePath);
                    remoteName=remoteName.substring(remoteName.lastIndexOf("/") + 1,remoteName.length());
                }else{
                    sftp.cd(directory);
                }
                File file = new File(uploadFile);
                sftp.put(new FileInputStream(file), remoteName);
                return true;
            } catch (Exception e) {
                logger.error("sftp上传文件出错,directory:" + directory, e);
                throw e;
            }
        }
        
        /**
         * 下载文件
         * 
         * @param directory 下载目录
         * @param downloadFile 下载的文件
         * @param saveFile 存在本地的路径
         * @throws Exception 
         */
        public boolean downloadFile(String downloadFile, String saveFile) throws Exception {
            try {
                setReady();
                sftp.cd(directory);
                File localFile=new File(saveFile);
                if(localFile!=null&&!localFile.exists()){
                    if(localFile.getParentFile()!=null&&!localFile.getParentFile().exists()){
                        localFile.getParentFile().mkdirs();
                    }
                    localFile.createNewFile();
                }
                sftp.get(downloadFile, new FileOutputStream(localFile));
                return true;
            } catch (Exception e) {
                logger.error("sftp下载文件出错,directory:" + directory, e);
                throw e;
            }
        }
        
        /**
         * 删除文件
         * 
         * @param deleteFile 要删除的文件
         * @throws Exception 
         */
        public boolean removeFile(String deleteFile) throws Exception {
            try {
                setReady();
                sftp.cd(directory);
                sftp.rm(deleteFile);
                return true;
            } catch (Exception e) {
                logger.error("sftp删除文件出错,directory:" + directory, e);
                throw e;
            }
        }
        
        /**
         * 
         * 复制文件
         * @param @param src
         * @param @param dst
         * @param @return
         * @param @throws Exception     
         * @return boolean
         */
        public boolean copyFile(String src,String dst) throws Exception {
            ByteArrayInputStream bStreams =null;
            try {
                setReady();
                if (!isFileExist(src)) {
                    //文件不存在直接反回.
                    return false;
                }
                String parentPath=dst.substring(0,dst.lastIndexOf("/"));
                if (!this.isDirExist(parentPath)) {
                    createDir(parentPath);
                }
                byte[] srcFtpFileByte = inputStreamToByte(sftp.get(src));
                 bStreams = new ByteArrayInputStream(srcFtpFileByte);
                //二进制流写文件
                sftp.put(bStreams, dst);
                
                return true;
            } catch (Exception e) {
                logger.error("sftp移动文件出错,[src:" + src+",dst:"+dst+"]", e);
                throw e;
            }finally{
                if(bStreams!=null){
                    bStreams.close();
                }
            }
        }
        
        /**
         * 判断远程文件是否存在
         * @param srcSftpFilePath
         * @return
         * @throws SftpException
         */
        public boolean isFileExist (String srcSftpFilePath) throws SftpException {
            boolean isExitFlag = false;
            // 文件大于等于0则存在文件
            if (getFileSize(srcSftpFilePath) >= 0) {
                isExitFlag = true;
            }
            return isExitFlag;
        }
        
        /** 
         * 得到远程文件大小
         * @param srcSftpFilePath
         * @return 返回文件大小，如返回-2 文件不存在，-1文件读取异常
         * @throws SftpException
         */
        public long getFileSize (String srcSftpFilePath) throws SftpException {
            long filesize = 0;//文件大于等于0则存在
            try {
                SftpATTRS sftpATTRS = sftp.lstat(srcSftpFilePath);
                filesize = sftpATTRS.getSize();
            } catch (Exception e) {
                filesize = -1;//获取文件大小异常
                if (e.getMessage().toLowerCase().equals("no such file")) {
                    filesize = -2;//文件不存在
                }
            }
            return filesize;
        }
        /**
         * inputStream类型转换为byte类型
         * @param iStrm
         * @return
         * @throws IOException
         */
        public byte[] inputStreamToByte (InputStream iStrm) throws IOException {
            ByteArrayOutputStream bytestream = new ByteArrayOutputStream();
            int ch;
            while ((ch = iStrm.read()) != -1) {
                bytestream.write(ch);
            }
            byte imgdata[] = bytestream.toByteArray();
            bytestream.close();
            return imgdata;
        }
        
        /**
         * 创建远程目录
         * @param sftpDirPath
         * @throws SftpException
         */
        public void createDir (String sftpDirPath) throws SftpException {
            sftp.cd("/");
            String pathArry[] = sftpDirPath.split("/");
            for (String path : pathArry) {
                if (path.equals("")) {
                    continue;
                }
                if (isDirExist(path)) {
                    sftp.cd(path);
                }
                else {
                    //建立目录
                    sftp.mkdir(path);
                    //进入并设置为当前目录
                    sftp.cd(path);
                }
            }
            sftp.cd(directory);
        }
        
        /**
         * 判断目录是否存在
         * @param directory
         * @return
         * @throws SftpException
         */
        public boolean isDirExist (String directory) throws SftpException {
            boolean isDirExistFlag = false;
            try {
                SftpATTRS sftpATTRS = sftp.lstat(directory);
                isDirExistFlag = true;
                return sftpATTRS.isDir();
            } catch (Exception e) {
                if (e.getMessage().toLowerCase().equals("no such file")) {
                    isDirExistFlag = false;
                }
            }
            return isDirExistFlag;
        }
        /**
         * 列出目录下的文件
         * 
         * @param directory 要列出的目录
         * @return
         * @throws SftpException
         */
        public Vector<?> listFiles() throws Exception {
            setReady();
            return sftp.ls(directory);
        }
        
        public ChannelSftp getSftp() {
            return sftp;
        }
        
        public void setSftp(ChannelSftp sftp) {
            this.sftp = sftp;
        }
        
        public void close() throws IOException {
            if (sftp != null && sftp.isConnected()) {
                sftp.disconnect();
            }
            if (sshSession != null && sshSession.isConnected()) {
                sshSession.disconnect();
            }
            isReady = false;
            logger.info("JSCH session close");
            
        }
    }