jdbcTemplate学习（二）

前面讲了增加、删除、更新操作，这节讲一下查询。

查询操作：

(一)查询一个值（不需要注入参数）

queryForObject(String sql, Class<T> requiredType)；

注意：参数requiredType只能是String，Integer这种类型，不能是自定义的实体类型，只能返回一个值，不能映射对象（映射对象下面会说）；

　　sql:预处理sql；requiredType：查询单列结果的类型；

public void test() {
        String sql = "select count(*) from test";
        int count = jdbcTemplate.queryForObject(sql, Integer.class);

    }

（二）查询一个值（使用预处理sql，需要注入参数）

queryForObject(String sql, Object[] args, Class<T> requiredType)；

public void test(Integer id) {
        String sql = "select name from test where id = ?";
        String name = jdbcTemplate.queryForObject(sql, new Object[]{id}, String.class);
    }

还有如下方式：queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType)；

（三）查询单行记录，转换成一个对象（固定sql，不需要参数）

<T> T queryForObject(String sql, RowMapper<T> rowMapper)

public void test() {
        String sql = "select name,age from test where id = 10";
        Customer customer = jdbcTemplate.queryForObject(sql, new RowMapper<Customer>() {

            @Override
            public Customer mapRow(ResultSet rs, int i)
                    throws SQLException {
                Customer c = new Customer();
                c.setName(rs.getString("name"));
                c.setAge(rs.getInt("age"));
                return c;
            }

        });
    }

（四）查询单行记录，转换成一个对象（预处理sql，需要注入参数）

<T> T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper)

public void test(Integer id) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）
        String sql = "select name,age from test where id = ?";
        Customer customer = jdbcTemplate.queryForObject(sql, new Object[]{id}, new RowMapper<Customer>() {

            @Override
            public Customer mapRow(ResultSet rs, int paramInt)
                    throws SQLException {
                Customer c = new Customer();
                c.setName(rs.getString("name"));
                c.setAge(rs.getInt("age"));
                return c;
            }

        });
    }

也可以使用如下方式：（1）<T> T queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper);

　　　　　　　　　　（2）<T> T queryForObject(String sql, RowMapper<T> rowMapper, Object... args);

（五）查询数据库中一列多行数据，即查询数据库中单列数据存入一个list中，方式如下：（固定sql，没参数）

　　（a）List<Map<String, Object>> queryForList(String sql)

这个方法封装成map放入list中，key:列名（Oracle数据库sql执行结果列名默认为大写，需要小写用as取别名，别名用双引号）  value:列的值

public void test() {//如果Oracle用这个sql查询，返回的列名就是NAME(大写的)，对应Map里面的key就是NAME
        String sql = "select name from test where id > 0";
        //如果用这个sql查询，返回的列名就是name(小写的)，对应Map里面的key就是name
        String sql2 = "select name as \"name\" from test where id > 0";

        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql);//这里用的是第一个sql
    }

　　（b）<T> List<T> queryForList(String sql, Class<T> elementType)

这个方法就是直接将单类型数据存入List中。

　　    注意：这个T虽然是泛型，但是只支持Integer.class String.class 这种单数据类型的，自己定义的Bean不支持。（所以用来查询单列数据）

public void test() {

        String sql = "select name from test where id > 0";
        List<String> list = jdbcTemplate.queryForList(sql, String.class);
    }

（六）查询数据库中一列多行数据，即查询数据库中单列数据存入一个list中，方式如下：（预处理sql，需要注入参数）

　　（a）<T> List<T> queryForList(String sql, Object[] args, Class<T> elementType)

　　  注意：这个T虽然是泛型，但是只支持Integer.class String.class 这种单数据类型的，自己定义的Bean不支持。（所以用来查询单列数据,同前面一个意思，后面不再解释）

public void test(Integer id) {

        String sql = "select name from test where id > ?";
        List<String> list = jdbcTemplate.queryForList(sql, new Object[]{id}, String.class);
    }

　　还有如下方式实现：（1）<T> List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType)；

　　　　　　　　　　    （2）<T> List<T> queryForList(String sql, Class<T> elementType, Object... args)；

　　（b）List<Map<String, Object>> queryForList(String sql, Object... args)

　　封装成map存入List,和之前一样，要注意Oracle数据库返回的列名默认是大写的，如果需要，用别名变小写。

public void test(Integer id) {

        String sql = "select name from test where id > ?";
        List<Map<String, Object>> list = jdbcTemplate.queryForList(sql, new Object[]{id});
    }

　　还有一种方式实现：List<Map<String, Object>> queryForList(String sql, Object[] args, int[] argTypes)；

（七）查询多条数据（固定sql，没有参数）

　　（a）<T> List<T> query(String sql, RowMapper<T> rowMapper)

　　　　每条数据映射为java对象，放入List中。

public void test() {
        String sql = "select name,age from test where id > 10";
        List<Customer> list = jdbcTemplate.query(sql, new RowMapper<Customer>() {

            @Override
            public Customer mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                //这里必须new对象，不能在方法外new，然后用同一个，因为是一个List，查询出来多个对象映射，
                //必须保证每一次调用都使用一个新的。
                //如果不new，而是使用同一个对象，会导致存入到List中的都是一样的对象（都是最后一个对象）。
                Customer customer = new Customer();
                customer.setName(rs.getString("name"));
                customer.setAge(rs.getInt("age"));
                return customer;
            }
        });
    }

