Transaction with Spring-Hibernate by Annotation

In this tutorial, we are going to explain how to configure and perform transaction management within the database using Spring Framework with Hibernate and Annotations. The transaction management involves managing database transactions such as -

Deleting a customer account from database.
Inserting a customer account record in the database.
Depositing an amount in an account.
Withdrawing an amount from an account.

What Spring-Hibernate transaction management by Annotation does?

The Spring-Hibernate transaction management by Annotation makes sure :

The transaction operations i.e. amount deposit or withdrawn should be atomic i.e. either of these operations should happen entirely or nothing at all.

The transaction operations trying to access the shared data at the same time, should only be executed in isolation. i.e. one transaction at a time.

In case of any exceptional or erroneous situation taking place(while any of the deposit or withdraw transaction operations were being performed), the effect of these operations should be rolled back to maintain the consistency of data and not leave any anomalous data in the database.

How Spring-Hibernate transaction management by Annotation works?

To perform transaction management within the database using Spring Framework with Hibernate and Annotations, we need an access to the source code to edit it and add @Transactional Annotation to class and methods involved in performing the transaction operations.

Note :

Before we proceed with the example of database transaction management, we would first need to configure Spring Framework to work with Hibernate. To perform this, we will use a very important template class provided by Spring Framework, named - HibernateTemplate, which provides different methods for querying and retrieving data from the database.

Creating the Java class - Customer_Account

We are going to create a java class named Customer_Account within the decodejava package and this class contains -

An int property named id.
A String property named name.
A String property named address.
A String property named age.

This class and its properties will be annotated with @Entity, @Table, @Id, @Column, @GeneratedValue annotations, which allow us to create a database table with a primary key id and columns without using a mapping resource xml file. For those who are unaware of these Hibernate Annotations, please read our article Hibernate with Annotations.

Besides this, we are also going to define a couple of getter and setter methods within this class to set the above mentioned properties of Customer class.

package decodejava;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table (name ="Customer_Account")
public class Customer_Account 
{
	@Id
	@Column (name = "ID")
	@GeneratedValue
	int id;
	
	@Column (name = "Name")
	String name;
	
	@Column (name = "Amount")
	int amount;
	
	@Column (name = "Age")
	int age;
	
	//Default Constructor
	public Customer_Account() 
	{
	}

	//Paramaterized Constructor
	public Customer_Account(int id, String name, int amount, int age) 
	{
		this.id = id;
		this.name = name;
		this.amount = amount;
		this.age = age;
	}


	public String getName() 
	{
		return name;
	}
	
	
	public void setName(String name) 
	{
		this.name = name;
	}
	
	
	public int getAmount() {
		return amount;
	}


	public void setAmount(int amount) {
		this.amount = amount;
	}


	public int getAge() 
	{
		return age;
	}
	
	
	public void setAge(int age) 
	{
		this.age = age;
	}
	
	
	public int getId() 
	{
		return id;
	}


	public void setId(int id) 
	{
		this.id = id;
	}

}

Class performing data access operations(DAO) using Spring

Next, we are going to add another Java class named CustomerDAO this class will contain separate methods to perform database operations using methods of Spring Framework template class HibernateTemplate, to perform Hibernate operations such as -

Creating a table to contain records of customer accounts in the database,

Getting all the records from a database table,

Getting the total count of all the records from a database table, and,

Getting all the account details from the database.

Besides the above mentioned database operations, this class will also contain separate methods(headed by @Transactional Annotation) to perform transaction operations such as -

Performing a transaction operation i.e. adding a new customer account to the database.
Performing a transaction operation i.e. deleting a customer account from the database.
Performing a transaction operation i.e. depositing an amount in an account.
Performing a transaction operation i.e. withdrawing an amount from an account.

This class is also going to contain a HibernateTemplate property named hibernateTemplate. This hibernateTemplate property will be assigned a value by the Spring Container using its respective setter methods, when the CustomerDAO bean is created by it using the configuration xml file(to be created in the upcoming section).

package decodejava;

