经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Spring » 查看文章
Spring6 的JdbcTemplate的JDBC模板类的详细使用说明 - Rainbow-Sea
来源：cnblogs　　作者：Rainbow-Sea　　时间：2024/5/13 8:53:34　　对本文有异议

1. Spring6 的JdbcTemplate的JDBC模板类的详细使用说明

@

目录

每博一文案

  1. 他伸直双臂，举过头顶，两只手握在一起，伸了个懒腰，望着天地交接的地方，声音飘渺，嗯，有人说高中喜欢的人是能记一辈子的。
  2. 你信吗？
  3. 他侧着头望着他，邢武对他笑，笑得那么云淡风轻，眼神却那么复杂，声音透过风有些不真切地传了过去。
  4. 你这么优秀，不能回在感情上。
  5. 那一瞬间，晴也身上仿佛迸发出耀眼自信的光芒，转过身，逆着光昂起下巴说，一辈子很长，可以做很多事，但我不会把它用来记住一个人。
  6. 我晴也不可能毁在任何事情上。
  7. 信我，我不是懦夫。
  8. 如果我敢拿未来赌一把，你会让我输吗？
  9. 晴也把选择权重新拾了起来，郑重地交还到邢武手中。
  10. 他知道邢武的担忧和闪躲，也知道他的顾虑和徘徊。
  11. 无论是他的家庭，他的出身，他的背景，让他不敢去想以后。
  12. 所以晴也把自己的决心赤裸裸地洒在这片戈壁滩上，让他清晰地感受着，神情凝重地望着邢武，身影被夕阳拉得颀长，那一刻，他只感觉到一股强大的力量撞进他的心脏。
  13. 仿佛藏着排山倒海的光束向他奔腾而来，那么强烈，那么坚定。
  14. 他的生命中从来没有出现过这样一个人，一个不惧天地万物，不怕世俗捆绑的女孩儿，一个浑身是光让他看见未来的女孩儿。
  15. 一个充满智慧，勇敢，把命运牢牢攥在手中的女孩儿。
  16. 他忽然很怕眼前的这个女孩儿，怕过了这辈子就再也遇不到了。
  17. 如果他都敢赌，他又有什么理由退缩呢？
  18. 							——————《耀眼》

JdbcTemplate 是Spring 提供的一个JDBC模板类，是对JDBC的封装，简化JDBC代码，当然，你也可以不用，可以让Spring集成其它的ORM框架，例如：MyBatis，Hibernate 等。其中JDBC关于数据库的连接也是一个重要的内容，想要了解更多的大家可以移步至：?????? JDBC_ChinaRainbowSea的博客-CSDN博客

下面我们正式开始对 JdbcTemplate 上的学习，完成增删改查。

2. 环境准备

这里，我们新建一个模块，方便学习，如下：因为我们这里是Spring6，而Spring6最低支持的JDK是17，所以我这里是 JDK17的。

在这里插入图片描述
新建好模块以后，我们需要导入相关的依赖，这里我们通过 maven 导入依赖。关于Maven 的内容呢，大家可以移步至：??????Maven_ChinaRainbowSea的博客-CSDN博客 ，进行更多的学习了解

具体的依赖有：

  1. spring context 依赖 (spring6 的依赖)
  2. mysql-connector-java(关于MySQL驱动的依赖，因为我们要连接数据库，这里我们连接的是MySQL数据库)
  3. spring-jdbc (spring jdbc，这个依赖中有JdbcTemplate)
  4. junit (Junit4 单元测试依赖)

特殊的还有这个，也得添加上

在这里插入图片描述

  1. <repositories>
  2.         <repository>
  3.             <id>repository.spring.milestone</id>
  4.             <name>Spring Milestone Repository</name>
  5.             <url>https://repo.spring.io/milestone</url>
  6.         </repository>
  7.     </repositories>