　　该方法也可以把每一行数据转换为自定义key-value的map对象放入list中，如下：（所以说使用回调类比简单方法更强大，里面逻辑自己按需求写）

public void test() {
        String sql = "select name,age from test where id > 10";
        List<Map<Integer,Object>> list = jdbcTemplate.query(sql, new RowMapper<Map<Integer,Object>>() {

            @Override
            public Map<Integer,Object> mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                Map<Integer, Object> map = new HashMap<Integer, Object>();
                map.put(rowNum, rs.getString("name"));
                map.put(rowNum, rs.getInt("age"));
                return map;
            }
        });
    }

map中的key，value类型根据需要自定义，非常方便。像这种实现RowMapper<T>接口的匿名类，T可以为Map，也可以为自定义的对象类型，如上两种，根据需要选择。

　　（b） void query(String sql, RowCallbackHandler rch)

　　　注意：如果使用RowCallbackHandler 回调类，这个方法是没有返回值的，而是在回调类中将结果放入预先定义的List中，用法如下：

public void test() {
        String sql = "select name,age from test where id > 10";

        //局部变量，必须用final修饰，内部类中才能访问（全局变量不用）
        final List<Customer> list = new ArrayList<Customer>();
        jdbcTemplate.query(sql, new RowCallbackHandler() {

            @Override
            public void processRow(ResultSet rs) throws SQLException {
                Customer customer = new Customer();
                customer.setName(rs.getString("name"));
                customer.setAge(rs.getInt("age"));
                list.add(customer);
            }
        });
    }

当然，这种方式也可以转换为map，存入list中，和上面a方式一样，这里就不详解了。

　　（c）<T> T query(final String sql, final ResultSetExtractor<T> rse)

　　ResultSetExtractor使用回调方法extractData(ResultSet rs)提供给用户整个结果集，让用户决定如何处理该结果集。

public void test() {
        String sql = "select name,age from test where id > 10";

        List<Customer> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Customer>>() {

            @Override
            public List<Customer> extractData(ResultSet rs)
                    throws SQLException, DataAccessException {
                List<Customer> result = new ArrayList<Customer>();
                while(rs.next()) {
                    Customer customer = new Customer();
                    customer.setName(rs.getString("name"));
                    customer.setAge(rs.getInt("age"));
                    result.add(customer);
                }
                return result;
            }
        });
    }

同样也可以转换为map对象放入list中，如下：

public void test() {
        String sql = "select name,age from test where id > 10";

        List<Map<String, Integer>> list = jdbcTemplate.query(sql, new ResultSetExtractor<List<Map<String, Integer>>>() {

            @Override
            public List<Map<String, Integer>> extractData(ResultSet rs)
                    throws SQLException, DataAccessException {
                List<Map<String, Integer>> result = new ArrayList<Map<String, Integer>>();
                while(rs.next()) {
                    Map<String, Integer> map = new HashMap<String, Integer>();
                    map.put(rs.getString("name"), rs.getInt("age"));
                    result.add(map);
                }
                return result;
            }
        });
    }

　　（d）<T> List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper)

public void test() {//局部变量，必须用final修饰，内部类中才能访问（全局变量不用）
        final String sql = "select name,age from test where id > 10";

        List<Customer> list = jdbcTemplate.query(new PreparedStatementCreator() {

            @Override
            public PreparedStatement createPreparedStatement(Connection conn)
                    throws SQLException {
                PreparedStatement ps = conn.prepareStatement(sql);
　　　　　　　　　//如果sql是预处理的，需要传入参数，可以在这里写jdbc代码传入，后面就不列举这种方法了
                return ps;
            }
        }, new RowMapper<Customer>() {

            @Override
            public Customer mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                Customer customer = new Customer();
                customer.setAge(rs.getInt("age"));
                customer.setName(rs.getString("name"));
                return customer;
            }
        });
    }

可以将RowMapper换成ResultSetExtractor或者RowCallbackHandler回调类，和前面一样，因此还有下面两种方法：

　　（1）void query(PreparedStatementCreator psc, RowCallbackHandler rch)；

　　（2）<T> T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse)；

（八）查询多条数据（预处理sql，需要传入参数）

　　（a）<T> List<T> query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper)

public void test(final Integer id) {//参数也是局部变量，也必须用final修饰，内部类中才能访问（全局变量不用）
        String sql = "select name,age from test where id > ?";

        List<Customer> list = jdbcTemplate.query(sql, new PreparedStatementSetter() {

            @Override
            public void setValues(PreparedStatement ps)
                    throws SQLException {
                ps.setInt(1, id);
            }
        }, new RowMapper<Customer>() {

            @Override
            public Customer mapRow(ResultSet rs, int rowNum)
                    throws SQLException {
                Customer customer = new Customer();
                customer.setName(rs.getString("name"));
                customer.setAge(rs.getInt("age"));

                return customer;
            }
        });
    }

用RowMapper回调类还有三种方法：

　　　　（1）<T> List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper)；

　　　　（2）<T> List<T> query(String sql, Object[] args, RowMapper<T> rowMapper)；

　　　　（3）<T> List<T> query(String sql, RowMapper<T> rowMapper, Object... args)；

而如果把回调类换成ResultSetExtractor或者RowCallbackHandler回调类，又有八种方法（像上面一样各有四种），这里就不举出来了，和前面用法一致。