package xxx.ftporsftpconfig;

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.List;
import java.util.Properties;
import java.util.Vector;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.ChannelSftp.LsEntry;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.Session;
import com.jcraft.jsch.SftpATTRS;
import com.jcraft.jsch.SftpException;


public class SftpUtil {

     private long count;
        /**
         * 已经连接次数
         */
        private long count1 = 0;

        private long sleepTime;

        private static final Logger logger = LoggerFactory.getLogger(SftpUtil.class);

        /**
         * 连接sftp服务器
         *
         * @return
         */
        public ChannelSftp connect(FtpOrSftpConfig sftpConfig) {
            ChannelSftp sftp = null;
            try {
                JSch jsch = new JSch();
                jsch.getSession(sftpConfig.getUsername(), sftpConfig.getHostname(), sftpConfig.getPort());
                Session sshSession = jsch.getSession(sftpConfig.getUsername(), sftpConfig.getHostname(), sftpConfig.getPort());
                logger.info("Session created ... UserName=" + sftpConfig.getUsername() + ";host=" + sftpConfig.getHostname() + ";port=" + sftpConfig.getPort());
                sshSession.setPassword(sftpConfig.getPassword());
                Properties sshConfig = new Properties();
                sshConfig.put("StrictHostKeyChecking", "no");
                sshSession.setConfig(sshConfig);
                sshSession.connect();
                logger.info("Session connected ...");
                logger.info("Opening Channel ...");
                Channel channel = sshSession.openChannel("sftp");
                channel.connect();
                sftp = (ChannelSftp) channel;
                logger.info("登录成功");
            } catch (Exception e) {
                try {
                    count1 += 1;
                    if (count == count1) {
                        throw new RuntimeException(e);
                    }
                    Thread.sleep(sleepTime);
                    logger.info("重新连接....");
                    connect(sftpConfig);
                } catch (InterruptedException e1) {
                    throw new RuntimeException(e1);
                }
            }
            return sftp;
        }

        /**
         * 上传文件
         *
         * @param directory  上传的目录
         * @param uploadFile 要上传的文件
         * @param sftpConfig
         */
        public void upload(String directory, String uploadFile, FtpOrSftpConfig sftpConfig) {
            ChannelSftp sftp = connect(sftpConfig);
            try {
                sftp.cd(directory);
            } catch (SftpException e) {
                try {
                    createDir(directory, sftp);
                    sftp.cd(directory);
                } catch (SftpException e1) {
                    throw new RuntimeException("ftp创建文件路径失败" + directory);
                }
            }
            File file = new File(uploadFile);
            InputStream inputStream=null;
            try {
                inputStream = new FileInputStream(file);
                sftp.put(inputStream, file.getName());
            } catch (Exception e) {
                throw new RuntimeException("sftp异常" + e);
            } finally {
                disConnect(sftp);
                closeStream(inputStream,null);
            }
        }

        public void createDir(String createpath, ChannelSftp sftp) {
              try {
               if (isDirExist(createpath,sftp)) {
               sftp.cd(createpath); 
                return;
               }
               String pathArry[] = createpath.split("/");
               StringBuffer filePath = new StringBuffer("/");
               for (String path : pathArry) {
                if (path.equals("")) {
                 continue;
                }
                filePath.append(path + "/");
                if (isDirExist(filePath.toString(),sftp)) {
                 sftp.cd(filePath.toString());
                } else {
                 // 建立目录
                 sftp.mkdir(filePath.toString());
                 // 进入并设置为当前目录
                 sftp.cd(filePath.toString());
                }
               }
               sftp.cd(createpath);
              } catch (SftpException e) {

              }
             }

