经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring Boot » 查看文章
Java GenericObjectPool 对象池化技术--SpringBoot sftp 连接池工具类
来源：cnblogs　　作者：VipSoft　　时间：2023/4/7 8:55:27　　对本文有异议

Java BasePooledObjectFactory 对象池化技术

通常一个对象创建、销毁非常耗时的时候，我们不会频繁的创建和销毁它，而是考虑复用。复用对象的一种做法就是对象池，将创建好的对象放入池中维护起来，下次再用的时候直接拿池中已经创建好的对象继续用，这就是池化的思想。

Apache Commons Pool是一个对象池的框架，他提供了一整套用于实现对象池化的API。它提供了三种对象池：GenericKeyedObjectPool，SoftReferenceObjectPool和GenericObjectPool，其中GenericObjectPool是我们最常用的对象池，内部实现也最复杂。

GenericObjectPool

GenericObjectPool 是一个通用对象池框架，我们可以借助它实现一个健壮的对象池，UML图如下所示：
image

GenericObjectPool 实现了ObjectPool接口，而ObjectPool就是对象池的核心接口，它定义了一个对象池应该实现的行为。

  1. public interface ObjectPool<T> extends Closeable {
  2.     /**
  3.      * 从池中借走到一个对象
  4.      */
  5.     T borrowObject() throws Exception, NoSuchElementException, IllegalStateException;
  6.     /**
  7.      * 把对象归还给对象池
  8.      */
  9.     void returnObject(T var1) throws Exception;
  10.     /**
  11.      * 验证对象的有效性
  12.      */
  13.     void invalidateObject(T var1) throws Exception;
  15.     /**
  16.      * 往池中添加一个对象
  17.      */
  18.     void addObject() throws Exception, IllegalStateException, UnsupportedOperationException;
  19.     /**
  20.      * 返回对象池中有多少对象是空闲的，也就是能够被借走的对象的数量。
  21.      */
  22.     int getNumIdle();
  23.     /**
  24.      * 返回对象池中有对象对象是活跃的，也就是已经被借走的，在使用中的对象的数量。
  25.      */
  26.     int getNumActive();
  27.     /**
  28.      * 清理对象池。注意是清理不是清空，该方法要求的是，清理所有空闲对象，释放相关资源。
  29.      */
  30.     void clear() throws Exception, UnsupportedOperationException;
  31.     /**
  32.      * 关闭对象池。这个方法可以达到清空的效果，清理所有对象以及相关资源。
  33.      */
  34.     void close();
  35. }

BasePooledObjectFactory

Java BasePooledObjectFactory 对象池化技术

使用GenericObjectPool只需要创建一个对象工厂类，继承BasePooledObjectFactory并重写它的create()和destroyObject()。
如下文中的：SftpPool.java

  1. public interface PooledObjectFactory<T> {
  2.     /**
  3.      * 创建一个可由池提供服务的实例，并将其封装在由池管理的PooledObject中。
  4.      */
  5.     PooledObject<T> makeObject() throws Exception;
  7.     /**
  8.      *  销毁池不再需要的实例
  9.      */
  10.     void destroyObject(PooledObject<T> var1) throws Exception;
  12.     /**
  13.      * 确保实例可以安全地由池返回
  14.      */
  15.     boolean validateObject(PooledObject<T> var1);
  17.     /**
  18.      * 重新初始化池返回的实例
  19.      */
  20.     void activateObject(PooledObject<T> var1) throws Exception;
  22.     /**
  23.      * 取消初始化要返回到空闲对象池的实例
  24.      */
  25.     void passivateObject(PooledObject<T> var1) throws Exception;
  26. }

配置类GenericObjectPoolConfig

GenericObjectPoolConfig是封装GenericObject池配置的简单“结构”，此类不是线程安全的；它仅用于提供创建池时使用的属性。大多数情况，可以使用GenericObjectPoolConfig提供的默认参数就可以满足日常的需求。

