当前位置：首页 > article >正文

Java 对象池管理的高性能工具库 Apache Commons Pool 2

article 2025/1/17 14:40:10

Apache Commons Pool 2 是一个用于对象池管理的高性能工具库，主要用于管理复用昂贵的对象（如数据库连接、网络连接、线程等）。它实现了常见的对象池模式，可以通过配置来优化资源的分配与回收。

Maven 依赖

在项目中添加 commons-pool2 的依赖：

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

核心概念

PooledObjectFactory：对象池中对象的创建和销毁管理接口。
ObjectPool：对象池接口，负责对象的借用与归还。
GenericObjectPool：通用对象池实现，最常用的对象池类。
GenericKeyedObjectPool：支持多个键值的对象池管理。

使用步骤

1. 定义对象的工厂类

创建一个工厂类，继承 BasePooledObjectFactory 或实现 PooledObjectFactory 接口，用于管理对象的创建、销毁、激活等生命周期。

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.impl.DefaultPooledObject;

// 定义池化对象的工厂
public class MyObjectFactory extends BasePooledObjectFactory<MyObject> {

    @Override
    public MyObject create() {
        return new MyObject(); // 创建对象
    }

    @Override
    public PooledObject<MyObject> wrap(MyObject obj) {
        return new DefaultPooledObject<>(obj); // 包装成池化对象
    }

    @Override
    public void destroyObject(PooledObject<MyObject> p) {
        System.out.println("Destroying object: " + p.getObject());
    }
}

// 自定义对象
class MyObject {
    public void doSomething() {
        System.out.println("Working...");
    }
}

2. 创建对象池

使用 GenericObjectPool 进行对象池管理。

import org.apache.commons.pool2.impl.GenericObjectPool;

public class ObjectPoolExample {
    public static void main(String[] args) throws Exception {
        // 创建对象池
        GenericObjectPool<MyObject> pool = new GenericObjectPool<>(new MyObjectFactory());

        // 配置对象池
        pool.setMaxTotal(5); // 最大对象数
        pool.setMinIdle(2); // 最小空闲对象数

        // 借用对象
        MyObject obj = pool.borrowObject();
        obj.doSomething();

        // 归还对象
        pool.returnObject(obj);

        // 关闭池
        pool.close();
    }
}

对象池配置参数

对象池（GenericObjectPool）提供了一些常见的配置项，用于优化资源使用：

配置项	作用
`setMaxTotal(int)`	池中最大对象数，默认值为 8。
`setMinIdle(int)`	池中最小空闲对象数，当对象数低于此值时，池会尝试创建新对象。
`setMaxIdle(int)`	池中最大空闲对象数，超过此值的对象会被销毁。
`setMaxWaitMillis(long)`	从池中借用对象时的最大等待时间，超过此时间会抛出 `NoSuchElementException`。
`setBlockWhenExhausted(boolean)`	是否在对象耗尽时阻塞等待，默认值为 `true`。
`setTestOnBorrow(boolean)`	借用对象时是否验证对象有效性，默认值为 `false`。
`setTestOnReturn(boolean)`	归还对象时是否验证对象有效性，默认值为 `false`。
`setTestWhileIdle(boolean)`	空闲时是否验证对象有效性，默认值为 `false`。

高级用法

1. 带键的对象池 (`GenericKeyedObjectPool`)

如果需要根据键来区分不同的对象池，可以使用 GenericKeyedObjectPool。

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
import org.apache.commons.pool2.impl.GenericKeyedObjectPool;
import org.apache.commons.pool2.BaseKeyedPooledObjectFactory;

// 定义带键的对象工厂
class KeyedObjectFactory extends BaseKeyedPooledObjectFactory<String, MyObject> {

    @Override
    public MyObject create(String key) {
        return new MyObject(); // 根据键创建对象
    }

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

public class KeyedObjectPoolExample {
    public static void main(String[] args) throws Exception {
        // 创建带键的对象池
        GenericKeyedObjectPool<String, MyObject> pool = new GenericKeyedObjectPool<>(new KeyedObjectFactory());

        // 借用对象
        MyObject obj1 = pool.borrowObject("key1");
        MyObject obj2 = pool.borrowObject("key2");

        obj1.doSomething();
        obj2.doSomething();

        // 归还对象
        pool.returnObject("key1", obj1);
        pool.returnObject("key2", obj2);

        // 关闭池
        pool.close();
    }
}

2. 对象池的销毁和验证

通过自定义工厂方法，实现销毁和验证逻辑：

import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;

class CustomObjectFactory extends BasePooledObjectFactory<MyObject> {
    @Override
    public MyObject create() {
        return new MyObject();
    }

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

    @Override
    public void destroyObject(PooledObject<MyObject> p) {
        System.out.println("Destroying object: " + p.getObject());
    }

    @Override
    public boolean validateObject(PooledObject<MyObject> p) {
        // 验证对象有效性
        return true; // 根据需求实现具体逻辑
    }
}