Spring JDBC，JDBCTemplate对象简化JDBC的开发

Spring JDBC，JDBCTemplate对象简化JDBC的开发

1. 本篇文章中使用到了Druid数据库连接池，和自己创建的一个配合数据库连接池的工具类，本篇文章对于这些没有进行详细说明，对于这个，详细请看这篇文章IDEA中使用数据库连接池连接数据库 - GUP_X - 博客园 (cnblogs.com)

2. 导入jar包

    

    

3. 链接：https://pan.baidu.com/s/1RP31eomO6GZoU1iVhf01Hg 提取码：vr3t

4. 创建JdbcTemplate对象。依赖于数据源DataSource

   • JdbcTemplate template = new JdbcTemplate(DataSource ds);

5. 调用JdbcTemplate的方法来完成增删改查的操作

   update()  // 执行DML语句。增、删、改语句
   queryForMap()  // 查询结果将结果集封装为Map集合，该方法的查询结果集长度只能是1，即只能有一行
   queryForList()  // 查询结果集封装为List集合
   query()  // 查询结果，将结果封装为JavaBean对象
            // 一般我们使用BeanPropertyRowMapper实现类，可以完成数据到JavaBean的自动封装
            // new BeanPropertyRowMapper<类型>(类型.class)
   queryForObject()  // 查询结果，将结果封装为对象，一般用于聚合函数的查询

    

   import jdbc.dataSource.jdbcutils.JDBCUtils;
   import org.springframework.jdbc.core.JdbcTemplate;
   ​
   public class JDBCTemplateDemo {
       public static void main(String[] args) {
           // 导入jar包
           // 创建JDBCTemplate对象，JDBCUtils是自己创建的一个工具类
           JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
   ​
           // 调用方法
           String sql = "update account set balance = ? where name = ?";
           // 执行sql语句，第一个参数是sql语句，后面的参数都按照顺序对应sql语句中的"?"
           int count = template.update(sql, 5000, "野猪佩奇");
           System.out.println(count);
           // 不需要释放资源，JdbcTemplate会自动帮我们释放资源
       }
   }

6. 测试：

   • 需求：

     1. 修改1号数据的balance为10000

     2. 添加一条记录

     3. 删除刚才添加的记录

     4. 查询id为1的记录，将其封装为Map集合

     5. 查询所有记录，将其封装为List集合

     6. 查询所有记录，将其封装为Account对象，在将Account对象添加到List集合中去

     7. 查询总记录数

测试所用数据库中表为：

创建一个Account类来完成第六个需求的一部分

public class Account {
    private Integer id;
    private String name;
    private Double balance;
​
    public Account() {
    }
​
    public Account(Integer id, String name, Double balance) {
        this.id = id;
        this.name = name;
        this.balance = balance;
    }
​
    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 Double getBalance() {
        return balance;
    }
​
    public void setBalance(Double balance) {
        this.balance = balance;
    }
​
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", balance=" + balance +
                '}';
    }
}

具体实现需求：