工作原理流程

  1. 构造方法
    当我们执行构造方法时，主要工作就是创建了一个存储对象的LinkedList类型容器，也就是概念意义上的“池”
  2. 从对象池中获取对象
    获取池中的对象是通过borrowObject()命令，源码比较复杂，简单而言就是去LinkedList中获取一个对象，如果不存在的话，要调用构造方法中第一个参数Factory工厂类的makeObject()方法去创建一个对象再获取，获取到对象后要调用validateObject方法判断该对象是否是可用的，如果是可用的才拿去使用。LinkedList容器减一
  3. 归还对象到线程池
    简单而言就是先调用validateObject方法判断该对象是否是可用的，如果可用则归还到池中，LinkedList容器加一，如果是不可以的则调用destroyObject方法进行销毁

上面三步就是最简单的流程，由于取和还的流程步骤都在borrowObject和returnObject方法中固定的，所以我们只要重写Factory工厂类的makeObject()和validateObject以及destroyObject方法即可实现最简单的池的管理控制，通过构造方法传入该Factory工厂类对象则可以创建最简单的对象池管理类。这算是比较好的解耦设计模式，借和还的流程如下图所示：
image

使用Demo

  1. <dependency>
  2.     <groupId>org.apache.commons</groupId>
  3.     <artifactId>commons-pool2</artifactId>
  4.     <version>2.7.0</version>
  5. </dependency>
  7. <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
  8. <dependency>
  9.     <groupId>com.jcraft</groupId>
  10.     <artifactId>jsch</artifactId>
  11.     <version>0.1.55</version>
  12. </dependency>
点击查看代码 
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <parent>
  6.         <artifactId>vipsoft-parent</artifactId>
  7.         <groupId>com.vipsoft.boot</groupId>
  8.         <version>1.0-SNAPSHOT</version>
  9.     </parent>
  10.     <modelVersion>4.0.0</modelVersion>
  12.     <artifactId>vipsoft-sftp</artifactId>
  13.     <version>1.0-SNAPSHOT</version>
  15.     <dependencies>
  17.         <dependency>
  18.             <groupId>org.apache.commons</groupId>
  19.             <artifactId>commons-pool2</artifactId>
  20.             <version>2.7.0</version>
  21.         </dependency>
  23.         <!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
  24.         <dependency>
  25.             <groupId>com.jcraft</groupId>
  26.             <artifactId>jsch</artifactId>
  27.             <version>0.1.55</version>
  28.         </dependency>
  30.         <dependency>
  31.             <groupId>org.eclipse.paho</groupId>
  32.             <artifactId>org.eclipse.paho.client.mqttv3</artifactId>
  33.             <version>1.2.5</version>
  34.         </dependency>
  37.         <dependency>
  38.             <groupId>cn.hutool</groupId>
  39.             <artifactId>hutool-all</artifactId>
  40.             <version>5.3.6</version>
  41.         </dependency>
  42.         <dependency>
  43.             <groupId>org.springframework.boot</groupId>
  44.             <artifactId>spring-boot-starter-web</artifactId>
  45.         </dependency>
  46.         <dependency>
  47.             <groupId>org.springframework.boot</groupId>
  48.             <artifactId>spring-boot-starter-actuator</artifactId>
  49.         </dependency>
  50.         <dependency>
  51.             <groupId>org.springframework.boot</groupId>
  52.             <artifactId>spring-boot-starter-test</artifactId>
  53.             <scope>test</scope>
  54.             <exclusions>
  55.                 <exclusion>
  56.                     <groupId>org.junit.vintage</groupId>
  57.                     <artifactId>junit-vintage-engine</artifactId>
  58.                 </exclusion>
  59.             </exclusions>
  60.         </dependency>
  62.     </dependencies>
  64.     <build>
  65.         <plugins>
  66.             <plugin>
  67.                 <groupId>org.springframework.boot</groupId>
  68.                 <artifactId>spring-boot-maven-plugin</artifactId>
  69.             </plugin>
  70.         </plugins>
  71.     </build>
  72. </project>

