common-pool2实现sftp连接池

已于 2022-07-27 13:52:20 修改
阅读量1.8k 收藏 17
点赞数 2
分类专栏： 个人 文章标签： java
于 2022-07-26 18:32:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43316101/article/details/126000195
版权

背景

项目使用sftp作为存储介质，需要大量的上传下载，单例的sftp不能满足场景，使用ThreadLocal存储sftp连接，会频繁创建销毁连接，性能太差，于是想到将连接对象池化。

common-pool2介绍

Apache Common Pool2 是Apache提供的一个通用对象池技术实现，可以方便定制化自己需要的对象池，大名鼎鼎的 Redis 客户端 Jedis 内部连接池就是基于它来实现的。

  • 依赖
   <dependency>
        <groupId>com.jcraft</groupId>
        <artifactId>jsch</artifactId>
        <version>0.1.55</version>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.8.0</version>
    </dependency>
  • sftpClient，用于创建连接，验证连接，销毁连接使用
package com.zhanghao.base.util;

import com.jcraft.jsch.*;
import lombok.Data;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.Properties;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author zh
 */
@Data
public class SftpClient {
  private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  private static final AtomicLong CLIENT_NUMBER = new AtomicLong(1L);
  private ChannelSftp channelSftp;
  private Session session;
  /**
   *
   */
  private String clientInfo = "sftpclient";
  /**
   * ssh 根目录。
   * 用于判断是否成功返回连接到连接池的条件之一
   */
  private String originalDir;
  //创建连接
  public SftpClient(SftpProperties sftpProperties) throws SftpException, JSchException {
    try {
      JSch jsch = new JSch();
      session = jsch.getSession(sftpProperties.getUsername(), sftpProperties.getHost(), sftpProperties.getPort());
      session.setPassword(sftpProperties.getPassword());
      Properties config = new Properties();
      if (sftpProperties.getSession() != null) {
        sftpProperties.getSession().forEach(config::put);
      }
      session.setConfig(config);
      session.connect();
      channelSftp = (ChannelSftp) session.openChannel("sftp");
      channelSftp.connect();
      clientInfo += CLIENT_NUMBER.getAndIncrement() + ",createTime:" + DATE_TIME_FORMATTER.format(LocalDateTime.now());
      originalDir = channelSftp.pwd();
    } catch (Exception e) {
      disconnect();
      throw e;
    }
  }
 //断开连接
  public void disconnect() {
    if (channelSftp != null) {
      try {
        channelSftp.disconnect();
      } catch (Exception ignored) {
      }
    }
    if (session != null) {
      try {
        session.disconnect();
      } catch (Exception ignored) {
      }
    }
  }
 //验证连接
  public boolean validateConnect() {
    try {
      return session.isConnected() && channelSftp.isConnected() && originalDir.equals(channelSftp.pwd());
    } catch (Exception e) {
      return false;
    }
  }
}
  • 配置
package com.zhanghao.base.util;

import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * @author zh
 */
@Component
@ConfigurationProperties("sftp")
@Getter
@Setter
public class SftpProperties {
  /**
   * 地址
   */
  private String host;
  /**
   * 端口号
   */
  private int port = 22;
  /**
   * 用户名
   */
  private String usernamel;
  /**
   * 密码
   */
  private String password;
  /**
   * Session 参数配置
   */
  private Map<String, String> session;
  /**
   * 连接池配置
   */
  private Pool pool;


  /**
   * 连接池配置类
   */
  @Data
  public static class Pool {
    /**
     * 池中最小的连接数，只有当 timeBetweenEvictionRuns 为正时才有效
     */
    private int minIdle = 0;

    /**
     * 池中最大的空闲连接数，为负值时表示无限
     */
    private int maxIdle = 8;

    /**
     * 池可以产生的最大对象数，为负值时表示无限
     */
    private int maxActive = 16;

    /**
     * 当池耗尽时，阻塞的最长时间，为负值时无限等待
     */
    private long maxWait = -1;

    /**
     * 从池中取出对象是是否检测可用
     */
    private boolean testOnBorrow = true;

    /**
     * 将对象返还给池时检测是否可用
     */
    private boolean testOnReturn = false;

    /**
     * 检查连接池对象是否可用
     */
    private boolean testWhileIdle = true;

    /**
     * 距离上次空闲线程检测完成多久后再次执行
     */
    private long timeBetweenEvictionRuns = 300000L;
  }
}
  • 连接池（核心）
package com.zhanghao.base.util;

import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.ObjectPool;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;


/**
 * @author zh
 */
public class SftpPool implements ObjectPool<SftpClient> {
  private final GenericObjectPool<SftpClient> internalPool;

