Advertisement

---

Top

< Prev

Next >

In our last tutorial we have explained how to configure and perform transaction management within the database using Spring Framework with JDBC and Annotations. In this tutorial, we are going to explain how to configure and perform transaction management within the database using Spring Framework with JDBC and Schema.

Difference between Spring-JDBC transaction by Annotation and Spring-JDBC transaction by Schema

The difference between two approaches is that when we perform transaction management within the database using Spring Framework with JDBC and Annotation, we need an access to the source code to edit it and add @Transactional Annotation to class and methods involved in transaction operations.

But, in case of performing transaction management within the database using Spring Framework with JDBC and Schema, we don't need to change anything in the source code, rather we configure the transaction management using the configuration xml file.

What Spring-JDBC transaction management by Schema does?

The transaction management involves managing database transaction operations 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.

The Spring-JDBC transaction management by Schema 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.

Note :

Before we proceed with the database transaction management, we would first need to configure Spring Framework to work with JDBC. To perform this, we will use a very important template class provided by Spring Framework which allows us to perform JDBC operations, named - JDBCTemplate.

Creating the Java class - Customer_Account

We are going to create a java class named Customer 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.

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;

public class Customer_Account 
{
	int id;
	String name;
	int amount;
	int 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 JDBC operations using methods of Spring Framework template class JDBCTemplate, to perform JDBC queries 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 JdbcTemplate property named jdbcTemplate, used to perform JDBC operations using Spring.

This JdbcTemplate 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.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ResultSetExtractor;

public class CustomerDAO 
{
private JdbcTemplate jdbcTemplate;



	//Creating a table
	public void createTable()
	{
		String query = "create table Customer_Account"
					+ "("
					+ "id int,"
					+ "name varchar(40),"
					+ "amount int,"
					+ "age int"
					+ ")";
		
		jdbcTemplate.execute(query);
	}
	
	
	//Getter for JdbcTemplate
	public JdbcTemplate getJdbcTemplate() 
	{
		return jdbcTemplate;
	}

	
	//Setter for JdbcTemplate
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) 
	{
		this.jdbcTemplate = jdbcTemplate;
	}


	
	//Adding a customer
	public void addCustomer(int id, String name, int amount, int age)
	{
		String query ="insert into Customer_Account values(" + id + ",'" + name + "','" + amount + "'," + age + ")";
		jdbcTemplate.execute(query);
	}
	
	
	//Deleting a customer
	public void deleteCustomer(int id)
	{
		String query = "delete from Customer_Account where id =" + id ;
		jdbcTemplate.execute(query);
	}
	
	
	//Extracting a count of all the customers
	public int countCustomer()
	{
		String query = "select count(*) from Customer_Account";
		return jdbcTemplate.queryForObject(query, Integer.class);
	}
	
	
	//Getting a List of all customers from database
	public List<Customer_Account> getAllCustomer()
	{
		String query ="select * from Customer_Account";
		return jdbcTemplate.query(query, new ResultSetExtractor<List<Customer_Account>>()
		//Anonymous Inner Class
		{
						
				@Override
				public List<Customer_Account> extractData(ResultSet rs) throws SQLException, DataAccessException
				{
					List<Customer_Account> customers = new ArrayList<Customer_Account>();
					while(rs.next())
					{
						Customer_Account customer = new Customer_Account();
						customer.setId(rs.getInt("id"));
						customer.setName(rs.getString("name"));
						customer.setAmount(rs.getInt("amount"));
						customer.setAge(rs.getInt("age"));
						customers.add(customer);
					}
				return customers;
				}
			});
		}
	

	
	//Transaction method i.e. depositing an amount in an account
	public void depositAmount(int id, int amount)
	{
		getJdbcTemplate().update("update Customer_Account set amount=amount+? where id=?", amount, id);		
	}
	
	//Transaction method i.e. withdrawing an amount from an account
	public void withdrawAmount(int id, int amount)
	{
		getJdbcTemplate().update("update Customer_Account set amount=amount-? where id=?", amount, id);		
	}
}

