public class JdoTransactionManager
extends org.springframework.transaction.support.AbstractPlatformTransactionManager
implements org.springframework.transaction.support.ResourceTransactionManager, org.springframework.beans.factory.InitializingBean
PlatformTransactionManager
implementation for a
single JDO PersistenceManagerFactory
. Binds a JDO PersistenceManager
from the specified factory to the thread, potentially allowing for one thread-bound
PersistenceManager per factory. PersistenceManagerFactoryUtils
and
SpringPersistenceManagerProxyBean
are aware
of thread-bound persistence managers and participate in such transactions automatically.
Using either of those (or going through a TransactionAwarePersistenceManagerFactoryProxy
is required for JDO access code supporting this transaction management mechanism.
This transaction manager is appropriate for applications that use a single
JDO PersistenceManagerFactory for transactional data access. JTA (usually through
JtaTransactionManager
) is necessary
for accessing multiple transactional resources within the same transaction.
Note that you need to configure your JDO provider accordingly in order to make
it participate in JTA transactions.
This transaction manager also supports direct DataSource access within a
transaction (i.e. plain JDBC code working with the same DataSource).
This allows for mixing services which access JDO and services which 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(javax.sql.DataSource)
or going through a
TransactionAwareDataSourceProxy
).
Note: To be able to register a DataSource's Connection for plain JDBC code,
this instance needs to be aware of the DataSource (setDataSource(javax.sql.DataSource)
).
The given DataSource should obviously match the one used by the given
PersistenceManagerFactory. This transaction manager will autodetect the DataSource
that acts as "connectionFactory" of the PersistenceManagerFactory, so you usually
don't need to explicitly specify the "dataSource" property.
This transaction manager supports nested transactions via JDBC 3.0 Savepoints.
The AbstractPlatformTransactionManager.setNestedTransactionAllowed(boolean)
"nestedTransactionAllowed"} flag defaults
to "false", though, as nested transactions will just apply to the JDBC Connection,
not to the JDO PersistenceManager and its cached entity objects and related context.
You can manually set the flag to "true" if you want to use nested transactions
for JDBC access code which participates in JDO transactions (provided that your
JDBC driver supports Savepoints). Note that JDO itself does not support
nested transactions! Hence, do not expect JDO access code to semantically
participate in a nested transaction.
setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory)
,
setDataSource(javax.sql.DataSource)
,
PersistenceManagerFactory.getConnectionFactory()
,
LocalPersistenceManagerFactoryBean
,
PersistenceManagerFactoryUtils.getPersistenceManager(javax.jdo.PersistenceManagerFactory, boolean)
,
PersistenceManagerFactoryUtils.releasePersistenceManager(javax.jdo.PersistenceManager, javax.jdo.PersistenceManagerFactory)
,
TransactionAwarePersistenceManagerFactoryProxy
,
DataSourceUtils.getConnection(javax.sql.DataSource)
,
DataSourceUtils.releaseConnection(java.sql.Connection, javax.sql.DataSource)
,
org.springframework.jdbc.core.JdbcTemplate
,
DataSourceTransactionManager
,
JtaTransactionManager
,
Serialized FormConstructor and Description |
---|
JdoTransactionManager()
Create a new JdoTransactionManager instance.
|
JdoTransactionManager(javax.jdo.PersistenceManagerFactory pmf)
Create a new JdoTransactionManager instance.
|
Modifier and Type | Method and Description |
---|---|
void |
afterPropertiesSet()
Eagerly initialize the JDO dialect, creating a default one
for the specified PersistenceManagerFactory if none set.
|
protected void |
closePersistenceManagerAfterFailedBegin(org.springframework.orm.jdo.JdoTransactionManager.JdoTransactionObject txObject)
Close the current transaction's EntityManager.
|
protected org.springframework.dao.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,
org.springframework.transaction.TransactionDefinition definition) |
protected void |
doCleanupAfterCompletion(Object transaction) |
protected void |
doCommit(org.springframework.transaction.support.DefaultTransactionStatus status) |
protected Object |
doGetTransaction() |
protected void |
doResume(Object transaction,
Object suspendedResources) |
protected void |
doRollback(org.springframework.transaction.support.DefaultTransactionStatus status) |
protected void |
doSetRollbackOnly(org.springframework.transaction.support.DefaultTransactionStatus status) |
protected Object |
doSuspend(Object 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.
|
Object |
getResourceFactory() |
protected boolean |
isExistingTransaction(Object 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.
|
protected boolean |
shouldCommitOnGlobalRollbackOnly()
This implementation returns "true": a JDO commit will properly handle
transactions that have been marked rollback-only at a global level.
|
commit, determineTimeout, getDefaultTimeout, getTransaction, getTransactionSynchronization, invokeAfterCompletion, isFailEarlyOnGlobalRollbackOnly, isGlobalRollbackOnParticipationFailure, isNestedTransactionAllowed, isRollbackOnCommitFailure, isValidateExistingTransaction, newTransactionStatus, prepareForCommit, prepareSynchronization, prepareTransactionStatus, registerAfterCompletionWithExistingTransaction, resume, rollback, setDefaultTimeout, setFailEarlyOnGlobalRollbackOnly, setGlobalRollbackOnParticipationFailure, setNestedTransactionAllowed, setRollbackOnCommitFailure, setTransactionSynchronization, setTransactionSynchronizationName, setValidateExistingTransaction, suspend, triggerBeforeCommit, triggerBeforeCompletion, useSavepointForNestedTransaction
public JdoTransactionManager()
public JdoTransactionManager(javax.jdo.PersistenceManagerFactory pmf)
pmf
- PersistenceManagerFactory to manage transactions forpublic void setPersistenceManagerFactory(javax.jdo.PersistenceManagerFactory pmf)
The PersistenceManagerFactory specified here should be the target PersistenceManagerFactory to manage transactions for, not a TransactionAwarePersistenceManagerFactoryProxy. Only data access code may work with TransactionAwarePersistenceManagerFactoryProxy, while the transaction manager needs to work on the underlying target PersistenceManagerFactory.
public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory()
public void setDataSource(DataSource dataSource)
If the PersistenceManagerFactory uses a DataSource as connection factory, the DataSource will be autodetected: You can still explicitly 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 provider to allow for exposing JDO transactions as JDBC transactions.
The DataSource specified here should be the target DataSource to manage transactions for, not a TransactionAwareDataSourceProxy. Only data access code may work with TransactionAwareDataSourceProxy, while the transaction manager needs to work on the underlying target DataSource. If there's nevertheless a TransactionAwareDataSourceProxy passed in, it will be unwrapped to extract its target DataSource.
setAutodetectDataSource(boolean)
,
setJdoDialect(org.springframework.orm.jdo.JdoDialect)
,
PersistenceManagerFactory.getConnectionFactory()
,
TransactionAwareDataSourceProxy
,
DataSourceUtils
,
org.springframework.jdbc.core.JdbcTemplate
public DataSource getDataSource()
public void setAutodetectDataSource(boolean autodetectDataSource)
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.
setDataSource(javax.sql.DataSource)
,
PersistenceManagerFactory.getConnectionFactory()
public void setJdoDialect(JdoDialect jdoDialect)
The dialect object can be used to retrieve the underlying JDBC connection and thus allows for exposing JDO transactions as JDBC transactions.
public JdoDialect getJdoDialect()
Creates a default one for the specified PersistenceManagerFactory if none set.
public void afterPropertiesSet()
afterPropertiesSet
in interface org.springframework.beans.factory.InitializingBean
public Object getResourceFactory()
getResourceFactory
in interface org.springframework.transaction.support.ResourceTransactionManager
protected Object doGetTransaction()
doGetTransaction
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected boolean isExistingTransaction(Object transaction)
isExistingTransaction
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doBegin(Object transaction, org.springframework.transaction.TransactionDefinition definition)
doBegin
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void closePersistenceManagerAfterFailedBegin(org.springframework.orm.jdo.JdoTransactionManager.JdoTransactionObject txObject)
txObject
- the current transactionprotected Object doSuspend(Object transaction)
doSuspend
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doResume(Object transaction, Object suspendedResources)
doResume
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected boolean shouldCommitOnGlobalRollbackOnly()
shouldCommitOnGlobalRollbackOnly
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doCommit(org.springframework.transaction.support.DefaultTransactionStatus status)
doCommit
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doRollback(org.springframework.transaction.support.DefaultTransactionStatus status)
doRollback
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doSetRollbackOnly(org.springframework.transaction.support.DefaultTransactionStatus status)
doSetRollbackOnly
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected void doCleanupAfterCompletion(Object transaction)
doCleanupAfterCompletion
in class org.springframework.transaction.support.AbstractPlatformTransactionManager
protected org.springframework.dao.DataAccessException convertJdoAccessException(javax.jdo.JDOException ex)
org.springframework.dao
hierarchy.
The default implementation delegates to the JdoDialect. May be overridden in subclasses.
ex
- JDOException that occuredJdoDialect.translateException(javax.jdo.JDOException)