Spring JDBC

1. Spring JDBC 的概念

Spring 为了提供对 JDBC 的支持，在 JDBC 的基础上封装了一套实现，以此建立了一个 JDBC 存取框架，就是 Spring JDBC。

2. Spring JDBC 的作用

使用传统的 JDBC 实现中，JDBC 操作会有很多重复的代码，而 Spring JDBC 提供了一个 JdbcTemplate 对象来简化 JDBC 的操作。

3. Spring JDBC 的使用步骤

1. 导入 Spring JDBC 的 jar 包，右键 Add as Library

   • commons-logging-1.2.jar
   • spring-beans-5.0.0.RELEASE.jar
   • spring-core-5.0.0.RELEASE.jar
   • spring-jdbc-5.0.0.RELEASE.jar
   • spring-tx-5.0.0.RELEASE.jar

2. 创建 JdbcTemplate 对象（需要传入 DataSource 对象）

   JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
   

3. 调用 JdbcTemplate 的方法

   • int update(String sql, Object… args)

     • 功能：执行DML语句（增、删、改）

   • Map<String, Object> queryForMap(String sql, Object… args)

     • 功能：查询结果并将结果集封装为 map 集合，将列名作为 key，将值作为 value

     • 注意：这个方法只能查询一条记录，结果集长度只能为 1

   • List<Map<String, Object>> queryForList(String sql, Object… args)

     • 功能：查询结果并将结果集封装为 list 集合

     • 注意：这个方法将每一条记录封装为一个 Map 集合，再将 Map 集合装载到 List 集合中

   • List query(String sql, RowMapper rowMapper)

     • 功能：查询结果，将结果封装为 JavaBean 对象

     • 注意：RowMapper 是一个接口，用来将数据自动封装到 JavaBean 中。一般我们使用 BeanPropertyRowMapper 的对象作为 RowMapper 类型的参数。（BeanPropertyRowMapper 类是 RowMapper 接口的实现类）

       new BeanPropertyRowMapper<类型>(类型.class)
       

   • T queryForObject(String sql, Class class, Object… args)

     • 功能：查询结果，将结果封装为对象

4. Spring JDBC 的练习

1. 需求

   1. 修改张三的年龄为 21 岁
   2. 添加一条记录：小明 19岁 2班
   3. 删除刚才添加的记录
   4. 查询 id 为 1 的记录，将其封装为 Map 集合
   5. 查询所有记录，将其封装为 List 集合
   6. 查询所有记录，将其封装为 Student 对象的 List 集合
   7. 查询总记录数

2. 编码实现

   1. 创建 Student 类

      package com.zt.datasource.domain;
      
      public class Student {
          // 注意这里定义的是包装类，而不是基本数据类型，因为基本数据类型不能为 null
          private Integer id;
          private String name;
          private Integer age;
          private Integer class_id;
      
          public Student() {
          }
      
          public Student(Integer id, String name, Integer age, Integer class_id) {
              this.id = id;
              this.name = name;
              this.age = age;
              this.class_id = class_id;
          }
      
          public Integer getId() {
              return id;
          }
      
          public void setId(Integer id) {
              this.id = id;
          }
      
          public String getName() {
              return name;
          }
      
          public void setName(String name) {
              this.name = name;
          }
      
          public Integer getAge() {
              return age;
          }
      
          public void setAge(Integer age) {
              this.age = age;
          }
      
          public Integer getClass_id() {
              return class_id;
          }
      
          public void setClass_id(Integer class_id) {
              this.class_id = class_id;
          }
      
          @Override
          public String toString() {
              return "Student{" +
                      "id=" + id +
                      ", name='" + name + '\'' +
                      ", age=" + age +
                      ", class_id=" + class_id +
                      '}';
          }
      }
      
      

   2. 创建测试类

      package com.zt.datasource.jdbctemplate;
      
      import com.zt.datasource.domain.Student;
      import com.zt.datasource.utils.JDBCUtils;
      import org.junit.Test;
      import org.springframework.jdbc.core.BeanPropertyRowMapper;
      import org.springframework.jdbc.core.JdbcTemplate;
      
      import java.util.List;
      import java.util.Map;
      
      
      public class JDBCTemplateDemo2 {
          // 创建 JdbcTemplate 对象
          private JdbcTemplate jdbcTemplate = new JdbcTemplate(JDBCUtils.getDataSource());
      
          /**
           * 修改张三的年龄为 21 岁
           */
          @Test
          public void test1(){
              String sql = "update stu set age = 21 where name = ?";
              jdbcTemplate.update(sql,"张三");
          }
      
          /**
           * 添加一条记录：小明 19岁 2班
           */
          @Test
          public void test2(){
              String sql = "insert into stu values(?,?,?,?)";
              jdbcTemplate.update(sql,null,"小明",19,2);
          }
      
          /**
           * 删除刚才添加的记录
           */
          @Test
          public void test3(){
              String sql = "delete from stu where name = ?";
              jdbcTemplate.update(sql,"小明");
          }
      
          /**
           * 查询 id 为 1 的记录，将其封装为 Map 集合
           */
          @Test
          public void test4(){
              String sql = "select * from stu where id = ?";
              Map<String, Object> stringObjectMap = jdbcTemplate.queryForMap(sql, 1);
              for (String s : stringObjectMap.keySet()) {
                  System.out.println(s+":"+stringObjectMap.get(s));
              }
          }
      
          /**
           * 查询所有记录，将其封装为 List 集合
           */
          @Test
          public void test5(){
              String sql = "select * from stu";
              List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);
              for (Map<String, Object> map : maps) {
                  System.out.println(map);
              }
          }
      
          /**
           * 查询所有记录，将其封装为 Student 对象的 List 集合
           */
          @Test
          public void test6(){
              String sql = "select * from stu";
              List<Student> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
              for (Student student : query) {
                  System.out.println(student);
              }
          }
      
          /**
           * 查询总记录数
           */
          @Test
          public void test7(){
              String sql = "select count(id) from stu";
              Integer integer = jdbcTemplate.queryForObject(sql, Integer.class);
              System.out.println(integer);
          }
      
      
      }