Example usage for org.apache.commons.pool2 PooledObject getObject

Introduction

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

Prototype

T getObject();

Source Link

Document

Obtain the underlying object that is wrapped by this instance of PooledObject .

Usage

From source file:org.adriss.bucketpool.BucketFactory.java

@Override
public void destroyObject(PooledObject<Bucket> p) throws Exception {
    WrappedBucket bucket = (WrappedBucket) p.getObject();
    logger.debug("Destroyed [{}] bucket", bucket);
    WrappedCluster cluster = bucket.getCluster();
    if (bucket.close()) {
        this.unusedClusters.add(cluster);
    }/*from  ww  w  .j a  va  2  s. co  m*/
}

From source file:org.adriss.bucketpool.BucketFactory.java

@Override
public boolean validateObject(PooledObject<Bucket> p) {
    return !p.getObject().isClosed();
}

From source file:org.adriss.bucketpool.BucketFactory.java

@Override
public void activateObject(PooledObject<Bucket> p) throws Exception {
    WrappedBucket bucket = (WrappedBucket) p.getObject();
    if (bucket.isClosed()) {
        bucket.open();/*from  ww w  . j a  v a 2  s.  c o  m*/
    }
}

From source file:org.adriss.bucketpool.BucketFactory.java

@Override
public void passivateObject(PooledObject<Bucket> p) throws Exception {
    if (this.passivate) {
        p.getObject().close();
    }/*from   w  w  w  .ja  v a  2 s .  c o  m*/
}

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

public ConnectionPool(Connection connection) {
    final GenericKeyedObjectPoolConfig poolConfig = new GenericKeyedObjectPoolConfig();
    poolConfig.setJmxEnabled(false);//from w w w  .j  av a  2s.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/*from   w ww.ja  v a  2s. 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.jmeter.visualizers.backend.graphite.SocketOutputStreamPoolFactory.java

@Override
public void destroyObject(SocketConnectionInfos socketConnectionInfos,
        PooledObject<SocketOutputStream> socketOutputStream) throws Exception {
    super.destroyObject(socketConnectionInfos, socketOutputStream);
    SocketOutputStream outputStream = socketOutputStream.getObject();
    JOrphanUtils.closeQuietly(outputStream);
    JOrphanUtils.closeQuietly(outputStream.getSocket());
}

From source file:org.apache.jmeter.visualizers.backend.graphite.SocketOutputStreamPoolFactory.java

/**
 *///from   w  w  w  .  j a va 2s. c o  m
@Override
public boolean validateObject(SocketConnectionInfos hostAndPort,
        PooledObject<SocketOutputStream> socketOutputStream) {
    Socket socket = socketOutputStream.getObject().getSocket();
    return socket.isConnected() && socket.isBound() && !socket.isClosed() && !socket.isInputShutdown()
            && !socket.isOutputShutdown();
}

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/* www . jav  a  2s.c om*/
        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//www.  j a va  2  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);
    }
}