org.apache.commons.dbcp2.managed

## Class ManagedConnection<C extends Connection>

- java.lang.Object
- - org.apache.commons.dbcp2.AbandonedTrace
  - - org.apache.commons.dbcp2.DelegatingConnection<C>
    - - org.apache.commons.dbcp2.managed.ManagedConnection<C>

- Type Parameters:
    `C` - the Connection type
  All Implemented Interfaces:
    AutoCloseable, Connection, Wrapper, TrackedUse

      public class ManagedConnection<C extends Connection>
      extends DelegatingConnection<C>

  ManagedConnection is responsible for managing a database connection in a transactional environment (typically called "Container Managed"). A managed connection operates like any other connection when no global transaction (a.k.a. XA transaction or JTA Transaction) is in progress. When a global transaction is active a single physical connection to the database is used by all ManagedConnections accessed in the scope of the transaction. Connection sharing means that all data access during a transaction has a consistent view of the database. When the global transaction is committed or rolled back the enlisted connections are committed or rolled back. Typically upon transaction completion, a connection returns to the auto commit setting in effect before being enlisted in the transaction, but some vendors do not properly implement this. When enlisted in a transaction the setAutoCommit(), commit(), rollback(), and setReadOnly() methods throw a SQLException. This is necessary to assure that the transaction completes as a single unit.
  Since:
    2.0
  Author:
    Dain Sundstrom

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `ManagedConnection.CompletionListener` Delegates to `transactionComplete()` for transaction completion events.

  - ### Field Summary

    - ### Fields inherited from interface java.sql.Connection

      `TRANSACTION_NONE, TRANSACTION_READ_COMMITTED, TRANSACTION_READ_UNCOMMITTED, TRANSACTION_REPEATABLE_READ, TRANSACTION_SERIALIZABLE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ManagedConnection(ObjectPool<C> pool, TransactionRegistry transactionRegistry, boolean accessToUnderlyingConnectionAllowed)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `checkOpen()`
    `void` | `close()` Closes the underlying connection, and close any Statements that were not explicitly closed.
    `void` | `commit()`
    `C` | `getDelegate()` Returns my underlying `Connection`.
    `Connection` | `getInnermostDelegate()` If my underlying `Connection` is not a `DelegatingConnection`, returns it, otherwise recursively invokes this method on my delegate.
    `boolean` | `isAccessToUnderlyingConnectionAllowed()` If false, getDelegate() and getInnermostDelegate() will return null.
    `void` | `rollback()`
    `void` | `setAutoCommit(boolean autoCommit)`
    `void` | `setReadOnly(boolean readOnly)`
    `protected void` | `transactionComplete()`

    - ### Methods inherited from class org.apache.commons.dbcp2.DelegatingConnection

      `abort, activate, clearCachedState, clearWarnings, closeInternal, createArrayOf, createBlob, createClob, createNClob, createSQLXML, createStatement, createStatement, createStatement, createStruct, getAutoCommit, getCacheState, getCatalog, getClientInfo, getClientInfo, getDefaultQueryTimeout, getDelegateInternal, getHoldability, getInnermostDelegateInternal, getMetaData, getNetworkTimeout, getSchema, getTransactionIsolation, getTypeMap, getWarnings, handleException, innermostDelegateEquals, isClosed, isClosedInternal, isReadOnly, isValid, isWrapperFor, nativeSQL, passivate, prepareCall, prepareCall, prepareCall, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, prepareStatement, releaseSavepoint, rollback, setCacheState, setCatalog, setClientInfo, setClientInfo, setClosedInternal, setDefaultQueryTimeout, setDelegate, setHoldability, setNetworkTimeout, setSavepoint, setSavepoint, setSchema, setTransactionIsolation, setTypeMap, toString, unwrap`

    - ### Methods inherited from class org.apache.commons.dbcp2.AbandonedTrace

      `addTrace, clearTrace, getLastUsed, getTrace, removeTrace, setLastUsed, setLastUsed`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### ManagedConnection

          public ManagedConnection(ObjectPool<C> pool,
                                   TransactionRegistry transactionRegistry,
                                   boolean accessToUnderlyingConnectionAllowed)
                            throws SQLException

      Throws:
        `SQLException`

  - ### Method Detail

    - #### checkOpen

          protected void checkOpen()
                            throws SQLException

      Overrides:
        `checkOpen` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### close

          public void close()
                     throws SQLException

      Description copied from class: `DelegatingConnection`
      Closes the underlying connection, and close any Statements that were not explicitly closed. Sub-classes that override this method must:
      1. Call passivate()
      2. Call close (or the equivalent appropriate action) on the wrapped connection
      3. Set _closed to `false`
      Specified by:
        `close` in interface `AutoCloseable`
      Specified by:
        `close` in interface `Connection`
      Overrides:
        `close` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### transactionComplete

          protected void transactionComplete()

    - #### setAutoCommit

          public void setAutoCommit(boolean autoCommit)
                             throws SQLException

      Specified by:
        `setAutoCommit` in interface `Connection`
      Overrides:
        `setAutoCommit` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### commit

          public void commit()
                      throws SQLException

      Specified by:
        `commit` in interface `Connection`
      Overrides:
        `commit` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### rollback

          public void rollback()
                        throws SQLException

      Specified by:
        `rollback` in interface `Connection`
      Overrides:
        `rollback` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### setReadOnly

          public void setReadOnly(boolean readOnly)
                           throws SQLException

      Specified by:
        `setReadOnly` in interface `Connection`
      Overrides:
        `setReadOnly` in class `DelegatingConnection<C extends Connection>`
      Throws:
        `SQLException`

    - #### isAccessToUnderlyingConnectionAllowed

          public boolean isAccessToUnderlyingConnectionAllowed()

      If false, getDelegate() and getInnermostDelegate() will return null.
      Returns:
        if false, getDelegate() and getInnermostDelegate() will return null

    - #### getDelegate

          public C getDelegate()

      Description copied from class: `DelegatingConnection`
      Returns my underlying `Connection`.
      Overrides:
        `getDelegate` in class `DelegatingConnection<C extends Connection>`
      Returns:
        my underlying `Connection`.

    - #### getInnermostDelegate

          public Connection getInnermostDelegate()

      Description copied from class: `DelegatingConnection`
      If my underlying `Connection` is not a `DelegatingConnection`, returns it, otherwise recursively invokes this method on my delegate.

      Hence this method will return the first delegate that is not a `DelegatingConnection`, or `null` when no non-`DelegatingConnection` delegate can be found by traversing this chain.

      This method is useful when you may have nested `DelegatingConnection`s, and you want to make sure to obtain a "genuine" `Connection`.

      Overrides:
        `getInnermostDelegate` in class `DelegatingConnection<C extends Connection>`

Copyright © 2001–2018 The Apache Software Foundation. All rights reserved.