Example usage for org.apache.commons.pool2.impl GenericKeyedObjectPool GenericKeyedObjectPool

Introduction

In this page you can find the example usage for org.apache.commons.pool2.impl GenericKeyedObjectPool GenericKeyedObjectPool.

Prototype

public GenericKeyedObjectPool(KeyedPooledObjectFactory<K, T> factory) 

Source Link

Document

Create a new GenericKeyedObjectPool using defaults from GenericKeyedObjectPoolConfig .

Usage

From source file:org.apache.karaf.jms.pool.internal.ConnectionPool.java

public ConnectionPool(Connection connection) {

    this.connection = connection;

    // Create our internal Pool of session instances.
    this.sessionPool = new GenericKeyedObjectPool<>(new KeyedPooledObjectFactory<SessionKey, PooledSession>() {

        @Override//from   w w  w .j  av  a 2  s.c o  m
        public void activateObject(SessionKey key, PooledObject<PooledSession> session) throws Exception {
            ConnectionPool.this.loanedSessions.add(session.getObject());
        }

        @Override
        public void destroyObject(SessionKey key, PooledObject<PooledSession> session) throws Exception {
            ConnectionPool.this.loanedSessions.remove(session.getObject());
            session.getObject().getInternalSession().close();
        }

        @Override
        public PooledObject<PooledSession> makeObject(SessionKey key) throws Exception {
            Session session = makeSession(key);
            return new DefaultPooledObject<>(
                    new PooledSession(key, session, sessionPool, key.isTransacted(), useAnonymousProducers));
        }

        @Override
        public void passivateObject(SessionKey key, PooledObject<PooledSession> session) throws Exception {
            ConnectionPool.this.loanedSessions.remove(session.getObject());
        }

        @Override
        public boolean validateObject(SessionKey key, PooledObject<PooledSession> session) {
            return true;
        }
    });
}

---

From source file:org.apache.karaf.jms.pool.internal.PooledConnectionFactory.java

public void initConnectionsPool() {
    if (this.connectionsPool == null) {
        this.connectionsPool = new GenericKeyedObjectPool<>(
                new KeyedPooledObjectFactory<ConnectionKey, ConnectionPool>() {
                    @Override// w  ww  .  j av a 2s  .  c o  m
                    public void activateObject(ConnectionKey key, PooledObject<ConnectionPool> connection)
                            throws Exception {
                    }

                    @Override
                    public void destroyObject(ConnectionKey key, PooledObject<ConnectionPool> connection)
                            throws Exception {
                        try {
                            if (LOG.isTraceEnabled()) {
                                LOG.trace("Destroying connection: {}", connection);
                            }
                            connection.getObject().close();
                        } catch (Exception e) {
                            LOG.warn("Close connection failed for connection: " + connection
                                    + ". This exception will be ignored.", e);
                        }
                    }

                    @Override
                    public PooledObject<ConnectionPool> makeObject(ConnectionKey key) throws Exception {
                        Connection delegate = createConnection(key);

                        ConnectionPool connection = createConnectionPool(delegate);
                        connection.setIdleTimeout(getIdleTimeout());
                        connection.setExpiryTimeout(getExpiryTimeout());
                        connection.setMaximumActiveSessionPerConnection(getMaximumActiveSessionPerConnection());
                        connection.setBlockIfSessionPoolIsFull(isBlockIfSessionPoolIsFull());
                        if (isBlockIfSessionPoolIsFull() && getBlockIfSessionPoolIsFullTimeout() > 0) {
                            connection.setBlockIfSessionPoolIsFullTimeout(getBlockIfSessionPoolIsFullTimeout());
                        }
                        connection.setUseAnonymousProducers(isUseAnonymousProducers());

                        if (LOG.isTraceEnabled()) {
                            LOG.trace("Created new connection: {}", connection);
                        }

                        return new DefaultPooledObject<>(connection);
                    }

                    @Override
                    public void passivateObject(ConnectionKey key, PooledObject<ConnectionPool> connection)
                            throws Exception {
                    }

                    @Override
                    public boolean validateObject(ConnectionKey key, PooledObject<ConnectionPool> connection) {
                        if (connection != null && connection.getObject() != null
                                && connection.getObject().expiredCheck()) {
                            if (LOG.isTraceEnabled()) {
                                LOG.trace("Connection has expired: {} and will be destroyed", connection);
                            }

                            return false;
                        }

                        return true;
                    }
                });

        // Set max idle (not max active) since our connections always idle in the pool.
        this.connectionsPool.setMaxIdlePerKey(1);

        // We always want our validate method to control when idle objects are evicted.
        this.connectionsPool.setTestOnBorrow(true);
        this.connectionsPool.setTestWhileIdle(true);
    }
}

---