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;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class ObjPool {
    public static void main(String[] args) throws Exception {
        // 聲明對(duì)象池
        DevObjPool devObjPool = new DevObjPool() ;
        // 池中借用對(duì)象
        DevObj devObj = devObjPool.borrowObject();
        System.out.println("Idle="+devObjPool.getNumIdle()+"；Active="+devObjPool.getNumActive());
        // 使用對(duì)象
        devObj.devObjInfo();
        // 歸還給對(duì)象池
        devObjPool.returnObject(devObj);
        System.out.println("Idle="+devObjPool.getNumIdle()+"；Active="+devObjPool.getNumActive());
        // 查看對(duì)象池
        System.out.println(devObjPool.listAllObjects());
    }
}
/**
 * 對(duì)象定義
 */
class DevObj {
    private static final Logger logger = LoggerFactory.getLogger(DevObj.class) ;
    public DevObj (){
        logger.info("build...dev...obj");
    }
    public void devObjInfo (){
        logger.info("dev...obj...info");
    }
}
/**
 * 對(duì)象工廠
 */
class DevObjFactory extends BasePooledObjectFactory<DevObj> {
    @Override
    public DevObj create() throws Exception {
        // 創(chuàng)建對(duì)象
        return new DevObj() ;
    }
    @Override
    public PooledObject<DevObj> wrap(DevObj devObj) {
        // 池化對(duì)象
        return new DefaultPooledObject<>(devObj);
    }
}
/**
 * 對(duì)象池
 */
class DevObjPool extends GenericObjectPool<DevObj> {
    public DevObjPool() {
        super(new DevObjFactory(), new GenericObjectPoolConfig<>());
    }
}

public GenericObjectPool(final PooledObjectFactory<T> factory,final GenericObjectPoolConfig<T> config);

private final LinkedBlockingDeque<PooledObject<T>> idleObjects;
public GenericObjectPool(final PooledObjectFactory<T> factory,final GenericObjectPoolConfig<T> config) {
    idleObjects = new LinkedBlockingDeque<>(config.getFairness());
}

// 隊(duì)首節(jié)點(diǎn)
private transient LinkedBlockingDeque.Node<E> first;
// 隊(duì)尾節(jié)點(diǎn)
private transient LinkedBlockingDeque.Node<E> last;
// 主鎖
private final InterruptibleReentrantLock lock;
// 非空狀態(tài)鎖
private final Condition notEmpty;
// 未滿狀態(tài)鎖
private final Condition notFull;

public void GenericObjectPool.addObject() throws Exception ;

public T GenericObjectPool.borrowObject(final long borrowMaxWaitMillis) throws Exception ;

public void GenericObjectPool.returnObject(final T obj) ；

spring:
  redis:
    host: ${REDIS_HOST:127.0.0.1}
    lettuce:
      pool:
        min-idle: 10
        max-active: 100
        max-idle: 100

// 連接配置
class LettuceConnectionConfiguration extends RedisConnectionConfiguration {
    private static class PoolBuilderFactory {
        // 構(gòu)建對(duì)象池配置
        private GenericObjectPoolConfig<?> getPoolConfig(RedisProperties.Pool properties) {
            GenericObjectPoolConfig<?> config = new GenericObjectPoolConfig<>();
            config.setMaxTotal(properties.getMaxActive());
            config.setMaxIdle(properties.getMaxIdle());
            config.setMinIdle(properties.getMinIdle());
            return config;
        }
    }
}

class LettucePoolingConnectionProvider implements LettuceConnectionProvider {
    // 對(duì)象池核心角色
    private final GenericObjectPoolConfig poolConfig;
    private final BoundedPoolConfig asyncPoolConfig;
    private final Map<Class<?>, GenericObjectPool> pools = new ConcurrentHashMap(32);
    LettucePoolingConnectionProvider(LettuceConnectionProvider provider, LettucePoolingClientConfiguration config) {
        this.poolConfig = clientConfiguration.getPoolConfig();
        this.asyncPoolConfig = CommonsPool2ConfigConverter.bounded(this.config);
    }
}

class LettucePoolingConnectionProvider implements LettuceConnectionProvider {
    // 獲取Redis連接
    public <T extends StatefulConnection<?, ?>> T getConnection(Class<T> connectionType) {
        GenericObjectPool pool = (GenericObjectPool)this.pools.computeIfAbsent();
        StatefulConnection<?, ?> connection = (StatefulConnection)pool.borrowObject();
    }
    // 釋放Redis連接
    public void release(StatefulConnection<?, ?> connection) {
        GenericObjectPool<StatefulConnection<?, ?>> pool = (GenericObjectPool)this.poolRef.remove(connection);
    }
}