Spring中使用JdbcTemplate操作数据库（增删改查以及批量操作）附带源码解释【超详细】

目录

• JdbcTemplate概述
• JdbcTemplate准备工作
• • 引入相关 jar 包
  • 如果是maven项目，使用pom.xml代替引入jar包的过程（注意）
  • 配置xml配置文件
• JdbcTemplate 操作数据库
• • 准备好数据库uset_db创建一个t_user表
  • 对应数据库创建User实体类
  • 创建UserDao接口并创建UserDaoImpl类
  • 创建UserService类并在其中注入UserDao
  • 编写测试类进行测试
• JdbcTemplate源码解释
• • jdbcTemplate.update(增删改操作)
  • jdbcTemplate.queryForObject（返回记录条数）
  • jdbcTemplate.queryForObject（返回对象）
  • jdbcTemplate.query(返回对象集合)
  • jdbcTemplate.batchUpdate(批量操作)

JdbcTemplate概述

Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。

JdbcTemplate准备工作

引入相关 jar 包

如果是maven项目，使用pom.xml代替引入jar包的过程（注意）

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.Keafmd</groupId>
    <artifactId>day04_eesy_01jdbctemplate</artifactId>
    <version>1.0-SNAPSHOT</version>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>7</source>
                    <target>7</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.6.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.2.7.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.9</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>


</project>

maven项目的代码结构：

配置xml配置文件

在 spring 配置文件配置数据库连接池，配置 JdbcTemplate 对象，注入 DataSource。配置时用的是引用外部配置文件，所以还需要引入外部的属性文件，同时创建对象时是基于注解的所以还要开启组件扫描。

bean1.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:p="http://www.springframework.org/schema/p"
       xmlns:util="http://www.springframework.org/schema/util"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
                           http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--开启组件扫描-->
    <context:component-scan base-package="com.Keafmd"></context:component-scan>

    <!--引入外部的属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">

        <property name="driverClassName" value="${jdbc.driverClass}"></property>
        <property name="url" value="${jdbc.url}" ></property>
        <property name="username" value="${jdbc.username}" ></property>
        <property name ="password" value="${jdbc.password}" ></property>

    </bean>

    <!--创建jdbcTemplate对象-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入DataSource-->
        <property name="dataSource" ref="dataSource"></property>

    </bean>

</beans>

jdbc.properties：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/user_db?characterEncoding=utf8&useUnicode=true&useSSL=false
jdbc.username=root
jdbc.password=root

JdbcTemplate 操作数据库

相关的操作及注释都在代码中，请看代码。

准备好数据库uset_db创建一个t_user表

对应数据库创建User实体类

User类：

package com.Keafmd.spring5.entity;

/**
 * Keafmd
 *
 * @ClassName: User
 * @Description: 数据库对应user实体类
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 10:07
 */

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public User() {
    }

    public User(String userId, String username, String ustatus) {
        this.userId = userId;
        this.username = username;
        this.ustatus = ustatus;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }

    public String getUserId() {
        return userId;
    }

    public String getUsername() {
        return username;
    }

    public String getUstatus() {
        return ustatus;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId='" + userId + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + ustatus + '\'' +
                '}';
    }
}

创建UserDao接口并创建UserDaoImpl类

在UserDaoImpl类注入jdbcTemplate。

UserDao接口：

package com.Keafmd.spring5.dao;

import com.Keafmd.spring5.entity.User;

import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: UserDao
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:56
 */

public interface UserDao {

    //添加方法
    void add(User user);

    //修改方法
    void updateUser(User user);

    //删除方法
    void delete(String id);

    //查询记录数
    int selectCount();

    //查询返回对象
    User findUserInfo(String id);

    //查询集合
    List<User> findAllUser();

    //批量添加
    void batchAddUser(List<Object[]> batchArgs);

    //批量修改
    void batchUpdateUser(List<Object[]> batchArgs);
    
	//批量删除
    void batchDeleteUser(List<Object[]> batchArgs);
}

UserDaoImpl类：

package com.Keafmd.spring5.dao;

import com.Keafmd.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.Arrays;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: UserDaoImpl
 * @Description: UserDao实现类
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:56
 */
@Repository
public class UserDaoImpl implements UserDao {

    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;


