在平时的工作中，很少会听到回调这个词语。但是在自己不断地学习当中，发现很多地方用到了回调，比如 I/O 模型中的 Reactor 模型、Spring 框架中的 JdbcTemplate、Spring WebFlux 和观察者模式，其实也用上了回调。若是以后学习反应式编程，回调知识是必备的基础。

含义

回调基于组合关系来实现，把一个对象引用传递给另一个对象，一种对象之间的关系。
回调也可以说是把一段可执行代码当做参数传递到另一段代码中，然后在将来某个时间点执行这段可执行代码。我知道上面那句话很抽象，下面会用例子讲解给大家。

实际案例

传递对象

在 Java 8 之前，java 语法不支持传递函数指针，只能通过传递对象给另外一个对象。

  1. public class Test {
  2.     public static void main(String[] args) throws  Exception {
  3.         new Test().doWork(new Callback() { // 匿名类
  4.             @Override
  5.             public void call() {
  6.                 System.out.println("回调了");
  7.             }
  8.         });
  9.     }
  11.     public void doWork(Callback callback) {
  12.         System.out.println("正在工作");
  13.         callback.call();
  14.     }
  16.     public interface Callback {
  17.         void call();
  18.     }
  19. }

执行结果：

  1. 正在工作
  2. 回调了

当调用 doWork 的方法时，将 CallBack 对象引用传递给 doWork 的方法参数，传递进入的引用稍后执行回调。整个流程还是比较清晰。这样做的好处是，我们将 doWork 方法的流程和 call 方法的流程剥离开来，两个函数不会产生太多的耦合。doWork 方法可以执行一些其他操作（这里只打印了几个字），到 call 方法时发生回调，call 方法之前的代码不会产生阻塞。

传递函数

Java 8 以后有了 lambda 表达式，我们可以将一个函数当做一个参数传递到方法参数里。所以我们继续用 lambda 表达式改造上面的代码。

  1. public class Test {
  2.     public static void main(String[] args) throws  Exception {
  3.         // 匿名类
  4.         new Test().doWork(() -> System.out.println("回调了"));
  5.     }
  7.     public void doWork(Callback callback) {
  8.         System.out.println("正在工作");
  9.         callback.call();
  10.     }
  12.     public interface Callback {
  13.         void call();
  14.     }
  15. }

这里用 lambda 表达式把一段代码塞进了 doWork 中，可以执行回调，成功打印字符串。接下来我们继续改造，假设这段 lambda 表达式有返回值，而且 doWork 方法里要根据回调方法的返回值产生新的流程分支。思考一下，这段代码我们应该如何修改。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         // 匿名类
  4.         new Test().doWork(() -> {
  5.             Random random = new Random();
  6.             return random.nextInt(100);
  7.         });
  8.     }
  10.     public void doWork(Supplier supplier) {
  11.         System.out.println("正在工作");
  12.         Integer result = (Integer) supplier.get();
  13.         if (result % 2 == 0) {
  14.             System.out.println(result + "被2整除");
  15.         } else {
  16.             System.out.println(result + "不能被2整除");
  17.         }
  18.     }
  20.     public interface Supplier<T> {
  21.         T get();
  22.     }
  23. }

在上面一段代码中，主函数 doWork 依赖回调函数的返回值，所以调用 get 方法时会发生阻塞，而 get 方法之前的代码不会发生阻塞（还没有回调呢）。

JdbcTemplate

Java 提供了 JDBC 类库来封装不同类型的数据库操作。不过，直接使用 JDBC 来编写操作数据库的代码，还是有点复杂的。比如，下面这段是使用 JDBC 来查询用户信息的代码。

  1. public class JdbcDemo {
  2.   public User queryUser(long id) {
  3.     Connection conn = null;
  4.     Statement stmt = null;
  5.     try {
  6.       //1.加载驱动
  7.       Class.forName("com.mysql.jdbc.Driver");
  8.       conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/demo", "root", "123456");
  10.       //2.创建statement类对象，用来执行SQL语句
  11.       stmt = conn.createStatement();
  13.       //3.ResultSet类，用来存放获取的结果集
  14.       String sql = "select * from user where id=" + id;
  15.       ResultSet resultSet = stmt.executeQuery(sql);
  17.       String eid = null, ename = null, price = null;
  19.       while (resultSet.next()) {
  20.         User user = new User();
  21.         user.setId(resultSet.getLong("id"));
  22.         user.setName(resultSet.getString("name"));
  23.         user.setTelephone(resultSet.getString("telephone"));
  24.         return user;
  25.       }
  26.     } catch (ClassNotFoundException e) {
  27.       // TODO: log...
  28.     } catch (SQLException e) {
  29.       // TODO: log...
  30.     } finally {
  31.       if (conn != null)
  32.         try {
  33.           conn.close();
  34.         } catch (SQLException e) {
  35.           // TODO: log...
  36.         }
  37.       if (stmt != null)
  38.         try {
  39.           stmt.close();
  40.         } catch (SQLException e) {
  41.           // TODO: log...
  42.         }
  43.     }
  44.     return null;
  45.   }
  46. }

