Java GenericObjectPool 对象池化技术--SpringBoot sftp 连接池工具类
发布时间
阅读量：
阅读量
当单独为每个对象进行创建和销毁时效率低下时
Apache Commons Pool基于对象池框架设计构建而成，并为实现对象池化提供了丰富的API支持。该框架包含三类具体实现：分别是带有键的通用对象池、软引用对象池以及通用对象池，在这些具体实现中以通用对象池最为常用且其内部机制最为复杂
GenericObjectPool
GenericObjectPool 具备广泛适用性作为一个通用对象池框架 借助该框架可以轻易地构建出健壮的对象池系统 UML图如下所示
GenericObjectPool遵循了ObjectPool接口的规定，在功能设计上与这一核心接口保持一致。作为核心组件之一的ObjectPool，则构成了所有对象池的基础架构，并且该接口规范了对象池必须执行的行为标准。
public interface ObjectPool<T> extends Closeable {
/** * 从池中借走到一个对象
*/
T borrowObject() throws Exception, NoSuchElementException, IllegalStateException;
/** * 把对象归还给对象池
*/
void returnObject(T var1) throws Exception;
/** * 验证对象的有效性
*/
void invalidateObject(T var1) throws Exception;
/** * 往池中添加一个对象
*/
void addObject() throws Exception, IllegalStateException, UnsupportedOperationException;
/** * 返回对象池中有多少对象是空闲的，也就是能够被借走的对象的数量。
*/
int getNumIdle();
/** * 返回对象池中有对象对象是活跃的，也就是已经被借走的，在使用中的对象的数量。
*/
int getNumActive();
/** * 清理对象池。注意是清理不是清空，该方法要求的是，清理所有空闲对象，释放相关资源。
*/
void clear() throws Exception, UnsupportedOperationException;
/** * 关闭对象池。这个方法可以达到清空的效果，清理所有对象以及相关资源。
*/
void close();
}BasePooledObjectFactory
基于对象的资源管理方案：Java BasePooledObjectProvider 实现的对象池化机制
仅需创建一个继承自BasePooledObjectFactory的对象工厂类，并重现实现两个核心方法：create()和destroyObject()。例如，在如下的示例中可见
public interface PooledObjectFactory<T> {
/** * 创建一个可由池提供服务的实例，并将其封装在由池管理的PooledObject中。
*/
PooledObject<T> makeObject() throws Exception;
/** * 销毁池不再需要的实例
*/
void destroyObject(PooledObject<T> var1) throws Exception;
/** * 确保实例可以安全地由池返回
*/
boolean validateObject(PooledObject<T> var1);
/** * 重新初始化池返回的实例
*/
void activateObject(PooledObject<T> var1) throws Exception;
/** * 取消初始化要返回到空闲对象池的实例
*/
void passivateObject(PooledObject<T> var1) throws Exception;
}配置类GenericObjectPoolConfig
GenericObjectPoolConfig 是 包含 GenericObject 池 配置信息的一个基本组件；它 不具备线程安全性 ， 主要 用于指定 创建池 所需的属性设置 。 通常情况下，默认设置 足够满足 日常需求 。
工作原理流程
构建方式实现了对存储对象的一个LinkedList容器进行创建，并可理解为一种存储机制或临时存储空间。
从一个特定的位置开始，在容器中取出一个待赋值的对象实例；由于源码实现较为复杂，在未被占用的情况下（即该位置未被占用），则会调用构造方法的第一个参数Factory工厂类的makeObject()方法来创建一个新的对象实例；随后会调用validateObject方法来判断该新创建的对象是否为可用状态。若验证结果为真，则取用该新创建的对象实例作为当前操作的基础；此时容器中的链表长度减一。
Basically, this process involves first using the validateObject method to determine if the object is available. If it is available, it will be returned to the thread pool, incrementing the count of a LinkedList container. If not available, the destroyObject method will be called to remove it.
在实现基础功能时最为直接的就是这三个步骤，在其中取与还的操作步骤均固定在borrowObject与returnObject这两个方法体内因此我们只需对Factory工厂类中的makeObject()、validateObject()以及destroyObject这三个方法进行重构即可实现基础功能的一键式管理通过将构造函数传递给Factory工厂类对象，则可轻松构建出一个最基本的对象池管理系统这也是一种具有良好解耦性的设计模式借与还的具体流程如上图所示
使用Demo
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.7.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.jcraft/jsch -->
<dependency>
<groupId>com.jcraft</groupId>
<artifactId>jsch</artifactId>
<version>0.1.55</version>
</dependency>点击查看代码
application.yaml
server:
port: 8088
application:
name: sftp Demo
sftp:
host: 172.16.3.88 # 服务器ip
port: 22 # ssh端口
username: root # 用户名
password: root # 密码
# 连接池参数
pool:
max-total: 10
max-idle: 10
min-idle: 5SftpPoolException.java
package com.vipsoft.sftp.exception;
/** * sftp连接池异常
*/
public class SftpPoolException extends RuntimeException {
private static final long serialVersionUID = 1L;
/** * Constructs a new runtime exception with {@code null} as its
* detail message. The cause is not initialized, and may subsequently be
* initialized by a call to {@link #initCause}.
*/
public SftpPoolException() {
}
/** * Constructs a new runtime exception with the specified detail message.
* The cause is not initialized, and may subsequently be initialized by a
* call to {@link #initCause}.
* * @param message the detail message. The detail message is saved for
* later retrieval by the {@link #getMessage()} method.
*/
public SftpPoolException(String message) {
super(message);
}
/** * Constructs a new runtime exception with the specified detail message and
* cause. <p>Note that the detail message associated with
* {@code cause} is <i>not</i> automatically incorporated in
* this runtime exception's detail message.
* * @param message the detail message (which is saved for later retrieval
* by the {@link #getMessage()} method).
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public SftpPoolException(String message, Throwable cause) {
super(message, cause);
}
/** * Constructs a new runtime exception with the specified cause and a
* detail message of <tt>(cause==null ? null : cause.toString())</tt>
* (which typically contains the class and detail message of
* <tt>cause</tt>). This constructor is useful for runtime exceptions
* that are little more than wrappers for other throwables.
* * @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @since 1.4
*/
public SftpPoolException(Throwable cause) {
super(cause);
}
/** * Constructs a new runtime exception with the specified detail
* message, cause, suppression enabled or disabled, and writable
* stack trace enabled or disabled.
* * @param message the detail message.
* @param cause the cause. (A {@code null} value is permitted,
* and indicates that the cause is nonexistent or unknown.)
* @param enableSuppression whether or not suppression is enabled
* or disabled
* @param writableStackTrace whether or not the stack trace should
* be writable
* @since 1.7
*/
public SftpPoolException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}config
SftpConfig.java
package com.vipsoft.sftp.config;
import com.vipsoft.sftp.pool.SftpFactory;
import com.vipsoft.sftp.pool.SftpPool;
import com.vipsoft.sftp.utils.SftpUtil;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableConfigurationProperties(SftpProperties.class)
public class SftpConfig {
// 工厂
@Bean
public SftpFactory sftpFactory(SftpProperties properties) {
return new SftpFactory(properties);
}
// 连接池
@Bean
public SftpPool sftpPool(SftpFactory sftpFactory) {
return new SftpPool(sftpFactory);
}
// 辅助类
@Bean
public SftpUtil sftpUtil(SftpPool sftpPool) {
return new SftpUtil(sftpPool);
}
}SftpProperties.java
package com.vipsoft.sftp.config;
import com.jcraft.jsch.ChannelSftp;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(prefix = "sftp")
public class SftpProperties {
private String host;
private int port = 22;
private String username = "root";
private String password = "root";
private Pool pool = new Pool();
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Pool getPool() {
return pool;
}
public void setPool(Pool pool) {
this.pool = pool;
}
public static class Pool extends GenericObjectPoolConfig<ChannelSftp> {
private int maxTotal = DEFAULT_MAX_TOTAL;
private int maxIdle = DEFAULT_MAX_IDLE;
private int minIdle = DEFAULT_MIN_IDLE;
public Pool() {
super();
}
@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;
}
}
}Pool
SftpFactory.java
package com.vipsoft.sftp.pool;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;
import com.vipsoft.sftp.config.SftpProperties;
import com.vipsoft.sftp.exception.SftpPoolException;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Properties;
public class SftpFactory extends BasePooledObjectFactory<ChannelSftp> {
private final Logger logger = LoggerFactory.getLogger(this.getClass());
private SftpProperties properties;
public SftpProperties getProperties() {
return properties;
}
public void setProperties(SftpProperties properties) {
this.properties = properties;
}
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();
ChannelSftp channel = (ChannelSftp) sshSession.openChannel("sftp");
channel.connect();
return channel;
} catch (JSchException e) {
throw new SftpPoolException("连接sfpt失败", e);
}
}
@Override
public PooledObject<ChannelSftp> wrap(ChannelSftp channelSftp) {
return new DefaultPooledObject<>(channelSftp);
}
// 销毁对象
@Override
public void destroyObject(PooledObject<ChannelSftp> p) {
ChannelSftp channelSftp = p.getObject();
channelSftp.disconnect();
}
}SftpPool.java
package com.vipsoft.sftp.pool;
import com.jcraft.jsch.ChannelSftp;
import org.apache.commons.pool2.impl.GenericObjectPool;
public class SftpPool<T> extends GenericObjectPool<ChannelSftp> {
public SftpPool(SftpFactory factory) {
super(factory,factory.getProperties().getPool());
}
/** * 获取一个sftp连接对象
* @return sftp连接对象
*/
@Override
public ChannelSftp borrowObject() throws Exception {
return super.borrowObject();
}
/** * 归还一个sftp连接对象
* @param channelSftp sftp连接对象
*/
@Override
public void returnObject(ChannelSftp channelSftp) {
if (channelSftp!=null) {
super.returnObject(channelSftp);
}
}
}Utils
ByteUtil.java
package com.vipsoft.sftp.utils;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.SftpException;
import com.vipsoft.sftp.exception.SftpPoolException;
import com.vipsoft.sftp.pool.SftpPool;
import java.io.InputStream;
public class SftpUtil {
private SftpPool pool;
public SftpUtil(SftpPool pool) {
this.pool = pool;
}
/** * 下载文件
* * @param dir 远程目录
* @param name 远程文件名
* @return 文件字节数组
*/
public byte[] download(String dir, String name) {
ChannelSftp sftp = null;
try {
sftp = pool.borrowObject();
sftp.cd(dir);
InputStream in = sftp.get(name);
return ByteUtil.inputStreamToByteArray(in);
} catch (Exception e) {
throw new SftpPoolException("sftp下载文件出错", e);
} finally {
pool.returnObject(sftp);
}
}
/** * 上传文件
* * @param dir 远程目录
* @param name 远程文件名
* @param in 输入流
*/
public void upload(String dir, String name, InputStream in) {
ChannelSftp sftp = null;
try {
sftp = pool.borrowObject();
mkdirs(sftp, dir);
sftp.cd(dir);
sftp.put(in, name);
} catch (Exception e) {
throw new SftpPoolException("sftp上传文件出错", e);
} finally {
pool.returnObject(sftp);
}
}
/** * 删除文件
* * @param dir 远程目录
* @param name 远程文件名
*/
public void delete(String dir, String name) {
ChannelSftp sftp = null;
try {
sftp = pool.borrowObject();
sftp.cd(dir);
sftp.rm(name);
} catch (Exception e) {
throw new SftpPoolException("sftp删除文件出错", e);
} finally {
pool.returnObject(sftp);
}
}
/** * 递归创建多级目录
* * @param dir 多级目录
*/
private void mkdirs(ChannelSftp sftp, String dir) {
String[] folders = dir.split("/");
try {
sftp.cd("/");
for (String folder : folders) {
if (folder.length() > 0) {
try {
sftp.cd(folder);
} catch (Exception e) {
sftp.mkdir(folder);
sftp.cd(folder);
}
}
}
} catch (SftpException e) {
throw new SftpPoolException("sftp创建目录出错", e);
}
}
}Test
SftpTest.java
package com.vipsoft.sftp;
import com.vipsoft.sftp.utils.SftpUtil;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class SftpTest {
@Autowired
private SftpUtil sftpUtil;
@Test
void downloadTest() {
byte[] dockerfiles = sftpUtil.download("/opt/demo/", "Dockerfile");
System.out.println("FileSize =>" + dockerfiles.length);
}
}
全部评论 (0)
还没有任何评论哟~