在这里插入图片描述

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.rainbowsea</groupId>
  8.     <artifactId>spring6-009-jdbc-blog</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <maven.compiler.source>17</maven.compiler.source>
  13.         <maven.compiler.target>17</maven.compiler.target>
  14.     </properties>
  17.     <repositories>
  18.         <repository>
  19.             <id>repository.spring.milestone</id>
  20.             <name>Spring Milestone Repository</name>
  21.             <url>https://repo.spring.io/milestone</url>
  22.         </repository>
  23.     </repositories>
  26.     <dependencies>
  27.         <!--        spring context 依赖-->
  28.         <dependency>
  29.             <groupId>org.springframework</groupId>
  30.             <artifactId>spring-context</artifactId>
  31.             <version>6.0.11</version>
  32.         </dependency>
  34.         <!-- mysql驱动 -->
  35.         <dependency>
  36.             <groupId>mysql</groupId>
  37.             <artifactId>mysql-connector-java</artifactId>
  38.             <version>8.0.30</version>
  39.         </dependency>
  41.         <!--spring jdbc，这个依赖中有JdbcTemplate-->
  42.         <dependency>
  43.             <groupId>org.springframework</groupId>
  44.             <artifactId>spring-jdbc</artifactId>
  45.             <version>6.0.0-M2</version>
  46.         </dependency>
  48.         <!-- junit4 -->
  49.         <dependency>
  50.             <groupId>junit</groupId>
  51.             <artifactId>junit</artifactId>
  52.             <version>4.13.2</version>
  53.             <scope>test</scope>
  54.         </dependency>
  55.     </dependencies>
  57. </project>

3. 数据准备

首先，我们创建一个名为 spring6的数据库，想要了解SQL语句的内容的，大家可以移步至?????? SQL语法学习_ChinaRainbowSea的博客-CSDN博客

  1. /* 判断该数据库是否存在，不存在，创建*/
  2. CREATE DATABASE IF NOT EXISTS spring6;

然后在 spring6 数据库中创建一个名为 user 的数据表

  2. CREATE TABLE `user`  (
  3.   `id` int NOT NULL AUTO_INCREMENT,
  4.   `real_name` varchar(255) ,
  5.   `age` int ,
  6.   PRIMARY KEY (`id`) USING BTREE
  7. ) ;
  9. -- ----------------------------
  10. -- Records of user
  11. -- ----------------------------
  12. INSERT INTO `user` VALUES (1, '李四', 33);
  13. INSERT INTO `user` VALUES (2, '李华', 20);
  14. INSERT INTO `user` VALUES (3, '李华', 21);

在这里插入图片描述
在这里插入图片描述

准备实体类：表user对应的实体类User。根据user 数据表结构创建对于的Bean 实体类。

注意： 这里我们定义用对应简单类型的包装类，来定义成员变量，防止数据库的数值为Null时，报错，中断。

在这里插入图片描述

  1. package com.rainbowsea.spring6.bean;
  4. /**
  5.  * user 数据表对应的映射的 bean 对象
  6.  */
  7. public class User {
  10.     // 定义包装类，作为属性类型，防止 数据库中的数值为 null，报错
  11.     private Integer id;
  12.     private String realName;
  13.     private Integer age;
  15.     public User(Integer id, String realName, Integer age) {
  16.         this.id = id;
  17.         this.realName = realName;
  18.         this.age = age;
  19.     }
  22.     public User() {
  23.     }
  26.     public Integer getId() {
  27.         return id;
  28.     }
  30.     public void setId(Integer id) {
  31.         this.id = id;
  32.     }
  34.     public String getRealName() {
  35.         return realName;
  36.     }
  38.     public void setRealName(String realName) {
  39.         this.realName = realName;
  40.     }
  42.     public Integer getAge() {
  43.         return age;
  44.     }
  46.     public void setAge(Integer age) {
  47.         this.age = age;
  48.     }
  50.     @Override
  51.     public String toString() {
  52.         return "User{" +
  53.                 "id=" + id +
  54.                 ", realName='" + realName + '\'' +
  55.                 ", age=" + age +
  56.                 '}';
  57.     }
  58. }

配置编写相关的spring.xml的信息

JdbcTemplate 是Spring 提供好的类，这类的完整类名是：org.springframework.jdbc.core.JdbcTemplate 。这个类上的使用，我们 new 对象就好了，而Spring 可以帮我们 new 对象，所以，我们就将这个new JdbcTemplate 对象这件事交给 Spring 来做。直接将这个类配置到 spring.xml 的配置文件当中，纳入 Bean管理即可。

在这里插入图片描述

我们来看一下这个JdbcTemplate源码：

在这里插入图片描述
所以这里，我们只需要配置好 DataSource 数据源，用来连接数据库即可，将DataSource 属性进行 set 注入赋值上。可以看到JdbcTemplate中有一个DataSource属性，这个属性是数据源，我们都知道连接数据库需要Connection对象，而生成Connection对象是数据源负责的。所以我们需要给JdbcTemplate设置数据源属性。
所有的数据源都是要实现javax.sql.DataSource接口的。这个数据源可以自己写一个，也可以用写好的，比如：阿里巴巴的德鲁伊连接池，c3p0，dbcp等。我们这里自己先手写一个数据源。

