JdbcTemplate 易被 Java 8 Lambda 带入的坑
Spring 的 JdbcTemplate 为我们操作数据库提供非常大的便利，不需要显式的管理资源和处理异常。在我们进入到了 Java 8 后，JdbcTemplate 方法中的回调函数可以用 Lambda 表达式进行简化，而本文要说的正是这种 Lambda 简化容易给我们带来的一个 Bug, 这是我在一个实际项目中写的单元测试发现的。
下面就是我们的一个样板代码，在我们的UserRespository 中有一个方法 findAll() 用于获得所有用户：1public List<User> findAll() {
2 List<User> users = new ArrayList<>();
3 jdbcTemplate.query("select id, name from user", rs -> {
4 while (rs.next()) {
5 users.add(new User(rs.getInt("id"), rs.getString("name")));
6 }
7 });
8 return users;
9}初看上面的代码，好像也没问题啊，调用 jdbcTemplate.query(sql, callback) 方法执行 SQL 语句，接着在回调函数中拿到 ResultSet 循环获得每一行结果啊。
那么我们用事实来验证，下面是相应的测试代码
1@Test
2@Sql(statements = {
3 "delete from user",
4 "INSERT INTO user(id, name) VALUES(1, 'user1'), (2, 'user2'), (3,'user3'), (4, 'user4'), (5, 'user5')"
5})
6public void findAllShouldFetchAllUsers() {
7 List<User> allUsers = userRepository.findAll();
8 allUsers.forEach(System.out::println);
9 assertEquals(5, allUsers.size());
10}用 @Sql 往数据库中只插入 5 条记录，可是上面的断言失败了
java.lang.AssertionError:
Expected :5
Actual :4
findAll() 返回的是 4 条记录，而不是我们所期望的 5 条记录，那么还有一条记录跑哪去了。上面的 allUser.forEach(System.out::println) 打印出来的结果是：User{id=2, name='user2'}是的，第一条记录不见了，如果我们反复针对数据库表中不同的记录数进行测试的的话，丢失的记录总是第一条。分析总是丢失第一条记录的原因肯定是有人帮我们做了一次
User{id=3, name='user3'}
User{id=4, name='user4'}
User{id=5, name='user5'}
rs.next() 把光标跳了一下。这是为何呢？这就是我要说的 JdbcTemplate 被 Java 8 的 Lambda 表达式带沟里去了，因为 Lambda，让我们忽略了方法原型是什么，Lambda 相对应的
@FunctionalInterface 是什么，同时 IDE 也是帮凶。因为当我们在 IDE 中写到jdbcTemplate.query("select id, name from user", rs -> {后，很容易仗着先前用原生 JDBC 操作 ResultSet 的惯性立即就会对
rs 变量用 whilc (rs.next) {...} 进行遍历，于是问题就发生了。如果我们回归到从前，还是用匿名类的方式来写回调函数的时候，
findAll() 相应的不正确的代码就是 1public List<User> findAll() {
2 List<User> users = new ArrayList<>();
3 jdbcTemplate.query("select id, name from user", new RowCallbackHandler() {
4 @Override
5 public void processRow(ResultSet rs) throws SQLException {
6 while (rs.next()) {
7 users.add(new User(rs.getInt("id"), rs.getString("name")));
8 }
9 }
10 });
11 return users;
12}现在我们明明白白的能看到回调函数的类型是
RowCallbackHandler, 如类名所示，它就是处理 ResultSet 的当前行, 有人在帮我们遍历结果集，所以我们再次对 ResultSet 就跳过了第一行记录。在应用 Java 8 之前的 JDK, 我们出现上面错误的概率应该很小的吧，会写成如下正确的代码
1public List<User> findAll() {
2 List<User> users = new ArrayList<>();
3 jdbcTemplate.query("select id, name from user", new RowCallbackHandler() {
4 @Override
5 public void processRow(ResultSet rs) throws SQLException {
6 users.add(new User(rs.getInt("id"), rs.getString("name")));
7 }
8 });
9 return users;
10}因此再回到我们 Java 8 用 Lambda 简化后的版本就是
1public List<User> findAll() {
2 List<User> users = new ArrayList<>();
3 jdbcTemplate.query("select id, name from user", rs -> {
4 users.add(new User(rs.getInt("id"), rs.getString("name")));
5 });
6 return users;
7}这个才是正确的代码，相比于文中最开始出现的错误代码，我们做了一件吃力不讨好的事情，代码行多了反而引入了一个 Bug。
这真是被 Java 8 的 Lambda 和 IDE 惯坏了，当我们在享受 Lambda 给我们带来便利的同时，却忘记了自己是谁，方法原型是什么，以及Lambda 所代表的功能性接口是什么。
针对上面的
findAll() 方法的的意图，其实我们更应该调用<T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException;而不是现在的
void query(String sql, RowCallbackHandler rch) throws DataAccessException;对上面的方法再进一步简化就是
1public List<User> findAll() {
2 return jdbcTemplate.query("select id, name from user",
3 (rs, index) -> new User(rs.getInt("id"), rs.getString("name")));
4}为何我这么衷情于 JdbcTemplate 的各个
query(...) 的重载方法呢，而不是直接调用 queryForList(...), 各种变体呢？因为有时候需要作流式处理，而是一下把所有结果全加载到内存中。当然这里的 findAll() 完全可以用 queryForList(...) 来简化1public List<Map<String, Object>> findAll() {
2 return jdbcTemplate.queryForList("select id, name from user", new BeanPropertyRowMapper<>(User.class));
3}话说到现在，我们还是有必要从 JdbcTemplate 的原代码来理解
query(String sql, RowCallbackHandler rch) 的实现原理。下面的代码来自于 JdbcTemplate 类 1@Override
2public <T> T query(final String sql, final ResultSetExtractor<T> rse) throws DataAccessException {
3 Assert.notNull(sql, "SQL must not be null");
4 Assert.notNull(rse, "ResultSetExtractor must not be null");
5 if (logger.isDebugEnabled()) {
6 logger.debug("Executing SQL query [" + sql + "]");
7 }
8 class QueryStatementCallback implements StatementCallback<T>, SqlProvider {
9 @Override
10 public T doInStatement(Statement stmt) throws SQLException {
11 ResultSet rs = null;
12 try {
13 rs = stmt.executeQuery(sql);
14 ResultSet rsToUse = rs;
15 if (nativeJdbcExtractor != null) {
16 rsToUse = nativeJdbcExtractor.getNativeResultSet(rs);
17 }
18 return rse.extractData(rsToUse);
19 }
20 finally {
21 JdbcUtils.closeResultSet(rs);
22 }
23 }
24 @Override
25 public String getSql() {
26 return sql;
27 }
28 }
29 return execute(new QueryStatementCallback());
30}
31
32@Override
33public void query(String sql, RowCallbackHandler rch) throws DataAccessException {
34 query(sql, new RowCallbackHandlerResultSetExtractor(rch));
35}
36
37private static class RowCallbackHandlerResultSetExtractor implements ResultSetExtractor<Object> {
38
39 private final RowCallbackHandler rch;
40
41 public RowCallbackHandlerResultSetExtractor(RowCallbackHandler rch) {
42 this.rch = rch;
43 }
44
45 @Override
46 public Object extractData(ResultSet rs) throws SQLException {
47 while (rs.next()) {
48 this.rch.processRow(rs);
49 }
50 return null;
51 }
52}关键是类
RowCallbackHandlerResultSetExtractor, 它在遍历结果集，针对每一行调用我们传入的回调函数，所以它至少有一次机会作 rs.next(), 如果我们在 Lambda 也作一次 rs.next() 就成功的跳过了第一条记录。这里还有一个要非常小心的地方，如果调用的是
<T> T query(String sql, ResultSetExtractor<T> rse)而不是
void query(String sql, RowCallbackHandler rch)的话，是可以在 Lambda 中进行自主
while(rs.next()) 的，即下面的代码是下确的1public List<User> findAll() {
2 return jdbcTemplate.query("select * from user", rs -> {
3 List<User> users = new ArrayList<>();
4 while(rs.next()) {
5 users.add(new User(rs.getInt("id"), rs.getString("name")));
6 }
7 return users;
8 });
9}Lambda 的写法上与第一段代码毫无区别，唯一的不同是这个 query 方法有返回值。也就是说
- 有返回值的 JdbcTemplate.query(sql, rs -> {....}) 要自己遍历结果集
- 无反回值的 JdbcTemplate.query(sql, rs -> {....}) 不可自己遍历结果集，否则会丢失第一条记录，也就是在 Lambda 内部最后写上一句
return null就行为大变了
Java 中是不能仅以返回值的不同来重载方法，但是转换为 Lambda 表达式制造出来的假象就是根据返回值的不同而调用了不同的方法。
何时可以
while(rs.next()) 何时不可以，真是极具隐蔽性，而且出问题了还不明显，真是一个事故多发地，一不小心就会踩上地雷。
永久链接 https://yanbin.blog/jdbctemplate-java-8-lambda-trick/, 来自 隔叶黄莺 Yanbin's Blog[版权声明]
本文采用 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) 进行许可。