Examples of javax.sql.PooledConnection

javax.sql.PooledConnection
An interface which provides facilities for handling connections to a database which are pooled.
Typically, a PooledConnection is recycled when it is no longer required by an application, rather than being closed and discarded. The reason for treating connections in this way is that it can be an expensive process both to establish a connection to a database and to destroy the connection. Reusing connections through a pool is a way of improving system performance and reducing overhead.
It is not intended that an application use the PooledConnection interface directly. The PooledConnection interface is intended for use by a component called a Connection Pool Manager, typically part of the infrastructure that supports use of the database by applications.
Applications obtain connections to the database by calling the DataSource.getConnection method. Under the covers, the Connection Pool Manager will get a PooledConnection object from its connection pool and passes back a Connection object that wraps or references the PooledConnection object. A new PooledConnection object will only be created if the pool is empty.
When the application is finished using a PooledConnection, the application calls the Connection.close method. The Connection Pool Manager is notified via a ConnectionEvent from the Connection that this has happened (the Pool Manager registers itself with the Connection before the Connection is given to the application). The Pool Manager removes the underlying PooledConnection object from the Connection and returns it to the pool for reuse - the PooledConnection is thus recycled rather than being destroyed.
The connection to the database represented by the PooledConnection is kept open until the PooledConnection object itself is deactivated by the Connection Pool Manager, which calls the PooledConnection.close method. This is typically done if there are too many inactive connections in the pool, if the PooledConnection encounters a problem that makes it unusable or if the whole system is being shut down.

   * @see net.sf.hajdbc.Database#connect(java.lang.Object, java.lang.String)
   */
  @Override
  public Connection connect(ConnectionPoolDataSource dataSource, String password) throws SQLException
  {
    PooledConnection connection = this.requiresAuthentication() ? dataSource.getPooledConnection(this.getUser(), password) : dataSource.getPooledConnection();
    
    return connection.getConnection();
  }

View Full Code Here

                    + " doesn't implement javax.sql.ConnectionPoolDataSource");
            }
        }
        
        // try to get a connection with the supplied username/password
        PooledConnection conn = null;
        try {
            if (username != null) {
                conn = cpds.getPooledConnection(username, password);
            }
            else {
                conn = cpds.getPooledConnection();
            }
            if (conn == null) {
                throw new SQLException(
                    "Cannot connect using the supplied username/password");
            }
        }
        finally {
            if (conn != null) {
                try {
                    conn.close();
                }
                catch (SQLException e) {
                    // at least we could connect
                }
            }

View Full Code Here

        if (username != this.username || password != this.password)
        {
            throw new SQLException("Username and password are invalid.");
        }


        PooledConnection pcon = null;
        if (pool.empty() && totalConnections < maxConnections)
        {
            pcon = getNewConnection();
        }
        else

View Full Code Here

     * @exception SQLException if there is aproblem with the db connection
     */
    private PooledConnection getNewConnection()
        throws SQLException
    {
        PooledConnection pc = null;
        if (username == null)
        {
            pc = cpds.getPooledConnection();
        }
        else
        {
            pc = cpds.getPooledConnection(username, password);
        }
        pc.addConnectionEventListener(this);


        // Age some connections so that there will not be a run on the db,
        // when connections start expiring
        //
        // I did some experimentation here with integers but as this

View Full Code Here

    private PooledConnection popConnection()
        throws Exception
    {
        while (!pool.empty())
        {
            PooledConnection con = (PooledConnection) pool.pop();


            // It's really not safe to assume this connection is
            // valid even though it's checked before being pooled.
            if (isValid(con))
            {
                return con;
            }
            else
            {
                // Close invalid connection.
                con.close();
                totalConnections--;


                // If the pool is now empty, create a new connection.  We're
                // guaranteed not to exceed the connection limit since we
                // just killed off one or more invalid connections, and no

View Full Code Here

     * Creates and returns new PooledConnection object, adding itself as a listener 
     * for connection events. 
     */
    protected PooledConnection newPooledConnection(String userName, String password)
        throws SQLException {
        PooledConnection connection =
            (userName != null)
                ? poolDataSource.getPooledConnection(userName, password)
                : poolDataSource.getPooledConnection();
        connection.addConnectionEventListener(this);
        return connection;
    }

View Full Code Here

    public void dispose() throws SQLException {
        synchronized (this) {
            // clean connections from the pool
            ListIterator<PooledConnection> unusedIterator = unusedPool.listIterator();
            while (unusedIterator.hasNext()) {
                PooledConnection con = unusedIterator.next();
                // close connection
                con.close();
                // remove connection from the list
                unusedIterator.remove();
            }


            // clean used connections
            ListIterator<PooledConnection> usedIterator = usedPool.listIterator();
            while (usedIterator.hasNext()) {
                PooledConnection con = usedIterator.next();
                // stop listening for connection events
                con.removeConnectionEventListener(this);
                // close connection
                con.close();
                // remove connection from the list
                usedIterator.remove();
            }
        }

View Full Code Here

        throws SQLException {


        int i = 0;
        int startPoolSize = getPoolSize();
        for (; i < addConnections && startPoolSize + i < maxConnections; i++) {
            PooledConnection newConnection = newPooledConnection(userName, password);
            unusedPool.add(newConnection);
        }


        return i;
    }

View Full Code Here

    }


    protected synchronized void shrinkPool(int closeConnections) {
        int idleSize = unusedPool.size();
        for (int i = 0; i < closeConnections && i < idleSize; i++) {
            PooledConnection con = unusedPool.remove(i);


            try {
                con.close();
            } catch (SQLException ex) {
                // ignore
            }
        }
    }

View Full Code Here


    /** Returns connection from the pool. */
    public synchronized Connection getConnection(String userName, String password)
            throws SQLException {


        PooledConnection pooledConnection = uncheckPooledConnection(userName, password);


        try {
            return uncheckConnection(pooledConnection);
        }
        catch (SQLException ex) {


            try {
                pooledConnection.close();
            }
            catch (SQLException ignored) {
            }
            
            // do one reconnect attempt...
            pooledConnection = uncheckPooledConnection(userName, password);
            try {
                return uncheckConnection(pooledConnection);
            }
            catch (SQLException reconnectEx) {
                try {
                    pooledConnection.close();
                }
                catch (SQLException ignored) {
                }
                
                throw reconnectEx;

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of javax.sql.PooledConnection

co.cask.cdap.common.db.DBConnectionPoolManager

co.cask.cdap.common.db.DBConnectionPoolManager$PoolConnectionEventListener

com.alibaba.druid.bvt.pool.DruidDataSourceTest_getPooledConnection

com.alibaba.druid.bvt.pool.DruidDataSourceTest_testOnBorrowFailed

com.alibaba.druid.bvt.pool.DruidDataSourceTest_testOnWhileIdleFailed

com.alibaba.wasp.jdbcx.JdbcConnectionPool

com.atomikos.jdbc.ConnectionPool

com.atomikos.jdbc.SimpleDataSourceBean

com.caucho.sql.DriverConfig

com.caucho.sql.ManagedConnectionImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.