【Spring6】| JdbcTemplate（Spring中的CRUD）

港控/mmm° 2024-03-29 16:17 78阅读 0赞

**目录**

一、JdbcTemplate

1. 环境准备

2. 新增、修改、删除

3. 查询

4. 批量添加、修改、删除

5. 使用回调函数（了解）

6. 使用德鲁伊连接池

--------------------

## 一、JdbcTemplate ##

> JdbcTemplate是Spring提供的一个JDBC模板类，是对JDBC的封装，简化JDBC代码。
> 
> 当然，你也可以不用！可以让Spring集成其它的ORM框架，例如：MyBatis、Hibernate等。
> 
> 接下来我们简单来学习一下，使用JdbcTemplate完成增删改查。

#### 1. 环境准备 ####

数据库表准备t\_user

![2e9a7f3a1df14721a205657ee26b26da.png][]

插入数据

![36a840abb9664600bb80c863bfe751d5.png][]

新建模块：spring6-008-jdbc

![c28d1090fec94cb49970040e494951b8.png][]

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.bjpowernode</groupId>
        <artifactId>spring6-008-jdbc</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <repositories>
            <repository>
                <id>repository.spring.milestone</id>
                <name>Spring Milestone Repository</name>
                <url>https://repo.spring.io/milestone</url>
            </repository>
        </repositories>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.0-M2</version>
            </dependency>
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.13.2</version>
                <scope>test</scope>
            </dependency>
            
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>8.0.30</version>
            </dependency>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>6.0.0-M2</version>
            </dependency>
        </dependencies>
        
        <properties>
            <maven.compiler.source>17</maven.compiler.source>
            <maven.compiler.target>17</maven.compiler.target>
        </properties>
    
    </project>

准备实体类：表t\_user对应的实体类User

package com.powernode.spring6.bean;
    
    public class User {
    
        private Integer id;
        private String realName;
        private Integer age;
    
        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", realName='" + realName + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public User() {
        }
    
        public User(Integer id, String realName, Integer age) {
            this.id = id;
            this.realName = realName;
            this.age = age;
        }
    
        public Integer getId() {
            return id;
        }
    
        public void setId(Integer id) {
            this.id = id;
        }
    
        public String getRealName() {
            return realName;
        }
    
        public void setRealName(String realName) {
            this.realName = realName;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
    
    }

编写数据源DataSource

> 我们使用JdbcTemplate对象，完成增删改查，所以我们先分析一下源码：

![15885a9f3e90e3d54fb47ee573e6164b.png][]

![77bfeb63e4f5a06eff0e82121d5ccb9c.png][]

> ①可以看到**JdbcTemplate类中有一个DataSource属性**，这个属性是数据源，我们都知道连接数据库需要Connection对象，而生成Connection对象是数据源负责的，所以我们需要给JdbcTemplate设置数据源属性。
> 
> ②所有的数据源都是要实现javax.sql.DataSource接口的。这个数据源可以自己写一个，也可以用写好的，比如：阿里巴巴的德鲁伊连接池druid，c3p0，dbcp等。我们这里自己先手写一个数据源，命名为MyDataSource。

准备数据源

package com.powernode.spring6.jdbc;
    
    import javax.sql.DataSource;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.SQLFeatureNotSupportedException;
    import java.util.logging.Logger;
    
    public class MyDataSource implements DataSource {
        // 提供连接数据库的属性
        private String driver;
        private String url;
        private String username;
        private String password;
        // 提供setter方法
        public void setDriver(String driver) {
            this.driver = driver;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        // 重点写怎么获取Connection对象就行，其他方法不用管。
        @Override
        public Connection getConnection() throws SQLException {
            // 获取Connection对象
            try {
                // 注册驱动
                Class.forName(driver);
                // 获取连接
                Connection connection = DriverManager.getConnection(url, username, password);
                // 返回connection对象
                return connection;
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }
    
        @Override
        public Connection getConnection(String username, String password) throws SQLException {
            return null;
        }
    
        @Override
        public PrintWriter getLogWriter() throws SQLException {
            return null;
        }
    
        @Override
        public void setLogWriter(PrintWriter out) throws SQLException {
    
        }
    
        @Override
        public void setLoginTimeout(int seconds) throws SQLException {
    
        }
    
        @Override
        public int getLoginTimeout() throws SQLException {
            return 0;
        }
    
        @Override
        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
            return null;
        }
    
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            return null;
        }
    
        @Override
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            return false;
        }
    }

spring.xml配置

> 写完数据源MyDataSource，我们需要把这个数据源传递给JdbcTemplate；因为**JdbcTemplate类中需要一个DataSource属性**！

<?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">
    
        
        <bean id="myDataSource" class="com.powernode.spring6.jdbc.MyDataSource">
            <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
            <property name="username" value="root"/>
            <property name="password" value="123"/>
        </bean>
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            
            <property name="dataSource" ref="myDataSource"/>
        </bean>
    </beans>

编写测试程序

package com.powernode.spring6.test;
    
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class SpringJdbcTest {
        @Test
        public void testTest(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            System.out.println(jdbcTemplate);
        }
    }

