Springboot整合Jsch-Sftp

背景

  开发一个基于jsch的sftp工具类，方便在以后的项目中使用。写代码的过程记录下来，作为备忘录。。。

Maven依赖

• springboot依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.0</version>
</parent>

• jsch依赖

 <dependency>
    <groupId>com.jcraft</groupId>
    <artifactId>jsch</artifactId>
    <version>0.1.55</version>
</dependency>

• 完整依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>jsch-sftp</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>

    <dependencies>

        <!-- web应用相关 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- 单元测试 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
        </dependency>

        <!-- jsch SFTP -->
        <dependency>
            <groupId>com.jcraft</groupId>
            <artifactId>jsch</artifactId>
            <version>0.1.55</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

</project>

项目结构

Sftp连接工具类

• JschSftpRun： 项目启动类

package cn.com.soulfox;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

/**
 * 启动类
 *
 * @author xxxx
 * @create 2024/7/5 11:50
 */
@SpringBootApplication
public class JschSftpRun {

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(JschSftpRun.class, args);
    }
}

• JschSftpConneciton: 创建sftp连接工具类
    用于创建sftp连接，类中提供了创建sftp连接的方法，另外还提供了在创建sftp连接失败后，重新尝试创建连接的方法

package cn.com.soulfox.jsch;

import com.jcraft.jsch.*;
import lombok.extern.slf4j.Slf4j;

/**
 * @author xxxx
 * @create 2024/7/4 12:15
 */
@Slf4j
public class JschSftpConneciton {

    private static final String SFTP_PROTOCOL = "sftp";
    private static final Integer DEFAULT_RETRY_COUNT_5 = 5;
    private static final Long SLEEP_ITME_1000 = 1000L;//每次重试的时间间隔

    private String host;
    private Integer port;
    private String username;
    private String password;
    private Integer sessionTimeout;
    private Integer connectionTimeout;

    public JschSftpConneciton setHost(String host) {
        this.host = host;
        return this;
    }

    public JschSftpConneciton setPort(Integer port) {
        this.port = port;
        return this;
    }

    public JschSftpConneciton setUsername(String username) {
        this.username = username;
        return this;
    }

    public JschSftpConneciton setPassword(String password) {
        this.password = password;
        return this;
    }

    public JschSftpConneciton setSessionTimeout(Integer sessionTimeout) {
        this.sessionTimeout = sessionTimeout;
        return this;
    }

    public JschSftpConneciton setConnectionTimeout(Integer connectionTimeout) {
        this.connectionTimeout = connectionTimeout;
        return this;
    }

    /**
     * 返回SftpWrapper对象，是为了方便释放Session，Channel,ChannelSftp资源
     * SFTP连接服务器
     */
    public SftpWrapper connect() throws  Exception {
        JSch jsch = new JSch();
        Session session = null;
        Channel channel = null;
        ChannelSftp sftp = null;
        try {

            session = jsch.getSession(username, host, port);
            if (session == null) {
                throw new JSchException("create session error");
            }
            //设置登陆主机的密码
            session.setPassword(password);
            //设置第一次登陆的时候提示，可选值：(ask | yes | no)
            session.setConfig("StrictHostKeyChecking", "no");
            //设置登陆超时时间
            session.connect(sessionTimeout);
            session.sendKeepAliveMsg();
            //创建sftp通信通道
            channel = session.openChannel(SFTP_PROTOCOL);
            channel.connect(connectionTimeout);
            sftp = (ChannelSftp) channel;

            return new SftpWrapper(session, channel, sftp);
        }catch (JSchException e){
            log.error("SFTP连接异常：", e);
            if (sftp != null ) {
                sftp.disconnect();
            }
            if (channel != null ) {
                channel.disconnect();
            }
            if (session != null ) {
                session.disconnect();
            }
            throw e;
        } catch (Exception e1) {
            log.error("SFTP连接异常：", e1);
            if (sftp != null ) {
                sftp.disconnect();
            }
            if (channel != null ) {
                channel.disconnect();
            }
            if (session != null ) {
                session.disconnect();
            }
            throw e1;
        }
    }