  public SftpPool(SftpProperties sftpProperties) {
    this.internalPool = new GenericObjectPool<SftpClient>(new SftpFactory(sftpProperties), getPoolConfig(sftpProperties.getPool())){
      @Override
      public void returnObject(SftpClient sftpClient) {
        try {
          sftpClient.getChannelSftp().cd(sftpClient.getOriginalDir());
        } catch (Exception ignored) {
        }
        super.returnObject(sftpClient);
      }
    };
  }

  @Override
  public void addObject() throws Exception {
    internalPool.addObject();
  }

  @Override
  public SftpClient borrowObject() throws Exception {
    return internalPool.borrowObject();
  }

  @Override
  public void clear() {
    internalPool.clear();
  }

  @Override
  public void close() {
    internalPool.close();
  }

  @Override
  public int getNumActive() {
    return internalPool.getNumActive();
  }

  @Override
  public int getNumIdle() {
    return internalPool.getNumIdle();
  }

  @Override
  public void invalidateObject(SftpClient obj) throws Exception {
    internalPool.invalidateObject(obj);
  }

  @Override
  public void returnObject(SftpClient obj) {
    internalPool.returnObject(obj);
  }

  private static class SftpFactory extends BasePooledObjectFactory<SftpClient> {

    private final SftpProperties sftpProperties;

    public SftpFactory(SftpProperties sftpProperties) {
      this.sftpProperties = sftpProperties;
    }

    @Override
    public SftpClient create() throws Exception {
      return new SftpClient(sftpProperties);
    }

    @Override
    public PooledObject<SftpClient> wrap(SftpClient sftpClient) {
      return new DefaultPooledObject<>(sftpClient);
    }

    @Override
    public boolean validateObject(PooledObject<SftpClient> p) {
      return p.getObject().validateConnect();
    }

    @Override
    public void destroyObject(PooledObject<SftpClient> p) {
      p.getObject().disconnect();
    }

  }

  private GenericObjectPoolConfig<SftpClient> getPoolConfig(SftpProperties.Pool properties) {
    if (properties == null) {
      properties = new SftpProperties.Pool();
    }
    GenericObjectPoolConfig<SftpClient> config = new GenericObjectPoolConfig<>();
    config.setMinIdle(properties.getMinIdle());
    config.setMaxIdle(properties.getMaxIdle());
    config.setMaxTotal(properties.getMaxActive());
    config.setMaxWaitMillis(properties.getMaxWait());
    config.setTestOnBorrow(properties.isTestOnBorrow());
    config.setTestOnReturn(properties.isTestOnReturn());
    config.setTestWhileIdle(properties.isTestWhileIdle());
    config.setTimeBetweenEvictionRunsMillis(properties.getTimeBetweenEvictionRuns());
    return config;
  }
}
  • 实例化对象池
package com.zhanghao.base.util;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 *
 * @author zh
 */
@Configuration
public class SftpPoolConfig {

    @Bean
    public SftpPool getSftpPool(SftpProperties sftpProperties){
        return new SftpPool(sftpProperties);
    }
}
  • demo
@Resource
    private SftpPool sftpPool;
    /**
     * demo
     *
     * @return void
     * @author zh
     */
    @GetMapping("/file/download")
    public Integer fileDownload() {
            SftpClient sftpClient = null;
                try {
                    log.info("sftp连接池大小{}",sftpPool.getNumIdle());
                    sftpClient = sftpPool.borrowObject();
                    InputStream inputStream = sftpClient.getChannelSftp().get("/upload/233.jpg");
                    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                    IOUtils.copy(inputStream,byteArrayOutputStream);
                    return byteArrayOutputStream.size();
                } catch (Exception e1) {
                    log.info("下载异常！",e1);
                    try {
                        sftpPool.invalidateObject(sftpClient);
                    } catch (Exception e2) {
                        log.info("销毁sftp连接异常！",e2);
                    }
                    sftpClient = null;
                } finally {
                    if (null != sftpClient) {
                        sftpPool.returnObject(sftpClient);
                    }
                }
            return null;
        }
  • 压测数据解析
    在这里插入图片描述

在这里插入图片描述

2022-07-26 18:26:06.467  INFO 6424 --- [io-8090-exec-77] c.zhanghao.base.biz.BizCommonController  : sftp连接池大小8
2022-07-26 18:26:06.471  INFO 6424 --- [o-8090-exec-113] c.zhanghao.base.biz.BizCommonController  : sftp连接池大小7

总结：

根据上文的配置，200线程下，最大创建了8个连接对象，根据根据自己的需要调整最大连接对象数和空闲数，正常情况下保持几个连接就够用了。

