基于Apache Common-pool2理解连接池

目的

• 理解连接池的参数设置

文档介绍

PooledObjectState

java代码实现

代码实现

• StringPoolObject.java

package com;

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

public class StringPoolObject extends BasePooledObjectFactory<StringBuffer> {

    @Override
    public StringBuffer create() {
        System.out.println("创造了一个object");
        return new StringBuffer();
    }

    @Override
    public PooledObject<StringBuffer> wrap(StringBuffer obj) {
        DefaultPooledObject<StringBuffer> stringBufferDefaultPooledObject = new DefaultPooledObject<>(obj);
        System.out.println("wrap状态为-->"+stringBufferDefaultPooledObject.getState());
        return stringBufferDefaultPooledObject;
    }

    @Override
    public void passivateObject(PooledObject<StringBuffer> p) throws Exception {
        System.out.println("passivateObject状态为-->"+p.getState());
        super.passivateObject(p);
    }
}

• MyStringUtils.java

package com;

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

import java.util.Random;
import java.util.concurrent.atomic.AtomicInteger;

public class MyStringUtils {
    private ObjectPool<StringBuffer> objectPool;
    private AtomicInteger count;

    public MyStringUtils(ObjectPool<StringBuffer> objectPool) {
        this.objectPool = objectPool;
        count = new AtomicInteger();
    }

    public StringBuffer read() throws Exception {
        return objectPool.borrowObject();
    }

    public String write(StringBuffer write) throws Exception {
        Random random = new Random();
        int randomValue = random.nextInt(300);
        int order = count.addAndGet(1);
        StringBuffer append = write.append("第几个写的:").append(order).append("-->").append("写了什么:").append(randomValue);
        objectPool.returnObject(write);
        return append.toString();
    }

    public static void main(String[] args) throws Exception {
        PooledObjectFactory pooledObjectFactory = new StringPoolObject();
        ObjectPool objectPool = new GenericObjectPool(pooledObjectFactory);
        MyStringUtils myStringUtils = new MyStringUtils(objectPool);

        StringBuffer read = myStringUtils.read();

        myStringUtils.write(read);
        StringBuffer data = myStringUtils.read();
        System.out.println("数据是-->" + data.toString());
    }
}

输出

创造了一个Object
wrap状态为-->IDLE
passivateObject状态为-->RETURNING
数据是-->第几个写的:1-->写了什么:240

接口

PooledObjectFactor

作用

• 提供poolObject的工厂,顶层的抽象类是BasePooledObjectFactory，复写create和wrap方法

代码

//连接池的工厂，通过makeObject返回连接池的包装类
//activateObject激活连接对象
//passivateObject钝化连接对象
//validateObject校验对象
//destroyObject摧毁对象
public interface PooledObjectFactory<T> {
    //返回连接池对象的包装器
    PooledObject<T> makeObject();
    void activateObject(PooledObject<T> obj);
    void passivateObject(PooledObject<T> obj);
    boolean validateObject(PooledObject<T> obj);
    void destroyObject(PooledObject<T> obj);
}

PooledObject

作用

• 提供对象的包装类，封装了状态变更的方法，默认实现类是DefaultPooledObject

代码

//这个接口是连接池的包装类接口，用于管理连接池的状态
public interface PooledObject<T> extends Comparable<PooledObject<T>> {
    //返回连接池对象
    T getObject();
    //返回连接池创建时间。
    long getCreateTime();
    //返回连接的上次活动时间
    long getActiveTimeMillis();
    //该对象被调用的次数
    default long getBorrowedCount() {
        return -1;
    }
    //该对象空闲多少时间
    long getIdleTimeMillis();
    //最后一次被包装对象的时间
    long getLastBorrowTime();
    //上一次包装对象返回的时间
    long getLastReturnTime();
    //最新的使用时间
    long getLastUsedTime();
    //尝试将池对象置于PooledObjectState.EVICTION状态
    boolean startEvictionTest();
    //被叫通知对象驱逐测试已经结束 目前没有使用，参数： 空闲队列
    boolean endEvictionTest(Deque<PooledObject<T>> idleQueue);
    //分配该对象,如果源状态为PooledObjectState.IDLE空闲状态则返回true，
    //同时将状态改为PooledObjectState.ALLOCATED，该状态表明对象正在被使用
    boolean allocate();
    //取消分配对象并空闲 在当前设置它ALLOCATED。
    boolean deallocate();
    //设置是否记录对象使用的堆栈信息,可用于池泄漏时问题追溯
    void setLogAbandoned(boolean logAbandoned);
    /** 根据是否需要完全详细的堆栈跟踪配置堆栈跟踪生成策略。
        当设置为false时，被放弃的日志可能只包含调用者类信息，而不包含方法名、行
        数字，以及完整堆栈跟踪中可用的其他正常元数据。*/
    default void setRequireFullStackTrace(boolean requireFullStackTrace) {
        // noop
    }
    //将当前堆栈跟踪记录为上次使用对象的时间。
    void use();
    //打印借用此池对象的代码的堆栈跟踪以及最后一个代码的堆栈跟踪，以将此对象（如果可用）用于提供的编写器。
    void printStackTrace(PrintWriter writer);
    //返回此对象的状态。
    PooledObjectState getState();
    //将池化对象标记为已放弃。
    void markAbandoned();
    //将对象标记为返回池。
    void markReturning();
        @Override
    int compareTo(PooledObject<T> other);

    @Override
    boolean equals(Object obj);

    @Override
    int hashCode();
    
    @Override
    String toString();
}

ObjectPool

作用

• 提供类使从池对象中使用方法，实现类是GenericObjectPool

代码

public interface ObjectPool<T> extends Closeable {
    //借用对象idle -> 
    T borrowObject() throws Exception, NoSuchElementException,
            IllegalStateException;
    //返回对象
    void returnObject(T obj) throws Exception;
    //使对象无效
    void invalidateObject(T obj) throws Exception;
    //添加对象
    void addObject() throws Exception, IllegalStateException,
            UnsupportedOperationException;
    //获得空闲数量
    int getNumIdle();
    //获得活动数量
    int getNumActive();
    //清除
    void clear() throws Exception, UnsupportedOperationException;
    //关闭
    void close();
}

实现类分析

DefaultPooledObject

文档地址

Common-pool2 文档地址