JdoTransactionManager (Spring Framework)

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.springframework.orm.jdo
Class JdoTransactionManager

java.lang.Object
  org.springframework.transaction.support.AbstractPlatformTransactionManager
      org.springframework.orm.jdo.JdoTransactionManager

All Implemented Interfaces:: InitializingBean, PlatformTransactionManager, Serializable

public class JdoTransactionManager
extends AbstractPlatformTransactionManager
implements InitializingBean

PlatformTransactionManager implementation for a single JDO PersistenceManagerFactory. Binds a JDO PersistenceManager from the specified factory to the thread, potentially allowing for one thread PersistenceManager per factory. PersistenceManagerFactoryUtils and JdoTemplate are aware of thread-bound persistence managers and participate in such transactions automatically. Using either is required for JDO access code supporting this transaction management mechanism.

This implementation is appropriate for applications that solely use JDO for transactional data access. JTA respectively JtaTransactionManager is necessary for accessing multiple transactional resources. Note that you need to configure your JDO tool accordingly to make it participate in JTA transactions. In contrast to Hibernate, this cannot be transparently provided by the Spring transaction manager implementation.

With a JdoDialect specified, this implementation also supports direct DataSource access within a transaction (i.e. plain JDBC code working with the same DataSource). This allows for mixing services that access JDO (including transactional caching) and services that use plain JDBC (without being aware of JDO)! Application code needs to stick to the same simple Connection lookup pattern as with DataSourceTransactionManager (i.e. DataSourceUtils.getConnection).

Note that to be able to register a DataSource's Connection for plain JDBC code, this instance needs to be aware of the DataSource (see "dataSource" property). The given DataSource should obviously match the one used by the given PersistenceManagerFactory. This transaction manager will auto-detect the DataSource that acts as "connectionFactory" of the PersistenceManagerFactory, so you usually don't need to explicitly specify the "dataSource" property.

On JDBC 3.0, this transaction manager supports nested transactions via JDBC 3.0 Savepoints. The "nestedTransactionAllowed" flag defaults to false, though, as nested transactions will just apply to the JDBC Connection, not to the JDO PersistenceManager and its cached objects. You can manually set the flag to true if you want to use nested transactions for JDBC access code that participates in JDO transactions (provided that your JDBC driver supports Savepoints).

Since:: 03.06.2003
Author:: Juergen Hoeller
See Also:: setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory), setDataSource(javax.sql.DataSource), PersistenceManagerFactory.getConnectionFactory(), LocalPersistenceManagerFactoryBean, PersistenceManagerFactoryUtils.getPersistenceManager(javax.jdo.PersistenceManagerFactory, boolean), PersistenceManagerFactoryUtils.closePersistenceManagerIfNecessary(javax.jdo.PersistenceManager, javax.jdo.PersistenceManagerFactory), JdoTemplate.execute(org.springframework.orm.jdo.JdoCallback), DataSourceUtils.getConnection(javax.sql.DataSource), DataSourceUtils.closeConnectionIfNecessary(java.sql.Connection, javax.sql.DataSource), JdbcTemplate, JtaTransactionManager, HibernateTransactionManager, Serialized Form

Field Summary

Fields inherited from class org.springframework.transaction.support.AbstractPlatformTransactionManager

logger, SYNCHRONIZATION_ALWAYS, SYNCHRONIZATION_NEVER, SYNCHRONIZATION_ON_ACTUAL_TRANSACTION

Constructor Summary
`JdoTransactionManager()` Create a new JdoTransactionManager instance.
`JdoTransactionManager(javax.jdo.PersistenceManagerFactory pmf)` Create a new JdoTransactionManager instance.

