* ACID * Nested a Flat model transakcí * Lokální a distribuované transakce * Propagace a Izolace transakcí * Volba transakčního manažeru * Deklarativní ovládání transakcí * Programové ovládání transakcí

1. Spring framework
Motto: Musíte rozbít vejce když chcete udělat omeletu
Spring framework training materials by Roman Pichlík is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Sunday 13 May 2012 1

2. Řízení transakcí
Commit, rollback, programové a deklarativní použití transakcí
Sunday 13 May 2012 2

3. Transakce
• Správné použití a pochopení
transakcí je jednou ze základních
výzev J2EE aplikací
• Transakce
• nedělitelná jednotka operace
• ACID
Sunday 13 May 2012 3

4. ACID
• Atomicity
• Consistency
• Isolation
• Durability
Sunday 13 May 2012 4

5. Transakce v Jave
• Každý framework nebo
technologie má vlastní API
• JPA, Hibernate, JDBC, JTA...
• Transakce dělíme
• Lokální
• Globální
Sunday 13 May 2012 5

6. Transakce v Jave
• Vetšinou aplikací - lokální
transakce
• autocommit
• řízení transakcí per connection
Sunday 13 May 2012 6

7. Lokální transakce
Sunday 13 May 2012 7

8. Autocommit mode
private void updateSomething() {
• Defaultní chování JDBC
Connection conn = null;
Statement stmt = null;
• Commit po každé operaci try {
conn = ds.getConnection();
stmt = conn.createStatement();
• Možná nekonzistence dat 1 stmt.executeUpdate("update table1");
2 stmt.executeUpdate("update table2");
} finally {
DatabaseUtils.close(conn, stmt);
}
}
Sunday 13 May 2012 8

9. Manuální řízení
• Commit/Rollback private void updateSomething() {
programově Connection conn = ds.getConnection();
Statement stmt = null;
try {
• Nutnost propagovat conn.setAutoCommit(false);
stmt = conn.createStatement();
connection se započatou
stmt.executeUpdate("update table1");
transakcí stmt.executeUpdate("update table2");
conn.commit();
} catch(Exception e) {
conn.rollback();
} finally {
DatabaseUtils.close(conn, stmt);
zahájení transakce }
}
Sunday 13 May 2012 9

10. Globální transakce
Sunday 13 May 2012 10

11. JTA
• JTA je Java EE standard pro
transakce
• Řízení
• Programové/Deklarativní
• Flat model
• Distribuované chování
Sunday 13 May 2012 11

12. Flat model
• All or nothing princip
Sunday 13 May 2012 12

13. Nested model
• Vnořená transakce může být rollbacknutá aniž
by muselo dojít k rollbacku celé transakce
Sunday 13 May 2012 13

14. Transakční atributy
• Transakce s různým chováním
• Propagace transakce
• Izolace transakce
• Rollback pravidla
Sunday 13 May 2012 14

15. Propagace
• Required
• RequiresNew
• Supports
• Mandatory
• NotSupported
Sunday 13 May 2012 15

16. Izolace
• Určuje jak hodně se mohou
transakce ovlivnit
Sunday 13 May 2012 16

17. Read uncommited
Sunday 13 May 2012 17

18. Read commited
Sunday 13 May 2012 18

19. Read repeatable
Sunday 13 May 2012 19

20. Serializable
Sunday 13 May 2012 20

21. Transakce ve Springu
Sunday 13 May 2012 21

22. • Spring podporuje možnost definovat/ovládat transakce
• programově
• deklarativně
• Spring definuje abstraktní transakční API
• to umožňuje stejný přístup k řízení transakcí pro různé
frameworky
• Hibernate, iBatis, JPA, JDBC
• V mnohém přebírá úspěšný koncept EJB
• CMT
• izolace, propagace
Sunday 13 May 2012 22

23. Transakční manažer
• Pro využití transakcí musíme nadefinovat transakční manager beanu
• HibernateTransactionManager
• DataSourceTransactionManager
• JtaTransactionManager
• Podle typu transakčního manageru se definuje i jeho závislost
• DataSourceTransactionManager závisí na datasource
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
Sunday 13 May 2012 23

24. Deklarativní řízení
• Založeno na AOP
• Rollback
RuntimteException
• XML
• Anotace
• @Transactional
Sunday 13 May 2012 24

25. XML
Sunday 13 May 2012 25

26. <beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<aop:aspectj-autoproxy/>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost/booking-demo?useUnicode=true&amp;characterEncoding=UTF-8"/>
<property name="username" value="admin"/>
<property name="password" value="changeit"/>
</bean>
<bean id="userStorageDaoJdbc" class="cz.bookingdemo.dao.UserStorageDaoJdbc" >
<property name="dataSource" ref="dataSource"/>
</bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- the transactional advice (i.e. what 'happens'; see the <aop:advisor/> bean below) -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- the transactional semantics... -->
<tx:attributes>
<!-- all methods starting with 'get' are read-only -->
<tx:method name="get*" read-only="true"/>
<!-- other methods use the default transaction settings (see below) -->
<tx:method name="*"/>
</tx:attributes>
</tx:advice>
<aop:config>
<aop:pointcut id="daoOperation" expression="execution(* cz.bookingdemo.dao.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="daoOperation"/>
</aop:config>
</beans>
Sunday 13 May 2012 26

27. Anotace
Sunday 13 May 2012 27

28. <beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<bean class="cz.sweb.pichlik.springdao.hibernate.UserStorageDaoHibernate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- ... Hibernate session ommited -->
</beans>
@Transactional(readOnly=false, propagation = Propagation.REQUIRED)
public class UserStorageDaoHibernate extends HibernateDaoSupport implements UserStorageDao
{
public void delete(User user) {
getHibernateTemplate().delete(user);
}
@Transactional(readOnly= true)
public User get(long userId) {
return (User) getHibernateTemplate().get(User.class, userId);
}
}
Sunday 13 May 2012 28

29. Výjimky
• běhová (runtime) => vždy rollback
• kontrolovaná (checked) =>
neovlivňuje
• možno změnit chování viz atribut
• rollbackFor
• noRollbackFor
Sunday 13 May 2012 29

30. Programový způsob
• Stará dobrá template method
• TransactionTemplate
• Méně flexibilní pro práci s except.
• netřeba explicitní commit/
rollback
• RuntimeException
• status.setRoolbackOnly()
Sunday 13 May 2012 30

31. TransactionTemplate tt = new TransactionTemplate(txManager);
tt.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
tt.execute(new TransactionCallbackWithoutResult() {
protected void doInTransactionWithoutResult(TransactionStatus status) {
dao.save(user);
dao.update(user);
}
});
Sunday 13 May 2012 31

32. Transakce test
public class MyService {
@Transactional
public void doSomething() {
//code ommited...
}
public void addSomething() {
doSomething();
//code ommited...
deleteSomething();
}
@Transactional
protected void deleteSomething() {
//code ommited...
}
}
Sunday 13 May 2012 32

33. • Nadefinujte pro předchozí DAO objekt transakce
• Vyzkoušejte programový způsob
• transakce nad vice metodami
• vyzkoušejte rollback
• Deklarativní způsob
• anotace
• XML
Sunday 13 May 2012 33