执行结果：成功创建JdbcTemplate对象

![c161907f13bc477cbed02a110acf5b24.png][]

#### 2. 新增、修改、删除 ####

**注意：**在**JdbcTemplate当中**，只要是**insert、update、delete**语句，都是**调用update()方法**。

> **update方法有两个参数：**
> 
> ①第一个参数：要执行的SQL语句。（SQL语句中可能会有占位符 ? ）
> 
> ②第二个参数：可变长参数（给前面的占位符传值），参数的个数可以是0个，也可以是多个；一般是SQL语句中有几个问号，则对应几个参数。

**注：对于JdbcTemplate不想MyBatis那样需要手动提交！**

**新增**

@Test
        public void testInsert(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "insert into t_user(real_name,age) values(?,?)";
            int count = jdbcTemplate.update(sql,"王五",20);
            System.out.println(count);
        }

![6cebcbecba1d40b1904e5db771e8e7d3.png][]

**修改**

@Test
        public void testUpdate(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "update t_user set real_name=?,age=? where id=?";
            int count = jdbcTemplate.update(sql,"小红",10,3);
            System.out.println(count);
        }

![2e4a574da57b4ccda981b8e556c0c4f6.png][]

**删除**

@Test
        public void testDelete(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "delete from t_user where id = ?";
            int count = jdbcTemplate.update(sql,3);
            System.out.println(count);
        }

![409c0de5df6340ceb781559d06c6acf7.png][]

#### 3. 查询 ####

**注意：select语句**调用的是**queryForObject**方法。

> **queryForObject方法有三个参数：**
> 
> ①第一个参数：sql语句。
> 
> ②第二个参数：创建一个**BeanPropertyRowMapper**对象，用来指定属性值和数据库记录行的映射关系，并且调用在构造方法中指定映射的对象类型。
> 
> ③第三个参数：可变长参数（给前面的占位符传值），给sql语句的占位符问号传值。

**查询一个对象**

> 调用**queryForObject**方法，返回的是我们构造方法中指定的对象！

@Test
        public void testSelectOne(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "select id,real_name,age from t_user where id = ?";
            User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 1);
            System.out.println(user);
        }

![49e2ff85fe644dbe9d59f730bb18920b.png][]

**查询多个对象**

> 调用的是**query**方法，**返回的是一个List集合**，类型是我们构造方法中指定的类型

@Test
        public void testSelectAll() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "select id,real_name,age from t_user";
            List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
            users.forEach(user -> {
                System.out.println(user);
            });
        }

![b7181b05b7514ddab85622c33b3ed6f7.png][]

**查询一个值**

> 还是调用**queryForObject**方法，返回的肯定是记录的条数，所以指定一下类型是int类型

**注：**因为吃查询记录的个数，和数据库中的字段没有关系，所以就不需要BeanPropertyRowMapper对象去指定映射关系，直接写int.class即可！

@Test
        public void testSelectOneValue() {
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "select count(*) from t_user";
            Integer total = jdbcTemplate.queryForObject(sql, int.class);
            System.out.println("总记录条数是："+total);
        }

![8783996e3cd34cd7aaf514094c64c236.png][]

#### 4. 批量添加、修改、删除 ####

> 批量增加、修改、删除操作，基本上的步骤都是相同的，都是要**先把要操作的数据封装到一个List集合当中**；主要的区别就是：执行的SQL不同 和 准备的数据不同！

**注：无论是批量增加、修改、还是删除调用的都是batchUpdate()方法！**

**批量增加**

> 首先把**要插入的数据封装到一个List集合**当中，然后调用**batchUpdate()**方法，把这个**List集合传进去即可！**

@Test
        public void testBatchInsert(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "insert into t_user(real_name,age) values(?,?)";
            // 准备要插入的数据
            Object[] obj1 = {"小花",12};
            Object[] obj2 = {"小明",14};
            // 创建List集合
            List<Object[]> list = new ArrayList<>();
            // 把数据添加到集合当中
            list.add(obj1);
            list.add(obj2);
            // 执行sql，调用batchUpdate方法
            int[] count = jdbcTemplate.batchUpdate(sql, list);
            System.out.println(Arrays.toString(count)); // [1, 1]
    
        }

![f57717dc2da7457bb475e7f2f10e513e.png][]

**批量修改**

> 和批量增加的步骤基本相同！

@Test
        public void testBatchUpdate(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "update t_user set real_name = ?,age = ? where id = ?";
            // 准备要插入的数据
            Object[] obj1 = {"小红",18,5};
            Object[] obj2 = {"小虹",18,6};
            // 创建List集合
            List<Object[]> list = new ArrayList<>();
            // 把数据添加到集合当中
            list.add(obj1);
            list.add(obj2);
            // 执行sql，调用batchUpdate方法
            int[] count = jdbcTemplate.batchUpdate(sql, list);
            System.out.println(Arrays.toString(count)); // [1, 1]
    
        }

![83e7e31e114a48f5a85509cbca775503.png][]

**批量删除**

> 和批量增加、修改的步骤基本相同！