自己的数据源，数据源存在的目的是为了提供 Connection 对象；只要实现了DataSource 接口的都是数据源：德鲁伊连接池，C3p0连接池，dbcp连接池，都实现了DataSource 接口

如下：

在这里插入图片描述
重写其中的**public Connection getConnection() throws SQLException ** 方法，注意是没有参数的。

在这里插入图片描述

  1. @Override
  2.     public Connection getConnection() throws SQLException {
  3.         try {
  4.             // 注册驱动
  5.             Class<?> clazz = Class.forName(driver);
  6.             // 获取数据库连接对象
  7.             Connection connection = DriverManager.getConnection(url, userName, password);
  9.             System.out.println(connection);
  10.             return connection;
  12.         } catch (Exception e) {
  13.             e.printStackTrace();
  14.         }
  15.         return null;
  16.     }
  1. package com.rainbowsea.spring6.bean;
  3. import javax.sql.DataSource;
  4. import java.io.PrintWriter;
  5. import java.sql.Connection;
  6. import java.sql.DriverManager;
  7. import java.sql.SQLException;
  8. import java.sql.SQLFeatureNotSupportedException;
  9. import java.util.logging.Logger;
  12. /**
  13.  * 自己的数据源，数据源存在的目的是为了提供 Connection 对象
  14.  * 只要实现了DataSource 接口的都是数据源
  15.  * 德鲁伊连接池，C3p0连接池，dbcp连接池，都实现了DataSource 接口
  16.  */
  17. public class MyDataSource implements DataSource {
  20.     private String driver;
  21.     private String url;
  22.     private String userName;
  23.     private String password;
  25.     public MyDataSource() {
  26.     }
  28.     public MyDataSource(String driver, String url, String userName, String password) {
  29.         this.driver = driver;
  30.         this.url = url;
  31.         this.userName = userName;
  32.         this.password = password;
  33.     }
  36.     public String getDriver() {
  37.         return driver;
  38.     }
  40.     public void setDriver(String driver) {
  41.         this.driver = driver;
  42.     }
  44.     public String getUrl() {
  45.         return url;
  46.     }
  48.     public void setUrl(String url) {
  49.         this.url = url;
  50.     }
  52.     public String getUserName() {
  53.         return userName;
  54.     }
  56.     public void setUserName(String userName) {
  57.         this.userName = userName;
  58.     }
  60.     public String getPassword() {
  61.         return password;
  62.     }
  64.     public void setPassword(String password) {
  65.         this.password = password;
  66.     }
  69.     @Override
  70.     public String toString() {
  71.         return "MyDataSource{" +
  72.                 "driver='" + driver + '\'' +
  73.                 ", url='" + url + '\'' +
  74.                 ", userName='" + userName + '\'' +
  75.                 ", password='" + password + '\'' +
  76.                 '}';
  77.     }
  79.     @Override
  80.     public Connection getConnection() throws SQLException {
  81.         try {
  82.             // 注册驱动
  83.             Class<?> clazz = Class.forName(driver);
  84.             // 获取数据库连接对象
  85.             Connection connection = DriverManager.getConnection(url, userName, password);
  87.             System.out.println(connection);
  88.             return connection;
  90.         } catch (Exception e) {
  91.             e.printStackTrace();
  92.         }
  93.         return null;
  94.     }
  96.     @Override
  97.     public Connection getConnection(String username, String password) throws SQLException {
  99.         return null;
  101.     }
  103.     @Override
  104.     public PrintWriter getLogWriter() throws SQLException {
  105.         return null;
  106.     }
  108.     @Override
  109.     public void setLogWriter(PrintWriter out) throws SQLException {
  111.     }
  113.     @Override
  114.     public void setLoginTimeout(int seconds) throws SQLException {
  116.     }
  118.     @Override
  119.     public int getLoginTimeout() throws SQLException {
  120.         return 0;
  121.     }
  123.     @Override
  124.     public Logger getParentLogger() throws SQLFeatureNotSupportedException {
  125.         return null;
  126.     }
  128.     @Override
  129.     public <T> T unwrap(Class<T> iface) throws SQLException {
  130.         return null;
  131.     }
  133.     @Override
  134.     public boolean isWrapperFor(Class<?> iface) throws SQLException {
  135.         return false;
  136.     }
  137. }