Advertisement

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("Creating a table in database");
		customerDAO.createTable();
		
		
		System.out.println("Adding the customers");
		customerDAO.addCustomer(1, "First Customer", 1000, 23);
		customerDAO.addCustomer(2, "Second Customer", 2000, 27);
		customerDAO.addCustomer(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 with id = 2");
		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 and their updated amount :");
		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 with its String property named tableName and JdbcTemplate property named jdbcTemplate. These properties will be assigned a value by the Spring Container using their respective setter methods, when the CustomerDAO bean is created by it using the configuration xml file.


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:util="springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       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.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd
       http://www.springframework.org/schema/tx
       https://www.springframework.org/tx/spring-tx.xsd
       ">
      
 
  
<aop:config proxy-target-class="true">

<aop:advisor advice-ref="txnAdvice" pointcut="execution(*decodejava.CustomerDAO.*(..))"/>
</aop:config>

 
<tx:advice transaction-manager="txManagerBean" id="txnAdvice">
	<tx:attributes>
		<tx:method name="withdrawAmount" propagation="REQUIRES_NEW" isolation="DEFAULT" rollback-for="Exception"/>
		<tx:method name="depositAmount" propagation="REQUIRES_NEW" isolation="DEFAULT" rollback-for="Exception"/>
	</tx:attributes>
</tx:advice>
 
           
<bean id="CustomerDAOBean" class="decodejava.CustomerDAO">
<property name="jdbcTemplate" ref="jdbcTemplateBean"></property>
</bean>


<bean id="jdbcTemplateBean" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSourceBean"></property>
</bean>


<bean id="txManagerBean" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSourceBean"></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.



The property child element in <bean> tag refers to a property within the CustomerDAO class.
• The name child attribute refers to the name of a property in the CustomerDAO class i.e. jdbcTemplate.
• 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="jdbcTemplateBean" refers to a JdbcTemplate bean with id having a similar value - jdbcTemplateBean, declared in this configuration file, to initiate the JdbcTemplate object. This JdbcTemplate bean has a datasource property which refers to a data source implementation class declared in this configuration file.


A data source implementation class provided by Spring Framework - DriverManagerDataSource, used to access the configuration database details specified in xml file, such as -
• The Connection URL
• The driverClassName
• The username
• The password
to connect to the database and perform JDBC operations using Spring Framework.

A few important tags used in the configuration xml file -

We have used a few tags specific for transaction management -

• <tx:advice> - This tag has a transaction-manager attribute which connects the transaction manager class with the class that is going to perform transaction operations through its methods.
This tag has a child tag <tx:attributes> :


<tx:attributes> - This is a child tag of <tx:advice> tag and it is used to configure the transaction methods of the target class. Some of its attributes are :

1. The method attribute is used to specify the method of target class which is performing the transaction operation.


2. The propagation attribute is used to specify the transaction behaviour i.e. REQUIRES_NEW specifies that the associated method should be executed in a new transaction.


3. The isolation attribute is used to specify the way of configuring the concurrent transactions i.e. DEFAULT specifies that a default isolation levels defined in relational databases.


4. The rollback-for attribute is used to specify checked exception classes. The transaction will be rolled back when any of the specified exceptions are thrown during the runtime of exception.

• Next, the <aop:config> tag is used define aspect oriented programming configuration elements and its proxy-target-class attribute takes a boolean value. If it is set to true then a proxy is created by extending the target class. This tag has a child tag <aop:advisor>

<aop:advisor> - This is a child tag of <proxy-target-class> tag and it is wire the pointcut expression with the advice.
1. The advice-ref attribute is used to refer to the advice mentioned within the <tx:advice> tag.
2. The pointcut attribute is used to specify a pointcut using its attribute - expression.

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 - SpringWithJDBCTransactionBySchema is the name of our Project and it is a top-level directory.

This project folder contains a package of our project i.e. decodejava containing three classes -
• 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.

JAug 10, 2018 12:29:26 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.FileSystemXmlApplicationContext@5e91993f: startup date [Fri Aug 10 12:29:26 2018]; root of context hierarchy
Aug 10, 2018 12:29:26 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [config.beans.xml]
Aug 10, 2018 12:29:31 PM org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName
INFO: Loaded JDBC driver: oracle.jdbc.driver.OracleDriver
Creating a table in database
Adding the customers
Getting all the customers from the database
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
Total Customers : 3
Deleting a Customer with id = 2
Getting the new total count of all the Customers after deleting a customer
Total Customers : 2
A customer with id = 1, is depositing an amount of 20000
A customer with id = 3, is withdrawing an amount of 500
Getting all the customers from the database and their updated amount :
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 JDBC using Schema.

Please share this article -

< Prev

Next >

< Spring-JDBC TS By Annotation

Spring-JDBC TS By Proxy >

Advertisement