Spring Transaction Management Examples
Transaction:
Begin -------------->[Transaction]
/\
/ \
/ \
/ \
Transaction Succeed Transaction Falied
| |
| |
| |
Commit Rollback
ACID Properties:
- A. Atomicity
- C. Consistency
- I. Isolation
- D. Durability
Spring Transaction Management:
- Supports programmatic and declarative transactions.
-
Programmatic transaction management achieve via
PlatformTransactionManager
TransactionTemplate -
Declarative transaction management achieve via
Spring AOP
Annotation -
Supports many transaction properties:
- Propagation
- Isolation level
- Rollback condition
- Read Only
- Timeout
Spring transaction Built-In Implementations:
PlatformTransactionManager
|
AbstractPlatformTransactionManager
|
|
------------------------------------------------------------------------------------------------------------------------------------------
| | | | | |
JtaTransactionManager JpaTransactionManager DataSourceTransactionManager HibernateTransactionManager JdoTransactionManager JmsTransactionManager
Spring transaction management API:
PlatformTransactionManager interface
TransactionStatus getTransaction(TransactionDefinition difinition) throws TransactionException
void commit(TransactionStatus status) throws TransactionException
void rollback(TransactionStatus status) throws TransactionException
Programmatic Transaction Management:(Transactional Class)
import org.springframework.transaction.support.TransactionTemplate
public class TransactionalJdbcBookShop extends JdbcDaoSupport implements BookShop{
private TransactionTemplate transactionTemplate;
public void setTransactionTemplate(TransactionTemplate transactionTemplate){
this.transactionTemplate=transactionTemplate;
}
public void purchase(final String isbn,final String username){
transactionTemplate.execute(new TransactionCallbackWithoutResult(){
protected void doInTransactionWithoutResult(TransactionStatus status){
.......
}
});
}
}
Programmatic Transaction Management:(Bean Definition)
<beans>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
<property name="transactionManager" ref="transactionManager"/>
</bean>
<bean id="bookShop" class="com.springexamples.TransactionalJdbcBookShop">
<property name="transactionTemplate" ref="transactionTemplate"/>
</bean>
</beans>
Declarative Transaction Management:
- aop:config, aop:pointcut, aop:advisor
- tx:advice, tx:method, tx:attributes
- @Transactional
- Propogation
- Read-Only
- timeout
- Isolation
- Rollback-rules
- REQUIRED: If there is an existing transaction in progress, the current method should run within this transaction. otherwise, it should start a new transaction and run within its own transaction.
- REQUIRES_NEW:The current method must start a new transaction and run within its own transaction. If there's an existing transaction in progress, it should be suspended.
- SUPPORTS:If there's existing transaction progress, the current method can run within this transaction. otherwise, it is not necessary to run within a transaction
- NOT_SUPPORTED:The current method should not run within a transaction.If there's an existing transaction in progress, it should be suspended.
- MANDATORY:The current method must run within a transaction.If there's no existing transaction in progress, an exception will trown.
- NEVER:The current method should not run within a transaction. If there's an existing transaction in progress, exception will be thrown.
- NESTED:If there's an existing transaction in progress,the current method should run within the nested transaction of the transaction.Otherwise it should start a new transaction and run within its own transaction.
- Lost Update
- Dirty Read
- Unrepeatable Read
- Second lost updates problem
- Phantom read
- Read Uncommited:Permits dirty reads but not lost updates. One transaction may not write to a row if another uncommited transaction has already written to it.This isolation level may be implemented using exclusive write lock.
- Read Committed:Permits unrepeatable reads but not dirty reads.This may be achieved using momentary shared read locks and exclusive write locks. Reading transaction dont block other transaction from accessing row.However, an uncommitted writing transaction blocks all other transaction from accessing a row.
- Repeatable Read:Permits neither unrepeatable reads nor dirty reads.Phantom reads may occur.This may be achieved using shared reads lock and exclusive write lock Reading transaction block writing transaction and writing transaction blocks all other transaction.
- Serializable:Provides the strictest transaction isolation.It emulates serial transaction execution.as if transaction had been executed one after another,serially, rather than concurrently.Serializablity may not implemented using only row-level locks