写完数据源，我们需要把这个数据源传递给JdbcTemplate。因为JdbcTemplate中有一个DataSource属性;同时获取为该 DataSource 数据源，通过Spring的set 注入，为其中的成员变量赋值。就是连接我们MySQL数据库的一些信息。如下：

在这里插入图片描述

  1. <!--        配置自己写的数据源-->
  2. <!--        当然，也可以集成其他人或者其他组织开发的数据源，例如：c3p0，dbcp druid-->
  3.         <bean id="dataSource" class="com.rainbowsea.spring6.bean.MyDataSource">
  4.             <property name="driver" value="com.mysql.cj.jdbc.Driver"></property>
  5.             <property name="url" value="jdbc:mysql://localhost:3306/spring6"></property>
  6.             <property name="userName" value="root"></property>
  7.             <property name="password" value="123"></property>
  8.         </bean>

这时候，我们就可以将这个数据源传递给JdbcTemplate。因为JdbcTemplate中有一个DataSource属性。在这里插入图片描述

在这里插入图片描述

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  7. <!--        配置自己写的数据源-->
  8. <!--        当然，也可以集成其他人或者其他组织开发的数据源，例如：c3p0，dbcp druid-->
  9.         <bean id="dataSource" class="com.rainbowsea.spring6.bean.MyDataSource">
  10.             <property name="driver" value="com.mysql.cj.jdbc.Driver"></property>
  11.             <property name="url" value="jdbc:mysql://localhost:3306/spring6"></property>
  12.             <property name="userName" value="root"></property>
  13.             <property name="password" value="123"></property>
  14.         </bean>
  17.     <!--    配置JdbcTemplate -->
  18.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  19.         <property name="dataSource" ref="dataSource"></property>
  20.     </bean>
  22. </beans>

这里，我们的环境准备好了，数据表也准备好了，下面就可以开始通过Spring 的JdbcTemplate 操作数据库了（对数据库进行增删改查）的操作了。具体内容如下。

4. 开始

4.1 从数据表中插入(添加)数据

首先，我们通过 Spring 读取上面我们配置好的spinrg.xml 文件当中的，从而实例化 JdbcTemplate 类对象。

在这里插入图片描述
然后使用：jdbcTemplate.update() 的方法，执行SQL语句。

需要注意的是：在Spring当中的JdbcTemplate，对于数据库上的增删改，执行SQL语句都是使用update() 的方法处理的。

  1. 第一个参数：String sql

  2. 第二个参数: @Nullable Object... args 是一个可变参数(是一个数组)，表示

    表示：SQL语句当中的? 占位符的要填入的值。

在这里插入图片描述

返回值：int 表示修改/更新的记录条数。

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  1. package com.rainbowsea.test;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  8. public class JdbcTest {
  10.     @Test
  11.     public void testInsert() {
  12.         // 获取JdbcTemplate对象
  13.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  14.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  15.         // 执行插入操作
  16.         // 注意：insert delete update的sql语句，都是执行update方法。,? 表示占位符
  17.         // 因为 id 是自增的，所以，这里我们不赋值
  19.         String sql = "insert into user(real_name,age) values(?,?)";
  20.         // 返回修改的记录条数
  21.         int count = jdbcTemplate.update(sql,  "张三", 30);
  22.         System.out.println("插入的记录条数：" + count);
  23.     }
  24. }

在这里插入图片描述

4.2 从数据表中修改数据

在Spring当中的JdbcTemplate，对于数据库上的增删改，执行SQL语句都是使用update() 的方法处理的。

我们这里：将id 为1的，real_name修改为：张小六，age 为 18

在这里插入图片描述

  1. package com.rainbowsea.test;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  8. public class JdbcTest {
  11.     @Test
  12.     public void testUpdate() {
  13.         // 获取JdbcTemplate对象
  14.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  15.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  16.         // 执行插入操作
  17.         // 注意：insert delete update的sql语句，都是执行update方法。,? 表示占位符
  18.         // 执行更新操作
  19.         String sql = "update user2 set real_name = ?, age = ? where id = ?";
  20.         int count = jdbcTemplate.update(sql, "张小六", 18, 1);
  21.         System.out.println(count);
  22.     }
  23. }

在这里插入图片描述

4.3 从数据表中删除数据

在Spring当中的JdbcTemplate，对于数据库上的增删改，执行SQL语句都是使用update() 的方法处理的。

