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

分手后的思念是犯贱 2023-01-08 08:21 66阅读 0赞

### 目录 ###

*  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 包 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]

## 如果是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项目的代码结构：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]

## 配置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>
    
        
        <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表 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 2]

## 对应数据库创建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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 3]

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

# 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操作数据库（增删改查以及批量操作）附带源码解释的全部内容。**

**看完如果对你有帮助，感谢点赞支持！  
如果你是电脑端的话，看到右下角的 “一键三连” 了吗，没错点它\[哈哈\]**  
![在这里插入图片描述][20210115230629703.gif_pic_center]

**加油！**

**共同努力！**

**Keafmd**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70]: /images/20221119/fe24fff136dd4f308b9fe481a268bb7c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 1]: /images/20221119/21ee752706a3404e81658262c3b2a4a5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 2]: /images/20221119/dd120fccade94d1d9398c7d8bc65f53b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg4MzkxNw_size_16_color_FFFFFF_t_70 3]: /images/20221119/465572e8e7cd4706bd77678b9e3f7952.png
[20210115230629703.gif_pic_center]: /images/20221119/4df163d495974cd2825202376a24fb27.png