Java KeyedObjectPool类代码示例

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public void testPoolWithNullFactory() throws Exception {
    KeyedObjectPool pool = new StackKeyedObjectPool(10);
    for(int i=0;i<10;i++) {
        pool.returnObject("X",new Integer(i));
    }
    for(int j=0;j<3;j++) {
        Integer[] borrowed = new Integer[10];
        BitSet found = new BitSet();
        for(int i=0;i<10;i++) {
            borrowed[i] = (Integer)(pool.borrowObject("X"));
            assertNotNull(borrowed);
            assertTrue(!found.get(borrowed[i].intValue()));
            found.set(borrowed[i].intValue());
        }
        for(int i=0;i<10;i++) {
            pool.returnObject("X",borrowed[i]);
        }
    }
    pool.invalidateObject("X",pool.borrowObject("X"));
    pool.invalidateObject("X",pool.borrowObject("X"));
    pool.clear("X");
    pool.clear();
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public V openCache(K key) throws KeyedCacheException {
	V result = null;
	try {
		KeyedObjectPool<K, V> keyedObjectPool = keyedObjectPoolHolder.get();
		if (keyedObjectPool == null) {
			keyedObjectPool = keyedObjectPoolFactory.createPool();
			keyedObjectPoolHolder.set(keyedObjectPool);
		}
		//
		result = keyedObjectPool.borrowObject(key);
	} catch (Exception ex) {
		throw new KeyedCacheException("Could not open Cache", ex);
	}
	return result;
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public void closeCache(K key, V obj) {
	try {
		KeyedObjectPool<K, V> keyedObjectPool = keyedObjectPoolHolder.get();
		keyedObjectPoolHolder.set(null);
		if (keyedObjectPool != null) {
			//
			keyedObjectPool.returnObject(key, obj);
		}
	} catch (Exception ex) {
		throw new KeyedCacheException("Could not close Cache", ex);
	}
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
protected PreparedStatementCachingConnection wrapConnection(Connection realConnection) {
	// can't initialize the following variable in the constructor because the prepared statement cache size won't be available
	if (_stmtPoolFactory == null) {
		_stmtPoolFactory = createStatementPoolFactory();
	}
	
       KeyedObjectPool stmtpool = _stmtPoolFactory.createPool();
       PreparedStatementCachingConnection wrappedConnection = new PreparedStatementCachingConnection(realConnection, stmtpool);
       
       stmtpool.setFactory(wrappedConnection);
       return wrappedConnection;
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
/**
 * Constructor
 * @param stmt my underlying {@link PreparedStatement}
 * @param key my key" as used by {@link KeyedObjectPool}
 * @param pool the {@link KeyedObjectPool} from which I was obtained.
 * @param conn the {@link Connection} from which I was created
 */
public PoolablePreparedStatement(PreparedStatement stmt, Object key, KeyedObjectPool pool, Connection conn) {
    super((DelegatingConnection) conn, stmt);
    _pool = pool;
    _key = key;

    // Remove from trace now because this statement will be 
    // added by the activate method.
    if(_conn != null) {
        _conn.removeTrace(this);
    }
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
/**
 * Wrap the real connection.
 * @param connection the connection to be wrapped
 * @param pool the pool to use
 */
PooledConnectionImpl(Connection connection, KeyedObjectPool pool) {
    this.connection = connection;
    if (connection instanceof DelegatingConnection) {
        this.delegatingConnection = (DelegatingConnection) connection;
    } else {
        this.delegatingConnection = new DelegatingConnection(connection);
    }
    eventListeners = new Vector();
    isClosed = false;
    if (pool != null) {
        pstmtPool = pool;
        pstmtPool.setFactory(this);            
    }
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param stmt the underlying {@link CallableStatement}
 * @param key the key for this statement in the {@link KeyedObjectPool}
 * @param pool the {@link KeyedObjectPool} from which this CallableStatement was obtained
 * @param conn the {@link Connection} that created this CallableStatement
 */
public PoolableCallableStatement(CallableStatement stmt, Object key, KeyedObjectPool pool, Connection conn) {
    super((DelegatingConnection)conn, stmt);
    _pool = pool;
    _key = key;

    // Remove from trace now because this statement will be 
    // added by the activate method.
    if(_conn != null) {
        _conn.removeTrace(this);
    }
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public Object makeObject() throws Exception {
    Connection conn = _connFactory.createConnection();
    if (conn == null) {
        throw new IllegalStateException("Connection factory returned null from createConnection");
    }
    initializeConnection(conn);
    if(null != _stmtPoolFactory) {
        KeyedObjectPool stmtpool = _stmtPoolFactory.createPool();
        conn = new PoolingConnection(conn,stmtpool);
        stmtpool.setFactory((PoolingConnection)conn);
    }
    return new PoolableConnection(conn,_pool,_config);
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public void testBorrowFromEmptyPoolWithNullFactory() throws Exception {
    KeyedObjectPool pool = new StackKeyedObjectPool();
    try {
        pool.borrowObject("x");
        fail("Expected NoSuchElementException");
    } catch(NoSuchElementException e) {
        // expected
    }
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public void testSetFactory() throws Exception {
    KeyedObjectPool pool = new StackKeyedObjectPool();
    try {
        pool.borrowObject("x");
        fail("Expected NoSuchElementException");
    } catch(NoSuchElementException e) {
        // expected
    }
    pool.setFactory(new SimpleFactory());
    Object obj = pool.borrowObject("x");
    assertNotNull(obj);
    pool.returnObject("x",obj);
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public void testCantResetFactoryWithActiveObjects() throws Exception {
    KeyedObjectPool pool = new StackKeyedObjectPool();
    pool.setFactory(new SimpleFactory());
    Object obj = pool.borrowObject("x");
    assertNotNull(obj);

    try {
        pool.setFactory(new SimpleFactory());
        fail("Expected IllegalStateException");
    } catch(IllegalStateException e) {
        // expected
    }
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
/**
 * Create a new delegating context for the specified pool, context and context type.
 * 
 * @param keyedObjectPool The pool the delegate context was checked out from.
 * @param delegateContext The context to delegate operations to.
 * @param dirContextType The type of context, used as a key for the pool.
 * @throws IllegalArgumentException if any of the arguments are null
 */
public DelegatingContext(KeyedObjectPool keyedObjectPool, Context delegateContext, DirContextType dirContextType) {
    Assert.notNull(keyedObjectPool, "keyedObjectPool may not be null");
    Assert.notNull(delegateContext, "delegateContext may not be null");
    Assert.notNull(dirContextType, "dirContextType may not be null");
    
    this.keyedObjectPool = keyedObjectPool;
    this.delegateContext = delegateContext;
    this.dirContextType = dirContextType;
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    contextMock = mock(Context.class);
    dirContextMock = mock(DirContext.class);
    ldapContextMock = mock(LdapContext.class);
    keyedObjectPoolMock = mock(KeyedObjectPool.class);
    contextSourceMock = mock(ContextSource.class);
    dirContextValidatorMock = mock(DirContextValidator.class);
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public PoolablePersistenceBroker(PersistenceBrokerInternal broker, KeyedObjectPool pool)
{
    super(broker);
    this.pool = pool;
}
 

import org.apache.commons.pool.KeyedObjectPool; //导入依赖的package包/类
public PBKeyedPoolableObjectFactory(PersistenceBrokerFactoryDefaultImpl pbf, KeyedObjectPool pool)
{
    this.pbf = pbf;
    this.pool = pool;
}