我们这里：将id 为4的一条记录删除了。

在这里插入图片描述

  1. package com.rainbowsea.test;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.JdbcTemplate;
  8. public class JdbcTest {
  10.     @Test
  11.     public void testDelete() {
  12.         // 获取JdbcTemplate对象
  13.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  14.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  15.         // 执行插入操作
  16.         // 编写SQL语句，? 表示占位符
  17.         String sql = "delete from user2 where id = ?";
  18.         // 执行更新操作
  19.         // 注意：insert delete update的sql语句，都是执行update方法。
  20.         // 返回修改的记录条数
  21.         int count = jdbcTemplate.update(sql,  4);
  22.         System.out.println("插入的记录条数：" + count);
  23.     }
  24. }

在这里插入图片描述

4.4 从数据表中查询一个对象

关于查询一条记录，使用 jdbcTemplate.queryForObject() 方法：

在这里插入图片描述

  1. 第一个参数：String sql 要执行的SQL语句

  2. 第二个参数：BeanPropertyRowMapper 与对应数据库表中 bean 类的相映射的类。一般用： new BeanPropertyRowMapper<>(T.class) 这样的对象装配上。Bean属性值和数据库记录行的映射对象。在构造方法中指定映射的对象类型。

    在这里插入图片描述
    在这里插入图片描述

  1. 第三个参数：SQL语句当中的 ？ 占位符。可变长参数，给sql语句的占位符问号传值。

  2. 返回值：运用了泛型，也就是对应数据库表中在Java当中相对应，映射的 bean 类。

在这里插入图片描述
这里我们查询一个id为1的，其中的ID，real_name，age 的一条记录

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. public class JdbcTest {
  11.     @Test
  12.     public void testSelectOne() {
  13.         // 获取JdbcTemplate对象
  14.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  15.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  16.         // 执行插入操作
  17.         // 编写SQL语句，? 表示占位符
  18.         String sql = "select id, real_name, age from user2 where id = ?";
  19.         // 执行更新操作
  20.         // 返回对应查询到的 Bean 类
  21.         User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 1);
  22.         System.out.println(user);
  23.     }
  24. }

在这里插入图片描述

4.5 从数据表中查询一个值

查询数据表当中有几条记录，对应查询数据表中的一个值的内容，我们同样还是使用：jdbcTemplate.queryForObject() 方法来进行。不同的是，这个参数是两个的，是对应的类对象，

  1. 比如这里我们查询的是一个数据表中有几条记录，几条记录，就是一个值了，一个数值类型的类对象了，可以是 int.class，也可以是 long.class，还可以是 short.class 因为只要是数值类型就可以了。
  2. 返回值是对应类的包装类，

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import java.util.List;
  11. public class JdbcTest {
  14.     /**
  15.      * 查询数据表中的一个值
  16.      */
  17.     @Test
  18.     public void testSelectOneValue() {
  19.         // 获取JdbcTemplate对象
  20.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  21.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  22.         // 执行插入操作
  23.         // 编写SQL语句，? 表示占位符
  24.         // 执行select
  25.         String sql = "select count(1) from user2";
  26.         // 返回对应数据类型的包装类
  27.         Integer count = jdbcTemplate.queryForObject(sql, int.class);
  28.         System.out.println(count);
  29.     }
  30. }

在这里插入图片描述
用 Long.class 也是可以的。

在这里插入图片描述

4.6 从数据表中查询多条记录

查询数据表中的多个对象，我们就要使用：jdbcTemplate.query() 方法了

  1. 第一个参数：同样还是：要执行的SQL语句
  2. 第二个参数：。Bean属性值和数据库记录行的映射对象。在构造方法中指定映射的对象类型。；BeanPropertyRowMapper 与对应数据库表中 bean 类的相映射的类。一般用： new BeanPropertyRowMapper<>(T.class) 这样的对象装配上。
  3. 返回值：是一个List 集合了，因为我们查询到的多条记录，自然就是存储到集合当中去了。

在这里插入图片描述
这里我们查询，user2 表中的所有用户的所有信息。

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import java.util.List;
  11. public class JdbcTest {
  13.     /**
  14.      * 查询多条记录
  15.      */
  16.     @Test
  17.     public void testSelectAll() {
  18.         // 获取JdbcTemplate对象
  19.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  20.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  21.         // 执行插入操作
  22.         // 编写SQL语句，? 表示占位符
  23.         // 执行select
  24.         String sql = "select id, real_name, age from user2";
  25.         List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
  26.         System.out.println(users);
  28.     }
  29. }

