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

JdbcTemplate概述

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

JdbcTemplate准备工作

引入相关 jar 包

配置xml配置文件

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

bean1.xml：

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

    bean>

    
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        
        <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 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 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