    /**
     * 获取sftp连接，获取连接失败时会重试，
     * 默认重试次数：5次
     * @return
     * @throws Exception
     */
    public SftpWrapper connectWithRetry() throws Exception {
        return connectWithRetry(DEFAULT_RETRY_COUNT_5);
    }
    public SftpWrapper connectWithRetry(int retryCount) throws Exception {
        //最大重试次数
        int maxRetryCount = DEFAULT_RETRY_COUNT_5;
        if(retryCount > 0){
            maxRetryCount = retryCount;
        }

        int retry = 0;
        Throwable t = null;
        do {
            try {
                SftpWrapper channelSftpWrapper = this.connect();
                if(channelSftpWrapper != null){
                    t = null;
                    return channelSftpWrapper;
                }
            } catch (Exception e) {
                t = e;
            }

            try {
                Thread.sleep(SLEEP_ITME_1000);//休息1秒
            } catch (InterruptedException e) {
            }
        }while (retry++ < maxRetryCount);
        if(t != null){
            throw new Exception(t);
        }
        return null;
    }

}

• SftpWrapper： sftp连接对象包装类，属性包括Session，Channel，ChannelSftp
    执行sftp操作有ChannelSftp就可以了，使用Sftp包装类，是为了方便关闭资源

package cn.com.soulfox.jsch;

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.Session;
import lombok.AllArgsConstructor;
import lombok.Data;

/**
 * SftpWrapper类简单包装ChannelSftl对象，方便关闭资源
 * @author xxxx
 * @create 2024/7/4 14:26
 */
@AllArgsConstructor//生成全字段，构造方法
@Data //生成 getter,setter方法
public class SftpWrapper {
    private Session session = null;
    private Channel channel = null;
    private ChannelSftp sftp = null;

    /**
     * 关闭资源
     */
    public void disconnect() {
        if (sftp != null && sftp.isConnected()) {
            sftp.disconnect();
        }
        if (channel != null && channel.isConnected()) {
            channel.disconnect();
        }
        if (session != null && session.isConnected()) {
            session.disconnect();
        }
    }
}

• JschSftpConfig： jsch sftp配置类
    初始化 jsch sftp

package cn.com.soulfox.config;

import cn.com.soulfox.jsch.JschSftpConneciton;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

/**
 * @author xxxx
 * @create 2024/7/4 12:12
 */
@Configuration
public class JschSftpConfig {

    @Value("${jsch.sftp.host}")
    private String host;
    @Value("${jsch.sftp.port:22}")
    private Integer port;
    @Value("${jsch.sftp.username}")
    private String username;
    @Value("${jsch.sftp.password}")
    private String password;

    @Value("${jsch.sftp.session-timeout:60000}")
    private Integer sessionTimeout;//单位毫秒
    @Value("${jsch.sftp.connect-timeout:5000}")
    private Integer connectTimeout;//单位毫秒
    
    @Bean
    @Lazy
    public JschSftpConneciton jschSftpConneciton(){
        return new JschSftpConneciton()
        		.setHost(host)
                .setPort(port)
                .setUsername(username)
                .setPassword(password)
                .setSessionTimeout(sessionTimeout)
                .setConnectionTimeout(connectTimeout);
    }

}

sftp连接信息配置在文件application.yml里
jsch:
sftp:
host: 172.168.xxx.xx
port: 1221 #默认22,1221公司自己定义的，这里要配置正确
username: xxxx #远程服务器用户名
password: xxxx #远程服务器密码

SftpUitl 工具类，提供下载，上传文件功能

package cn.com.soulfox.jsch;

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.SftpException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.*;

/**
 * @author xxxx
 * @create 2024/7/4 14:28
 */
@Component
@Slf4j
public class JschSftpUtil {

    private static JschSftpConneciton jschSftpConneciton;

