14
Apr
10

Declarative Transactions Using Spring Framework


This page demonstrates very simple 1 resource (Local Transaction) commit and roll-back capabilities of the spring framework. The example on this page is heavy on practice and light on theory. For more information about spring transaction please check the resources section below for spring framework documentation.

Background

Based on the default behavior, when the application throws a run time exception any method that is defined to be transactional issues a roll-back on whatever resource is currently participating in the transaction. To define a method as transactional just put an @Transactional annotation before it.

Requirements

  • Java 5
  • MySQL installed and configured (not required if you just want to follow along)
  • Maven – (tutorial available on the right nav)
  • Basic understanding of Transactions

Implementation

The following example will demonstrate the transaction capabilities of the spring framework. Consider it a very basic “hello world” program for transactional code.

First step… Create the table… Its important that you specify the InnoDB engine. Otherwise the table will not support transactional capabilities.

Issue the following create statement in the mySQL database. If you don’t have access to a database to do this then just follow along with me below.

CREATE TABLE `test`.`test_table` (
`id` SMALLINT NOT NULL AUTO_INCREMENT ,
`data` TEXT NULL ,
PRIMARY KEY ( `id` )
) ENGINE = InnoDB

The Second step is to create a project using Maven archetype. Open up the command prompt and navigate to an empty directory.

mvn archetype:generate -DarchetypeArtifactId=maven-archetype-quickstart
groupId: com.test
artifactId: springTXTest

Answer the rest of the questions with defaults “Just hit the enter key”

Next, add a couple of entries in the dependencies section. Use the following pom.xml file as a guide. The 2 additional dependencies you need are the spring framework 2.5.5 and the mysql jdbc driver files. Both of these items are available using the maven central repository.

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelversion>4.0.0</modelversion>
  <groupId>com.test</groupId>
  <artifactId>springTXTest</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>springTXTest</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring</artifactId>
        <version>2.5.5</version>
    </dependency>
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.9</version>
	</dependency>
  </dependencies>
</project>

The applicationContext sets up the data source and transaction manager. Replace the database url, username, password “xxxx” with actual values.

src/main/resources/com/test/applicationContext.xml

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context" xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

<!-- The following <span class="hiddenGrammarError" pre="following ">is used</span> for the @Repository, @Component, @Service, @Controller -->
	<context:component-scan base-package="com.test"></context:component-scan>

<!-- The following <span class="hiddenGrammarError" pre="following ">is used</span> for the @Autowired, @Required, @Resource etc... -->
	<context:annotation-config></context:annotation-config>

<!-- The following <span class="hiddenGrammarError" pre="following ">is used</span> for the @Transactional -->
	<tx:annotation-driven transaction-manager="txManager"></tx:annotation-driven>

<bean name="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	mysql.jdbc.Driver">
	xxxx:3306/test">
	<property name="username" value="xxxx"></property>
	<property name="password" value="xxxx"></property>
<!--<span class="hiddenSpellError" pre=""-->bean>

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

The following is just an interface.

src/main/java/com/test/TestTransactionDataManager.java

package com.test;

public interface TestTransactionDataManager {
	public abstract Number writeData(String data);
}

The following DataManager inserts a row into the test_table using SimpleJdbcInsert. Since SimpleJDBCInsert is aware of any ongoing transactions the insert will happen in a transaction safe way. You could also use JdbcTemplate to achieve the same result.

src/main/java/com/test/TestTransactionDataManagerImpl.java

package com.test;

import java.util.HashMap;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
import org.springframework.stereotype.Repository;

/**
 * This data manager is used to test the transactional capabilities
 * of the spring framework. The code below is not marked as transactional
 * however it participates in one when called from a transactional method.
 */
@Repository("testTransactionDataManager")
public class TestTransactionDataManagerImpl implements TestTransactionDataManager {
	private SimpleJdbcInsert simpleInsert;

	@Required
	@Autowired
	public void setDataSource(DataSource dataSource) {
		simpleInsert = new SimpleJdbcInsert(dataSource).withTableName(
				"test_table").usingGeneratedKeyColumns("id");
	}
	/**
	 * Responsible for writing data to a transactional resource.
	 * @param data
	 */
	public Number writeData(String data) {
		Map<string, object=""> parameters = new HashMap<string, object="">(1);
        parameters.put("data", data);
        Number newId = simpleInsert.executeAndReturnKey(parameters);
        return newId.longValue();
	}
}

Just an interface…

src/main/java/com/test/TestTransactionModel.java

package com.test;

public interface TestTransactionModel {
	public abstract void writeDataWithTx();
	public abstract void writeDataWithOutTx();
	public abstract void writeDataWithMultipleCalls();
}

This is our Model class. The model layer is a natural place to define unit of work. Model methods are called from “control layer” in the MVC architecture. (Struts actions, SpringMVC Command, or Servlets) THERE SHOULD BE AT MOST ONE call to a transaction enabled model method to get a the “unit of work” behavior. Otherwise if you have more than one call to these methods and one succeeds and the other fails you will not get the “unit of work” behavior. Please keep this in mind… Only one call to a transactional method from the “control layer”.

src/main/java/com/test/TestTransactionModelImpl.java

package com.test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Required;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("testTransactionModel")
public class TestTransactionModelImpl implements TestTransactionModel {
	private TestTransactionDataManager testTransactionDataManager;

	/**
	 * This method will throw a runtime exception and the data will be rolled
	 * back.
	 */
	@Transactional  // remember @Transaction for public methods only!
	public void writeDataWithTx() {
		System.out.println("writing data within a transaction");
		Number number = testTransactionDataManager.writeData("writeDataWithTx");
		System.out.println("wrote item: " + number);
		System.out.println("issuing runtime exception in transactional method");
		throw new RuntimeException();
	}

	/**
	 * This method will throw a runtime exception and the data will still be
	 * persisted.
	 */
	public void writeDataWithOutTx() {
		System.out.println("writing data without a transaction");
		Number number = testTransactionDataManager.writeData("writeDataWithTx");
		System.out.println("wrote item: " + number);
		System.out.println("issuing runtime exception. you will still see this record in db.");
		throw new RuntimeException();
	}

	/**
	 * This method tests the capability of calling another method that is
	 * declared to be transactional where the second method throws an exception
	 * but this method still commits.
	 */
	@Transactional
	public void writeDataWithMultipleCalls() {
		try {
			writeDataWithTx();
		} catch(RuntimeException ex) {
			System.out.println("suppressing runtimeexception and committing anyway you should see this record in DB");
		}
	}
	@Autowired
	@Required
	public void setTestTransactionDataManager(
			TestTransactionDataManager testTransactionDataManager) {
		this.testTransactionDataManager = testTransactionDataManager;
	}
}

App.java#main() method is our entry point into the system. The doIt() method will call methods on the model layer. Catch any exceptions and continue processing the rest of the model methods.

src/main/java/com/test/App.java

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
	private ApplicationContext context = new ClassPathXmlApplicationContext("com/test/applicationContext.xml");

	public void doIt() {
		TestTransactionModel model = (TestTransactionModel)context.getBean("testTransactionModel");

		try {
			model.writeDataWithOutTx();
		} catch (RuntimeException ex) { // do nothing }

		try {
			model.writeDataWithTx();
		} catch (RuntimeException ex) { // do nothing }

		try {
			model.writeDataWithMultipleCalls();
		} catch (RuntimeException ex) { // do nothing }
	}

	public App() {
		doIt();
	}
	public static void main(String[] args) {
		new App();
	}
}

Results

The following is the console output of the program.

writing data without a transaction
wrote item: 1
issuing runtime exception. you will still see this record in db.
writing data within a transaction
wrote item: 2
issuing runtime exception in transactional method
writing data within a transaction
wrote item: 3
issuing runtime exception in transactional method
suppressing runtimeexception and committing anyway you should see this record in DB

Checking the database you will see that only row id’s 1 and 3 got saved on the table.

Resources

That’s all for now!

Advertisements

1 Response to “Declarative Transactions Using Spring Framework”


  1. April 15, 2010 at 9:41 am

    Nice information, I really appreciate the way you presented.Thanks for sharing..


Leave a Reply

Please log in using one of these methods to post your comment:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s


Enter your email address to subscribe to this blog and receive notifications of new posts by email.

Join 78 other followers

April 2010
S M T W T F S
« Mar   May »
 123
45678910
11121314151617
18192021222324
252627282930  

Blog Stats

  • 822,357 hits

%d bloggers like this: