{"id":1254,"date":"2022-09-17T20:40:12","date_gmt":"2023-11-18T11:52:47","guid":{"rendered":"https:\/\/www.silicloud.com\/blog\/uncategorized\/an-illustration-of-spring-transaction-management-using-jdbc\/"},"modified":"2024-03-18T15:08:28","modified_gmt":"2024-03-18T15:08:28","slug":"an-illustration-of-spring-transaction-management-using-jdbc","status":"publish","type":"post","link":"https:\/\/www.silicloud.com\/blog\/an-illustration-of-spring-transaction-management-using-jdbc\/","title":{"rendered":"An illustration of Spring Transaction Management using JDBC."},"content":{"rendered":"

One of the most crucial and frequently utilized features of the Spring framework is Spring Transaction Management. Managing transactions is an essential responsibility in any enterprise application. Previously, we learned to handle transactions using the JDBC API. However, Spring offers comprehensive assistance for transaction management, allowing developers to concentrate on their business logic and alleviate concerns about data integrity during system failures.<\/p>\n

Managing transactions in the Spring framework<\/h2>\n

There are several advantages of employing Spring Transaction Management:<\/p>\n

    \n
  1. \n
      Declarative Transaction Management is supported by Spring where AOP is used to ensure data integrity in most cases.<\/ol>\n<\/li>\n<\/ol>\n

       <\/p>\n

        \n
      1. \n
          Most transaction APIs such as JDBC, Hibernate, JPA, JDO, JTA etc. are supported. We simply need to use the appropriate transaction manager implementation class. For instance, org.springframework.jdbc.datasource.DriverManagerDataSource for JDBC transaction management or org.springframework.orm.hibernate3.HibernateTransactionManager for Hibernate as the ORM tool.<\/ol>\n<\/li>\n<\/ol>\n

           <\/p>\n

            Programmatic transaction management is also supported by using TransactionTemplate or a PlatformTransactionManager implementation.<\/ol>\n

            We will opt for Declarative transaction management for our example project as it supports most of the features we desire in a transaction manager.<\/p>\n

            Here’s a suggestion for a native paraphrase:<\/h2>\n

            Example of JDBC Implementation for Spring Transaction Management<\/p>\n

            We will be creating a Spring JDBC project that involves updating multiple tables in one transaction. The transaction will only be committed if all the JDBC statements execute successfully; otherwise, it will rollback to prevent data inconsistency. If you are familiar with JDBC transaction management, you may argue that this can easily be achieved by setting auto-commit to false for the connection and deciding whether to commit or rollback based on the statements’ results. While this approach is possible, it would result in a significant amount of redundant code for transaction management. Moreover, this code would need to be repeated in all instances where transaction management is required, leading to tightly coupled and difficult-to-maintain code. Spring’s declarative transaction management solves these concerns by utilizing Aspect Oriented Programming, which offers loose coupling and eliminates the need for excessive code in our application. Let’s explore how Spring accomplishes this through a simple example. But before we delve into our Spring project, we need to perform some database setup for our purposes.<\/p>\n

            Managing transactions in Spring – Setting up the database.<\/h3>\n

            We will generate two tables for our purpose and simultaneously update them within a single transaction.<\/p>\n

            CREATE TABLE `Customer` (\r\n  `id` int(11) unsigned NOT NULL,\r\n  `name` varchar(20) DEFAULT NULL,\r\n  PRIMARY KEY (`id`)\r\n) ENGINE=InnoDB DEFAULT CHARSET=utf8;\r\n<\/code><\/pre>\n
            CREATE TABLE `Address` (\r\n  `id` int(11) unsigned NOT NULL,\r\n  `address` varchar(20) DEFAULT NULL,\r\n  `country` varchar(20) DEFAULT NULL,\r\n  PRIMARY KEY (`id`)\r\n) ENGINE=InnoDB DEFAULT CHARSET=utf8;\r\n<\/code><\/pre>\n
            We have the option to establish a foreign-key relationship here, linking the Address id column to the Customer id column. However, to keep things simple, I have chosen not to define any constraints. Our Database setup is prepared for the spring transaction management project. Now, let’s create a basic Spring Maven Project in the Spring Tool Suite. The resulting project structure will resemble the image below. Now, let’s examine each component individually, as they will collectively demonstrate an example of spring transaction management with JDBC.<\/p>\n
            Maven Dependencies for Managing Spring Transactions<\/h3>\n
            Because we are utilizing the JDBC API, it is necessary to incorporate the spring-jdbc dependency into our application. Additionally, in order to connect to a MySQL database, we will include the mysql-connector-java dependency. The spring-tx artifact provides transaction management dependencies, which are typically included automatically by STS. However, if they are not, they must be included as well. Although there may be other dependencies for logging and unit testing, we will not be utilizing any of them. The code snippet displayed below represents our final pom.xml file.<\/p>\n
            <project xmlns=\"https:\/\/maven.apache.org\/POM\/4.0.0\" xmlns:xsi=\"https:\/\/www.w3.org\/2001\/XMLSchema-instance\"\r\n\txsi:schemaLocation=\"https:\/\/maven.apache.org\/POM\/4.0.0 https:\/\/maven.apache.org\/xsd\/maven-4.0.0.xsd\">\r\n\t<modelVersion>4.0.0<\/modelVersion>\r\n\t<groupId>org.springframework.samples<\/groupId>\r\n\t<artifactId>SpringJDBCTransactionManagement<\/artifactId>\r\n\t<version>0.0.1-SNAPSHOT<\/version>\r\n\r\n\t<properties>\r\n\r\n\t\t<!-- Generic properties -->\r\n\t\t<java.version>1.7<\/java.version>\r\n\t\t<project.build.sourceEncoding>UTF-8<\/project.build.sourceEncoding>\r\n\t\t<project.reporting.outputEncoding>UTF-8<\/project.reporting.outputEncoding>\r\n\r\n\t\t<!-- Spring -->\r\n\t\t<spring-framework.version>4.0.2.RELEASE<\/spring-framework.version>\r\n\r\n\t\t<!-- Logging -->\r\n\t\t<logback.version>1.0.13<\/logback.version>\r\n\t\t<slf4j.version>1.7.5<\/slf4j.version>\r\n\r\n\t\t<!-- Test -->\r\n\t\t<junit.version>4.11<\/junit.version>\r\n\r\n\t<\/properties>\r\n\r\n\t<dependencies>\r\n\t\t<!-- Spring and Transactions -->\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework<\/groupId>\r\n\t\t\t<artifactId>spring-context<\/artifactId>\r\n\t\t\t<version>${spring-framework.version}<\/version>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework<\/groupId>\r\n\t\t\t<artifactId>spring-tx<\/artifactId>\r\n\t\t\t<version>${spring-framework.version}<\/version>\r\n\t\t<\/dependency>\r\n\r\n\t\t<!-- Spring JDBC and MySQL Driver -->\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework<\/groupId>\r\n\t\t\t<artifactId>spring-jdbc<\/artifactId>\r\n\t\t\t<version>${spring-framework.version}<\/version>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>mysql<\/groupId>\r\n\t\t\t<artifactId>mysql-connector-java<\/artifactId>\r\n\t\t\t<version>5.0.5<\/version>\r\n\t\t<\/dependency>\r\n\r\n\t\t<!-- Logging with SLF4J & LogBack -->\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.slf4j<\/groupId>\r\n\t\t\t<artifactId>slf4j-api<\/artifactId>\r\n\t\t\t<version>${slf4j.version}<\/version>\r\n\t\t\t<scope>compile<\/scope>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>ch.qos.logback<\/groupId>\r\n\t\t\t<artifactId>logback-classic<\/artifactId>\r\n\t\t\t<version>${logback.version}<\/version>\r\n\t\t\t<scope>runtime<\/scope>\r\n\t\t<\/dependency>\r\n\r\n\t\t<!-- Test Artifacts -->\r\n\t\t<dependency>\r\n\t\t\t<groupId>org.springframework<\/groupId>\r\n\t\t\t<artifactId>spring-test<\/artifactId>\r\n\t\t\t<version>${spring-framework.version}<\/version>\r\n\t\t\t<scope>test<\/scope>\r\n\t\t<\/dependency>\r\n\t\t<dependency>\r\n\t\t\t<groupId>junit<\/groupId>\r\n\t\t\t<artifactId>junit<\/artifactId>\r\n\t\t\t<version>${junit.version}<\/version>\r\n\t\t\t<scope>test<\/scope>\r\n\t\t<\/dependency>\r\n\r\n\t<\/dependencies>\r\n<\/project>\r\n<\/code><\/pre>\n
            As of today, I have made sure to update the Spring versions, so please ensure that the MySQL database driver is compatible with your mysql installation.<\/p>\n
            Managing transactions in a Spring framework- Model Classes.<\/h3>\n
            We are going to develop two Java Beans, namely Customer and Address, which will correspond with our tables.<\/p>\n
             com.scdev.spring.jdbc.model;\r\n\r\npublic class Address {\r\n\r\n\tprivate int id;\r\n\tprivate String address;\r\n\tprivate String country;\r\n\t\r\n\tpublic int getId() {\r\n\t\treturn id;\r\n\t}\r\n\tpublic void setId(int id) {\r\n\t\tthis.id = id;\r\n\t}\r\n\tpublic String getAddress() {\r\n\t\treturn address;\r\n\t}\r\n\tpublic void setAddress(String address) {\r\n\t\tthis.address = address;\r\n\t}\r\n\tpublic String getCountry() {\r\n\t\treturn country;\r\n\t}\r\n\tpublic void setCountry(String country) {\r\n\t\tthis.country = country;\r\n\t}\r\n\t\r\n}\r\n<\/code><\/pre>\n
             com.scdev.spring.jdbc.model;\r\n\r\npublic class Customer {\r\n\r\n\tprivate int id;\r\n\tprivate String name;\r\n\tprivate Address address;\r\n\t\r\n\tpublic int getId() {\r\n\t\treturn id;\r\n\t}\r\n\tpublic void setId(int id) {\r\n\t\tthis.id = id;\r\n\t}\r\n\tpublic String getName() {\r\n\t\treturn name;\r\n\t}\r\n\tpublic void setName(String name) {\r\n\t\tthis.name = name;\r\n\t}\r\n\tpublic Address getAddress() {\r\n\t\treturn address;\r\n\t}\r\n\tpublic void setAddress(Address address) {\r\n\t\tthis.address = address;\r\n\t}\r\n\t\r\n}\r\n<\/code><\/pre>\n
            When implementing the DAO for the Customer, we must take note that the Customer bean includes the Address as one of its variables. Consequently, when retrieving data for both the customer and address tables, we will need to execute two independent insert queries for each table. To ensure data consistency, it is crucial to have transaction management in place.<\/p>\n
            Implementing DAO with Transaction Management in Spring.<\/h3>\n
            To simplify matters, we will focus on designing the DAO for the Customer bean and have only one method for inserting records in both the customer and address tables.<\/p>\n
             com.scdev.spring.jdbc.dao;\r\n\r\nimport com.scdev.spring.jdbc.model.Customer;\r\n\r\npublic interface CustomerDAO {\r\n\r\n\tpublic void create(Customer customer);\r\n}\r\n<\/code><\/pre>\n
             com.scdev.spring.jdbc.dao;\r\n\r\nimport javax.sql.DataSource;\r\n\r\nimport org.springframework.jdbc.core.JdbcTemplate;\r\n\r\nimport com.scdev.spring.jdbc.model.Customer;\r\n\r\npublic class CustomerDAOImpl implements CustomerDAO {\r\n\r\n\tprivate DataSource dataSource;\r\n\r\n\tpublic void setDataSource(DataSource dataSource) {\r\n\t\tthis.dataSource = dataSource;\r\n\t}\r\n\r\n\t@Override\r\n\tpublic void create(Customer customer) {\r\n\t\tString queryCustomer = \"insert into Customer (id, name) values (?,?)\";\r\n\t\tString queryAddress = \"insert into Address (id, address,country) values (?,?,?)\";\r\n\r\n\t\tJdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);\r\n\r\n\t\tjdbcTemplate.update(queryCustomer, new Object[] { customer.getId(),\r\n\t\t\t\tcustomer.getName() });\r\n\t\tSystem.out.println(\"Inserted into Customer Table Successfully\");\r\n\t\tjdbcTemplate.update(queryAddress, new Object[] { customer.getId(),\r\n\t\t\t\tcustomer.getAddress().getAddress(),\r\n\t\t\t\tcustomer.getAddress().getCountry() });\r\n\t\tSystem.out.println(\"Inserted into Address Table Successfully\");\r\n\t}\r\n\r\n}\r\n<\/code><\/pre>\n
            It should be noted that the CustomerDAO implementation does not handle transaction management. By doing this, we ensure a separation of concerns as there are instances where we obtain DAO implementations from external sources and have no control over these classes.<\/p>\n
            Spring’s declarative transaction management for services.<\/h3>\n
            We can develop a Customer Service that utilizes the CustomerDAO implementation and handles transaction management while inserting records into the customer and address tables within a single method.<\/p>\n
             com.scdev.spring.jdbc.service;\r\n\r\nimport com.scdev.spring.jdbc.model.Customer;\r\n\r\npublic interface CustomerManager {\r\n\r\n\tpublic void createCustomer(Customer cust);\r\n}\r\n<\/code><\/pre>\n
             com.scdev.spring.jdbc.service;\r\n\r\nimport org.springframework.transaction.annotation.Transactional;\r\n\r\nimport com.scdev.spring.jdbc.dao.CustomerDAO;\r\nimport com.scdev.spring.jdbc.model.Customer;\r\n\r\npublic class CustomerManagerImpl implements CustomerManager {\r\n\r\n\tprivate CustomerDAO customerDAO;\r\n\r\n\tpublic void setCustomerDAO(CustomerDAO customerDAO) {\r\n\t\tthis.customerDAO = customerDAO;\r\n\t}\r\n\r\n\t@Override\r\n\t@Transactional\r\n\tpublic void createCustomer(Customer cust) {\r\n\t\tcustomerDAO.create(cust);\r\n\t}\r\n\r\n}\r\n<\/code><\/pre>\n
            Simply put, the CustomerManager implementation utilizes the CustomerDAO implementation to create customers. It achieves declarative transaction management by annotating the createCustomer() method with @Transactional. This annotation is enough to enjoy the advantages of Spring transaction management. You can apply @Transactional to individual methods or the entire class if you wish to enable transaction management for all methods. To understand annotations further, refer to the Java Annotations Tutorial. The only remaining step is to wire the spring beans to make the spring transaction management example functional.<\/p>\n
            Configuring Beans for Spring Transaction Management<\/h3>\n
            Generate a Spring Bean Configuration file named “spring.xml”. This file will be utilized in our test program to establish connections between spring beans and execute our JDBC program for the purpose of testing transaction management.<\/p>\n
            <?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n<beans xmlns=\"https:\/\/www.springframework.org\/schema\/beans\"\r\n\txmlns:xsi=\"https:\/\/www.w3.org\/2001\/XMLSchema-instance\" xmlns:context=\"https:\/\/www.springframework.org\/schema\/context\"\r\n\txmlns:tx=\"https:\/\/www.springframework.org\/schema\/tx\"\r\n\txsi:schemaLocation=\"https:\/\/www.springframework.org\/schema\/beans https:\/\/www.springframework.org\/schema\/beans\/spring-beans.xsd\r\n\t\thttps:\/\/www.springframework.org\/schema\/context https:\/\/www.springframework.org\/schema\/context\/spring-context-4.0.xsd\r\n\t\thttps:\/\/www.springframework.org\/schema\/tx https:\/\/www.springframework.org\/schema\/tx\/spring-tx-4.0.xsd\">\r\n\r\n\t<!-- Enable Annotation based Declarative Transaction Management -->\r\n\t<tx:annotation-driven proxy-target-class=\"true\"\r\n\t\ttransaction-manager=\"transactionManager\" \/>\r\n\r\n\t<!-- Creating TransactionManager Bean, since JDBC we are creating of type \r\n\t\tDataSourceTransactionManager -->\r\n\t<bean id=\"transactionManager\"\r\n\t\tclass=\"org.springframework.jdbc.datasource.DataSourceTransactionManager\">\r\n\t\t<property name=\"dataSource\" ref=\"dataSource\" \/>\r\n\t<\/bean>\r\n\t\r\n\t<!-- MySQL DB DataSource -->\r\n\t<bean id=\"dataSource\"\r\n\t\tclass=\"org.springframework.jdbc.datasource.DriverManagerDataSource\">\r\n\r\n\t\t<property name=\"driverClassName\" value=\"com.mysql.jdbc.Driver\" \/>\r\n\t\t<property name=\"url\" value=\"jdbc:mysql:\/\/localhost:3306\/TestDB\" \/>\r\n\t\t<property name=\"username\" value=\"scdev\" \/>\r\n\t\t<property name=\"password\" value=\"scdev123\" \/>\r\n\t<\/bean>\r\n\r\n\t<bean id=\"customerDAO\" class=\"com.scdev.spring.jdbc.dao.CustomerDAOImpl\">\r\n\t\t<property name=\"dataSource\" ref=\"dataSource\"><\/property>\r\n\t<\/bean>\r\n\r\n\t<bean id=\"customerManager\" class=\"com.scdev.spring.jdbc.service.CustomerManagerImpl\">\r\n\t\t<property name=\"customerDAO\" ref=\"customerDAO\"><\/property>\r\n\t<\/bean>\r\n\r\n<\/beans>\r\n<\/code><\/pre>\n
            Some key aspects to consider in the spring bean configuration file include:<\/p>\n