Transaction Management with the Spring Framework

1. Transaction Management with the Spring Framework Jürgen Höller http://www.springframework.com juergen@interface21.com

2. Agenda • Introduction • Transaction Demarcation • Transaction Managers • Data Access • ORM Transactions • Summary

3. Introduction (1) • Spring is a general application framework • addresses overall application architecture • internal structure of an application • focus on consistent programming model • decoupling from concrete runtime environment • supports any kind of Java application • special support for J2EE environments • Open source project on SourceForge • founded by Rod Johnson & Jürgen Höller • Apache license

4. Introduction (2) • Foundation: core container • Inversion of Control • general lifecycle management • for any kind of application components • Dependency Injection • wiring between application components • instead service lookups • Further foundation: AOP framework • proxy-based AOP for POJOs • flexible combination of interceptors

5. Introduction (3) public class PetStoreImpl implements PetStoreFacade { private OrderDao orderDao; private ItemDao itemDao; ... public void setOrderDao(OrderDao orderDao) { this.orderDao = orderDao; } public void setItemDao(ItemDao itemDao) { this.itemDao = itemDao; } ... public void insertOrder(Order order) { this.orderDao.insertOrder(order); this.itemDao.updateQuantity(order); }}

6. Introduction (4) <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"> <property name="driverClassName"><value>...</value></property> <property name="url"><value>...</value></property> <property name="username"><value>...</value></property> <property name="password"><value>...</value></property> </bean> <bean id="itemDao" class="org.springframework.samples.jpetstore.dao.ibatis.SqlMapItemDao"> <property name="dataSource"><ref bean="dataSource"/></property> <property name="sqlMap"><ref bean="sqlMap"/></property> </bean> <bean id="petStore"class="org.springframework.samples.jpetstore.domain.logic.PetStoreImpl"> <property name="orderDao"><ref bean="orderDao"/></property> <property name="itemDao"><ref bean="itemDao"/></property> </bean>

7. Introduction (5) • Higher-level functionality on top • transaction management • data access support • lightweight remoting, etc • Subsystems can be used individually • e.g. just Spring transaction management • programmatically, in a plain library style • Subsystems integrate nicely as a stack • transaction management within core container • declarative transactions via AOP

8. Introduction (6) • Spotlight: transaction management • separates transaction demarcation from theconcrete backend transaction manager • consistent transaction demarcation style • seamless support for both native transactionsand J2EE server transactions (JTA) • flexible replacement for EJB CMT • Relevant for many applications • important part of overall application architecture • in general, any kind of data access should operate within a transaction

9. Transaction Demarcation (1) • Transaction definition • propagation behavior • defaults to PROPAGATION_REQUIRED • isolation level • defaults to ISOLATION_DEFAULT • read-only flag • defaults to false • transaction timeout • defaults to none • transaction name • defaults to current method name (in declarative case)

10. Transaction Demarcation (2) • Propagation behaviors • supporting all EJB CMT propagation codes • SUPPORTS • REQUIRED • REQUIRES_NEW • NOT_SUPPORTED • MANDATORY • NEVER • also supports NESTED • if supported by underlying transaction manager

11. Transaction Demarcation (3) • Programmatic demarcation a la JTA • direct PlatformTransactionManager usage • TransactionTemplate with TransactionCallback • Declarative demarcation for arbitrary POJOs • XML-based proxy definitions • TransactionProxyFactoryBean definition per target bean • auto-proxy creator mechanism • centralized XML transaction metadata for multiple beans • instead of specific transaction proxy definitions • transaction metadata in Java source code • Jakarta Commons Attributes • J2SE 5.0 annotations

