springboot整合SFTP，连接池连接
一、项目结构
SFTP
SftpProperties --配置载入
SftpFactory ---连接工厂
SftpPool ----连接池
SftpHelper ----辅助方法，下载
二、maven
<!-- ftp远程工具 -->
<dependency>
<groupId>commons-net</groupId>
<artifactId>commons-net</artifactId>
<version>3.3</version>
<!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.53</version>
</dependency>
<!-- pool 对象池 -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
</dependency>
三、配置文件
config:
# 协议
sftpClientProtocol: sftp
# ip地址
sftpClientHost: ip
# 端口
sftpClientPort: 2222
# 用户名
sftpClientUsername: name
# 密码
sftpClientPassword: password
# 根路径
sftpClientRoot: /
fileBackupPaths: D:/2023/TEST/LDPBACKS/
remotePaths: /home/LDP/
#本地路径
localPaths: D:/2023/TEST/LDP/
#
sftpClientSessionStrictHostKeyChecking: no
# session连接超时时间
sftpClientSessionConnectTimeout: 15000
# channel连接超时时间
sftpClientChannelConnectedTimeout: 15000
sftpMaxTotal: 100
sftpMinIdel: 2
sftpMaxIdle: 20
四、代码
4.1 SftpProperties.class
import com.jcraft.jsch.ChannelSftp;
import lombok.Data;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
/**
* @author gyDeBug
* @description: 配置文件和实体注入
* @param:
* @return:
* @date：2021/11/30
*/
@Data
@Component
@Configuration
public class SftpProperties {
private String host;
private int port;
private String username;
private String password;
private String root;
private String localPath;
private String fileBackupPaths;
private String remotePaths;
private Integer sessionConnectTimeout;
private Integer channelConnectedTimeout;
private Pool pool = new Pool();
@Value("${config.sftpClientHost}")
public void setHost(String host) {
this.host = host;
}
@Value("${config.sftpClientPort}")
public void setPort(int port) {
this.port = port;
}
@Value("${config.sftpClientUsername}")
public void setUsername(String username) {
this.username = username;
}
@Value("${config.sftpClientPassword}")
public void setPassword(String password) {
this.password = password;
}
@Value("${config.sftpClientRoot}")
public void setRoot(String root) {
this.root = root;
}
@Value("${config.localPaths}")
public void setLocalPath(String localPath) {
this.localPath = localPath;
}
@Value("${config.fileBackupPaths}")
public void setFileBackupPaths(String fileBackupPaths) {
this.fileBackupPaths = fileBackupPaths;
}
@Value("${config.remotePaths}")
public void setRemotePaths(String remotePaths) {
this.remotePaths = remotePaths;
}
@Value("${config.sftpClientSessionConnectTimeout}")
public void setSessionConnectTimeout(Integer sessionConnectTimeout) {
this.sessionConnectTimeout = sessionConnectTimeout;
}
@Value("${config.sftpClientChannelConnectedTimeout}")
public void setChannelConnectedTimeout(Integer channelConnectedTimeout) {
this.channelConnectedTimeout = channelConnectedTimeout;
}
public static class Pool extends GenericObjectPoolConfig<ChannelSftp> {
private int maxTotal = 100;
允许最大空闲对象数
private int maxIdle = 80;
// 允许最小空闲对象数
private int minIdle = 10;
//控制获取不到连接时超时时间，避免无限等待
private long maxWaitMillis = 60000;
public Pool() {
super();
}
@Override
public long getMaxWaitMillis() {
return maxWaitMillis;
}
@Override
public void setMaxWaitMillis(long maxWaitMillis) {
this.maxWaitMillis = maxWaitMillis;
}
@Override
public int getMaxTotal() {
return maxTotal;
}
@Override
public void setMaxTotal(int maxTotal) {
this.maxTotal = maxTotal;
}
@Override
public int getMaxIdle() {
return maxIdle;
}
@Override
public void setMaxIdle(int maxIdle) {
this.maxIdle = maxIdle;
}
@Override
public int getMinIdle() {
return minIdle;
}
@Override
public void setMinIdle(int minIdle) {
this.minIdle = minIdle;
}
}
}
4.2 SftpFactory.class
import com.airtravel.odb.common.wechat.WechatService;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
import java.util.Properties;
@Data
@Slf4j
public class SftpFactory extends BasePooledObjectFactory<ChannelSftp> {
private SftpProperties properties;
@Autowired
private Environment environment;
public SftpFactory(SftpProperties properties) {
this.properties = properties;
}
@Override
public ChannelSftp create() {
try {
JSch jsch = new JSch();
Session sshSession = jsch.getSession(properties.getUsername(), properties.getHost(), properties.getPort());
sshSession.setPassword(properties.getPassword());
Properties sshConfig = new Properties();
sshConfig.put("StrictHostKeyChecking", "no");
sshSession.setConfig(sshConfig);
sshSession.connect(properties.getSessionConnectTimeout());
ChannelSftp channel = (ChannelSftp) sshSession.openChannel("sftp");
channel.connect(properties.getChannelConnectedTimeout());
return channel;
} catch (JSchException e) {
log.info("连接sfpt失败："+e.getMessage());
e.printStackTrace();
return null;
}
}
@Override
public PooledObject<ChannelSftp> wrap(ChannelSftp channelSftp) {
return new DefaultPooledObject<>(channelSftp);
}
// 销毁对象
@Override
public void destroyObject(PooledObject<ChannelSftp> p) {
ChannelSftp channelSftp = p.getObject();
channelSftp.disconnect();
}
}
4.3 SftpPool.class
import com.jcraft.jsch.ChannelSftp;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.env.Environment;
@Data
@Slf4j
public class SftpPool {
private GenericObjectPool<ChannelSftp> pool;
@Autowired
private Environment environment;
public SftpPool(SftpFactory factory) {
this.pool = new GenericObjectPool<>(factory, factory.getProperties().getPool());
// 当池中对象用完时，请求新的对象所要执行的动作
// public byte whenExhaustedAction = DEFAULT_WHEN_EXHAUSTED_ACTION;
// 是否在从池中取出对象前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个.
// 在从对象池获取对象时是否检测对象有效(true : 是) , 配置true会降低性能；
this.pool.setTestOnBorrow(true);
// 是否在向池中归还对象前进行检验,如果检验失败
//在向对象池中归还对象时是否检测对象有效(true : 是) , 配置true会降低性能
this.pool.setTestOnReturn(true);
// 连接是否被空闲连接回收器(如果有)进行检验.如果检测失败,则连接将被从池中去除
this.pool.setTestWhileIdle(true);
// 在空闲连接回收器线程运行期间休眠的时间毫秒数. 如果设置为非正数,则不运行空闲连接回收器线程.空闲连接检测的周期（单位毫秒）
this.pool.setTimeBetweenEvictionRunsMillis(80000);
// 设定在进行后台对象清理时，每次检查对象数,检测空闲对象线程每次运行时检测的空闲对象的数量；
// public int numTestsPerEvictionRun = GenericObjectPool.DEFAULT_NUM_TESTS_PER_EVICTION_RUN;
// this.pool.setNumTestsPerEvictionRun(80000);
// 被空闲对象回收器回收前在池中保持空闲状态的最小时间毫秒数
this.pool.setMinEvictableIdleTimeMillis(90000);
// 被空闲对象回收器回收前在池中保持空闲状态的最小时间毫秒数
// public long softMinEvictableIdleTimeMillis = GenericObjectPool.DEFAULT_SOFT_MIN_EVICTABLE_IDLE_TIME_MILLIS;
this.pool.setTimeBetweenEvictionRunsMillis(80000);
// 是否采用后进先出策略
// public boolean lifo = GenericObjectPool.DEFAULT_LIFO;
}
/**
* 获取一个sftp连接对象
* @return sftp连接对象
*/
public ChannelSftp borrowObject() {
try {
return pool.borrowObject();
} catch (Exception e) {
log.info("获取sftp连接池连接失败："+e.getMessage());
return null;
}
}
/**
* 归还一个sftp连接对象
* @param channelSftp sftp连接对象
*/
public void returnObject(ChannelSftp channelSftp) {
if (channelSftp!=null) {
pool.returnObject(channelSftp);
}
}
}
4.4 SftpHelper.calss
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.core.env.Environment;
import javax.annotation.Resource;
import java.io.*;
import java.util.ArrayList;
import java.util.Vector;
// sftp辅助类
@Slf4j
public class SftpHelper {
@Resource
private SftpProperties sftpProperties;
private SftpPool pool;
@Autowired
private Environment environment;
public SftpHelper(SftpPool pool) {
this.pool = pool;
}
public ArrayList<String> downSftpFile(){
log.info("获取SFTP连接信息");
ChannelSftp sftp = pool.borrowObject();
log.info("登录成功,从连接池获取SFTP连接信息"+sftp);
ArrayList<String> fileList = new ArrayList<String>();
if(sftp == null){
String msg = "从连接池获取SFTP连接信息为null";
}else{
try {
sftp.cd(sftpProperties.getRemotePaths());
log.info("SFTP登录进入目录："+sftpProperties.getRemotePaths());
Vector<ChannelSftp.LsEntry> list = sftp.ls("*.txt");
if(list.size() >0){
for (ChannelSftp.LsEntry entry : list) {
String filename = entry.getFilename();
log.info("遍历SFTP文件————————————————"+filename);
String routeFileName = sftpProperties.getRemotePaths()+filename;
//下载
File localFile = new File(sftpProperties.getLocalPath()+filename);
OutputStream outputStream = new FileOutputStream(localFile);
sftp.get(routeFileName, outputStream);
outputStream.close();
//备份下载
File localbackupFile = new File(sftpProperties.getFileBackupPaths()+filename);
OutputStream osputStream = new FileOutputStream(localbackupFile);
sftp.get(routeFileName, osputStream);
osputStream.close();
log.info("下载文件："+filename);
fileList.add(sftpProperties.getLocalPath()+filename);
//删除文件
sftp.rm(filename);
}
}else{
log.info("本次遍历文件为空");
}
} catch (Exception e) {
log.info("SFTP文件下载失败："+e.getMessage());
e.printStackTrace();
} finally {
pool.returnObject(sftp);
}
}
return fileList;
}