Spring 框架 JDBC 模板技术详解

一、JDBC 模板技术概述

在传统 JDBC 开发中，开发人员需要手动处理数据库连接（Connection）、事务管理、语句执行（Statement）和结果集（ResultSet）等繁琐操作，不仅代码冗余度高，而且容易出错。Spring 框架针对这一痛点，提供了持久层模板类（XxxTemplate）来简化开发，其中用于 JDBC 操作的核心类是JdbcTemplate。

核心优势

• 简化编程：封装了 JDBC 的底层细节，开发者只需关注 SQL 语句和业务逻辑。
• 统一接口：提供一致的增删改查方法，避免重复编写样板代码。
• 整合连接池：支持 Spring 内置连接池和第三方开源连接池（如 Druid），方便管理数据库连接。

 二、JDBC 模板类的基础使用

 1. 创建 Maven 工程并引入依赖

 在pom.xml中添加以下坐标，包含 Spring 核心、JDBC 模块、数据库驱动及日志组件：

<dependencies>
    <!-- Spring核心 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!-- JDBC模块 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-tx</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>
    <!-- 数据库驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>
    <!-- 日志 -->
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.12</version>
    </dependency>
    <!-- 测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

 2. 手动创建对象方式（非 Spring 管理）

 通过硬编码方式创建连接池和JdbcTemplate对象，适用于简单测试场景：

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class Demo1 {
    @Test
    public void run1() {
        // 1. 创建Spring内置连接池
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///spring_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        
        // 2. 创建JdbcTemplate并绑定连接池
        JdbcTemplate template = new JdbcTemplate(dataSource);
        
        // 3. 执行SQL插入操作
        template.update("insert into account values(null, ?, ?)", "熊大", 1000);
    }
}

三、使用 Spring 容器管理 JDBC 组件

 1. Spring 配置文件管理连接池和模板

通过applicationContext_jdbc.xml将连接池和JdbcTemplate纳入 Spring 容器管理，实现解耦：

<?xml version="1.0" encoding="UTF-8"?>
<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">

    <!-- 1. 配置Spring内置连接池 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql:///spring_db"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>

    <!-- 2. 配置JdbcTemplate并注入连接池 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

</beans>

2. 基于 Spring 测试的依赖注入

通过@Autowired自动获取JdbcTemplate，简化代码：

package com.qcbyjy.test.demo1;

import com.qcbyjy.demo1.model.Account;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

//使用Spring框架来管理模板类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(value = "classpath:applicationContext_jdbc.xml")
//@ContextConfiguration(value = "classpath:applicationContext_druid.xml")
public class Demo1_1 {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //测试
//    插入
    @Test
    public void run1() {
        jdbcTemplate.update("INSERT  into account VALUES (null,?,?)", "圈圈", 5000);

    }
    //    修改
    @Test
    public void run2() {
        jdbcTemplate.update("UPDATE  account set name=?,money=? where id=?", "光头强", 122, 7);
    }

    //    删除
    @Test
    public void run3() {
        jdbcTemplate.update("delete from account where id=?", 7);

    }

    //    通过id查询
    @Test
    public void run4() {
    // 使用自定义RowMapper将ResultSet映射为Java对象
        Account account = jdbcTemplate.queryForObject("select *  from account where id=?", new BeanMapper(), 8);
        System.out.println(account);
    }

    //查询所有的数据
    @Test
    public void run5(){
        List<Account> list=jdbcTemplate.query("select * from account",new BeanMapper());
        for (Account account:list){
            System.out.println(account);
        }
    }

    // 自定义结果映射器
    class BeanMapper implements RowMapper<Account> {
        public Account mapRow(ResultSet resultSet, int i) throws
                SQLException {
            Account account = new Account();
            account.setId(resultSet.getInt("id"));
            account.setName(resultSet.getString("name"));
            account.setMoney(resultSet.getDouble("money"));
            return account;
        }
    }
}

四、集成开源连接池（以 Druid 为例）

1. 添加 Druid 依赖

 在pom.xml中引入 Druid 坐标：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.10</version>
</dependency>

2. 配置属性文件（jdbc.properties）

 将数据库连接信息外置到配置文件，便于维护：

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring_db
jdbc.username=root
jdbc.password=root

3. Spring 配置文件整合 Druid

通过<context:property-placeholder>加载属性文件，并替换为 Druid 连接池：

<beans ...>
    <!-- 加载属性文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!-- 使用Druid连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!-- JdbcTemplate配置不变 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>
</beans>

六、总结

核心流程

1. 引入依赖：包含 Spring JDBC 模块、数据库驱动和连接池（如 Druid）。
2. 配置连接池：通过 Spring 配置文件管理数据库连接信息，支持内置或开源连接池。
3. 注入模板类：将JdbcTemplate纳入 Spring 容器，通过依赖注入获取实例。
4. 执行操作：利用JdbcTemplate的增删改查方法，结合RowMapper处理结果集。

最佳实践

• 外置配置：将数据库连接信息放入属性文件，避免硬编码。
• 使用开源连接池：优先选择 Druid 等高性能连接池，提升应用性能。
• 结合 Spring 测试：通过@RunWith和@ContextConfiguration简化测试代码。

通过以上实践，开发者可以大幅提升 JDBC 开发效率，将更多精力聚焦于业务逻辑实现。