    //添加的方法
    @Override
    public void add(User user) {
        //创建sql语句
        String sql=" INSERT INTO t_user (user_id, username, ustatus) VALUES (?, ?, ?) ";
        // 调用方法实行
        int updat = jdbcTemplate.update(sql,user.getUserId(),user.getUsername(),user.getUstatus());
        // 返回成功的条数
        System.out.println(updat);
    }
    //修改
    @Override
    public void updateUser(User user) {

        String sql = "UPDATE   user_db.t_user SET   username = ?,  ustatus = ? WHERE user_id = ?";
        Object[] args = {user.getUsername(),user.getUstatus(),user.getUserId()};
        int updat = jdbcTemplate.update(sql,args);
        System.out.println(updat);
    }
    //删除
    @Override
    public void delete(String id) {

        String sql ="DELETE FROM user_db.t_user WHERE user_id = ?";
        int updat = jdbcTemplate.update(sql,id);
        System.out.println(updat);
    }

    //查询记录数
    @Override
    public int selectCount() {
        String sql ="SELECT COUNT(*) FROM t_user";
        Integer count = jdbcTemplate.queryForObject(sql,Integer.class);
        return count;

    }

    //返回对象
    @Override
    public User findUserInfo(String id) {
        String sql ="SELECT * FROM t_user where user_id = ?";
        User user = jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper<User>(User.class),id);
        return user;
    }

    //返回集合对象
    @Override
    public List<User> findAllUser() {
        String sql = "select * from t_user";
        List<User> userList =jdbcTemplate.query(sql,new BeanPropertyRowMapper<User>(User.class));
        return userList;
    }

    //批量添加
    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql=" INSERT INTO t_user (user_id, username, ustatus) VALUES (?, ?, ?) ";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量修改
    @Override
    public void batchUpdateUser(List<Object[]> batchArgs) {
        String sql = "UPDATE   user_db.t_user SET   username = ?,  ustatus = ? WHERE user_id = ?";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量删除
    @Override
    public void batchDeleteUser(List<Object[]> batchArgs) {
        String sql ="DELETE FROM user_db.t_user WHERE user_id = ?";
        int []ints = jdbcTemplate.batchUpdate(sql,batchArgs);
        System.out.println(Arrays.toString(ints));
    }
}

创建UserService类并在其中注入UserDao

UserService类：

package com.Keafmd.spring5.service;

import com.Keafmd.spring5.dao.UserDao;
import com.Keafmd.spring5.dao.UserDaoImpl;
import com.Keafmd.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: BookService
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 9:55
 */
@Service
public class UserService {

    //注入dao
    @Autowired
    private UserDao userDao;

    //添加的方法
    public void addUser(User user){
        userDao.add(user);
    }

    //修改的方法
    public void updateUser(User user){
        userDao.updateUser(user);
    }


    //删除的方法
    public void deleteUser(String id){
        userDao.delete(id);
    }

    //查询表中的记录数
    public int findCount(){
        return userDao.selectCount();
    }

    //查询返回对象
    public User findOne(String id){
        return userDao.findUserInfo(id);
    }

    //查询返回集合
    public List<User> findAll(){
        return userDao.findAllUser();
    }

    //批量添加
    public void batchAdd(List<Object[]> batchArgs){
        userDao.batchAddUser(batchArgs);
    }

    //批量修改
    public void batchUpdate(List<Object[]> batchArgs){
        userDao.batchUpdateUser(batchArgs);
    }

    //批量删除
    public void batchDelete(List<Object[]> batchArgs){
        userDao.batchDeleteUser(batchArgs);
    }

}

编写测试类进行测试

TestUser ：

package com.Keafmd.spring5.test;

import com.Keafmd.spring5.entity.User;
import com.Keafmd.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.ArrayList;
import java.util.List;

/**
 * Keafmd
 *
 * @ClassName: TestUser
 * @Description:
 * @author: 牛哄哄的柯南
 * @date: 2021-01-19 10:35
 */
public class TestUser {

    @Test
    public void testJdbcTemplate(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);

        //添加
        /*User user = new User("001","Keafmd","11");
        userService.addUser(user);*/

        //更新
        /*User user1 = new User("001","Keafmd","2");
        userService.updateUser(user1);*/

        //删除
        /*String id = "2";
        userService.deleteUser(id);*/

        //返回总条数
        int count = userService.findCount();
        System.out.println(count);

        // 返回对象
        User user = userService.findOne("1");
        System.out.println(user);

        // 返回集合对象