application.yaml

  1. server:
  2.   port: 8088
  3.   application:
  4.     name: sftp Demo
  7. sftp:
  8.   host: 172.16.3.88 # 服务器ip
  9.   port: 22 # ssh端口
  10.   username: root # 用户名
  11.   password: root # 密码
  12.   # 连接池参数
  13.   pool:
  14.     max-total: 10
  15.     max-idle: 10
  16.     min-idle: 5

SftpPoolException.java

  1. package com.vipsoft.sftp.exception;
  4. /**
  5.  * sftp连接池异常
  6.  */
  7. public class SftpPoolException extends RuntimeException {
  9.     private static final long serialVersionUID = 1L;
  11.     /**
  12.      * Constructs a new runtime exception with {@code null} as its
  13.      * detail message.  The cause is not initialized, and may subsequently be
  14.      * initialized by a call to {@link #initCause}.
  15.      */
  16.     public SftpPoolException() {
  17.     }
  19.     /**
  20.      * Constructs a new runtime exception with the specified detail message.
  21.      * The cause is not initialized, and may subsequently be initialized by a
  22.      * call to {@link #initCause}.
  23.      *
  24.      * @param message the detail message. The detail message is saved for
  25.      *                later retrieval by the {@link #getMessage()} method.
  26.      */
  27.     public SftpPoolException(String message) {
  28.         super(message);
  29.     }
  31.     /**
  32.      * Constructs a new runtime exception with the specified detail message and
  33.      * cause.  <p>Note that the detail message associated with
  34.      * {@code cause} is <i>not</i> automatically incorporated in
  35.      * this runtime exception's detail message.
  36.      *
  37.      * @param message the detail message (which is saved for later retrieval
  38.      *                by the {@link #getMessage()} method).
  39.      * @param cause   the cause (which is saved for later retrieval by the
  40.      *                {@link #getCause()} method).  (A <tt>null</tt> value is
  41.      *                permitted, and indicates that the cause is nonexistent or
  42.      *                unknown.)
  43.      * @since 1.4
  44.      */
  45.     public SftpPoolException(String message, Throwable cause) {
  46.         super(message, cause);
  47.     }
  49.     /**
  50.      * Constructs a new runtime exception with the specified cause and a
  51.      * detail message of <tt>(cause==null ? null : cause.toString())</tt>
  52.      * (which typically contains the class and detail message of
  53.      * <tt>cause</tt>).  This constructor is useful for runtime exceptions
  54.      * that are little more than wrappers for other throwables.
  55.      *
  56.      * @param cause the cause (which is saved for later retrieval by the
  57.      *              {@link #getCause()} method).  (A <tt>null</tt> value is
  58.      *              permitted, and indicates that the cause is nonexistent or
  59.      *              unknown.)
  60.      * @since 1.4
  61.      */
  62.     public SftpPoolException(Throwable cause) {
  63.         super(cause);
  64.     }
  66.     /**
  67.      * Constructs a new runtime exception with the specified detail
  68.      * message, cause, suppression enabled or disabled, and writable
  69.      * stack trace enabled or disabled.
  70.      *
  71.      * @param message            the detail message.
  72.      * @param cause              the cause.  (A {@code null} value is permitted,
  73.      *                           and indicates that the cause is nonexistent or unknown.)
  74.      * @param enableSuppression  whether or not suppression is enabled
  75.      *                           or disabled
  76.      * @param writableStackTrace whether or not the stack trace should
  77.      *                           be writable
  78.      * @since 1.7
  79.      */
  80.     public SftpPoolException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
  81.         super(message, cause, enableSuppression, writableStackTrace);
  82.     }
  84. }

config