import java.util.List;
import org.springframework.orm.hibernate5.HibernateTemplate;
import org.springframework.transaction.annotation.Transactional;


public class CustomerDAO 
{
private HibernateTemplate hibernateTemplate;
	
	
	//Getter for HibernateTemplate
	public HibernateTemplate getHibernateTemplate() {
		return hibernateTemplate;
	}

	
	//Setter for HibernateTemplate
	public void setHibernateTemplate(HibernateTemplate hibernateTemplate) 
	{
		this.hibernateTemplate = hibernateTemplate;
	}
	
	
	//Adding a customer
	@Transactional
	public void addCustomer(Customer_Account c)
	{
		hibernateTemplate.save(c);
	}
	
	
	//Deleting a customer
	@Transactional
	public void deleteCustomer(int id)
	{		
		Customer_Account c=hibernateTemplate.get(Customer_Account.class,id);
		hibernateTemplate.delete(c);
	}
	
	
	//Extracting a count of all the customers
	public int countCustomer()
	{
		List<Customer_Account> list =hibernateTemplate.loadAll(Customer_Account.class); 
		return list.size();
		
	}
	
	
	//Getting a List of all customers from database
	public List<Customer_Account> getAllCustomer()
	{		
		List<Customer_Account> list =hibernateTemplate.loadAll(Customer_Account.class);  
		return list;
	}
	
	
	@Transactional
	public void depositAmount(int id, int amount)
	{
		Customer_Account cust = getHibernateTemplate().get(Customer_Account.class, id);
		cust.setAmount(cust.getAmount() + amount);
		getHibernateTemplate().update(cust);		
	}
	
	
	
	
	@Transactional
	public void withdrawAmount(int id, int amount)
	{
		Customer_Account cust = getHibernateTemplate().get(Customer_Account.class, id);
		cust.setAmount(cust.getAmount() - amount);
		getHibernateTemplate().update(cust);				
	}
}

Adding the Utility class that calls the Spring API

Next, we are going to create another class named - Utility, which is a simple java class.

Utility.java

package decodejava;

import java.util.List;

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

public class Utility {

	public static void main(String[] args) 
	{
		ApplicationContext context = new FileSystemXmlApplicationContext("classpath:config.beans.xml");
		CustomerDAO customerDAO = context.getBean("CustomerDAOBean",CustomerDAO.class);
		
		
		System.out.println("Adding the customers");
		customerDAO.addCustomer(new Customer_Account(1, "First Customer",1000, 23));
		customerDAO.addCustomer(new Customer_Account(2, "Second Customer", 2000, 27));
		customerDAO.addCustomer(new Customer_Account(3, "Third Customer", 3000, 21));
		
		
		
		System.out.println("Getting all the customers from the database");
		List<Customer_Account> allCustomers = customerDAO.getAllCustomer();
		for(Customer_Account cust : allCustomers)
		{
			System.out.println("Customer ID : " + cust.getId());
			System.out.println("Customer Name : " + cust.getName());
			System.out.println("Customer Balance Amount : " + cust.getAmount());
			System.out.println("Customer Age : " + cust.getAge());
			
		}
	
		
		System.out.println("Getting the total count of all the Customers");
		System.out.println("Total Customers : " + customerDAO.countCustomer());
		
		
		System.out.println("Deleting a Customer");
		customerDAO.deleteCustomer(2);
		
		System.out.println("Getting the new total count of all the Customers after deleting a customer");
		System.out.println("Total Customers : " + customerDAO.countCustomer());
		
		
		System.out.println("A customer with id = 1, is depositing an amount of 20000");
		customerDAO.depositAmount(1, 20000);
		
		System.out.println("A customer with id = 3, is withdrawing an amount of 500");
		customerDAO.withdrawAmount(3, 500);;
		
		
		
		System.out.println("Getting all the customers from the database");
		List<Customer_Account> allCustomers2 = customerDAO.getAllCustomer();
		for(Customer_Account cust : allCustomers2)
		{
			System.out.println("Customer ID : " + cust.getId());
			System.out.println("Customer Name : " + cust.getName());
			System.out.println("Customer Balance Amount : " + cust.getAmount());
			System.out.println("Customer Age : " + cust.getAge());
			                                                           
		}
	}

}

