JdbcTemplate(jdbc模版)

JdbcTemplate是Spring对JDBC的封装

使用步骤★

1.导入jar包

2.创建JdbcTemplate对象

public JdbcTemplate(DataSource dataSource)
在创建对象时,传入数据源(连接池对象),JdbcTemplate会自动从连接池对象中获取连接

3.编写sql

​ String sql = "insert into user values(null,?,?) ";

4.执行并返回结果

增删改:

public int update(final String sql,Object... args)
    用于执行INSERT、UPDATE、DELETE等DML语句
    sql: 要执行的sql语句
    args: sql执行时需要的参数 (可变参数的顺序 个数 类型要和sql语句中?的顺序 个数 类型)
1
2
3
4

查询:

public <T> T queryForObject(String sql, Class<T> requiredType, Object... args) ★★★
    //返回指定类型的一个对象
    sql: 要执行的sql
    requiredType: 返回的类型的字节码对象
    args: sql所需要的参数
    // 我们主要用该方法查询聚合函数返回的结果
    // 我们使用该方法查询一条记录并封装到实体中 BeanPropertyRowMapper<T>(T.class)

public Map<String, Object> queryForMap(String sql, Object... args)
    //将一条查询结果封装到map中返回 
    sql: 要执行的sql
    args: sql所需要的参数

List<Map<String, Object>> queryForList(String sql, Object... args)
	//将每条记录放map中,再将每个map放入list中
    sql: 要执行的sql
    args: sql所需要的参数

public <T> List<T> query(String sql, RowMapper<T> rowMapper)
    //返回一个List集合，List中存放的是RowMapper指定类型的数据
    返回多条记录: rowMapper(需要自己封装结果集)
    返回值: BeanPropertyRowMapper
  	JDBCTemplate的 query 方法用于执行SQL语句，简化JDBC的代码。同时还可以在SQL语句中使用 ？ 占位，在query 方法的 Object... args 可变参数中传入对应的参数,可变参数可以传数组.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1.查询单对象结果的数据(queryForObject) ★

可以用于查询聚合函数

  /**
     * 需求: 查询id为 5 的商品的名称
     * api: queryForObject
     *      查询结过为一个对象
     *      参数1: sql语句
     *      参数2: 返回值的类型的字节码对象
     *      参数3: 可变参数
     */
    @Test
    public void select1(){
        //1.创建jdbcTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select pname from product where id = ? ";
        //3.执行sql并返回结果集
        String pname = template.queryForObject(sql, String.class, 5);
        //4.除了结果集
        System.out.println(pname);
    }

    @Test
    /**
     * 需求: 查询商品表中数据的总数量
     * api: queryForObject
     */
    public void select2(){
        //1.创建jdbcTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql ="select count(*) from product ";
        //3.执行sql并返回结果集
        int count = template.queryForObject(sql, int.class);
        //4.除了结果集
        System.out.println(count);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

2.查询一条记录(queryForMap)

多个值

 @Test
    /**
     * 需求: 查询id为5的商品信息
     * api: queryForMap
     *      将一条查询结果封装到map集合中
     *      Map<key,value>
     *          key(String): 字段名称
     *          value(Object): 值
     */
    public void select3(){
        //1.创建模版对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select * from product where id = ? ";
        //3.执行sql并返回结果集
        Map<String, Object> map = template.queryForMap(sql, 5);
        //4.处理
        System.out.println(map);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

3.查询多条记录并封装成List(queryForList)

/**
     * 需求: 查询商品表的所有数据信息
     * api: queryForList
     *      将多条查询结过封装到list集合中
     *      List<Map<key,value>>
     *          map: 每一条记录
     */
    @Test
    public void select4(){
        //1.创建模版对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select * from product ";
        //3.执行sql并返回结果集
        List<Map<String, Object>> list = template.queryForList(sql);
        //4.处理
        for (Map<String, Object> map : list) {
            System.out.println(map);
        }
    }
   /**
     * 需求: 查询所有商品的名称(select pname from product)
     * api: queryForList
     *      将多条查询结过封装到list集合中
     *      List<String>
     *
     */
    @Test
    public void select5(){
        //1.创建模版对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select pname from product ";
        //3.执行sql并返回结果集
        List<String> list = template.queryForList(sql, String.class);
        //4.处理
        for (String str : list) {
            System.out.println(str);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

4.查询多条记录自行封装成实体(query)

List

​ new RowMapper(){}

 /**
     * 需求: 查询商品表的所有数据信息  List<Product>
     *     select * from product; ResultSet ---> next()
     * api: query
     *          rowMapper接口
     */
    @Test
    public void select6(){
        //1.创建模版对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select * from product ";
        //3.执行sql并返回结果集
        List<Product> list = template.query(sql, new RowMapper<Product>() {
            @Override
            //ResultSet: 一条记录
            //int i: 当前记录的索引
            public Product mapRow(ResultSet rs, int i) throws SQLException {
                //System.out.println(i);
                Product pro = new Product();
                pro.setId(rs.getInt(1));
                pro.setPname(rs.getString(2));
                pro.setPrice(rs.getDouble(3));
                return pro;
            }
        });
        //4.处理结果集
        for (Product pro : list) {
            System.out.println(pro);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

5.查询多条记录自动封装成实体(query) ★★

List

​ new BeanPropertyRowMapper<>(Product.class)

/**
     * 需求: 查询商品表的所有数据信息  List<Product> ★★★
     *     select * from product; ResultSet ---> next()
     * api: query
     *          BeanPropertyRowMapper
     */
    @Test
    public void select7(){
        //1.创建模版对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select * from product ";
        //3.执行sql并返回结果集
        // 若向让模版帮我们自动封装成实体,实体中属性的名称要和数据库字段名称保持一致
        List<Product> list = template.query(sql,new BeanPropertyRowMapper<>(Product.class));
        //4.处理结果集
        for (Product pro : list) {
            System.out.println(pro);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

6.查询一条记录并封装成实体 ★

/**
     * 需求: 查询id为 1 的商品信息,并封装到product实体中
     * api: queryForObject
     */
    @Test
    public void select8(){
        //1.创建JdbcTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //2.编写sql语句
        String sql = "select * from product where id=? ";
        //3.执行并返回结果集
        Product pro = template.queryForObject(sql, new BeanPropertyRowMapper<Product>(Product.class),1);
        //4.处理结果集
        System.out.println(pro);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15