在这里插入图片描述

4.7 从数据表中批量添加数据

对于数据表中的批量添加数据，我们这里需要用上：jdbcTemplate.batchUpdate() 方法

  1. 第一个参数：String sql 要执行的SQL语句

  2. 第二个参数： List<Object[]> batchArgs 是一个List集合当中存储 Object[ ] 数组，注意是数组，这个List 就是，我们批量插入数据时，对于SQL语句当中的 ? 占位符的传值，因为这个参数是： List<Object[]> batchArgs，所以我们需要将我们 ？占位符的值，放入到List 集合当中，再作为参数，传给jdbcTemplate.batchUpdate() 方法。

    在这里插入图片描述

  1. 返回值：就是你各个批量插入的记录的，各个成功的记录条数，比如这里我们批量添加了3条记录，那么如果三条记录都插入成功了的话，就是[1,1,1]。表示每执行一次这个："insert into user2(real_name,age) values(?,?)"; SQL语句就会影响到一条记录。

插入这条记录，产生了一条记录的影响。

三条记录，各自都是只产生了一条记录的影响

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import java.util.ArrayList;
  10. import java.util.Arrays;
  11. import java.util.List;
  13. public class JdbcTest {
  16.     /**
  17.      * 批量添加数据
  18.      */
  19.     @Test
  20.     public void testAddBatch() {
  21. // 获取JdbcTemplate对象
  22.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  23.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  24.         // 批量添加，id 是自增的，这里可以省略
  25.         String sql = "insert into user2(real_name,age) values(?,?)";
  27.         Object[] objs1 = {"小花", 20};
  28.         Object[] objs2 = {"小明", 21};
  29.         Object[] objs3 = {"小刚", 22};
  31. // 将要修改的数据封装到 List 集合当中，再作为参数传入
  32.         List<Object[]> list = new ArrayList<>();
  33.         list.add(objs1);
  34.         list.add(objs2);
  35.         list.add(objs3);
  37.         int[] count = jdbcTemplate.batchUpdate(sql, list);
  38.         System.out.println(Arrays.toString(count));
  39.     }
  40. }

在这里插入图片描述

4.8 从数据表中批量修改数据

从数据表中批量修改数据还是使用：jdbcTemplate.batchUpdate() 方法。唯一不同的就是执行的SQL语句不同而已。下面我们将id 为 5,6,7 的 age 改为 10,11,12

在这里插入图片描述

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import java.util.ArrayList;
  10. import java.util.Arrays;
  11. import java.util.List;
  13. public class JdbcTest {
  15.     /**
  16.      * 批量修改
  17.      */
  18.     @Test
  19.     public void testUpdateBatch() {
  20.         // 获取JdbcTemplate对象
  21.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  22.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  23.         // 批量修改
  24.         String sql = "update user2 set age = ? where id = ?";
  25.         Object[] objs1 = { 10, 5};
  26.         Object[] objs2 = { 11, 6};
  27.         Object[] objs3 = { 12, 7};
  29.         // 将要修改的数据封装到 List 集合当中，再作为参数传入
  30.         List<Object[]> list = new ArrayList<>();
  31.         list.add(objs1);
  32.         list.add(objs2);
  33.         list.add(objs3);
  35.         int[] count = jdbcTemplate.batchUpdate(sql, list);
  36.         System.out.println(Arrays.toString(count));
  37.     }
  38. }

在这里插入图片描述

4.9 从数据表中批量删除数据

从数据表中批量删除数据还是使用：jdbcTemplate.batchUpdate() 方法。唯一不同的就是执行的SQL语句不同而已。下面我们将user 数据表中的 id 为 5,6,7 的记录删除了。

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  7. import org.springframework.jdbc.core.JdbcTemplate;
  9. import java.util.ArrayList;
  10. import java.util.Arrays;
  11. import java.util.List;
  13. public class JdbcTest {
  16.     /**
  17.      * 批量删除
  18.      */
  19.     @Test
  20.     public void testDeleteBatch() {
  21.         // 获取JdbcTemplate对象
  22.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  23.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  25.         // 批量删除
  26.         String sql = "delete from user2 where id = ?";
  27.         Object[] objs1 = {5};
  28.         Object[] objs2 = {6};
  29.         Object[] objs3 = {7};
  31.         // 将要修改的数据封装到 List 集合当中，再作为参数传入
  32.         List<Object[]> list = new ArrayList<>();
  33.         list.add(objs1);
  34.         list.add(objs2);
  35.         list.add(objs3);
  37.         int[] count = jdbcTemplate.batchUpdate(sql, list);
  38.         System.out.println(Arrays.toString(count));
  39.     }
  40. }