        public boolean isDirExist(String directory, ChannelSftp sftp) {
              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    下载目录
         * @param downloadFile 下载的文件
         * @param saveFile     存在本地的路径
         * @param sftpConfig
         */
        public void download(String directory, String downloadFile, String saveFile, FtpOrSftpConfig sftpConfig) {
            OutputStream output = null;
            try {
                File localDirFile = new File(saveFile);
                // 判断本地目录是否存在，不存在需要新建各级目录
                if (!localDirFile.exists()) {
                    localDirFile.mkdirs();
                }
                if (logger.isInfoEnabled()) {
                    logger.info("开始获取远程文件:[{}]---->[{}]", new Object[]{directory, saveFile});
                }
                ChannelSftp sftp = connect(sftpConfig);
                sftp.cd(directory);
                if(downloadFile.contains(".")) {
                      output = new FileOutputStream(new File(saveFile.concat(File.separator).concat(downloadFile)+File.separator));
                     sftp.get(downloadFile, output);
                }else {
                     File dirFile = new File(saveFile+File.separator+downloadFile+File.separator);
                     if (!dirFile.exists()) {
                         dirFile.mkdirs();
                     }
                }
                disConnect(sftp);
            } catch (Exception e) {
                throw new RuntimeException("文件下载出现异常，[{}]", e);
            } finally {
                closeStream(null,output);
            }
        }

        /**
         * 下载远程文件夹下的所有文件
         *
         * @param remoteFilePath
         * @param localDirPath
         * @throws Exception
         */
        public void getFileDir(String remoteFilePath, String localDirPath, FtpOrSftpConfig sftpConfig) throws Exception {
            File localDirFile = new File(localDirPath);
            // 判断本地目录是否存在，不存在需要新建各级目录
            if (!localDirFile.exists()) {
                localDirFile.mkdirs();
            }
            ChannelSftp channelSftp = connect(sftpConfig);
            Vector<LsEntry> lsEntries = channelSftp.ls(remoteFilePath);
            for (LsEntry entry : lsEntries) {
                String fileName = entry.getFilename();
                if (checkFileName(fileName)) {
                    continue;
                }
                if(fileName.contains(".")) {
                     String remoteFileName = getRemoteFilePath(remoteFilePath, fileName);
                     channelSftp.get(remoteFileName, localDirPath);
                }else {
                     File dirFile = new File(localDirPath+File.separator+fileName+File.separator);
                     if (!dirFile.exists()) {
                         dirFile.mkdirs();
                     }
                     getFileDir(remoteFilePath+File.separator+fileName, localDirPath+File.separator+fileName, sftpConfig);
                }

            }
            disConnect(channelSftp);
        }

        /**
         * 关闭流
         * @param outputStream
         */
        private void closeStream(InputStream inputStream,OutputStream outputStream) {
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        private boolean checkFileName(String fileName) {
            if (".".equals(fileName) || "..".equals(fileName)) {
                return true;
            }
            return false;
        }

        private String getRemoteFilePath(String remoteFilePath, String fileName) {
            if (remoteFilePath.endsWith("/")) {
                return remoteFilePath.concat(fileName);
            } else {
                return remoteFilePath.concat("/").concat(fileName);
            }
        }

        /**
         * 删除文件
         *
         * @param directory  要删除文件所在目录
         * @param deleteFile 要删除的文件
         * @param sftp
         */
        public void delete(String directory, String deleteFile, ChannelSftp sftp) {
            try {
                sftp.cd(directory);
                sftp.rm(deleteFile);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }

        /**
         * 列出目录下的文件
         *
         * @param directory  要列出的目录
         * @param sftpConfig
         * @return
         * @throws SftpException
         */
        public List<String> listFiles(String directory, FtpOrSftpConfig sftpConfig) throws SftpException {
            ChannelSftp sftp = connect(sftpConfig);
            List fileNameList = new ArrayList();
            try {
                sftp.cd(directory);
            } catch (SftpException e) {
                return fileNameList;
            }
            Vector vector = sftp.ls(directory);
            for (int i = 0; i < vector.size(); i++) {
                if (vector.get(i) instanceof LsEntry) {
                    LsEntry lsEntry = (LsEntry) vector.get(i);
                    String fileName = lsEntry.getFilename();
                    if (".".equals(fileName) || "..".equals(fileName)) {
                        continue;
                    }
                    fileNameList.add(fileName);
                }
            }
            disConnect(sftp);
            return fileNameList;
        }

        /**
         * 断掉连接
         */
        public void disConnect(ChannelSftp sftp) {
            try {
                sftp.disconnect();
                sftp.getSession().disconnect();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        public SftpUtil(long count, long sleepTime) {
            this.count = count;
            this.sleepTime = sleepTime;
        }

        public SftpUtil() {

        }
}

补充依赖

<!-- sftp文件下载jar -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.54</version>
        </dependency>
        <!-- ftp文件下载 -->
        <dependency>
            <groupId>commons-net</groupId>
            <artifactId>commons-net</artifactId>
            <version>3.6</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>