IT Log

Record various IT issues and difficulties.

Analysis of Spring Core Technology – IX: In-Depth Explanation of the Spring Data Access Module and Spring-Jdbc Component (Highly Practical Content)

In modern enterprise-level applications, the stability and efficiency of the data access layer are crucial. To simplify and optimize database operations, the Spring Framework provides the Spring-JDBC module, which aims to simplify developers’ coding tasks by encapsulating JDBC operations and reducing redundant code while enhancing system robustness and maintainability. One of the core components of the Spring-JDBC module is JdbcTemplate, which has become the most commonly used tool for developers in database interactions. It significantly reduces boilerplate code and automatically handles transaction management and exception handling. This article will delve into the basic functions, core components, and transaction management mechanisms of the Spring-JDBC module, helping developers better understand and utilize it to improve data access efficiency and security.

3、Spring-JDBC Transaction Management

3.1、Overview of Spring JDBC Transaction Management
3.2、Using @Transactional for Declarative Transaction Management
3.3、Programmatic Transaction Management
3.4、Transaction Propagation Behavior

Postscript

1、Introduction to the Spring-JDBC Module

1.1 Overview of the Spring-JDBC Module

The Spring JDBC module is a highly abstracted component that simplifies the process of accessing databases using JDBC.

Spring JDBC module includes a JdbcTemplate class, which encapsulates common operations such as querying, updating, and transaction handling. This makes writing database interaction code more concise and less error-prone. The JdbcTemplate also automatically manages resources and handles exception translation, enhancing the robustness of the code.

1.2 Dependencies of Spring-JDBC Module

The Spring-JDBC module has three dependencies: Spring-Beans module, Spring-Core module, and Spring-Tx module.

Among these, the Spring Beans module defines Spring Bean and implements the basic functionality of IOC. The Spring-Core is a fundamental module that provides core functionalities required for the framework to run. The Spring Tx module handles transaction management within Spring.

1.3、The Role of the Spring-Jdbc Module

The main functions of Spring-JDBC:

Simplify JDBC Operations: The Spring-JDBC provides the JdbcTemplate class, which encapsulates core JDBC operations (such as connection management, SQL execution, and result set processing). Developers only need to focus on SQL statements and business logic without manually handling resource management (such as closing connections or result sets).
Reduce Boilerplate Code: Traditional JDBC code requires manual creation and release of Connection, Statement, and ResultSet resources, which are error-prone and verbose. Spring-JDBC uses the template method pattern to automatically handle these resources, reducing repetitive code.
Error Handling: Spring-JDBC converts JDBC’s SQLException into Spring’s DataAccessException exception hierarchy, providing a clearer exception structure for easier handling of database operation errors.
Transaction Management: Spring-JDBC seamlessly integrates with Spring’s transaction management module, supporting declarative transactions (via annotations or XML configuration), simplifying the implementation of transaction control.
Support Multiple Database Operations: In addition to basic CRUD operations, Spring-JDBC also supports batch operations, stored procedure calls, and complex result set mapping features.
Integration with ORM Frameworks: Spring-JDBC can be combined with other ORM frameworks (such as Hibernate or MyBatis), offering more flexible data access options.

2、The Core Components of Spring-Jdbc

The JdbcTemplate is the core class of Spring JDBC, providing CRUD methods. This section introduces the usage of JdbcTemplate.

2.1、Configuration Files and Dependencies

If using Maven, ensure that the relevant Spring JDBC and database connection pool dependencies are correctly introduced in the pom.xml. For example:

    <dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.39</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.39</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.33</version>
</dependency>
</dependencies>

<groupId>org.springframework</groupId>

<artifactId>spring–context</artifactId>

</dependency>

<groupId>org.springframework</groupId>

<artifactId>spring–jdbc</artifactId>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql–connector–java</artifactId>

</dependency>

</dependencies>

2.2 Configure the Spring Container

First, ensure our Spring configuration file is correctly configured and has included Spring context and JDBC configurations. For example:

<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”>
<!– Configure data source –>
<bean id=”dataSource” class=”org.apache.commons.dbcp2.BasicDataSource”>
<property name=”driverClassName” value=”com.mysql.cj.jdbc.Driver”/>
<property name=”url” value=”jdbc:mysql://localhost:3306/yourdb”/>
<property name=”username” value=”yourusername”/>
<property name=”password” value=”yourpassword”/>
</bean>
<!– Configure JdbcTemplate –>
<bean id=”jdbcTemplate” class=”org.springframework.jdbc.core.JdbcTemplate”>
<property name=”dataSource” ref=”dataSource”/>
</bean>
<!– Configure EmpDao –>
<bean id=”empDao” class=”com.example.EmpDao”>
<property name=”jdbcTemplate” ref=”jdbcTemplate”/>
</bean>
</beans>