    @Autowired
    public void setJschSftpConneciton(JschSftpConneciton jschSftpConneciton) {
        JschSftpUtil.jschSftpConneciton = jschSftpConneciton;
    }

    /**
     * 下载文件
     * @param remotePath            远程目录
     * @param downloadFileName      待下载的远程文件名称
     * @param localSavePath         下载文件保存的本地目录
     */
    public static void downloadFile(String remotePath, String downloadFileName, String localSavePath) {

        SftpWrapper sftpWrapper = null;

        try {
            //sftp连接对象
            sftpWrapper = jschSftpConneciton.connectWithRetry();

            //进入远程服务器指定的目录
            sftpWrapper.getSftp().cd(remotePath);

            if (!checkLocalPath(localSavePath)) {
                log.info("本地目录[{}]不存在，且新建失败+++++", localSavePath);
                return;
            }

            String localFile = checkPathEnd(localSavePath) + downloadFileName;
            File outFile = new File(localFile);

            sftpWrapper.getSftp().get(downloadFileName, new FileOutputStream(outFile));
            log.info("从远程目录[{}]下载文件[{}]到本地目录[{}]成功", remotePath, downloadFileName, localSavePath);

        } catch (SftpException e) {
            log.info("从远程目录[{}]下载文件[{}]到本地目录[{}]失败", remotePath, downloadFileName, localSavePath);
            log.error("下载文件失败: ", e);
        } catch (Exception e) {
            log.info("从远程目录[{}]下载文件[{}]到本地目录[{}]失败", remotePath, downloadFileName, localSavePath);
            log.error("下载文件失败: ", e);
        } finally {
            if (sftpWrapper != null) {
                sftpWrapper.disconnect();
            }
        }


    }

    /**
     *
     * @param localDir              保存上传文件的本地目录
     * @param uploadFileName        上传文件名称
     * @param remoteSaveDir         保存上传文件的远程目录, 建议使用绝对路径
     *                              如果使用相对路径，建议基准目录使用sfpt登录后所在的目录
     *                              这个目录，使用channelSftp.goHome()可以获取
     */
    public static void uploadFile(String localDir, String uploadFileName, String remoteSaveDir) {

        String uploadFilePath = checkPathEnd(localDir) + uploadFileName;
        File uploadFile = new File(uploadFilePath);
        uploadFile(uploadFile, remoteSaveDir);

    }

    /**
     * 上传文件
     * @param uploadFilePath        本地文件的路径
     * @param remoteSaveDir         保存上传文件的远程目录, 建议使用绝对路径
     *                              如果使用相对路径，建议基准目录使用sfpt登录后所在的目录
     *                              这个目录，使用channelSftp.goHome()可以获取
     */
    public static void uploadFile(String uploadFilePath, String remoteSaveDir) {
        File uploadFile = new File(uploadFilePath);
        uploadFile(uploadFile, remoteSaveDir);
    }