@Test
        public void testBatchDelete(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "delete from t_user where id = ?";
            // 准备要插入的数据
            Object[] obj1 = {5};
            Object[] obj2 = {7};
            // 创建List集合
            List<Object[]> list = new ArrayList<>();
            // 把数据添加到集合当中
            list.add(obj1);
            list.add(obj2);
            // 执行sql，调用batchUpdate方法
            int[] count = jdbcTemplate.batchUpdate(sql, list);
            System.out.println(Arrays.toString(count)); // [1, 1]
    
        }

![fab8d96f14bb40f5b1afb91dc4837766.png][]

#### 5. 使用回调函数（了解） ####

> **回调函数的作用：**如果我们需要编写JDBC代码，就可以使用回调函数；在这个回调函数里就可以编写原生的JDBC代码，步骤如下：
> 
> ①先调用**execute**方法，注册回调函数；方法中的参数：第一个参数是**sql语句**，第二个参数是一个**PreparedStatementCallback**对象，就是一个回调函数。
> 
> ②使用回调函数我们要重写里面的**doInPreparedStatement**方法，这个方法的参数就是原生JDBC中的**PreparedStatement**对象。
> 
> ③通过PreparedStatement对象，我们就可以编写下面原生的JDBC代码了

@Test
        public void testCallback(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
            // 准备sql语句
            String sql = "select id,real_name,age from t_user where id = ?";
            // 注册回调函数
            // 调用execute方法来注册回调函数：第一个参数是sql语句，第二个参数是一个PreparedStatementCallback
            User user = jdbcTemplate.execute(sql, new PreparedStatementCallback<User>() {
                @Override
                public User doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
                   User user = null;
                    // 使用ps进行?赋值
                    ps.setInt(1,2);
                    // 返回一个set集合
                    ResultSet rs = ps.executeQuery();
                    if (rs.next()){
                        // 获取数据
                        int id = rs.getInt("id");
                        String realName = rs.getString("real_name");
                        int age = rs.getInt("age");
                        // 封装数据
                        user = new User(id,realName,age);
                    }
    
                    return user;
                }
            });
            System.out.println(user);
        }

####  ####

#### 6. 使用德鲁伊连接池 ####

> 之前的数据源MyDateSource是用我们自己写的；当然也可以使用别人写好的，例如：比较牛的阿里巴巴旗下的**德鲁伊连接池(druid)**！

**第一步：引入德鲁伊连接池的依赖**

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

**第二步：将德鲁伊中的数据源配置到spring配置文件中**

> **注：**使用德鲁伊连接池druid和自己写的连接池相比，就driver不同，其它的配置都是相同的，使用自己写的driver，我们定义的就是String类型；一旦使用德鲁伊连接池此时driver属性代表的就是Driver类型，要想使用String类型必须是使用**属性driverClassName**！

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
            <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/spring"/>
            <property name="username" value="root"/>
            <property name="password" value="123"/>
        </bean>
    
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            
            <property name="dataSource" ref="druidDataSource"/>
        </bean>

**执行结果：**

> 根据输出的信息就能看出使用的确实是德鲁伊连接池！

![1a0381db42f449b9bbfd4f6d58440738.png][]

[2e9a7f3a1df14721a205657ee26b26da.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f77ecd46285e4c798f04157e13de42a0.png
[36a840abb9664600bb80c863bfe751d5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/8e8d3fad17ad439989970437b6937dc4.png
[c28d1090fec94cb49970040e494951b8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/970cf7863f88402abce01eb0ff683a5e.png
[15885a9f3e90e3d54fb47ee573e6164b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/75e8204bdb6c48ec9cbfe61b5879ab27.png
[77bfeb63e4f5a06eff0e82121d5ccb9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c2cdf179a5a44afa84cb72c5c76c5982.png
[c161907f13bc477cbed02a110acf5b24.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c47878a57d3048aa95a77069fde0bcc8.png
[6cebcbecba1d40b1904e5db771e8e7d3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/f70a21b9ac784a3cb0af764923f9afda.png
[2e4a574da57b4ccda981b8e556c0c4f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/cfccb042942a407284ad3333faf02141.png
[409c0de5df6340ceb781559d06c6acf7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/5e0584ccd0374ba690b7736fbfe7bddd.png
[49e2ff85fe644dbe9d59f730bb18920b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2c52b724a5164ebe83ab7e2682d8bb4d.png
[b7181b05b7514ddab85622c33b3ed6f7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/305df300302f4b95aa6970c1540373b9.png
[8783996e3cd34cd7aaf514094c64c236.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/a3da75667a4f48eca5d7360dd58e89f4.png
[f57717dc2da7457bb475e7f2f10e513e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/b8af4b1a5ea2477299f3f0a632b19c0a.png
[83e7e31e114a48f5a85509cbca775503.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/ca5705c1ec71480498b104d130673232.png
[fab8d96f14bb40f5b1afb91dc4837766.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c384ac7a25a348f6a5841b6a743d5b41.png
[1a0381db42f449b9bbfd4f6d58440738.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/10fcc6e7884449a5861c9cce7b9d1be4.png