Method Summary
`void`	`afterPropertiesSet()` Eagerly initialize the JDO dialect, creating a default one for the specified PersistenceManagerFactory if none set.
`protected DataAccessException`	`convertJdoAccessException(javax.jdo.JDOException ex)` Convert the given JDOException to an appropriate exception from the org.springframework.dao hierarchy.
`protected void`	`doBegin(Object transaction, TransactionDefinition definition)` Begin a new transaction with the given transaction definition.
`protected void`	`doCleanupAfterCompletion(Object transaction)` Cleanup resources after transaction completion.
`protected void`	`doCommit(DefaultTransactionStatus status)` Perform an actual commit on the given transaction.
`protected Object`	`doGetTransaction()` Return a current transaction object, i.e. a JTA UserTransaction.
`protected void`	`doResume(Object transaction, Object suspendedResources)` Resume the resources of the current transaction.
`protected void`	`doRollback(DefaultTransactionStatus status)` Perform an actual rollback on the given transaction.
`protected void`	`doSetRollbackOnly(DefaultTransactionStatus status)` Set the given transaction rollback-only.
`protected Object`	`doSuspend(Object transaction)` Suspend the resources of the current transaction.
`DataSource`	`getDataSource()` Return the JDBC DataSource that this instance manages transactions for.
`JdoDialect`	`getJdoDialect()` Return the JDO dialect to use for this transaction manager.
`javax.jdo.PersistenceManagerFactory`	`getPersistenceManagerFactory()` Return the PersistenceManagerFactory that this instance should manage transactions for.
`protected boolean`	`isExistingTransaction(Object transaction)` Check if the given transaction object indicates an existing, i.e. already begun, transaction.
`void`	`setAutodetectDataSource(boolean autodetectDataSource)` Set whether to autodetect a JDBC DataSource used by the JDO PersistenceManagerFactory, as returned by the `getConnectionFactory()` method.
`void`	`setDataSource(DataSource dataSource)` Set the JDBC DataSource that this instance should manage transactions for.
`void`	`setJdoDialect(JdoDialect jdoDialect)` Set the JDO dialect to use for this transaction manager.
`void`	`setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory pmf)` Set the PersistenceManagerFactory that this instance should manage transactions for.

Methods inherited from class org.springframework.transaction.support.AbstractPlatformTransactionManager

commit, getTransaction, getTransactionSynchronization, isNestedTransactionAllowed, isRollbackOnCommitFailure, rollback, setNestedTransactionAllowed, setRollbackOnCommitFailure, setTransactionSynchronization, setTransactionSynchronizationName, useSavepointForNestedTransaction

Methods inherited from class java.lang.Object

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

Constructor Detail

JdoTransactionManager

public JdoTransactionManager()

Create a new JdoTransactionManager instance. A PersistenceManagerFactory has to be set to be able to use it.
See Also:: setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory)

JdoTransactionManager

public JdoTransactionManager(javax.jdo.PersistenceManagerFactory pmf)

Create a new JdoTransactionManager instance.
Parameters:: pmf - PersistenceManagerFactory to manage transactions for

Method Detail

setPersistenceManagerFactory

public void setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory pmf)

Set the PersistenceManagerFactory that this instance should manage transactions for.

getPersistenceManagerFactory

public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory()

Return the PersistenceManagerFactory that this instance should manage transactions for.

setDataSource

public void setDataSource(DataSource dataSource)

Set the JDBC DataSource that this instance should manage transactions for. The DataSource should match the one used by the JDO PersistenceManagerFactory: for example, you could specify the same JNDI DataSource for both.

If the PersistenceManagerFactory uses a DataSource as connection factory, the DataSource will be auto-detected: You can still explictly specify the DataSource, but you don't need to in this case.

A transactional JDBC Connection for this DataSource will be provided to application code accessing this DataSource directly via DataSourceUtils or JdbcTemplate. The Connection will be taken from the JDO PersistenceManager.

Note that you need to use a JDO dialect for a specific JDO implementation to allow for exposing JDO transactions as JDBC transactions.

See Also:: setAutodetectDataSource(boolean), setJdoDialect(org.springframework.orm.jdo.JdoDialect), PersistenceManagerFactory.getConnectionFactory()

getDataSource

public DataSource getDataSource()

Return the JDBC DataSource that this instance manages transactions for.

setAutodetectDataSource

public void setAutodetectDataSource(boolean autodetectDataSource)

Set whether to autodetect a JDBC DataSource used by the JDO PersistenceManagerFactory, as returned by the getConnectionFactory() method. Default is true.

Can be turned off to deliberately ignore an available DataSource, to not expose JDO transactions as JDBC transactions for that DataSource.

See Also:: setDataSource(javax.sql.DataSource), PersistenceManagerFactory.getConnectionFactory()

setJdoDialect

public void setJdoDialect(JdoDialect jdoDialect)

Set the JDO dialect to use for this transaction manager.

The dialect object can be used to retrieve the underlying JDBC connection and thus allows for exposing JDO transactions as JDBC transactions.

See Also:: JdoDialect.getJdbcConnection(javax.jdo.PersistenceManager, boolean)

getJdoDialect

public JdoDialect getJdoDialect()

Return the JDO dialect to use for this transaction manager. Creates a default one for the specified PersistenceManagerFactory if none set.

afterPropertiesSet

public void afterPropertiesSet()

Eagerly initialize the JDO dialect, creating a default one for the specified PersistenceManagerFactory if none set. Auto-detect the PersistenceManagerFactory's DataSource, if any.

Specified by:: afterPropertiesSet in interface InitializingBean