In the previous tutorial, I introduced you to the concept of a transaction in the database, which helps us to ensure data integrity and consistency. Spring also supports us to manage transactions, allowing us to focus on developing business logic without worrying about the integrity of the data. Spring supports many types of transaction management but in this tutorial, I just introduced you to JDBC transaction management in Spring.
First, I will create a new Maven project as an example:
In this project, I declare the Spring framework dependencies as follows: in addition to spring-context for Spring Core, there is spring-jdbc for using the JDBC API and spring-tx for transaction management.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>${spring-framework.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-tx</artifactId> <version>${spring-framework.version}</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring-framework.version}</version> </dependency> |
with the property of “spring-framework.version” is:
|
1 2 3 |
<properties> <spring-framework.version>6.1.10</spring-framework.version> </properties> |
I will use JDBC with MySQL database, so I will also add MySQL driver to our project dependency.
|
1 2 3 4 5 |
<dependency> <groupId>com.mysql</groupId> <artifactId>mysql-connector-j</artifactId> <version>9.0.0</version> </dependency> |
The database is defined with the following structure:
|
1 2 3 4 5 |
CREATE TABLE account ( id INT AUTO_INCREMENT PRIMARY KEY, name VARCHAR(45) NOT NULL, amount DECIMAL ); |
In addition, we need to mention Spring’s configuration file, spring.xml, located in the /src/main/resource directory with the following content:
|
1 2 3 4 5 |
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans> |
In this example, we will create a small bank application that allows us to transfer funds from account A to account B. The transfer process consists of two steps: subtracting money from account A and adding money to account B. Any exceptions that occur during the transfer process, will all be rolled back.
OK, now I’m going to detail the classes in our example.
First, we must mention the AccountDAO interface and its implementation: the AccountDAOImpl.
These classes will help us manipulate the database directly.
The contents of these classes are as follows:
AccountDAO
|
1 2 3 4 5 6 7 8 9 10 |
package com.huongdanjava.springjdbctransactionmanagement.dao; import java.math.BigDecimal; public interface AccountDAO { BigDecimal getCurrentAmount(int id); void updateAmount(int id, BigDecimal amount); } |
In this interface, I declare two methods, used to directly manipulate the database to get the current amount in an account and update the amount for an account.
AccountDAOImpl:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
package com.huongdanjava.springjdbctransactionmanagement.dao.impl; import java.math.BigDecimal; import java.sql.ResultSet; import java.sql.SQLException; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataAccessException; import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.jdbc.core.ResultSetExtractor; import org.springframework.stereotype.Repository; import com.huongdanjava.springjdbctransactionmanagement.dao.AccountDAO; @Repository public class AccountDAOImpl implements AccountDAO { @Autowired private JdbcTemplate jdbcTemplate; public BigDecimal getCurrentAmount(int id) { String sql = "SELECT amount FROM account WHERE id=" + id; return jdbcTemplate.query(sql, new ResultSetExtractor<BigDecimal>() { public BigDecimal extractData(ResultSet resultSet) throws SQLException, DataAccessException { if (resultSet.next()) { return BigDecimal.valueOf(resultSet.getInt("amount")); } return BigDecimal.ZERO; } }); } public void updateAmount(int id, BigDecimal amount) { String sql = String.format("UPDATE account SET amount=%f WHERE id=%d", amount, id); jdbcTemplate.execute(sql); } } |
I already declared this class in the Spring container using the @Repository annotation and the JdbcTemplate object to manipulate the database.
The second thing is the AccountService interface and its implementation AccountServiceImpl.
AccountService
|
1 2 3 4 5 6 7 8 |
package com.huongdanjava.springjdbctransactionmanagement.service; import java.math.BigDecimal; public interface AccountService { void transfer(int sourceId, int destId, BigDecimal amount) throws Exception; } |
This interface has only one method that helps us transfer money from one account to another.
AccountServiceImpl
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
package com.huongdanjava.springjdbctransactionmanagement.service.impl; import java.math.BigDecimal; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import com.huongdanjava.springjdbctransactionmanagement.dao.AccountDAO; import com.huongdanjava.springjdbctransactionmanagement.service.AccountService; @Service public class AccountServiceImpl implements AccountService { @Autowired private AccountDAO accountDAO; @Transactional(rollbackFor = Exception.class) public void transfer(int sourceId, int destId, BigDecimal amount) throws Exception { BigDecimal sourceAmount = accountDAO.getCurrentAmount(sourceId); BigDecimal destAmount = accountDAO.getCurrentAmount(destId); // Update source account accountDAO.updateAmount(sourceId, sourceAmount.subtract(amount)); // Update dest account accountDAO.updateAmount(destId, destAmount.add(amount)); } } |
For this class, I used @Service annotation to declare it in Spring’s container and used the AccountDao interface to manipulate the database.
Another thing to note is that on the transfer() method, I declare an @Transactional annotation with the rollbackFor property having the value “Exception.class”. This annotation, the purpose is to specify that this method will be executed in a transaction. For any operation that fails in this method, all previous changes in this method will be rolled back.
Next, we will look at Spring’s configuration file.
There are some declarations that we have to do:
– Enable the auto component scan for the classes that we have declared using the @Repository annotation and @Service.
|
1 |
<context:component-scan base-package="com.huongdanjava.springjdbctransactionmanagement"/> |
If someone does not know about the auto component scan in Spring, can refer to this tutorial.
– Configure Datasource to manipulate the database.
|
1 2 3 4 5 6 7 8 9 10 |
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/example"/> <property name="username" value="root"/> <property name="password" value="123456"/> </bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <constructor-arg ref="dataSource"/> </bean> |
– Enable transaction management for our application.
|
1 2 3 4 5 |
<tx:annotation-driven proxy-target-class="true" transaction-manager="transactionManager"/> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean> |
In the above declaration, the tx:annotation-driven tag is used to declare to Spring that we will use the annotation to handle the transaction. The transaction-manager attribute used to declare the bean ID of the class handles transactions. As you can see, here we use the DataSourceTransactionManager object to handle transactions.
OK, so we have declared and implemented the necessary classes. In the last step, we will implement this application.
For example, in our database there are two accounts A and B with the following information:
I will now write the code to make the transfer of $10 from account A to account B. The content of the application class will be as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
package com.huongdanjava.springjdbctransactionmanagement; import java.math.BigDecimal; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.huongdanjava.springjdbctransactionmanagement.service.AccountService; public class Application { public static void main(String[] args) throws Exception { ApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml"); AccountService as = (AccountService) ctx.getBean("accountServiceImpl"); as.transfer(1, 2, BigDecimal.valueOf(10)); } } |
Result:
This is the result in case everything is OK.
If everything is not OK then?
Suppose now, after deducting money from account A, I check the remaining money in account A. If the amount is less than $20 then I do not allow the transfer by throwing an Exception as follows:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 |
package com.huongdanjava.springjdbctransactionmanagement.service.impl; import java.math.BigDecimal; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import com.huongdanjava.springjdbctransactionmanagement.dao.AccountDAO; import com.huongdanjava.springjdbctransactionmanagement.service.AccountService; @Service public class AccountServiceImpl implements AccountService { @Autowired private AccountDAO accountDAO; @Transactional(rollbackFor = Exception.class) public void transfer(int sourceId, int destId, BigDecimal amount) throws Exception { BigDecimal sourceAmount = accountDAO.getCurrentAmount(sourceId); BigDecimal destAmount = accountDAO.getCurrentAmount(destId); // Update source account BigDecimal subtract = sourceAmount.subtract(amount); accountDAO.updateAmount(sourceId, subtract); if (subtract.compareTo(BigDecimal.valueOf(20)) <= 0) { throw new Exception("Not allow send money if current amount is less than 20$"); } // Update dest account accountDAO.updateAmount(destId, destAmount.add(amount)); } } |
when running with the database as follows:
An exception will occur:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
Exception in thread "main" java.lang.Exception: Not allow send money if current amount is less than 20$ at com.huongdanjava.springjdbctransactionmanagement.service.impl.AccountServiceImpl.transfer(AccountServiceImpl.java:26) at com.huongdanjava.springjdbctransactionmanagement.service.impl.AccountServiceImpl$$FastClassBySpringCGLIB$$9ca7be9f.invoke(<generated>) at org.springframework.cglib.proxy.MethodProxy.invoke(MethodProxy.java:204) at org.springframework.aop.framework.CglibAopProxy$CglibMethodInvocation.invokeJoinpoint(CglibAopProxy.java:738) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157) at org.springframework.transaction.interceptor.TransactionInterceptor$1.proceedWithInvocation(TransactionInterceptor.java:99) at org.springframework.transaction.interceptor.TransactionAspectSupport.invokeWithinTransaction(TransactionAspectSupport.java:282) at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:96) at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179) at org.springframework.aop.framework.CglibAopProxy$DynamicAdvisedInterceptor.intercept(CglibAopProxy.java:673) at com.huongdanjava.springjdbctransactionmanagement.service.impl.AccountServiceImpl$$EnhancerBySpringCGLIB$$c260db33.transfer(<generated>) at com.huongdanjava.springjdbctransactionmanagement.Application.main(Application.java:15) |
and nothing changes in the database.
