Spring JDBC

Spring 框架对 JDBC 的简单封装。提供了一个 JDBCTemplate 对象简化 JDBC 的开发

  1. 导入 jar 包
  2. 创建 JdbcTemplate 对象。
    依赖于数据源 DataSource * JdbcTemplate template = new JdbcTemplate(ds);
  3. 调用JdbcTemplate的方法来完成CRUD的操作
    • update():执行DML语句。增、删、改语句
    • queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
      • 注意：这个方法查询的结果集长度只能是1
    • queryForList():查询结果将结果集封装为list集合
      • 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
    • query():查询结果，将结果封装为JavaBean对象
      • query的参数：RowMapper
        • 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
        • new BeanPropertyRowMapper<类型>(类型.class)
    • queryForObject：查询结果，将结果封装为对象
      • 一般用于聚合函数的查询
  4. 练习：
    • 需求：
      1. 修改1号数据的 salary 为 10000
      2. 添加一条记录
      3. 删除刚才添加的记录
      4. 查询id为1的记录，将其封装为Map集合
      5. 查询所有记录，将其封装为List
      6. 查询所有记录，将其封装为Emp对象的List集合
      7. 查询总记录数
  1. import cn.itcast.domain.Emp;
  2. import cn.itcast.utils.JDBCUtils;
  3. import org.junit.Test;
  4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.jdbc.core.RowMapper;
  8. import java.sql.Date;
  9. import java.sql.ResultSet;
  10. import java.sql.SQLException;
  11. import java.util.List;
  12. import java.util.Map;
  14. public class JdbcTemplateDemo2 {
  16.     //Junit单元测试，可以让方法独立执行
  19.     //1. 获取JDBCTemplate对象
  20.     private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
  21.     /**
  22.         * 1. 修改1号数据的 salary 为 10000
  23.         */
  24.     @Test
  25.     public void test1(){
  27.         //2. 定义sql
  28.         String sql = "update emp set salary = 10000 where id = 1001";
  29.         //3. 执行sql
  30.         int count = template.update(sql);
  31.         System.out.println(count);
  32.     }
  34.     /**
  35.         * 2. 添加一条记录
  36.         */
  37.     @Test
  38.     public void test2(){
  39.         String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
  40.         int count = template.update(sql, 1015, "郭靖", 10);
  41.         System.out.println(count);
  43.     }
  45.     /**
  46.         * 3.删除刚才添加的记录
  47.         */
  48.     @Test
  49.     public void test3(){
  50.         String sql = "delete from emp where id = ?";
  51.         int count = template.update(sql, 1015);
  52.         System.out.println(count);
  53.     }
  55.     /**
  56.         * 4.查询id为1001的记录，将其封装为Map集合
  57.         * 注意：这个方法查询的结果集长度只能是1
  58.         */
  59.     @Test
  60.     public void test4(){
  61.         String sql = "select * from emp where id = ? or id = ?";
  62.         Map<String, Object> map = template.queryForMap(sql, 1001,1002);
  63.         System.out.println(map);
  64.         //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20}
  66.     }
  68.     /**
  69.         * 5. 查询所有记录，将其封装为List
  70.         */
  71.     @Test
  72.     public void test5(){
  73.         String sql = "select * from emp";
  74.         List<Map<String, Object>> list = template.queryForList(sql);
  76.         for (Map<String, Object> stringObjectMap : list) {
  77.             System.out.println(stringObjectMap);
  78.         }
  79.     }
  81.     /**
  82.         * 6. 查询所有记录，将其封装为Emp对象的List集合
  83.         */
  85.     @Test
  86.     public void test6(){
  87.         String sql = "select * from emp";
  88.         List<Emp> list = template.query(sql, new RowMapper<Emp>() {
  90.             @Override
  91.             public Emp mapRow(ResultSet rs, int i) throws SQLException {
  92.                 Emp emp = new Emp();
  93.                 int id = rs.getInt("id");
  94.                 String ename = rs.getString("ename");
  95.                 int job_id = rs.getInt("job_id");
  96.                 int mgr = rs.getInt("mgr");
  97.                 Date joindate = rs.getDate("joindate");
  98.                 double salary = rs.getDouble("salary");
  99.                 double bonus = rs.getDouble("bonus");
  100.                 int dept_id = rs.getInt("dept_id");
  102.                 emp.setId(id);
  103.                 emp.setEname(ename);
  104.                 emp.setJob_id(job_id);
  105.                 emp.setMgr(mgr);
  106.                 emp.setJoindate(joindate);
  107.                 emp.setSalary(salary);
  108.                 emp.setBonus(bonus);
  109.                 emp.setDept_id(dept_id);
  111.                 return emp;
  112.             }
  113.         });
  116.         for (Emp emp : list) {
  117.             System.out.println(emp);
  118.         }
  119.     }
  121.     /**
  122.         * 6. 查询所有记录，将其封装为Emp对象的List集合
  123.         */
  125.     @Test
  126.     public void test6_2(){
  127.         String sql = "select * from emp";
  128.         List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
  129.         for (Emp emp : list) {
  130.             System.out.println(emp);
  131.         }
  132.     }
  134.     /**
  135.         * 7. 查询总记录数
  136.         */
  138.     @Test
  139.     public void test7(){
  140.         String sql = "select count(id) from emp";
  141.         Long total = template.queryForObject(sql, Long.class);
  142.         System.out.println(total);
  143.     }
  145. }