在这里插入图片描述

4.10 JdbcTemplate 使用回调函数

使用回调函数，可以参与的更加细节：例如：如果你想写JDBC代码，可以使用callback回调函数

想要执行回调函数，用使用上 jdbcTemplate.execute() 方法，

在这里插入图片描述

  1. 第一个参数是：String sql 要执行的SQL语句
  2. 第二个参数是：PreparedStatementCallback action ，是个接口，我们要传其实例化对象，

在这里插入图片描述
PreparedStatementCallback，一般我们通常是使用 lambda 表达式 ，简化代码。

在这里插入图片描述
在这里插入图片描述
需要注意的是：注册回调函数，当execute 方法执行的时候，回调函数中的doInPreparedStatement()会被调用

  1. 返回值：就是这里运用的泛型，返回值，就是你传的 T.class 的 Bean 对象。

这里我们使用回调函数，查询 user 数据表中 id 为 2的 用户的，id, real_name，age 的记录信息

在这里插入图片描述

  2. import com.rainbowsea.spring6.bean.User;
  3. import org.junit.Test;
  4. import org.springframework.context.ApplicationContext;
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;
  6. import org.springframework.dao.DataAccessException;
  7. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  8. import org.springframework.jdbc.core.JdbcTemplate;
  9. import org.springframework.jdbc.core.PreparedStatementCallback;
  11. import java.sql.PreparedStatement;
  12. import java.sql.ResultSet;
  13. import java.sql.SQLException;
  14. import java.util.ArrayList;
  15. import java.util.Arrays;
  16. import java.util.List;
  18. public class JdbcTest {
  21.     /**
  22.      * 回调函数
  23.      * 如果你想写JDBC代码，可以使用callback回调函数
  24.      */
  25.     @Test
  26.     public void testCallback() {
  27.         ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring6.xml");
  28.         JdbcTemplate jdbcTemplate = applicationContext.getBean("jdbcTemplate", JdbcTemplate.class);
  29.         // 准备 sql语句
  30.         String sql = "select id,real_name,age from user2 where id = ?";
  32.         // 注册回调函数，当execute 方法执行的时候，回调函数中的doInPreparedStatement()会被调用
  33.         User user = jdbcTemplate.execute(sql, new PreparedStatementCallback<User>() {
  35.             @Override
  36.             public User doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
  37.                 User user = null;
  38.                 // 1 表示第一个占位符，?的下标， 为 2
  39.                 ps.setInt(1,2);
  40.                 ResultSet resultSet = ps.executeQuery();
  41.                 if(resultSet.next()) {
  42.                     int id = resultSet.getInt("id");
  43.                     String realName = resultSet.getString("real_name");
  44.                     int age = resultSet.getInt("age");
  46.                     user = new User(id,realName,age);
  47.                 }
  49.                 return user;
  50.             }
  51.         });
  53.         System.out.println(user);
  56.     }
  57. }

在这里插入图片描述

4.11 JdbcTemplate 配合使用上德鲁伊连接池

上面演示的是用我们自己写的数据源。这里我们其实也是可以使用别人写好的。例如比较牛的德鲁伊连接池。
第一步：引入德鲁伊连接池的依赖。（毕竟是别人写的，我需要导入，才能使用），使用 maven 导入。

在这里插入图片描述

  1. <!--引入德鲁伊连接池-->
  2.         <dependency>
  3.             <groupId>com.alibaba</groupId>
  4.             <artifactId>druid</artifactId>
  5.             <version>1.1.8</version>
  6.         </dependency>

第二步：将德鲁伊中的数据源配置到 spring.xml 配置文件中。和配置我们自己写的一样。就是一些：对应数据库的注册驱动，指明数据库的所在位置，以及连接数据库的账号和密码。

需要特别注意的是：注意这里是:driverClassName,是简单类型进行set注入对属性赋值，简单类型可以用 value

在这里插入图片描述
在这里插入图片描述

而如果是使用：driver，用 ref了

在这里插入图片描述
在这里插入图片描述

这里我们用：driverClassName，进行简单类型的set 注入，对 this.driver 成员变量的属性赋值。