<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”>

<!— Configure data source —>

</bean>

<!— Configure JdbcTemplate —>

</bean>

<!— Configure EmpDao —>

</bean>

</beans>

2.3、Starting the Spring Container

In a Spring project, we typically use ClassPathXmlApplicationContext to load configuration files and start the container. We can use the following code in the main method to start the Spring container:

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
// Load Spring configuration file
ApplicationContext context = new ClassPathXmlApplicationContext(“spring-bean.xml”);
// Retrieve EmpDao Bean and call its methods
EmpDao empDao = (EmpDao) context.getBean(“empDao”);
// Call methods in EmpDao
empDao.addEmployee(“John Doe”, 30);
empDao.deleteEmployee(5);
}
}

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

public static void main(String[] args) {

// Load Spring configuration file

ApplicationContext context = new ClassPathXmlApplicationContext(“spring-bean.xml”);

// Retrieve EmpDao Bean and call its methods

EmpDao empDao = (EmpDao) context.getBean(“empDao”);

// Call methods in EmpDao

empDao.addEmployee(“John Doe”, 30);

empDao.deleteEmployee(5);

}

2.4、Using methods in the EmpDao class

Ensure our EmpDao class has correctly configured CRUD methods and uses JdbcTemplate. For example:

import org.springframework.jdbc.core.JdbcTemplate;
public class EmpDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void addEmployee(String name, int age) {
String sql = “INSERT INTO employee (name, age) VALUES (?, ?)”;
jdbcTemplate.update(sql, name, age);
}
public void deleteEmployee(int id) {
String sql = “DELETE FROM employee WHERE id = ?”;
jdbcTemplate.update(sql, id);
}
}

import org.springframework.jdbc.core.JdbcTemplate;

public class EmpDao {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

public void addEmployee(String name, int age) {

String sql = “INSERT INTO employee (name, age) VALUES (?, ?)”;

jdbcTemplate.update(sql, name, age);

}

public void deleteEmployee(int id) {

String sql = “DELETE FROM employee WHERE id = ?”;

jdbcTemplate.update(sql, id);

}

3. Transcation Management with Spring JDBC

Spring JDBC provides support for transaction management, making the handling of database transactions simpler and more unified. Through Spring’s transaction management, we can ensure the consistency and atomicity of database operations, avoiding data inconsistencies.

Spring offers two mechanisms for transaction management:

Programmatic transaction management: Explicitly controlling the start, commit, and rollback of transactions through code.
Declarative transaction management: Achieving automatic transaction management via configuration and annotations ( @Transactional). Spring will automatically handle the start, commit, and rollback of transactions.

3.1 Overview of Spring JDBC Transaction Management

Spring provides DataSourceTransactionManager to manage JDBC transactions, which implements the PlatformTransactionManager interface. Spring uses this class to control the lifecycle of transactions.

Transaction states: Typically include begin (begin), commit (commit), and rollback (rollback).
Propagation behavior: Determines how a transaction propagates when a method is called, based on the current transaction state.

3.2 Declarative Transaction Management using @Transactional

The most common approach is to implement declarative transaction management via the @Transactional annotation. Spring will start the transaction before executing the method, commit it after execution, and rollback if an exception occurs.

Example: Using the @Transactional annotation

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Transactional;
public class EmpDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
// Use @Transactional annotation for declarative transaction management
@Transactional
public void addEmployeeAndDepartment(String empName, int empAge, String deptName) {
String addEmployeeSql = “INSERT INTO employee (name, age) VALUES (?, ?)”;
jdbcTemplate.update(addEmployeeSql, empName, empAge);
String addDepartmentSql = “INSERT INTO department (name) VALUES (?)”;
jdbcTemplate.update(addDepartmentSql, deptName);
// Simulate an error to trigger rollback
if (empAge < 0) {
throw new RuntimeException(“Invalid age”);
}
}
}

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.transaction.annotation.Transactional;