12. Transaction Demarcation (4) • TransactionTemplate usage example public class PetStoreImpl implements PetStoreFacade {private PlatformTransactionManager ptm; public void setTransactionManager(PlatformTransactionManager ptm) { this.ptm = ptm; } public void insertOrder(Order order) { TransactionTemplate tt = new TransactionTemplate(this.ptm); tt.execute(new TransactionCallback() { public Object doInTransaction(TransactionStatus ts) {// perform some transactional operations ... return null; } }); }}

13. Transaction Demarcation (5) <bean id="petStoreTarget" class="org.springframework.samples.jpetstore.domain.logic.PetStoreImpl"> <property name="orderDao"><ref bean="orderDao"/></property> <property name="itemDao"><ref bean="itemDao"/></property> </bean> <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"/> <bean id="petStore" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"> <property name="transactionManager"><ref bean="transactionManager"/></property> <property name="target"><ref bean="petStoreTarget"/></property> <property name="transactionAttributes"> <props> <prop key="insert*">PROPAGATION_REQUIRED</prop> <prop key="update*">PROPAGATION_REQUIRED</prop> <prop key="*">PROPAGATION_REQUIRED,readOnly</prop> </props> </property> </bean>

14. Transaction Demarcation (6) • Example for J2SE 5.0 annotations public class PetStoreImpl implements PetStoreFacade {private OrderDao orderDao; private ItemDao itemDao; ... public void setOrderDao(OrderDao orderDao) { this.orderDao = orderDao; } public void setItemDao(ItemDao itemDao) { this.itemDao = itemDao; } ...@Transactional public void insertOrder(Order order) { this.orderDao.insertOrder(order); this.itemDao.updateQuantity(order); }}

15. Transaction Managers (1) • Native transaction managers • JDBC: DataSourceTransactionManager • Hibernate: HibernateTransactionManager • TopLink: TopLinkTransactionManager • JDO: JdoTransactionManager • etc • Native strategies work in any environment • but only against a single database! • no distributed transaction coordination • leverage full power of underlying resource • isolation levels, savepoints, etc

16. Transaction Managers (2) • JTA-based transaction coordinator • Spring's JtaTransactionManager adapter • using the Java Transaction API to talk to anexternal transaction coordinator • typically using the standard XA protocol to coordinate heterogeneous transactional resources • Typically: J2EE server's JTA subsystem • delegates to JTA UserTransaction • a standard J2EE component, available from JNDI • optionally accesses JTA TransactionManager • server-specific, for transaction suspension • automatically detected on most J2EE servers

17. Transaction Managers (3) • Special support for extended JTA • on specific J2EE servers • through special JtaTransactionManager subclasses • WebLogicJtaTransactionManager • support for WebLogic's JTA extensions • transaction names for WebLogic's transaction monitor(part of the administration console) • enforced transaction resume in all cases • per-transaction isolation levels • runs on WebLogic 7.0+ • Support for other extensions on the roadmap

18. Transaction Managers (4) • Transaction manager is a deployment choice • application code is completely decoupled from concrete transaction infrastructure • application specifies desired transaction semantics; transaction manager provides them at runtime • Seamless switching between native transactions and JTA transactions • between non-J2EE and J2EE environments • e.g.: run integration tests with native transactions • e.g.: run with J2EE transactions in production • or even run with native transactions in production • if all you need is transactions for a single database

19. Transaction Managers (5) • Typical scenarios for JDBC • standalone application / integration tests • native JDBC DataSourceTransactionManager • J2EE web application running on Tomcat • native JDBC DataSourceTransactionManager • J2EE web application running on WebLogic • J2EE transactions via standard JtaTransactionManager • or WebLogicJtaTransactionManager for advanced support • Could also use third-party JTA provider • for standalone application or Tomcat • for example: ObjectWeb JOTM • or standalone Geronimo transaction manager

20. Data Access (1) • Data access objects need to access transactional resources • as seamlessly as possible • easy access to scoped transactional resource • automatically participate in transactions • ideally: run non-transactionally else • JDBC: talk to transactional DataSource • returns active Connection for current transaction • for example: J2EE server DataSource • fetched from JNDI via JndiObjectFactoryBean • or transactional DataSource proxy • for local connection pool

21. Data Access (2) • Two different approaches • use native resource API only • or use Spring's DAO implementation helpers • Native JDBC API • talk to provided transactional DataSource • Native Hibernate API • use SessionFactory.getCurrentSession() on provided SessionFactory • Native TopLink API • use Session.getActiveUnitOfWork() onprovided Session

22. Data Access (3) • Spring provides DAO implementation helpers • convenient template classes • implicit access to resources • many operations become one-liners • no try/catch blocks anymore • Pre-built integration classes for different APIs • JDBC: JdbcTemplate • Hibernate: HibernateTemplate • TopLink: TopLinkTemplate • JDO: JdoTemplate • etc

23. Data Access (4) • Further benefit: common DAO exceptions • well-defined exceptions at DAO interface level • do not couple caller to DAO implementation strategy • even if specific exception conditions need to be handled • Spring's DataAccessException hierarchy • independent of JDBC, Hibernate, TopLink, JDO, etc • unchecked (= a RuntimeException), as most data access failures are not recoverable • subclasses like OptimisticLockingFailureExceptionand DataAccessResourceFailureException

24. Data Access (5) • Example for a DAO based on Spring's JdbcTemplate public class ExampleDao extends JdbcDaoSupport { public void clearDatabase() throws DataAccessException {getJdbcTemplate().update("DELETE FROM imagedb");  }  public void deleteImage(int imageId) throws DataAccessException {getJdbcTemplate().update("DELETE FROM imagedb WHERE id=?", new Object[] {new Integer(imageId)});  }  public int getNrOfImages() throws DataAccessException {    return getJdbcTemplate().queryForInt( "SELECT COUNT(*) FROM imagedb");  }}

25. Data Access (6) • Example for a DAO based on Spring's HibernateTemplate public class ExampleHibernateDao extends HibernateDaoSupport { public List getVets() throws DataAccessException {    return getHibernateTemplate().find( "from Vet vet order by vet.lastName, vet.firstName");  }  public List findOwners(String lastName) throws DataAccessException {    return getHibernateTemplate().find( "from Owner owner where owner.lastName like ?", lastName + "%");  }  public Owner loadOwner(int id) throws DataAccessException {    return getHibernateTemplate().load(Owner.class, new Integer(id));  }}

26. Data Access (7) • Alternative: a plain Hibernate DAO public class ExampleHibernateDao { private SessionFactory sessionFactory; public void setSessionFactory(SessionFactory sf) {this.sessionFactory = sf; } public List getVets() {    return this.sessionFactory.getCurrentSession(). createQuery("from Vet vet order by vet.lastName, vet.firstName"). list();  }  public Owner loadOwner(int id) {    return this.sessionFactory.getCurrentSession(). load(Owner.class, new Integer(id));  }}

27. ORM Transactions (1) • Object/Relational Mapping tools require proper transaction integration • synchronization with transactions • cache callbacks on commit / rollback • required for transactional cache handling • scoping of ORM resources • one Hibernate Session per transaction • one TopLink UnitOfWork per transaction • one JDO PersistenceManager per transaction • required for proper transaction isolation

28. ORM Transactions (2) • ORM tools usually support two different transaction modes • native transactions through ORM API • participating in global JTA transactions • -> different programming model! • Spring supports consistent transaction demarcation across all environments • native transactions or global JTA • same transaction demarcation • same DAO implementation model

29. ORM Transactions (3) • Spring provides pre-built integration forall major ORM providers • Hibernate 2.1 / 3.x • TopLink 9.0.4 / 10.1.3 • JDO 1.0 / 2.0 • Apache OJB 1.0 • Set of integration classes per strategy • factories for ORM resources • native transaction managers • DAO implementation helpers

30. ORM Transactions (4) • Example: Hibernate • Spring's LocalSessionFactoryBean • setup of Hibernate SessionFactory • Spring's HibernateTransactionManager • native transactions against single database • Spring's HibernateTemplate • implicit management of Hibernate Sessions • or use SessionFactory.getCurrentSession() • Spring's OpenSessionInViewFilter • seamless lazy loading during view rendering

31. ORM Transactions (5) • Example: TopLink • Spring's LocalSessionFactoryBean • setup of TopLink SessionFactory /TopLink master Session • Spring's TopLinkTransactionManager • native transactions against single database • Spring's TopLinkTemplate • implicit management of TopLink Session / UnitOfWork • or use Session.getActiveSession() / Session.getActiveUnitOfWork()

32. ORM Transactions (6) • Newest kid on the block: JPA • Java Persistence API 1.0 • aka "EJB3 persistence" / "JSR-220 persistence" • part of the forthcoming J2EE 5.0 • optimized for application servers • explicit, strong integration with J2EE transactions • but also usable in a standalone fashion • Spring will support JPA persistence • as further ORM strategy, analogous to JDO • use Spring's transaction managementwith JPA-based DAOs

33. ORM Transactions (7) • Example for a plain JPA DAO, using the "shared EntityManager proxy" model public class ExampleJpaDao { private EntityManager entityManager; public void setEntityManager(EntityManager entityManager) {this.entityManager = entityManager; } public List getVets() {    return this.entityManager.createQuery("from Vet vet order by vet.lastName, vet.firstName"). getResultList();  }  public Owner loadOwner(int id) {    return this.entityManager.find(Owner.class, new Integer(id));  }}

34. Summary (1) • Spring provides generic transaction management for any kind of Java application • consistent programming model • consistent transaction demarcation • seamless switching between different transaction managers • Declarative transaction demarcation • XML-based proxy definitions • JDK 5.0 annotations • alternative: programmatic demarcation

35. Summary (2) • Seamless switching between native transactions and JTA transactions • consistent programming model across different deployment scenarios • leverage J2EE server when available,while still being able to run outside of J2EE • Full declarative transactions even on Tomcat! • on the other end of the spectrum:WebLogic JTA extensions supported as well • choose deployment environment according to your service needs (scaling both up and down)

36. Summary (3) • Explicit support for ORM tools • transaction synchronization • scoping of ORM resources • consistent transaction demarcation across native transactions and JTA transactions • with consistent ORM semantics • All major ORM providers supported • Hibernate, TopLink, JDO, JPA, etc • integration comes out-of-the-box! • maintained by Spring team

37. http://www.springframework.orghttp://www.springframework.com