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回调类，又有八种方法（像上面一样各有四种），这里就不举出来了，和前面用法一致。

巴特西

jdbcTemplate学习（二）

最新文章

热门文章