        List<User> userList =userService.findAll();
        System.out.println(userList);

        //批量添加
        /*List<Object[]> batchArgs = new ArrayList<>();
        Object[]o1 = {"7","77","7"};
        Object[]o2 = {"8","88","8"};
        Object[]o3 = {"9","99","9"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        userService.batchAdd(batchArgs);*/


        //批量修改
        /*List<Object[]> batchArgs = new ArrayList<>();
        Object[]o11 = {"tt","2","7"};
        Object[]o22 = {"uu","2","8"};
        Object[]o33 = {"ii","2","9"};
        batchArgs.add(o11);
        batchArgs.add(o22);
        batchArgs.add(o33);
        userService.batchUpdate(batchArgs);*/

        //批量删除
        List<Object[]> batchArgs = new ArrayList<>();
        Object[]o1 = {"7"};
        Object[]o2 = {"8"};
        Object[]o3 = {"9"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        userService.batchDelete(batchArgs);



    }
}

输出结果：

一月 19, 2021 4:05:28 下午 com.alibaba.druid.pool.DruidDataSource info
信息: {dataSource-1} inited
9
User{userId='1', username='Keafmd', ustatus='2'}
[User{userId='1', username='Keafmd', ustatus='2'}, User{userId='2', username='aa', ustatus='1'}, User{userId='3', username='bb', ustatus='1'}, User{userId='4', username='cc', ustatus='1'}, User{userId='5', username='dd', ustatus='1'}, User{userId='6', username='ee', ustatus='1'}, User{userId='7', username='tt', ustatus='2'}, User{userId='8', username='uu', ustatus='2'}, User{userId='9', username='ii', ustatus='2'}]
[1, 1, 1]

Process finished with exit code 0

上面两行红色的是日志信息，不是报错，不用担心。

JdbcTemplate源码解释

jdbcTemplate.update(增删改操作)

在增删改操作中调用的jdbcTemplate.update(sql,id);中有两个参数。
源码：

public int update(String sql, @Nullable Object... args) throws DataAccessException {
    return this.update(sql, this.newArgPreparedStatementSetter(args));
}

第一个参数：sql 语句。
第二个参数：可变参数，设置 sql 语句值。

jdbcTemplate.queryForObject（返回记录条数）

在查询记录数操作中调用的jdbcTemplate.queryForObject(sql,Integer.class);中有两个参数。

源码：

public <T> T queryForObject(String sql, Class<T> requiredType) throws DataAccessException {
    return this.queryForObject(sql, this.getSingleColumnRowMapper(requiredType));
}

两个参数：
第一个参数：sql 语句。
第二个参数：返回类型 Class。

jdbcTemplate.queryForObject（返回对象）

在返回对象中调用的jdbcTemplate.queryForObject(sql,new BeanPropertyRowMapper(User.class),id);中有三个参数。
源码：

public <T> T queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args) throws DataAccessException {
    List<T> results = (List)this.query((String)sql, (Object[])args, (ResultSetExtractor)(new RowMapperResultSetExtractor(rowMapper, 1)));
    return DataAccessUtils.nullableSingleResult(results);
}

有三个参数 ：
第一个参数：sql 语句。
第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。
第三个参数：sql 语句值。

jdbcTemplate.query(返回对象集合)

在返回对象集合中调用的jdbcTemplate.query(sql,newBeanPropertyRowMapper(User.class));中有两个参数。

源码：

public <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException {
    return (List)result(this.query((String)sql, (ResultSetExtractor)(new RowMapperResultSetExtractor(rowMapper))));
}

有两个个参数 ：
第一个参数：sql 语句。
第二个参数：RowMapper 是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装。

jdbcTemplate.batchUpdate(批量操作)

在批量操作中调用的jdbcTemplate.batchUpdate(sql,batchArgs);有两个参数。

源码：

public int[] batchUpdate(String sql, List<Object[]> batchArgs) throws DataAccessException {
    return this.batchUpdate(sql, batchArgs, new int[0]);
}

有两个参数 ：
第一个参数：sql 语句。
第二个参数：List 集合，添加多条记录数据。

以上就是Spring中使用JdbcTemplate操作数据库（增删改查以及批量操作）附带源码解释的全部内容。

看完如果对你有帮助，感谢点赞支持！
如果你是电脑端的话，看到右下角的 “一键三连” 了吗，没错点它[哈哈]

加油！

共同努力！

Keafmd