自定义SFTP线程池

在开发中，针对大对象频繁创建/销毁导致性能瓶颈的场景（如数据库连接、游戏粒子特效、网络会话管理），可通过 对象池（池化技术） 优化资源管理，减少性能的开销。

Apache Commons Pool2

Apache Commons Pool2 是一个高效的对象池管理库，用于缓存创建成本高的对象（如数据库连接、网络连接），以提升系统性能。

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version> <!-- 建议使用最新稳定版本 -->
</dependency>

核心组件

1. 对象池（ObjectPool）

管理对象的借出和归还，常用实现类为 GenericObjectPool 和 GenericKeyedObjectPool（支持键控池）。通过配置参数控制池行为，如最大空闲数、最小空闲数等12。

2. 池化对象工厂（PooledObjectFactory）

定义对象的生命周期方法：

• makeObject()：创建新对象。
• destroyObject()：销毁无效对象。
• validateObject()：验证对象有效性。
• activateObject() / passivateObject()：激活或钝化对象状态。

3. 配置类（GenericObjectPoolConfig）

常用参数包括：

• maxTotal：池中最大对象数。
• maxIdle：最大空闲对象数。
• minIdle：最小空闲对象数。
• testOnBorrow：借出时验证对象有效性。
• timeBetweenEvictionRuns：驱逐检测间隔（用于清理无效对象）

使用示例

1. 实现对象工厂

public class MyObjectFactory extends BasePooledObjectFactory<ExpensiveObject> {
   
    @Override
    public ExpensiveObject create() {
   
        return new ExpensiveObject(); // 创建昂贵对象
    }

    @Override
    public PooledObject<ExpensiveObject> wrap(ExpensiveObject obj) {
   
        return new DefaultPooledObject<>(obj);
    }

    @Override
    public boolean validateObject(PooledObject<ExpensiveObject> p) {
   
        return p.getObject().isValid(); // 验证对象是否有效
    }

    @Override
    public void destroyObject(PooledObject<ExpensiveObject> p) {
   
        p.getObject().close(); // 销毁对象
    }
}

2. 配置对象池

GenericObjectPoolConfig<ExpensiveObject> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(10);
config.setMaxIdle(5);
config.setMinIdle(2);
config.setTestOnBorrow(true);

3. 初始化池

ObjectPool<ExpensiveObject> pool = new GenericObjectPool<>(new MyObjectFactory(), config);

4. 使用对象

ExpensiveObject obj = pool.borrowObject();
try {
   
    // 使用对象...
} finally {
   
	// 务必通过 try-finally 确保借出的对象归还
    pool.returnObject(obj);
}

SFTP线程池

1. 实现对象工厂

池中对象各生命周期的具体实现，包括创建，销毁，校验等。

import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

@Slf4j
public class SftpClientFactory extends BasePooledObjectFactory<SftpClient> {
   

    private final SftpClientConfig clientConfig;

    public SftpClientFactory(SftpClientConfig clientConfig) {
   
        this.clientConfig = clientConfig;
    }

    @Override
    public SftpClient create() throws Exception {
   
        // 创建
        SftpClient sftpClient = new SftpClient(clientConfig);
        sftpClient.login();
        return sftpClient;
    }

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

    @Override
    public void destroyObject(PooledObject<SftpClient> p) throws Exception {
   
        // 销毁
        SftpClient client = p.getObject();
        if (client != null) {
   
            client.logout();
        }
    }

    @Override
    public boolean validateObject(PooledObject<SftpClient> p) {
   
        // 校验对象
        SftpClient client = p.getObject();
        if (client != null && client.getSftp() != null) {
   
            try {
   
                if (client.getSftp().isClosed()) {
   
                    return false;
                }
                client.getSftp().cd("/");
                return true;
            } catch (Exception e) {
   
                log.error("channelSftp 不可用 ", e);
                return false;
            }
        }
        return false;
    }

    @Override
    public void activateObject(PooledObject<SftpClient> p) throws Exception {
   
        // 前置处理器
    }

    @Override
    public void passivateObject(PooledObject<SftpClient> p) throws Exception {
   
        // 后置处理器
    }
}

2. 池对象SftpClient

被创建在对象池中的对象

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchExcep