基于Apache Commons Pool -- GenericObjectPool实现的MinioClient连接池

import io.minio.MinioClient;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericObjectPool;


@Slf4j
public class MinioClientPool {

    private final GenericObjectPool<MinioClient> pool;

    private final MinioClient defaultClient;

    public MinioClientPool(String endpoint, String accessKey, String secretKey,
                           int maxTotal, int maxIdle, int minIdle, long maxWaitMillis,
                           long minioConnectTimeout, long minioWriteTimeout, long minioReadTimeout) {
        pool = new GenericObjectPool<>(new MinioClientFactory(endpoint, accessKey, secretKey, minioConnectTimeout, minioWriteTimeout, minioReadTimeout));
        pool.setMaxTotal(maxTotal); // 最大连接数
        pool.setMaxIdle(maxIdle);   // 最大空闲连接数
        pool.setMinIdle(minIdle);   // 最小空闲连接数
        pool.setMaxWaitMillis(maxWaitMillis); // 获取连接的最大等待时间
        pool.setTestOnBorrow(false);  //在从池中借用对象时，是否验证对象的有效性。如果设置为 true，则在借用对象时会调用 validateObject() 方法。
        pool.setTestWhileIdle(true); //是否在空闲对象检查时验证对象的有效性。如果设置为 true，则会在空闲对象检查时调用 validateObject() 方法。
        MinioClient client = new MinioClient.Builder()
                .endpoint(endpoint)
                .credentials(accessKey, secretKey)
                .build();
        client.setTimeout(minioConnectTimeout, minioWriteTimeout, minioReadTimeout);
        defaultClient = client;
    }

    public MinioClient borrowObject() {
        try {
            return pool.borrowObject();
        }catch (Exception e){
            log.error(String.format("MinioClientPool borrowObject error msg:%s", e.getMessage()),e);
        }
        return defaultClient;
    }

    public void returnObject(MinioClient client) {
        pool.returnObject(client);
    }

    public void close() throws Exception {
        defaultClient.close();
        pool.close();
    }

    private static class MinioClientFactory extends BasePooledObjectFactory<MinioClient> {
        private final String endpoint;
        private final String accessKey;
        private final String secretKey;
        private final Long connectTimeout;
        private final Long writeTimeout;
        private final Long readTimeout;

        public MinioClientFactory(String endpoint, String accessKey, String secretKey,  Long connectTimeout, Long writeTimeout, Long readTimeout) {
            this.endpoint = endpoint;
            this.accessKey = accessKey;
            this.secretKey = secretKey;
            this.connectTimeout = connectTimeout;
            this.writeTimeout = writeTimeout;
            this.readTimeout = readTimeout;
        }

        @Override
        public MinioClient create() {
            MinioClient client = new MinioClient.Builder()
                    .endpoint(endpoint)
                    .credentials(accessKey, secretKey)
                    .build();
            client.setTimeout(connectTimeout, writeTimeout, readTimeout);
            return client;
        }

        @Override
        public PooledObject<MinioClient> wrap(MinioClient client) {
            return new DefaultPooledObject<>(client);
        }

        @Override
        public void destroyObject(PooledObject<MinioClient> p) throws Exception {
            // 如果需要关闭MinioClient的底层资源，可以在这里实现
            p.getObject().close();
        }

        @Override
        public boolean validateObject(PooledObject<MinioClient> p) {
            try {
                // 验证MinioClient是否可用，例如检查是否能连接到Minio服务
                p.getObject().listBuckets();
                return true;
            } catch (Exception e) {
                log.error(String.format("MinioClientFactory validateObject error msg:%s", e.getMessage()),e);
                return false;
            }
        }
    }
}

依赖

<dependencies>
    <!-- Minio SDK -->
    <dependency>
        <groupId>io.minio</groupId>
        <artifactId>minio-java</artifactId>
        <version>8.4.3</version>
    </dependency>
    <!-- Apache Commons Pool -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
        <version>2.11.1</version>
    </dependency>
</dependencies>

GenericObjectPool 是 Apache Commons Pool 项目中的一个类，它是一个通用的对象池实现，用于管理对象的创建、借用和归还等操作，以提高对象的复用性，减少频繁创建和销毁对象带来的开销。下面是对它的详细介绍：

1. 作用

• 对象复用：通过对象池，可以复用已经创建的对象，避免频繁创建和销毁对象，从而提高性能。例如，在数据库连接池中，数据库连接对象被复用，减少了连接数据库的开销。
• 资源控制：可以限制对象池中对象的最大数量，防止资源过度消耗。例如，限制数据库连接池的最大连接数，避免过多连接导致数据库服务器过载。

2. 核心概念

• 对象工厂（PooledObjectFactory）：用于创建、销毁、激活和钝化对象。GenericObjectPool 依赖对象工厂来管理对象的生命周期。
  • makeObject()：创建一个新对象。
  • destroyObject()：销毁一个对象。
  • activateObject()：激活一个对象，使其可以被借用。
  • passivateObject()：钝化一个对象，使其可以被归还到池中。
  • validateObject()：验证对象是否有效。
• 对象状态：
  • 空闲对象（Idle）：当前未被借用的对象。
  • 活跃对象（Active）：当前被借用的对象。
• 池的大小：
  • 最小空闲对象数（minIdle）：池中保持的最小空闲对象数。
  • 最大空闲对象数（maxIdle）：池中允许的最大空闲对象数。
  • 最大总对象数（maxTotal）：池中允许的最大对象总数（包括空闲和活跃对象）。

3. 配置参数

• maxTotal：池中允许的最大对象总数。如果设置为 -1，则表示无限制。
• maxIdle：池中允许的最大空闲对象数。如果设置为 -1，则表示无限制。
• minIdle：池中保持的最小空闲对象数。如果设置为 0，则表示不保持空闲对象。
• maxWaitMillis：当池中没有可用对象时，借用对象的最大等待时间（毫秒）。如果设置为 -1，则表示无限等待。
• testOnBorrow：在从池中借用对象时，是否验证对象的有效性。如果设置为 true，则在借用对象时会调用 validateObject() 方法。
• testOnReturn：在将对象归还到池中时，是否验证对象的有效性。如果设置为 true，则在归还对象时会调用 validateObject() 方法。
• testWhileIdle：是否在空闲对象检查时验证对象的有效性。如果设置为 true，则会在空闲对象检查时调用 validateObject() 方法。
• timeBetweenEvictionRunsMillis：空闲对象检查的间隔时间（毫秒）。如果设置为 -1，则表示不进行空闲对象检查。
• minEvictableIdleTimeMillis：空闲对象的最小空闲时间（毫秒）。如果一个对象的空闲时间超过这个值，它可能会被销毁。