Example usage for org.apache.commons.pool2 KeyedPooledObjectFactory KeyedPooledObjectFactory

Introduction

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

Prototype

KeyedPooledObjectFactory

Source Link

Usage

From source file:org.apache.activemq.jms.pool.ConnectionPool.java

public ConnectionPool(Connection connection) {
    final GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setJmxEnabled(false);/*  ww w. j  av a  2 s. c o  m*/
    this.connection = wrap(connection);

    // Create our internal Pool of session instances.
    this.sessionPool = new GenericKeyedObjectPool<SessionKey, SessionHolder>(
            new KeyedPooledObjectFactory<SessionKey, SessionHolder>() {
                @Override
                public PooledObject<SessionHolder> makeObject(SessionKey sessionKey) throws Exception {

                    return new DefaultPooledObject<SessionHolder>(new SessionHolder(makeSession(sessionKey)));
                }

                @Override
                public void destroyObject(SessionKey sessionKey, PooledObject<SessionHolder> pooledObject)
                        throws Exception {
                    ((SessionHolder) pooledObject.getObject()).close();
                }

                @Override
                public boolean validateObject(SessionKey sessionKey, PooledObject<SessionHolder> pooledObject) {
                    return true;
                }

                @Override
                public void activateObject(SessionKey sessionKey, PooledObject<SessionHolder> pooledObject)
                        throws Exception {
                }

                @Override
                public void passivateObject(SessionKey sessionKey, PooledObject<SessionHolder> pooledObject)
                        throws Exception {
                }
            }, poolConfig);
}

---

From source file:org.apache.activemq.jms.pool.PooledConnectionFactory.java

public void initConnectionsPool() {
    if (this.connectionsPool == null) {
        final GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
        poolConfig.setJmxEnabled(false);
        this.connectionsPool = new GenericKeyedObjectPool<ConnectionKey, ConnectionPool>(
                new KeyedPooledObjectFactory<ConnectionKey, ConnectionPool>() {
                    @Override/*  www. jav  a  2 s  .  co m*/
                    public PooledObject<ConnectionPool> makeObject(ConnectionKey connectionKey)
                            throws Exception {
                        Connection delegate = createConnection(connectionKey);

                        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());
                        connection.setReconnectOnException(isReconnectOnException());

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

                        PooledConnectionFactory.this.mostRecentlyCreated.set(connection);

                        return new DefaultPooledObject<ConnectionPool>(connection);
                    }

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

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

                            return false;
                        }

                        return true;
                    }

                    @Override
                    public void activateObject(ConnectionKey connectionKey,
                            PooledObject<ConnectionPool> pooledObject) throws Exception {
                    }

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

                }, poolConfig);

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

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

---

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/*  w w  w  .ja  v a 2s  .  co 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//from  w  w w  .java2  s  .  co  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);
    }
}

---