## org.hibernate.connection
Class ProxoolConnectionProvider

    java.lang.Object
      org.hibernate.connection.ProxoolConnectionProvider

All Implemented Interfaces:
  ConnectionProvider

    public class ProxoolConnectionProvider

extends Object
implements ConnectionProvider

A connection provider that uses a Proxool connection pool. Hibernate will use this by default if the `hibernate.proxool.*` properties are set.

See Also:
  `ConnectionProvider`

Constructor Summary
`ProxoolConnectionProvider()`

Method Summary
`void` `close()` Release all resources held by this provider.
`void` `closeConnection(Connection conn)` Dispose of a used connection.
`void` `configure(Properties props)` Initialize the connection provider from given properties.
`Connection` `getConnection()` Grab a connection
`boolean` `supportsAggressiveRelease()` Does this connection provider support aggressive release of JDBC connections and re-acquistion of those connections (if need be) later? This is used in conjunction with `org.hibernate.cfg.Environment.RELEASE_CONNECTIONS` to aggressively release JDBC connections.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### ProxoolConnectionProvider

    public ProxoolConnectionProvider()

Method Detail

### getConnection

    public Connection getConnection()
                             throws SQLException

  Grab a connection

  Specified by:
    `getConnection` in interface `ConnectionProvider`
  Returns:
    a JDBC connection
  Throws:
    `SQLException`

### closeConnection

    public void closeConnection(Connection conn)
                         throws SQLException

  Dispose of a used connection.

  Specified by:
    `closeConnection` in interface `ConnectionProvider`
  Parameters:
    `conn` - a JDBC connection
  Throws:
    `SQLException`

### configure

    public void configure(Properties props)
                   throws HibernateException

  Initialize the connection provider from given properties.

  Specified by:
    `configure` in interface `ConnectionProvider`
  Parameters:
    `props` - `SessionFactory` properties
  Throws:
    `HibernateException`

### close

    public void close()
               throws HibernateException

  Release all resources held by this provider. JavaDoc requires a second sentence.

  Specified by:
    `close` in interface `ConnectionProvider`
  Throws:
    `HibernateException`

### supportsAggressiveRelease

    public boolean supportsAggressiveRelease()

  Description copied from interface: `ConnectionProvider`
  Does this connection provider support aggressive release of JDBC connections and re-acquistion of those connections (if need be) later?

  This is used in conjunction with `org.hibernate.cfg.Environment.RELEASE_CONNECTIONS` to aggressively release JDBC connections. However, the configured ConnectionProvider must support re-acquisition of the same underlying connection for that semantic to work.

  Typically, this is only true in managed environments where a container tracks connections by transaction or thread. Note that JTA semantic depends on the fact that the underlying connection provider does support aggressive release.

  Specified by:
    `supportsAggressiveRelease` in interface `ConnectionProvider`
  See Also:
    `ConnectionProvider.supportsAggressiveRelease()`

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.