import jdbc.dataSource.domain.Account;
import jdbc.dataSource.jdbcutils.JDBCUtils;
import org.junit.Assert;
import org.junit.Test;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
​
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import java.util.Map;
​
public class JdbcTemplateDemo1 {
    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
    /**
     * 修改1号数据的balance为9000
     */
    @Test
    public void test1() {
        String sql = "update account set balance = ? where id = ?";
        int count = template.update(sql, 9000, 1);
        // 使用断言来判断结果是否是自己想要的结果，第一个参数：如果不是自己想要的结果，则输出该参数的内容；第二个参数：想要的结果；第三个参数：实际结果
        Assert.assertEquals("修改失败", 1, count);
    }
​
    /**
     * 添加一条记录
     */
    @Test
    public void test2() {
        String sql = "insert into account values(?, ?, ?)";
        int count = template.update(sql, 3, "佩奇它霸", 99.9);
        Assert.assertEquals("插入失败", 1, count);
    }
​
    /**
     * 删除刚刚添加的数据
     */
    @Test
    public void test3() {
        String sql = "delete from account where id = ?";
        int count = template.update(sql, 3);
        Assert.assertEquals("删除失败", 1, count);
    }
​
    /**
     * 查询id = 1 的记录，将其封装为Map集合
     * 注意：这个queryForMap() 方法的查询结果集长度只能是1
     */
    @Test
    public void test4() {
        // 如果要封装成Map集合，那么查询结果只能有一行才行，如果查询结果为多行，将会报错
        // String sql = "select * from account where id = ? or id = ?";
        // Map<String, Object> map = template.queryForMap(sql, 1, 2);
        String sql = "select * from account where id = ?";
        Map<String, Object> map = template.queryForMap(sql, 1);
        System.out.println(map);
        // 输出结果为：{id=1, name=野猪佩奇, balance=9000.0}
    }
​
    /**
     * 查询所有记录，将其封装成List集合
     */
    @Test
    public void test5() {
        String sql = "select * from account";
        // queryForList() 方法是将每一条记录封装成一个Map集合，再讲Map集合装到List集合中
        List<Map<String, Object>> lists = template.queryForList(sql);
        System.out.println(lists);
        // 输出结果为：[{id=1, name=野猪佩奇, balance=9000.0}, {id=2, name=野猪乔治, balance=10000.0}]
    }
​
    /**
     * 查询所有记录，将其封装为Account对象，在装到List集合中去
     */
    @Test
    public void test6_1() {
        String sql = "select * from account";
        List<Account> lists = template.query(sql, new RowMapper<Account>() {
            @Override
            public Account mapRow(ResultSet resultSet, int i) throws SQLException {
                int id = resultSet.getInt("id");
                String name = resultSet.getString("name");
                double balance = resultSet.getDouble("balance");
                Account account = new Account();
                account.setId(id);
                account.setName(name);
                account.setBalance(balance);
                return account;
            }
        });
        for (Account account : lists) {
            System.out.println(account);
        }
        /*
          输出结果：
          Account{id=1, name='野猪佩奇', balance=9000.0}
          Account{id=2, name='野猪乔治', balance=10000.0}
         */
    }
​
    /**
     * 查询所有记录，将其封装为Account对象，在装到List集合中去
     * 上面的那个方法还是要写一大堆代码，根本没有看到JdbcTemplate的简化
     * 这是因为我们自己去实现RowMapper接口的一个匿名内部类，重写了一个重写了mapRow() 方法
     * 我们可以用JdbcTemplate给我提供好的实现类BeanPropertyRowMapper()
     */
    @Test
    public void test6_2() {
        String sql = "select * from account";
        List<Account> lists = template.query(sql, new BeanPropertyRowMapper<>(Account.class));
        // 注意：如果我们自己定义的来接收数据库表中数据赋值的类的成员变量的类型是int、double等类型，这些类型的成员变量的值都不能赋值为null，
        // 如果数据库表中对应这些成员变量的的值为null，那么在赋值的时候将会报错，所以我们应该将类的成员变量类型设置为包装类类型，如Integer
        for (Account account : lists) {
            System.out.println(account);
        }
        /*
          输出结果：
          Account{id=1, name='野猪佩奇', balance=9000.0}
          Account{id=2, name='野猪乔治', balance=10000.0}
         */
    }
​
    /**
     * 查询总记录数
     */
    @Test
    public void test7() {
        // count() 聚合函数中最好不要写*，最好写主键名称，该聚合函数返回的是一个long类型的数据
        String sql = "select count(id) from account";
        // queryForObject() 方法一般用来执行一些聚合函数的查询，第二个参数是Class类型，需要传递一个将要封装的返回值结果类型
        Long total = template.queryForObject(sql, Long.class);
    }
}