The Utility class uses the ApplicationContext container(an interface) of Spring Framework by creating its instance using its implemented class FileSystemXmlApplicationContext, which loads the configuration xml file - config.beans.xml and does the following -

Reads XML to create the CustomerDAO bean named CustomerDAOBean and initiate its property jdbcTemplate with a value by calling its setter methods i.e. setJDBCTemplate().

Using CustomerDAOBean calls the method of CustomerDAO class i.e. createTable(), to create a table in database.

Using CustomerDAOBean calls the transaction method of CustomerDAO class i.e. addCustomer(int id, string name, int amount, int age), to add a customer to the database table.

Using CustomerDAOBean calls the method of CustomerDAO class i.e. getAllCustomer(), to get a List of all the customer stored in the database table.

Using CustomerDAOBean calls the method of CustomerDAO class i.e. countCustomer(), to get a total count of all the customer records stored in the database.

Using CustomerDAOBean calls the transaction method of CustomerDAO class i.e. deleteCustomer(int id), to delete a customer record by using its id value.

Using CustomerDAOBean calls the transaction method of CustomerDAO class i.e. depositAmount(int id), to deposit an amount into an account using its id value.

Using CustomerDAOBean calls the transaction method of CustomerDAO class i.e. withdrawAmount(int id), to withdraw an amount from an account using its id value.

Adding a configuration file

Next, we are going to add a configuration file to our project. This configuration document is an Extensible Markup Language(XML) file, ending with .xml extension and we are going to name file as config.beans.xml.

In this file, we have configured a CustomerDAO bean with a unique id and its HibernateTemplate property named HibernateTemplate. These property will be assigned a value by the Spring Container using its respective setter methods, when the CustomerDAO bean is created by it using the configuration xml file.

For the Spring container to provide the transaction support to CustomerDAO class, we have used the <tx:annotation-driven> tag, which provides the transaction support by referring to the HibernateTransactionManager bean.

config.beans.xml

<?xml version="1.0" encoding="utf-8"?>

<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"
       
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/tx
       https://www.springframework.org/tx/spring-tx.xsd
       ">
      
<tx:annotation-driven transaction-manager="txnManagerBean" proxy-target-class="true"/>
 
          
<bean id="CustomerDAOBean" class="decodejava.CustomerDAO">
<property name="jdbcTemplate" ref="jdbcTemplateBean"></property>
</bean>


<bean id="hibernateTemplateBean" class="org.springframework.orm.hibernate5.HibernateTemplate">
<property name="sessionFactory" ref="SessionFactoryBean"></property>
</bean>


<bean id="txnManagerBean" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="SessionFactoryBean"></property>
</bean>



<bean id="SessionFactoryBean" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="annotatedClasses" value="decodejava.CustomerDAO,decodejava.Customer_Account"></property>
<property name="dataSource" ref="dataSourceBean"></property>
<property name="hibernateProperties">
	<value>
	hibernate.hbm2ddl.auto=create
	hibernate.dialect=org.hibernate.dialect.Oracle10gDialect
	hibernate.show_sql=true
	hibernate.default_schema=system
	</value>
</property>
</bean>


<bean id="dataSourceBean" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="url" value="jdbc:oracle:thin:@localhost:1521:XE"></property>
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"></property>
<property name="username" value="scott"></property>
<property name="password" value="tiger"></property>
</bean>


</beans>

This mapping document has a parent <beans> tag as the root element and its individual child elements, each with a <bean> tag, containing all the attributes such as -

The id attribute within the <bean> element defines a unique id associated with the bean.
The class attribute within the <bean> element defines the name of the class of this bean.

property

<bean>

CustomerDAO

The name child attribute refers to the name of a property in the CustomerDAO class i.e. hibernateTemplate.
The value child attribute refers to the value assigned to be a specific property
The ref child attribute refers to the reference name of a property which is matched with the id of another bean declared in this configuration file within another <bean> tag.

