手动实现 SFTP/FTP 连接池，引发的深思

import com.jcraft.jsch.Channel;
import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSch;
import com.jcraft.jsch.JSchException;
import com.jcraft.jsch.Session;

public class SftpConnectionFactory {

    private final String host;
    private final int port;
    private final String username;
    private final String password;
    private final int connectTimeoutMs;

    public SftpConnectionFactory(String host, int port,
                                  String username, String password,
                                  int connectTimeoutMs) {
        this.host = host;
        this.port = port;
        this.username = username;
        this.password = password;
        this.connectTimeoutMs = connectTimeoutMs;
    }

    /** 创建一个新的 SFTP Channel */
    public ChannelSftp create() throws JSchException {
        JSch jsch = new JSch();
        Session session = jsch.getSession(username, host, port);
        session.setPassword(password);
        session.setConfig("StrictHostKeyChecking", "no");
        // 客户端主动发心跳，避免服务端因空闲超时断开 Session
        session.setServerAliveInterval(60_000);
        session.connect(connectTimeoutMs);

        Channel channel = session.openChannel("sftp");
        channel.connect(connectTimeoutMs);
        return (ChannelSftp) channel;
    }

    /** 验证连接是否仍然可用 */
    public boolean validate(ChannelSftp channel) {
        try {
            return channel != null
                    && channel.isConnected()
                    && channel.getSession().isConnected();
        } catch (JSchException e) {
            return false;
        }
    }

    /** 销毁连接，释放底层资源 */
    public void destroy(ChannelSftp channel) {
        if (channel == null) return;
        try {
            Session session = channel.getSession();
            channel.disconnect();
            if (session != null) session.disconnect();
        } catch (JSchException ignored) {
        }
    }
}

import com.jcraft.jsch.ChannelSftp;
import com.jcraft.jsch.JSchException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.TimeUnit;

public class SimpleSftpPool {

    private final ArrayBlockingQueue<ChannelSftp> pool;
    private final SftpConnectionFactory factory;

    public SimpleSftpPool(SftpConnectionFactory factory, int maxSize, int minIdle)
            throws JSchException {
        this.factory = factory;
        this.pool = new ArrayBlockingQueue<>(maxSize);

        // 预热：提前创建 minIdle 个连接
        for (int i = 0; i < minIdle; i++) {
            pool.offer(factory.create());
        }
    }

    /**
     * 借出一个连接，等待超时则抛出异常
     *
     * @param timeout 等待超时时间
     * @param unit    时间单位
     */
    public ChannelSftp borrowConnection(long timeout, TimeUnit unit)
            throws InterruptedException, JSchException {
        ChannelSftp channel = pool.poll(timeout, unit);
        if (channel == null) {
            throw new JSchException("Connection pool exhausted, no connection available within timeout");
        }
        // 验证连接有效性，失效则重建
        if (!factory.validate(channel)) {
            factory.destroy(channel);
            channel = factory.create();
        }
        return channel;
    }

    /**
     * 归还连接到池中
     *
     * @param channel 要归还的连接
     */
    public void returnConnection(ChannelSftp channel) {
        if (channel == null) return;
        if (factory.validate(channel)) {
            // 连接有效则放回队列；队列已满则直接销毁
            if (!pool.offer(channel)) {
                factory.destroy(channel);
            }
        } else {
            // 连接已失效，直接销毁
            factory.destroy(channel);
        }
    }

    /** 关闭连接池，销毁所有连接 */
    public void close() {
        ChannelSftp channel;
        while ((channel = pool.poll()) != null) {
            factory.destroy(channel);
        }
    }
}

// 初始化（通常在 Spring @Bean 或应用启动时）
SftpConnectionFactory factory = new SftpConnectionFactory(
        "sftp.example.com", 22, "user", "password", 5000
);
SimpleSftpPool pool = new SimpleSftpPool(factory, 10, 3);

// 业务代码：借出连接使用后归还
ChannelSftp channel = null;
try {
    channel = pool.borrowConnection(5, TimeUnit.SECONDS);
    channel.put("/local/path/report.csv", "/remote/path/report.csv");
} finally {
    // 必须在 finally 中归还，否则发生连接泄漏
    pool.returnConnection(channel);
}

import com.jcraft.jsch.ChannelSftp;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

public class SftpPooledObjectFactory extends BasePooledObjectFactory<ChannelSftp> {

    private final SftpConnectionFactory connectionFactory;

    public SftpPooledObjectFactory(SftpConnectionFactory connectionFactory) {
        this.connectionFactory = connectionFactory;
    }

    @Override
    public ChannelSftp create() throws Exception {
        return connectionFactory.create();
    }

    @Override
    public PooledObject<ChannelSftp> wrap(ChannelSftp channel) {
        return new DefaultPooledObject<>(channel);
    }

    /** 归还或空闲检测时调用，返回 false 则触发销毁并重建 */
    @Override
    public boolean validateObject(PooledObject<ChannelSftp> p) {
        return connectionFactory.validate(p.getObject());
    }

    /** 从池中移除对象时调用，释放底层资源 */
    @Override
    public void destroyObject(PooledObject<ChannelSftp> p) {
        connectionFactory.destroy(p.getObject());
    }
}

import com.jcraft.jsch.ChannelSftp;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

// 配置连接池参数
GenericObjectPoolConfig<ChannelSftp> config = new GenericObjectPoolConfig<>();
config.setMaxTotal(10);                               // 最大连接数
config.setMaxIdle(10);                                // 最大空闲连接数
config.setMinIdle(3);                                 // 最小空闲连接数（预热）
config.setMaxWaitMillis(5_000);                       // 借连接等待超时（ms）
config.setTestOnBorrow(true);                         // 借出时验证连接有效性
config.setTestWhileIdle(true);                        // 空闲时定期验证
config.setTimeBetweenEvictionRunsMillis(60_000);      // 空闲回收检查间隔（ms）
config.setMinEvictableIdleTimeMillis(300_000);        // 空闲超过 5 分钟则回收

// 创建连接池
SftpConnectionFactory connectionFactory = new SftpConnectionFactory(
        "sftp.example.com", 22, "user", "password", 5000
);
SftpPooledObjectFactory pooledFactory = new SftpPooledObjectFactory(connectionFactory);
GenericObjectPool<ChannelSftp> sftpPool = new GenericObjectPool<>(pooledFactory, config);

// 业务代码：借还必须配对
ChannelSftp channel = sftpPool.borrowObject();
try {
    channel.put("/local/report.csv", "/remote/report.csv");
} finally {
    sftpPool.returnObject(channel);
}

// FTPClient 工厂的 create() 实现示例
public FTPClient create() throws Exception {
    FTPClient client = new FTPClient();
    client.connect(host, port);
    if (!client.login(username, password)) {
        throw new IOException("FTP login failed");
    }
    client.enterLocalPassiveMode(); // 被动模式（穿防火墙必须开启）
    client.setFileType(FTP.BINARY_FILE_TYPE);
    return client;
}

// validate() 实现示例：发送 NOOP 命令探测连接
public boolean validate(FTPClient client) {
    try {
        return client != null && client.isConnected() && client.sendNoOp();
    } catch (IOException e) {
        return false;
    }
}