SftpConfig.java

  1. package com.vipsoft.sftp.config;
  3. import com.vipsoft.sftp.pool.SftpFactory;
  4. import com.vipsoft.sftp.pool.SftpPool;
  5. import com.vipsoft.sftp.utils.SftpUtil;
  6. import org.springframework.boot.context.properties.EnableConfigurationProperties;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  10. @Configuration
  11. @EnableConfigurationProperties(SftpProperties.class)
  12. public class SftpConfig {
  13.     // 工厂
  14.     @Bean
  15.     public SftpFactory sftpFactory(SftpProperties properties) {
  16.         return new SftpFactory(properties);
  17.     }
  19.     // 连接池
  20.     @Bean
  21.     public SftpPool sftpPool(SftpFactory sftpFactory) {
  22.         return new SftpPool(sftpFactory);
  23.     }
  25.     // 辅助类
  26.     @Bean
  27.     public SftpUtil sftpUtil(SftpPool sftpPool) {
  28.         return new SftpUtil(sftpPool);
  29.     }
  30. }

SftpProperties.java

  1. package com.vipsoft.sftp.config;
  3. import com.jcraft.jsch.ChannelSftp;
  4. import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
  5. import org.springframework.boot.context.properties.ConfigurationProperties;
  7. @ConfigurationProperties(prefix = "sftp")
  8. public class SftpProperties {
  10.     private String host;
  11.     private int port = 22;
  12.     private String username = "root";
  13.     private String password = "root";
  14.     private Pool pool = new Pool();
  16.     public String getHost() {
  17.         return host;
  18.     }
  20.     public void setHost(String host) {
  21.         this.host = host;
  22.     }
  24.     public int getPort() {
  25.         return port;
  26.     }
  28.     public void setPort(int port) {
  29.         this.port = port;
  30.     }
  32.     public String getUsername() {
  33.         return username;
  34.     }
  36.     public void setUsername(String username) {
  37.         this.username = username;
  38.     }
  40.     public String getPassword() {
  41.         return password;
  42.     }
  44.     public void setPassword(String password) {
  45.         this.password = password;
  46.     }
  48.     public Pool getPool() {
  49.         return pool;
  50.     }
  52.     public void setPool(Pool pool) {
  53.         this.pool = pool;
  54.     }
  56.     public static class Pool extends GenericObjectPoolConfig<ChannelSftp> {
  58.         private int maxTotal = DEFAULT_MAX_TOTAL;
  59.         private int maxIdle = DEFAULT_MAX_IDLE;
  60.         private int minIdle = DEFAULT_MIN_IDLE;
  62.         public Pool() {
  63.             super();
  64.         }
  65.         @Override
  66.         public int getMaxTotal() {
  67.             return maxTotal;
  68.         }
  69.         @Override
  70.         public void setMaxTotal(int maxTotal) {
  71.             this.maxTotal = maxTotal;
  72.         }
  73.         @Override
  74.         public int getMaxIdle() {
  75.             return maxIdle;
  76.         }
  77.         @Override
  78.         public void setMaxIdle(int maxIdle) {
  79.             this.maxIdle = maxIdle;
  80.         }
  81.         @Override
  82.         public int getMinIdle() {
  83.             return minIdle;
  84.         }
  85.         @Override
  86.         public void setMinIdle(int minIdle) {
  87.             this.minIdle = minIdle;
  88.         }
  89.     }
  90. }

Pool

SftpFactory.java

  1. package com.vipsoft.sftp.pool;
  3. import com.jcraft.jsch.ChannelSftp;
  4. import com.jcraft.jsch.JSch;
  5. import com.jcraft.jsch.JSchException;
  6. import com.jcraft.jsch.Session;
  7. import com.vipsoft.sftp.config.SftpProperties;
  8. import com.vipsoft.sftp.exception.SftpPoolException;
  9. import org.apache.commons.pool2.BasePooledObjectFactory;
  10. import org.apache.commons.pool2.PooledObject;
  11. import org.apache.commons.pool2.impl.DefaultPooledObject;
  12. import org.slf4j.Logger;
  13. import org.slf4j.LoggerFactory;
  15. import java.util.Properties;
  17. public class SftpFactory extends BasePooledObjectFactory<ChannelSftp> {
  19.     private  final Logger logger = LoggerFactory.getLogger(this.getClass());
  21.     private SftpProperties properties;
  23.     public SftpProperties getProperties() {
  24.         return properties;
  25.     }
  27.     public void setProperties(SftpProperties properties) {
  28.         this.properties = properties;
  29.     }
  31.     public SftpFactory(SftpProperties properties) {
  32.         this.properties = properties;
  33.     }
  35.     @Override
  36.     public ChannelSftp create() {
  37.         try {
  38.             JSch jsch = new JSch();
  39.             Session sshSession = jsch.getSession(properties.getUsername(), properties.getHost(), properties.getPort());
  40.             sshSession.setPassword(properties.getPassword());
  41.             Properties sshConfig = new Properties();
  42.             sshConfig.put("StrictHostKeyChecking", "no");
  43.             sshSession.setConfig(sshConfig);
  44.             sshSession.connect();
  45.             ChannelSftp channel = (ChannelSftp) sshSession.openChannel("sftp");
  46.             channel.connect();
  47.             return channel;
  48.         } catch (JSchException e) {
  49.             throw new SftpPoolException("连接sfpt失败", e);
  50.         }
  51.     }
  53.     @Override
  54.     public PooledObject<ChannelSftp> wrap(ChannelSftp channelSftp) {
  55.         return new DefaultPooledObject<>(channelSftp);
  56.     }
  58.     // 销毁对象
  59.     @Override
  60.     public void destroyObject(PooledObject<ChannelSftp> p) {
  61.         ChannelSftp channelSftp = p.getObject();
  62.         channelSftp.disconnect();
  63.     }
  65. }

SftpPool.java

  1. package com.vipsoft.sftp.pool;
  3. import com.jcraft.jsch.ChannelSftp;
  4. import org.apache.commons.pool2.impl.GenericObjectPool;
  6. public class SftpPool<T> extends GenericObjectPool<ChannelSftp> {
  8.     public SftpPool(SftpFactory factory) {
  9.         super(factory,factory.getProperties().getPool());
  10.     }
  12.     /**
  13.      * 获取一个sftp连接对象
  14.      * @return sftp连接对象
  15.      */
  16.     @Override
  17.     public ChannelSftp borrowObject() throws Exception {
  18.         return super.borrowObject();
  19.     }
  21.     /**
  22.      * 归还一个sftp连接对象
  23.      * @param channelSftp sftp连接对象
  24.      */
  25.     @Override
  26.     public void returnObject(ChannelSftp channelSftp) {
  27.         if (channelSftp!=null) {
  28.             super.returnObject(channelSftp);
  29.         }
  30.     }
  32. }

Utils