For example - ref="hibernateTemplateBean" refers to a HibernateTemplate bean with id having a similar value - hibernateTemplateBean, declared in this configuration file, to initiate the HibernateTemplate object. This HibernateTemplate bean has a sessionFactory property, which refers to a SessionFactoryBean bean of type org.springframework.orm.hibernate5.LocalSessionFactoryBean.

This bean - SessionFactoryBean bean has a few important properties -
The "annotatedClasses" property specifies the classes that are annotated with Hibernate Annotations i.e. Customer_Account class, and the classes that contain methods performing transaction operations and are annotated with @Transactional Annotation i.e. CustomerDAO class.
The dataSource property refers to a data source implementation class declared in this configuration file.
The hibernateProperties property specifies the important properties associated with Hibernate Framework.

DriverManagerDataSource

xml

The Connection URL
The driverClassName
The username
The password

Adding JARs

We are going to add some JARs files to our Java project. These JARs are required in order to successfully execute this Spring project.

All these JARs are included in the folder named libs(within our Spring installation folder). So, we need to add all the JARs in the libs folder to our build path of our Java project.

All these JARs are included in the folder named required(within our Hibernate installation folder). So, we need to add all the JARs in the required to our build path of our Java project.
Finally, we are going to add one more JAR file. This is a specific JDBC JAR file(ojdbc14.jar) required by Spring to connect to our database(Oracle Express Edition 10g) and perform database operations.

Note :

Adding JARs to your Spring project in Eclipse

Directory Structure of Project

The picture above depicts how and where to arrange classes and interfaces comprising this Spring Project, in a specific directory structure.

Project Folder - SpringWithHibernateTransactionByAnnotation is the name of our Project and it is a top-level directory.

decodejava

A POJO class named Customer_Account.java.
Another POJO class named CustomerDAO.java class.
A class that calls the Spring Framework into action i.e. Utility.java.

Besides this, the project folder also contains a configuration file i.e. config.beans.xml, used to configure the beans of classes in the project.
The project folder also contains all the needed Spring JARs present in the libs folder of Spring Framework installation.

Execution

Finally, after executing Utility class, you will get the following output within the Console window. This output shown below, shows how the Utility class has used the ApplicationContext container of Spring Framework to load the configuration xml file - config.beans.xml, access the beans specified in it, instantiate the CustomerDAO class and performs JDBC operations by calling the methods of CustomerDAO class.

Aug 11, 2018 3:52:22 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@26f0a63f: startup date [Sat Aug 11 15:52:22 2018]; root of context hierarchy
Aug 11, 2018 3:52:22 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Aug 11, 2018 3:52:24 PM org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName
INFO: Loaded JDBC driver: oracle.jdbc.driver.OracleDriver
Aug 11, 2018 3:52:24 PM org.hibernate.Version logVersion
INFO: HHH000412: Hibernate Core {5.2.17.Final}
Aug 11, 2018 3:52:24 PM org.hibernate.cfg.Environment 
INFO: HHH000206: hibernate.properties not found
Aug 11, 2018 3:52:24 PM org.hibernate.annotations.common.reflection.java.JavaReflectionManager 
INFO: HCANN000001: Hibernate Commons Annotations {5.0.1.Final}
Aug 11, 2018 3:52:26 PM org.hibernate.dialect.Dialect 
INFO: HHH000400: Using dialect: org.hibernate.dialect.Oracle10gDialect
Hibernate: create sequence system.hibernate_sequence start with 1 increment by  1
Hibernate: create table system.Customer_Account (ID number(10,0) not null, Age number(10,0), Amount number(10,0), Name varchar2(255 char), primary key (ID))
Aug 11, 2018 3:52:28 PM org.hibernate.tool.schema.internal.SchemaCreatorImpl applyImportSources
INFO: HHH000476: Executing import script 'org.hibernate.tool.schema.internal.exec.ScriptSourceInputNonExistentImpl@672f11c2'
Aug 11, 2018 3:52:28 PM org.springframework.orm.hibernate5.HibernateTransactionManager afterPropertiesSet
INFO: Using DataSource [org.springframework.jdbc.datasource.DriverManagerDataSource@3e1162e7] of Hibernate SessionFactory for HibernateTransactionManager