queryUser() 函数包含很多流程性质的代码，跟业务无关，比如，加载驱动、创建数据库连接、创建 statement、关闭连接、关闭 statement、处理异常。针对不同的 SQL 执行请求，这些流程性质的代码是相同的、可以复用的，我们不需要每次都重新敲一遍。
若使用 JdbcTemplate，代码瞬间少了很多。

  2. public class JdbcTemplateDemo {
  3.   private JdbcTemplate jdbcTemplate;
  5.   public User queryUser(long id) {
  6.     String sql = "select * from user where id="+id;
  7.     return jdbcTemplate.query(sql, BeanPropertyRowMapper.newInstance(User.class)).get(0);
  8.   }
  9. }

那 JdbcTemplate 底层具体是如何实现的呢？我们来看一下它的源码。因为 JdbcTemplate 代码比较多，我只摘抄了部分相关代码，贴到了下面。

  1. @Nullable
  2. public <T> T query(
  3.     PreparedStatementCreator psc, @Nullable final PreparedStatementSetter pss, final ResultSetExtractor<T> rse)
  4.     throws DataAccessException {
  6.     Assert.notNull(rse, "ResultSetExtractor must not be null");
  7.     logger.debug("Executing prepared SQL query");
  9.     return execute(psc, new PreparedStatementCallback<T>() {
  10.         @Override
  11.         @Nullable
  12.         public T doInPreparedStatement(PreparedStatement ps) throws SQLException {
  13.             ResultSet rs = null;
  14.             try {
  15.                 if (pss != null) {
  16.                     pss.setValues(ps);
  17.                 }
  18.                 rs = ps.executeQuery();
  19.                 return rse.extractData(rs);
  20.             }
  21.             finally {
  22.                 JdbcUtils.closeResultSet(rs);
  23.                 if (pss instanceof ParameterDisposer) {
  24.                     ((ParameterDisposer) pss).cleanupParameters();
  25.                 }
  26.             }
  27.         }
  28.     });
  29. }

execute 方法的第二个参数是一个回调函数，这个函数主要目的是执行查询、处理结果集，并关闭结果集资源。让我们再看看 execute 方法的内部。

  1. @Override
  2. @Nullable
  3. public <T> T execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action)
  4.     throws DataAccessException {
  6.     Assert.notNull(psc, "PreparedStatementCreator must not be null");
  7.     Assert.notNull(action, "Callback object must not be null");
  8.     if (logger.isDebugEnabled()) {
  9.         String sql = getSql(psc);
  10.         logger.debug("Executing prepared SQL statement" + (sql != null ? " [" + sql + "]" : ""));
  11.     }
  13.     Connection con = DataSourceUtils.getConnection(obtainDataSource());
  14.     PreparedStatement ps = null;
  15.     try {
  16.         ps = psc.createPreparedStatement(con);
  17.         applyStatementSettings(ps);
  18.         T result = action.doInPreparedStatement(ps);
  19.         handleWarnings(ps);
  20.         return result;
  21.     }
  22.     catch (SQLException ex) {
  23.         // Release Connection early, to avoid potential connection pool deadlock
  24.         // in the case when the exception translator hasn't been initialized yet.
  25.         if (psc instanceof ParameterDisposer) {
  26.             ((ParameterDisposer) psc).cleanupParameters();
  27.         }
  28.         String sql = getSql(psc);
  29.         psc = null;
  30.         JdbcUtils.closeStatement(ps);
  31.         ps = null;
  32.         DataSourceUtils.releaseConnection(con, getDataSource());
  33.         con = null;
  34.         throw translateException("PreparedStatementCallback", sql, ex);
  35.     }
  36.     finally {
  37.         if (psc instanceof ParameterDisposer) {
  38.             ((ParameterDisposer) psc).cleanupParameters();
  39.         }
  40.         JdbcUtils.closeStatement(ps);
  41.         DataSourceUtils.releaseConnection(con, getDataSource());
  42.     }
  43. }

根据之前的结论，T result = action.doInPreparedStatement(ps);这行代码之前是不会发生阻塞的。整个 excecute 方法就像是一个模板方法，我们不关心加载驱动、创建数据库连接、创建 statement、关闭连接、关闭 statement，我们想要的是执行查询，并给我们返回结果集。