在这里插入图片描述

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
  8.     <!--    引入德鲁伊连接池-->
  9.     <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
  10.         <!--            注意这里是:driverClassName,，如果是 driver 是 非简单类型了，是Driver 类型-->
  11.         <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
  12.         <property name="url" value="jdbc:mysql://localhost:3306/spring6"></property>
  13.         <property name="username" value="root"></property>
  14.         <property name="password" value="123"></property>
  15.     </bean>
  16.     <!--    配置JdbcTemplate -->
  17.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  18.         <property name="dataSource" ref="druidDataSource"></property>
  19.     </bean>
  21. </beans>

下面，我们测试，使用德鲁伊数据库连接池，进行对数据库的查询：

查询id 为1的一条记录。

在这里插入图片描述
在这里插入图片描述
查询成功。

我们再使用德鲁伊进行多个数据的查询。同样也是没有问题的。

在这里插入图片描述

5. 总结：

  1. JdbcTemplate 是Spring 提供的一个JDBC模板类，是对JDBC的封装，简化JDBC代码，当然，你也可以不用，可以让Spring集成其它的ORM框架，例如：MyBatis，Hibernate 等。

  2. 使用JdbcTemplate 需要导入的如下 jar依赖

    1. 1. spring context 依赖 (spring6 的依赖)
    2. 2. mysql-connector-java(关于MySQL驱动的依赖，因为我们要连接数据库，这里我们连接的是MySQL数据库)
    3. 3. spring-jdbc (spring jdbc，这个依赖中有JdbcTemplate)
    4. 4. junit (Junit4 单元测试依赖) 
    5.

  3. 在Spring当中的JdbcTemplate，对于数据库上的增删改，执行SQL语句都是使用update() 的方法处理的。

  4. 关于查询一条记录，使用 jdbcTemplate.queryForObject() 方法：

  5. 查询数据表中的多个对象，我们就要使用：jdbcTemplate.query() 方法了

  6. 查询数据表当中有几条记录，对应查询数据表中的一个值的内容，我们同样还是使用：jdbcTemplate.queryForObject() 方法来进行。不同的是，这个参数是两个的，是对应的类对象。需要注意的第二个参数，使用的是：对应返回类型的 T.class 类

  7. 使用回调函数，可以参与的更加细节：例如：如果你想写JDBC代码，可以使用callback回调函数

    想要执行回调函数，用使用上 jdbcTemplate.execute() 方法， 需要注意的是：注册回调函数，当execute 方法执行的时候，回调函数中的doInPreparedStatement()会被调用

  8. 对于数据表中的批量添加删除修改数据，我们这里需要用上：jdbcTemplate.batchUpdate() 方法

6. 最后：

“在这个最后的篇章中，我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉，我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底，继续在其他的领域奋斗。感谢你们，我们总会在某个时刻再次相遇。”

在这里插入图片描述

原文链接：https://www.cnblogs.com/TheMagicalRainbowSea/p/18188270

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Spring热门文章

  • 解决springboot+activemq启动报注解错误的问题
  • Springboot整合Rabbitmq之Confirm和Return机制
  • SpringBoot SpringEL表达式的使用
  • SpringBoot自动配置原理,你真的懂吗?(简单易懂)
  • Spring源码：Bean生命周期（终章）
  • Springboot-Management的项目实践
  • 解决springboot 启动找不到主类的问题
  • Spring5路径匹配器PathPattern解析
  • SpringAOP如何获取方法参数上的注解
  • java与es8实战之五：SpringBoot应用中操作es8(带安全检查：https、账号密码、API Key)

    • Spring推荐文章

  • SpringBoot Session共享，配置不生效问题排查 → 你竟然在代码里下毒！
  • 【Spring源码分析】Spring Scope功能中的动态代理 - Scoped Proxy
  • Spring AOP概念及原理
  • SpringBoot2.7还是任性的，就是不支持Logback1.3，你能奈他何
  • SpringBoot+ Sharding Sphere 轻松实现数据库字段加解密
  • Spring MVC 中视图的实现原理，在Spring MVC 中实现重定向和转发，以及访问静态资源 - Rainbow-Sea
  • Spring MVC 中 HttpMessageConverter 转换器 - Rainbow-Sea
  • SpringBoot+mail 轻松实现各类邮件自动推送
  • Spring MVC 获取三个域(request请求域，session 会话域，application 应用域)对象的方式 - Rainbow-Sea
  • SpringBoot3整合SpringDoc实现在线接口文档

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号