Adding the customers
Hibernate: select system.hibernate_sequence.nextval from dual
Hibernate: insert into system.Customer_Account (Age, Amount, Name, ID) values (?, ?, ?, ?)
Hibernate: select system.hibernate_sequence.nextval from dual
Hibernate: insert into system.Customer_Account (Age, Amount, Name, ID) values (?, ?, ?, ?)
Hibernate: select system.hibernate_sequence.nextval from dual
Hibernate: insert into system.Customer_Account (Age, Amount, Name, ID) values (?, ?, ?, ?)

Getting all the customers from the database
Hibernate: select this_.ID as ID1_0_0_, this_.Age as Age2_0_0_, this_.Amount as Amount3_0_0_, this_.Name as Name4_0_0_ from system.Customer_Account this_
Customer ID : 1
Customer Name : First Customer
Customer Balance Amount : 1000
Customer Age : 23
Customer ID : 2
Customer Name : Second Customer
Customer Balance Amount : 2000
Customer Age : 27
Customer ID : 3
Customer Name : Third Customer
Customer Balance Amount : 3000
Customer Age : 21

Getting the total count of all the Customers
Hibernate: select this_.ID as ID1_0_0_, this_.Age as Age2_0_0_, this_.Amount as Amount3_0_0_, this_.Name as Name4_0_0_ from system.Customer_Account this_
Total Customers : 3

Deleting a Customer
Hibernate: select customer_a0_.ID as ID1_0_0_, customer_a0_.Age as Age2_0_0_, customer_a0_.Amount as Amount3_0_0_, customer_a0_.Name as Name4_0_0_ from system.Customer_Account customer_a0_ where customer_a0_.ID=?
Hibernate: delete from system.Customer_Account where ID=?

Getting the new total count of all the Customers after deleting a customer
Hibernate: select this_.ID as ID1_0_0_, this_.Age as Age2_0_0_, this_.Amount as Amount3_0_0_, this_.Name as Name4_0_0_ from system.Customer_Account this_
Total Customers : 2

A customer with id = 1, is depositing an amount of 20000
Hibernate: select customer_a0_.ID as ID1_0_0_, customer_a0_.Age as Age2_0_0_, customer_a0_.Amount as Amount3_0_0_, customer_a0_.Name as Name4_0_0_ from system.Customer_Account customer_a0_ where customer_a0_.ID=?
Hibernate: update system.Customer_Account set Age=?, Amount=?, Name=? where ID=?

A customer with id = 3, is withdrawing an amount of 500
Hibernate: select customer_a0_.ID as ID1_0_0_, customer_a0_.Age as Age2_0_0_, customer_a0_.Amount as Amount3_0_0_, customer_a0_.Name as Name4_0_0_ from system.Customer_Account customer_a0_ where customer_a0_.ID=?
Hibernate: update system.Customer_Account set Age=?, Amount=?, Name=? where ID=?

Getting all the customers from the database
Hibernate: select this_.ID as ID1_0_0_, this_.Age as Age2_0_0_, this_.Amount as Amount3_0_0_, this_.Name as Name4_0_0_ from system.Customer_Account this_
Customer ID : 1
Customer Name : First Customer
Customer Balance Amount : 21000
Customer Age : 23
Customer ID : 3
Customer Name : Third Customer
Customer Balance Amount : 2500
Customer Age : 21

And, this concludes performing transaction management by configuring Spring Framework with Hibernate using Annotations.

Please share this article -

< Prev

Next >

< Spring-JDBC TS By Proxy

Spring-Hibernate TS By Schema >

Please Subscribe

Please subscribe to our social media channels for daily updates.

Notifications

Please check our latest addition

C#, PYTHON and DJANGO