AbstractDataSourceBasedMultiTenantConnectionProviderImpl (Hibernate JavaDocs)
Date: 2012-04-05

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.hibernate.service.jdbc.connections.spi
Class AbstractDataSourceBasedMultiTenantConnectionProviderImpl

    java.lang.Object
      org.hibernate.service.jdbc.connections.spi.AbstractDataSourceBasedMultiTenantConnectionProviderImpl

All Implemented Interfaces:
  Serializable, MultiTenantConnectionProvider, Service, Wrapped

Direct Known Subclasses:
  DataSourceBasedMultiTenantConnectionProviderImpl

    public abstract class AbstractDataSourceBasedMultiTenantConnectionProviderImpl

extends Object
implements MultiTenantConnectionProvider

Basic support for implementations of `MultiTenantConnectionProvider` based on DataSources.

See Also:
  Serialized Form

Constructor Summary
`AbstractDataSourceBasedMultiTenantConnectionProviderImpl()`

Method Summary
`Connection` | `getAnyConnection()` Allows access to the database metadata of the underlying database(s) in situations where we do not have a tenant id (like startup processing, for example).
`Connection` | `getConnection(String tenantIdentifier)` Obtains a connection for Hibernate use according to the underlying strategy of this provider.
`boolean` | `isUnwrappableAs(Class unwrapType)` Can this wrapped service be unwrapped as the indicated type?
`void` | `releaseAnyConnection(Connection connection)` Release a connection obtained from `MultiTenantConnectionProvider.getAnyConnection()`
`void` | `releaseConnection(String tenantIdentifier, Connection connection)` Release a connection from Hibernate use.
`protected abstract DataSource` | `selectAnyDataSource()`
`protected abstract DataSource` | `selectDataSource(String tenantIdentifier)`
`boolean` | `supportsAggressiveRelease()` Does this connection provider support aggressive release of JDBC connections and re-acquisition of those connections (if need be) later? This is used in conjunction with `AvailableSettings.RELEASE_CONNECTIONS` to aggressively release JDBC connections.
`
`<T> T`
` | `unwrap(Class<T> unwrapType)` Unproxy the service proxy

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

Constructor Detail

### AbstractDataSourceBasedMultiTenantConnectionProviderImpl

    public AbstractDataSourceBasedMultiTenantConnectionProviderImpl()

Method Detail

### selectAnyDataSource

    protected abstract DataSource selectAnyDataSource()

### selectDataSource

    protected abstract DataSource selectDataSource(String tenantIdentifier)

### getAnyConnection

    public Connection getAnyConnection()
                                throws SQLException

  Description copied from interface: `MultiTenantConnectionProvider`
  Allows access to the database metadata of the underlying database(s) in situations where we do not have a tenant id (like startup processing, for example).

  Specified by:
    `getAnyConnection` in interface `MultiTenantConnectionProvider`
  Returns:
    The database metadata.
  Throws:
    `SQLException` - Indicates a problem opening a connection

### releaseAnyConnection

    public void releaseAnyConnection(Connection connection)
                              throws SQLException

  Description copied from interface: `MultiTenantConnectionProvider`
  Release a connection obtained from `MultiTenantConnectionProvider.getAnyConnection()`

  Specified by:
    `releaseAnyConnection` in interface `MultiTenantConnectionProvider`
  Parameters:
    `connection` - The JDBC connection to release
  Throws:
    `SQLException` - Indicates a problem closing the connection

### getConnection

    public Connection getConnection(String tenantIdentifier)
                             throws SQLException

  Description copied from interface: `MultiTenantConnectionProvider`
  Obtains a connection for Hibernate use according to the underlying strategy of this provider.

  Specified by:
    `getConnection` in interface `MultiTenantConnectionProvider`
  Parameters:
    `tenantIdentifier` - The identifier of the tenant for which to get a connection
  Returns:
    The obtained JDBC connection
  Throws:
    `SQLException` - Indicates a problem opening a connection

### releaseConnection

    public void releaseConnection(String tenantIdentifier,
                                  Connection connection)
                           throws SQLException

  Description copied from interface: `MultiTenantConnectionProvider`
  Release a connection from Hibernate use.

  Specified by:
    `releaseConnection` in interface `MultiTenantConnectionProvider`
  Parameters:
    `tenantIdentifier` - The identifier of the tenant.
    `connection` - The JDBC connection to release
  Throws:
    `SQLException` - Indicates a problem closing the connection

### supportsAggressiveRelease

    public boolean supportsAggressiveRelease()

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

  This is used in conjunction with `AvailableSettings.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 `MultiTenantConnectionProvider`
  Returns:
    `true` if aggressive releasing is supported; `false` otherwise.

### isUnwrappableAs

    public boolean isUnwrappableAs(Class unwrapType)

  Description copied from interface: `Wrapped`
  Can this wrapped service be unwrapped as the indicated type?

  Specified by:
    `isUnwrappableAs` in interface `Wrapped`
  Parameters:
    `unwrapType` - The type to check.
  Returns:
    True/false.

### unwrap

    public <T> T unwrap(Class<T> unwrapType)

  Description copied from interface: `Wrapped`
  Unproxy the service proxy

  Specified by:
    `unwrap` in interface `Wrapped`
  Parameters:
    `unwrapType` - The java type as which to unwrap this instance.
  Returns:
    The unwrapped reference

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

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