public class EmpDao {

private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

// Use @Transactional annotation for declarative transaction management

@Transactional

public void addEmployeeAndDepartment(String empName, int empAge, String deptName) {

String addEmployeeSql = “INSERT INTO employee (name, age) VALUES (?, ?)”;

jdbcTemplate.update(addEmployeeSql, empName, empAge);

String addDepartmentSql = “INSERT INTO department (name) VALUES (?)”;

jdbcTemplate.update(addDepartmentSql, deptName);

// Simulate an error to trigger rollback

if (empAge < 0) {

throw new RuntimeException(“Invalid age”);

}

In the example above:

@Transactional annotation indicates that Spring will automatically manage transactions when the addEmployeeAndDepartment method is executed.
If the method executes normally, the transaction will be committed.
If an exception is thrown by the method, Spring will automatically roll back the transaction.

Enabling transaction management:

To have Spring manage transactions, we need to enable the transaction manager in the configuration file and ensure that Spring container scans for transaction management-related annotations.

<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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd”>
<!– Configure transaction manager –>
<bean id=”dataSource” class=”org.apache.commons.dbcp2.BasicDataSource”>
<property name=”driverClassName” value=”com.mysql.cj.jdbc.Driver”/>
<property name=”url” value=”jdbc:mysql://localhost:3306/yourdb”/>
<property name=”username” value=”yourusername”/>
<property name=”password” value=”yourpassword”/>
</bean>
<bean id=”transactionManager” class=”org.springframework.jdbc.datasource.DataSourceTransactionManager”>
<property name=”dataSource” ref=”dataSource”/>
</bean>
<!– Enable transaction management –>
<tx:annotation-driven transaction-manager=”transactionManager”/>
</beans>

<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

http://www.springframework.org/schema/tx

http://www.springframework.org/schema/tx/spring-tx.xsd”>

<!— Configure transaction manager —>

</bean>

</bean>

<!— Enable transaction management —>

<tx:annotation–driven transaction–manager=“transactionManager”/>

</beans>

3.3、Programmatic Transaction Management

If you do not want to use declarative transactions, you can use programmatic transaction management. In this approach, we need to explicitly use PlatformTransactionManager to control the transactions.

Example: Programmatic Transaction Management

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;
public class EmpDao {
private JdbcTemplate jdbcTemplate;
private PlatformTransactionManager transactionManager;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
public void setTransactionManager(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}
public void addEmployeeAndDepartment(String empName, int empAge, String deptName) {
// Create transaction definition
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = transactionManager.getTransaction(def);
try {
String addEmployeeSql = “INSERT INTO employee (name, age) VALUES (?, ?)”;
jdbcTemplate.update(addEmployeeSql, empName, empAge);
String addDepartmentSql = “INSERT INTO department (name) VALUES (?)”;
jdbcTemplate.update(addDepartmentSql, deptName);
// Simulate an error to rollback
if (empAge < 0) {
throw new RuntimeException(“Invalid age”);
}
// Commit the transaction
transactionManager.commit(status);
} catch (Exception e) {
// Rollback the transaction
transactionManager.rollback(status);
throw e; // Throw exception
}
}
}

import org.springframework.jdbc.core.JdbcTemplate;

import org.springframework.transaction.PlatformTransactionManager;

import org.springframework.transaction.TransactionDefinition;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.support.DefaultTransactionDefinition;

public class EmpDao {

private JdbcTemplate jdbcTemplate;

private PlatformTransactionManager transactionManager;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {

this.jdbcTemplate = jdbcTemplate;

}

public void setTransactionManager(PlatformTransactionManager transactionManager) {

this.transactionManager = transactionManager;

}

public void addEmployeeAndDepartment(String empName, int empAge, String deptName) {

// Create transaction definition

DefaultTransactionDefinition def = new DefaultTransactionDefinition();

def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);

TransactionStatus status = transactionManager.getTransaction(def);

try {

String addEmployeeSql = “INSERT INTO employee (name, age) VALUES (?, ?)”;

jdbcTemplate.update(addEmployeeSql, empName, empAge);

String addDepartmentSql = “INSERT INTO department (name) VALUES (?)”;

jdbcTemplate.update(addDepartmentSql, deptName);

// Simulate an error to rollback

if (empAge < 0) {

throw new RuntimeException(“Invalid age”);

}

// Commit the transaction

transactionManager.commit(status);

} catch (Exception e) {

// Rollback the transaction

transactionManager.rollback(status);

throw e; // Throw exception

}

In programmatic transaction management, we need to manually create transaction definitions (DefaultTransactionDefinition) and use PlatformTransactionManager to begin, commit, or roll back transactions.

3.4、Transaction Propagation Behavior

Transaction propagation behavior determines how transactions propagate across multiple method calls. Common propagation behaviors include:

PROPAGATION_REQUIRED: If no transaction is currently active, a new transaction is created; if a transaction already exists, the current transaction is joined (default behavior).
PROPAGATION_REQUIRES_NEW: A new transaction is always created, regardless of whether a transaction is already active.
PROPAGATION_NESTED: Supports nested transactions. If a current transaction exists, a sub-transaction is started within it.

We can control the propagation behavior by setting the @Transactional annotation’s propagation attribute, for example:

@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addEmployeeAndDepartmentWithNewTransaction(String empName, int empAge, String deptName) {
// Create a new transaction independent of the outer transaction
}

@Transactional(propagation = Propagation.REQUIRES_NEW)

public void addEmployeeAndDepartmentWithNewTransaction(String empName, int empAge, String deptName) {

// Create a new transaction independent of the outer transaction

}

X、Postscript

Through the explanations in this article, we have gained a deep understanding of how the Spring-JDBC module simplifies JDBC operations through the JdbcTemplate class and handles tasks such as database connection management, transaction management, and exception translation automatically. The Spring-JDBC module not only reduces the workload for developers but also significantly improves the readability and maintainability of code. Whether it’s common CRUD operations or complex transaction control, Spring-JDBC provides simple and flexible solutions. Mastering these core technologies will lead to a more efficient and reliable database interaction experience for developers. We hope that you can apply the knowledge points from this article to actual development and continuously optimize and enhance your technical skills.

February 12, 2025

@Transactional, Core Components, Database Access Layer, Declarative Transaction, JDBC, JdbcTemplate, ORM Integration, Programmatic Transaction, Spring-JDBC, Transaction Management

10 responses to “Analysis of Spring Core Technology – IX: In-Depth Explanation of the Spring Data Access Module and Spring-Jdbc Component (Highly Practical Content)”

A well-structured and insightful article that sheds light on the essential aspects of Spring-JDBC, from configuration to transaction management.

Log in to Reply
This guide demystifies the inner workings of JdbcTemplate and its role in streamlining database operations, making it a go-to reference for developers.

Log in to Reply
The practical examples and code snippets provided make this article an invaluable resource for enhancing database interaction in Spring applications.

Log in to Reply
A thorough exploration of the Spring-JDBC module’s features and dependencies ensures a solid understanding for both beginners and advanced users.

Log in to Reply
Excellent coverage of transaction management mechanisms. The @Transactional annotation explanation is particularly helpful for implementing robust transactions.

Log in to Reply
The article effectively breaks down complex concepts into digestible parts, making it easier to grasp how Spring-JDBC works in real-world scenarios.

Log in to Reply
This detailed analysis of the Spring Data Access Module and its integration with JDBC is both informative and practical. Highly recommended!

Log in to Reply
The step-by-step guide on configuring Spring-JDBC and using JdbcTemplate makes this article extremely valuable for hands-on learning.

Log in to Reply
A must-read for developers looking to optimize their data access layer! The explanation of JdbcTemplate and transaction management is highly insightful.

Log in to Reply
This article provides a comprehensive overview of the Spring-JDBC module, highlighting its core components and practical applications. It simplifies database operations and enhances code efficiency.

Log in to Reply

IT Log

Analysis of Spring Core Technology – IX: In-Depth Explanation of the Spring Data Access Module and Spring-Jdbc Component (Highly Practical Content)

Table of Contents

1、Introduction to the Spring-JDBC Module

1.1 Overview of the Spring-JDBC Module

1.2 Dependencies of Spring-JDBC Module

1.3、The Role of the Spring-Jdbc Module

2、The Core Components of Spring-Jdbc

2.1、Configuration Files and Dependencies

2.2 Configure the Spring Container

2.3、Starting the Spring Container

2.4、Using methods in the EmpDao class

3. Transcation Management with Spring JDBC

3.1 Overview of Spring JDBC Transaction Management

3.2 Declarative Transaction Management using @Transactional

3.3、Programmatic Transaction Management

3.4、Transaction Propagation Behavior

X、Postscript

10 responses to “Analysis of Spring Core Technology – IX: In-Depth Explanation of the Spring Data Access Module and Spring-Jdbc Component (Highly Practical Content)”

Leave a Reply Cancel reply