    /**
     * 上传文件
     * @param uploadFile        上传文件的File对象
     * @param remoteSavePath    保存上传文件的远程目录, 建议使用绝对路径
     *                          如果使用相对路径，建议基准目录使用sfpt登录后所在的目录
     *                          这个目录，使用channelSftp.goHome()可以获取
     */
    public static void uploadFile(File uploadFile, String remoteSavePath) {
        if(uploadFile == null ){
            log.info("本地文件对象不存在++++");
            return;
        }
        if(!uploadFile.exists()){
            log.info("本地文件[{}]不存在", uploadFile.getAbsoluteFile());
            return;
        }
        InputStream is = null;
        try {
            is = new FileInputStream(uploadFile);
        } catch (FileNotFoundException e) {
            log.info("获取本地文件[{}]的文件流失败", uploadFile.getAbsoluteFile());
            log.error("获取文件流失败: ", e);

            if(is != null){
                try {
                    is.close();
                } catch (IOException ioException) {
                }
            }
            return;
        }

        SftpWrapper sftpWrapper = null;
        try {
            //sftp连接对象
            sftpWrapper = jschSftpConneciton.connectWithRetry();

            //检查远程目录,不存在则创建
            createLinuxRemoteDirs(sftpWrapper.getSftp(), remoteSavePath);

            //进入用户home目录，
            sftpWrapper.getSftp().cd(sftpWrapper.getSftp().getHome());
            //保证当前目录在上传文件保存的目录
            sftpWrapper.getSftp().cd(remoteSavePath);

            //上传文件
            sftpWrapper.getSftp().put(is, uploadFile.getName());

        } catch (SftpException e) {
            log.info("上传本地文件[{}]到远程目录[{}]失败", uploadFile.getAbsoluteFile(), remoteSavePath);
            log.error("上传本地文件失败: ", e);
        } catch (Exception e) {
            log.info("上传本地文件[{}]到远程目录[{}]失败", uploadFile.getAbsoluteFile(), remoteSavePath);
            log.error("上传本地文件失败: ", e);
        } finally {
            if (sftpWrapper != null) {
                sftpWrapper.disconnect();
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                }
            }
        }
    }

    /**
     * 检查目录结是否以目录分隔符结尾
     * 如果不是，则加上目录分隔符结尾
     *
     * @param localPath 本地目录
     * @return
     */
    private static String checkPathEnd(String localPath) {

        if (localPath.endsWith("/") || localPath.endsWith("\\")) {
            return localPath;
        }

        return localPath + File.separator;
    }

    /**
     * 检查本地目录是否存在，不存在就创建。
     * 为了防止其他线程已创建目录，加上了重试代码
     *
     * @param localPath 本地目录
     * @return
     */
    private static boolean checkLocalPath(String localPath) {

        int maxRetryCount = 5;
        int retry = 0;

        do {
            File localDir = new File(localPath);
            if (localDir.exists()) {
                return true;
            }
            boolean result = localDir.mkdirs();
            if (result) {
                return true;
            }

            try {
                Thread.sleep(1000L);//休息1秒
            } catch (InterruptedException e) {
            }
        } while (retry++ < maxRetryCount);

        return false;
    }

    /**
     * 检查和创建[ linux系统 ]的远程多级目录,
     * 外部调用, 单纯的创建远程目录，不作其他操作
     * @param remoteDir     远程目录
     * @throws SftpException
     */
    public static void createLinuxRemoteDirs( String remoteDir) throws SftpException {
        SftpWrapper sftpWrapper = null;
        try {
            sftpWrapper = jschSftpConneciton.connectWithRetry();
            createLinuxRemoteDirs(sftpWrapper.getSftp(), remoteDir);

        } catch (SftpException e) {
            log.info("创建Linux远程目录[{}]失败", remoteDir);
            log.error("创建Linux远程目录失败: ", e);
        } catch (Exception e) {
            log.info("创建Linux远程目录[{}]失败", remoteDir);
            log.error("创建Linux远程目录失败: ", e);
        } finally {
            if (sftpWrapper != null) {
                sftpWrapper.disconnect();
            }
        }
    }
    /**
     * 检查和创建[ linux系统 ]的远程多级目录,
     * linux系统目录分隔符是 “/”
     * 内部上传文件的方法调用
     *
     * @param sftpChannel
     * @param remoteDir  远程目录
     * @throws SftpException
     */
    public static void createLinuxRemoteDirs(ChannelSftp sftpChannel, String remoteDir) throws SftpException {

        if(remoteDir == null || "".equals(remoteDir)){
            log.info("待创建的远程目录为空++++++++");
            return;
        }
        String[] dirs = remoteDir.split("/");;

        if(dirs == null || dirs.length == 0){
            log.info("拆分目录[{}]失败，没有获取到目录数组", remoteDir);
            return;
        }

        //进入用户home目录，保证初始目录正确
        sftpChannel.cd(sftpChannel.getHome());

        if( dirs.length == 1){
            //只有一层目录，直接处理
            try {
                sftpChannel.cd(dirs[0]);
            } catch (SftpException e) {
                if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
                    log.info("开始创建远程目录[{}]", dirs[0]);
                    sftpChannel.mkdir(dirs[0]);
                } else {
                    throw e;
                }
            }
            return;
        }

        StringBuilder sb = new StringBuilder();

        //处理第一个元素
        if(remoteDir.startsWith(".")){
            //相对路径,把缺少的路径补上
            sb.append(sftpChannel.getHome()).append("/");
        }else if(remoteDir.startsWith("/")){
            //绝对路径，把"/"放到目录开头
            sb.append("/");
        }else {
            //既不是”/“开头，也不是”.“开头
            //属于相对路径的一种情况
            try {
                //先处理第一层目录
                sftpChannel.cd(dirs[0]);
            } catch (SftpException e) {
                if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
                    log.info("开始创建远程目录[{}]", dirs[0]);
                    sftpChannel.mkdir(dirs[0]);
                } else {
                    throw e;
                }
            }
            //把已处理的目录加上
            sb.append(sftpChannel.getHome()).append("/").append(dirs[0]).append("/");
        }


        //从第二个元素开始创建不存在的目录
        for (int i = 1; i < dirs.length; i++) {
            String dir = dirs[i];
            if (dir.isEmpty() ) {
                //跳过空字符串
                continue;
            }
            sb.append(dir + "/");
            try {
                sftpChannel.cd(sb.toString());
            } catch (SftpException e) {
                if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
                    log.info("开始创建远程目录[{}]", sb.toString());
                    sftpChannel.mkdir(sb.toString());
                } else {
                    throw e;
                }
            }
        }