土豆怎么做都好吃
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
SFTP连接池管理
weixin_39080854的博客
10-11 853
sftp连接池
Java连接FTP服务器，并使用ftp连接池进行文件操作
最新发布
qq_41481924的博客
04-25 568
使用Java连接FTP服务器进行文件操作，包含文件和文件夹上传、下载、获取文件夹内文件名、文件数量、将文件夹打包成zip在浏览器下载等接口，并且使用FTP连接池降低资源消耗，提高响应速率。
FTPClient连接池
07-22
基于SpringBoot搭建 使用apache的commons-pool2 构建 FTPClient连接池 有FtpClientFactory、FtpClientPool、FtpConfig、FtpOperate 四个类组成 还有ftp连接池的一些配置参数信息在ftp.properties文件中 注释完整欢迎大家下载使用
Java 自定义FTP连接池
ankan7400的博客
09-12 196
转自:https://blog.csdn.net/eakom/article/details/79038590 版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/eakom/article/details/79038590 一、引入FTP包和连接池包 <!-- ftp连接start --> <dependenc...
第三方数据连接池使用
qq_43496435的博客
07-25 253
DBCP 第一步：导包 Commons-dbcp.jar：连接池的实现 Commons-pool.jar：连接池实现的依赖库 <dependency> <groupId>commons-dbcp</groupId> <artifactId>commons-dbcp</artifactId> <version>1.4</version> </dependency> <depen...
flysystem-sftp:用于SFTP的Flysystem适配器
04-30
用于SFTP的Flysystem适配器 该适配器使用phpseclib为Flysystem提供一个SFTP适配器。安装composer require league/flysystem-sftp文献资料该适配器的完整文档，可以发现： 用法use League \ Flysystem \ Sftp \ ...
前端开源库-ssh2-sftp-client
08-29
前端开源库-ssh2-sftp-clientssh2 sftp客户端，节点的ssh2 sftp客户端
sftp连接池和springboot启动器.rar
06-05
通过 sftp 连接 ，端口为默认的 22，用户为 Linux 当前登录用户。 格式：sftp -oPort=<port> 通过 sftp 连接 ，指定端口 ，用户为 Linux 当前登录用户。 格式：sftp <user>@ 通过 sftp 连接 ，端口为默认的 22...
JSch - Java实现的SFTP（文件上传详解篇）
07-17
JSch - Java实现的SFTP（文件上传详解篇）
spark-sftp:SFTP的Spark连接器
05-08
Spark SFTP连接器库 通过从SFTP下载文件并将数据帧写入SFTP服务器来构造数据帧的库 要求 该库需要Spark2.x。 对于Spark 1.x支持，请检查分支。 连结中 您可以通过以下方式在程序中链接到该库： Maven依赖 ...
java ftpClient 连接池设计
08-11
1 博文链接：https://bai2mumu.iteye.com/blog/2231916
上传下载文件（连接池）
10-28
上传下载文件（连接池）web工程，导入到MyEclipse下即可
java实现sftp操作工具类
03-12
1分让你得到sftp常用操作工具，工具实现如下操作: 1)得到当前工作目录地址 2)改变目录为配置的远程目录 3)取文件目录列表 4)取文件列表 5)下载文件 6)复制文件 7)删除文件 8)目录是否存在,文件是否存在 9)移动文件 10)可以基于chnSftp对象进行开发 依赖类包在我的sftp包下载下提供 版权声明：本工具类为个人兴趣基于chnSftp编写的应用，个人版权在先，后因各个办公环境无相关软件也有相关的个人使用，和办公环境内的推广使用，也欢迎互联网使用，如涉及相关环境认为本应用有不妥之处，请删除本人的工具软件。欢迎互联网使用和反馈。
SpringBoot2.2+commons-pool2实现多Ftp连接池完整项目，开箱即用，经过长期生产使用稳定可靠
全栈行动派的博客
04-04 3883
SpringBoot2.2+commons-pool2实现多Ftp连接池完整项目，开箱即用，经过长期生产使用稳定可靠
apache common pool2 对象池使用和原理
weixin_36001569的博客
06-01 1298
}} }System . out . println("激活对象，借用时调用");System . out . println("销毁对象");System . out . println("创建对象");System . out . println("钝化对象，归还时调用");System . out . println("判断对象是否可用");} }
common-pool2对象池(连接池)的介绍及使用
weixin_30861797的博客
11-29 865
我们在服务器开发的过程中，往往会有一些对象，它的创建和初始化需要的时间比较长，比如数据库连接，网络IO，大数据对象等。在大量使用这些对象时，如果不采用一些技术优化，就会造成一些不可忽略的性能影响。一种办法就是使用对象池，每次创建的对象并不实际销毁，而是缓存在对象池中，下次使用的时候，不用再重新创建，直接从对象池的缓存中取即可。为了避免重新造轮子，我们可以使用优秀的开源对象池化组件apache-co...
java sftp连接池_jsch连接sftp后连接未释放掉问题排查
weixin_42510768的博客
02-16 2945
项目中通过jsch中的sftp实现上传下载文件。在压测过程中，由于调用到sftp，下载文件不存在时，系统不断抛出异常，内存飙升，逐渐把swap区也占满，通过top监控未发现占用内存的进程，通过查找sshd进程，发现服务器多了很多sftp的进程没有被关闭。刚开始以为是sftp公共方法设计的有问题，每次创建连接都未释放，下面是部分代码片段@Repository("SftpClient")public ...
common-pool2
weixin_44457533的博客
12-27 1070
文章目录1、简介2、核心接口3、对象池逻辑分析3.1、对象池接口说明3.2、 对象创建解耦3.2、池对象的状态3.3、对象池相关配置项3.4、对象池源码分析4、对象池`browObject`的逻辑5、对象池`returnObject`的过程执行逻辑6、对象池的自我保护机制7、工厂的`passivateObject(PooledObject p)`和`passivateObject(PooledObject p)`即对象的激活和钝化方法有有什么作用？8、使用步骤9、注意事项 1、简介 对象池就是一种存放对象的
springboot sftp连接池实现
11-12
以下是使用Spring Boot和commons-pool2实现SFTP连接池的示例代码： 1.添加依赖 ```xml <dependency> <groupId>com.jcraft</groupId> <artifactId>jsch</artifactId> <version>0.1.55</version> </dependency> <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-pool2</artifactId> <version>2.6.2</version> </dependency> ``` 2.配置连接池 ```java @Configuration public class SftpPoolConfig { @Value("${sftp.host}") private String host; @Value("${sftp.port}") private int port; @Value("${sftp.username}") private String username; @Value("${sftp.password}") private String password; @Value("${sftp.timeout}") private int timeout; @Value("${sftp.pool.maxTotal}") private int maxTotal; @Value("${sftp.pool.maxIdle}") private int maxIdle; @Value("${sftp.pool.minIdle}") private int minIdle; @Bean public GenericObjectPool<ChannelSftp> sftpPool() { GenericObjectPoolConfig<ChannelSftp> poolConfig = new GenericObjectPoolConfig<>(); poolConfig.setMaxTotal(maxTotal); poolConfig.setMaxIdle(maxIdle); poolConfig.setMinIdle(minIdle); poolConfig.setTestOnBorrow(true); poolConfig.setTestOnReturn(true); poolConfig.setTestWhileIdle(true); poolConfig.setTimeBetweenEvictionRunsMillis(60000); poolConfig.setMinEvictableIdleTimeMillis(1800000); return new GenericObjectPool<>(new SftpPoolFactory(host, port, username, password, timeout), poolConfig); } } ``` 3.实现连接池工厂 ```java public class SftpPoolFactory extends BasePooledObjectFactory<ChannelSftp> { private String host; private int port; private String username; private String password; private int timeout; public SftpPoolFactory(String host, int port, String username, String password, int timeout) { this.host = host; this.port = port; this.username = username; this.password = password; this.timeout = timeout; } @Override public ChannelSftp create() throws Exception { JSch jsch = new JSch(); Session session = jsch.getSession(username, host, port); session.setPassword(password); Properties config = new Properties(); config.put("StrictHostKeyChecking", "no"); session.setConfig(config); session.setTimeout(timeout); session.connect(); Channel channel = session.openChannel("sftp"); channel.connect(); return (ChannelSftp) channel; } @Override public PooledObject<ChannelSftp> wrap(ChannelSftp sftp) { return new DefaultPooledObject<>(sftp); } @Override public void destroyObject(PooledObject<ChannelSftp> p) throws Exception { ChannelSftp sftp = p.getObject(); if (sftp.isConnected()) { sftp.disconnect(); } } @Override public boolean validateObject(PooledObject<ChannelSftp> p) { ChannelSftp sftp = p.getObject(); return sftp.isConnected(); } } ``` 4.使用连接池 ```java @Service public class SftpService { @Autowired private GenericObjectPool<ChannelSftp> sftpPool; public void upload(String remotePath, String fileName, InputStream inputStream) throws Exception { ChannelSftp sftp = sftpPool.borrowObject(); try { sftp.cd(remotePath); } catch (SftpException e) { sftp.mkdir(remotePath); sftp.cd(remotePath); } sftp.put(inputStream, fileName); sftpPool.returnObject(sftp); } public InputStream download(String remotePath, String fileName) throws Exception { ChannelSftp sftp = sftpPool.borrowObject(); sftp.cd(remotePath); InputStream inputStream = sftp.get(fileName); sftpPool.returnObject(sftp); return inputStream; } } ``` 相关问题：

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值