ByteUtil.java

  1. package com.vipsoft.sftp.utils;
  3. import com.jcraft.jsch.ChannelSftp;
  4. import com.jcraft.jsch.SftpException;
  5. import com.vipsoft.sftp.exception.SftpPoolException;
  6. import com.vipsoft.sftp.pool.SftpPool;
  8. import java.io.InputStream;
  10. public class SftpUtil {
  12.     private SftpPool pool;
  14.     public SftpUtil(SftpPool pool) {
  15.         this.pool = pool;
  16.     }
  18.     /**
  19.      * 下载文件
  20.      *
  21.      * @param dir  远程目录
  22.      * @param name 远程文件名
  23.      * @return 文件字节数组
  24.      */
  25.     public byte[] download(String dir, String name) {
  26.         ChannelSftp sftp = null;
  27.         try {
  28.             sftp = pool.borrowObject();
  29.             sftp.cd(dir);
  30.             InputStream in = sftp.get(name);
  31.             return ByteUtil.inputStreamToByteArray(in);
  32.         } catch (Exception e) {
  33.             throw new SftpPoolException("sftp下载文件出错", e);
  34.         } finally {
  35.             pool.returnObject(sftp);
  36.         }
  37.     }
  39.     /**
  40.      * 上传文件
  41.      *
  42.      * @param dir  远程目录
  43.      * @param name 远程文件名
  44.      * @param in   输入流
  45.      */
  46.     public void upload(String dir, String name, InputStream in) {
  47.         ChannelSftp sftp = null;
  48.         try {
  49.             sftp = pool.borrowObject();
  50.             mkdirs(sftp, dir);
  51.             sftp.cd(dir);
  52.             sftp.put(in, name);
  53.         } catch (Exception e) {
  54.             throw new SftpPoolException("sftp上传文件出错", e);
  55.         } finally {
  56.             pool.returnObject(sftp);
  57.         }
  58.     }
  60.     /**
  61.      * 删除文件
  62.      *
  63.      * @param dir  远程目录
  64.      * @param name 远程文件名
  65.      */
  66.     public void delete(String dir, String name) {
  67.         ChannelSftp sftp = null;
  68.         try {
  69.             sftp = pool.borrowObject();
  70.             sftp.cd(dir);
  71.             sftp.rm(name);
  72.         } catch (Exception e) {
  73.             throw new SftpPoolException("sftp删除文件出错", e);
  74.         } finally {
  75.             pool.returnObject(sftp);
  76.         }
  77.     }
  79.     /**
  80.      * 递归创建多级目录
  81.      *
  82.      * @param dir 多级目录
  83.      */
  84.     private void mkdirs(ChannelSftp sftp, String dir) {
  85.         String[] folders = dir.split("/");
  86.         try {
  87.             sftp.cd("/");
  88.             for (String folder : folders) {
  89.                 if (folder.length() > 0) {
  90.                     try {
  91.                         sftp.cd(folder);
  92.                     } catch (Exception e) {
  93.                         sftp.mkdir(folder);
  94.                         sftp.cd(folder);
  95.                     }
  96.                 }
  97.             }
  98.         } catch (SftpException e) {
  99.             throw new SftpPoolException("sftp创建目录出错", e);
  100.         }
  101.     }
  103. }

Test

SftpTest.java

  1. package com.vipsoft.sftp;
  3. import com.vipsoft.sftp.utils.SftpUtil;
  4. import org.junit.jupiter.api.Test;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.boot.test.context.SpringBootTest;
  8. @SpringBootTest
  9. public class SftpTest {
  11.     @Autowired
  12.     private SftpUtil sftpUtil;
  14.     @Test
  15.     void downloadTest() {
  16.         byte[] dockerfiles = sftpUtil.download("/opt/demo/", "Dockerfile");
  17.         System.out.println("FileSize =>" + dockerfiles.length);
  18.     }
  20. }

image

原文链接：https://www.cnblogs.com/vipsoft/p/17272728.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring Boot热门文章

  • 史上最详 Thymeleaf 使用教程
  • Spring Boot如何通过java -jar启动
  • Spring Boot 2.x（六）：优雅的统一返回值
  • Springboot使用Logback实现日志配置与异常记录
  • 使用SpringBoot+EasyExcel+Vue实现excel表格的导入和导出详解
  • spring boot上传文件超出大小异常无法捕获问题
  • paging组件的用法和意义
  • springboot2.0集成rabbitmq的示例代码
  • Spring MVC学习step1——框架熟悉
  • spring boot ${}占位符不起作用的解决方案

    • Spring Boot推荐文章

  • 3分钟带你搞定Spring Boot中Schedule
  • 不单独部署注册中心，又要具备注册中心的功能，我能上天！
  • 从零开始学Spring Boot系列-集成Spring Security实现用户认证与授权
  • 不单独部署注册中心，又要具备注册中心的功能，咋不让我上天？
  • EasyExcel 无法读取图片？用poi写了一个工具类
  • 【进阶篇】使用 Stream 流对比两个集合的常用操作分享
  • 关于DDD和COLA的一些总结和思考
  • SnakeYaml反序列化分析
  • RestTemplate进行https请求时适配信任证书
  • Kryo反序列化链分析

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号