//        for (String dir : dirs) {
//            if (dir.isEmpty() || dir.contains(".")) {
//                //跳过空字符串，和"."字符串
//                continue;
//            }
//            sb.append(dir + "/");
//            try {
//                sftpChannel.cd(sb.toString());
//            } catch (SftpException e) {
//                if (e.id == ChannelSftp.SSH_FX_NO_SUCH_FILE) {
//                    sftpChannel.mkdir(sb.toString());
//                } else {
//                    throw e;
//                }
//            }
//        }
    }
}

单元测试

• JschSftpConfigTest： 测试类

package cn.com.soulfox.config;

import cn.com.soulfox.JschSftpRun;
import cn.com.soulfox.jsch.JschSftpConneciton;
import cn.com.soulfox.jsch.JschSftpUtil;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

/**
 * @author xxxx
 * @create 2024/7/5 12:57
 */
@RunWith(SpringRunner.class)
@SpringBootTest(classes = JschSftpRun.class,
        webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class JschSftpConfigTest {


    @Autowired
    private JschSftpConneciton sftpConneciton;

    /**
     * 下载文件
     */
    @Test
    public void testDownload(){
        //从远程服务器上的下载 /home/jiyh/ 目录下的 testabc.txt
        //下载文件保存到 d:\jiyh
        String remotePath = "/home/jiyh/";
        String downloadFileName = "testabc.txt";
        String localSavePath = "d:\\jiyh";
        JschSftpUtil.downloadFile(remotePath, downloadFileName, localSavePath);
    }

    /**
     * 上传文件
     */
    @Test
    public void testUpload(){
        //上传传本地 d:\jiyh 目录下的 test123.txt文件
        //到远程 /home/jiyh/test/test 目录
        //目录不存在，会自动创建
        JschSftpUtil.uploadFile("d:\\jiyh", "test123.txt", "/home/jiyh/test/test");

    }
}

• 在远程服务器准备测试文件 文件内容随便，这里我准备的内容为“112dadfdefee”
  

• 测试下载功能
  测试结果：
  

• 测试上传功能 ：在本地 d:/jiyh 目录准备测试文件“test123.txt”，内容为“dfdfdfdfdaerwrt”
  测试结果