Java的回调机制

---

一、回调（Callback）

回调（Callback）是编程中常用的一种编程模式。在程序运行中，当程序执行到某个特定的点或者达到某个条件后，会执行一个用户自定义的方法，用于执行用户自定义的在这个点执行的逻辑，这种机制被称为回调。回调一般与一个事件绑定，当事件发生后，会自动调用这个方法。回调在很多地方都有用到，例如，注册一个监听器监听一个点击事件，在点击发生之前这个监听器将阻塞，点击事件发生后，就会自动调用用户自定义的运行逻辑，这种调用就是回调。回调的时机一般不是由用户自己控制的，而是由框架或者事件控制的，例如Spring中就大量使用回调机制（各种Template类，例如TransactionTemplate.java，JdbcTemplate.java等），这种回调机制类似一种hook，在模板执行的逻辑中的某些点上，使用用户自定义的逻辑。

TransactionTemplate.java中的execute方法，这里删除了一些逻辑：

@Override
  @Nullable
  public <T> T execute(TransactionCallback<T> action) throws TransactionException {
      
     ....
    TransactionStatus status = this.transactionManager.getTransaction(this);
    T result;
    try {
      result = action.doInTransaction(status);
    }
    catch (RuntimeException | Error ex) {
      // Transactional code threw application exception -> rollback
      rollbackOnException(status, ex);
      throw ex;
    }
    catch (Throwable ex) {
      // Transactional code threw unexpected exception -> rollback
      rollbackOnException(status, ex);
      throw new UndeclaredThrowableException(ex, "TransactionCallback threw undeclared checked exception");
    }
    this.transactionManager.commit(status);
    return result;
  }
}

Java不能像C++那样将一个函数作为参数传入另一个函数，但是Java可以传入一个实例作为参数，这样，我们可以将一个方法封装到一个类里面，并使其竟可能的轻量级。当我们需要传入这样的参数的时候，可以传入一个匿名内部类，在JDK8之后，你可以传入一个Lambda表达式。

所以，Java的回调是通过匿名内部类实现的。

以上面的Spring的TransactionTemplate.java类为例，其中封装了回调方法的类是TransactionCallback<T> action，这里删除了一些注释：

@FunctionalInterface
public interface TransactionCallback<T> {
  @Nullable
  T doInTransaction(TransactionStatus status);
}

这里面只封装了一个方法，这个方法就是回调方法，在execute方法里面调用：

result = action.doInTransaction(status);

@FunctionalInterface是一个编译器检查注解，用于提醒编译器检查这个接口是不是一个函数式接口。函数式接口意味着这个接口里面有且只有一个抽象方法。例如一下两个接口都是函数式接口：

@FunctionalInterface
public interface TransactionCallback<T> {
  @Nullable
  T doInTransaction(TransactionStatus status);
}

@FunctionalInterface
interface GreetingService{
  void foo0(String message);
  
  default void foo1(){}
  default void foo1(){}
}

函数式接口意味着，你在传入一个这个接口类型的参数的时候，可以使用Lambda表达式。

当然，你可以选择不使用@FunctionalInterface，也没有任何影响，因为它的作用仅仅是提醒编译器去检查一下。

二、自己写一个回调

@FunctionalInterface
interface Callback {
  void do();
}

class Caller {
  public void call(Callback callback) {
    System.out.println("before");
    callback.do();
    System.out.println("after");
  }
}

public static void main(String[] args) {
  Caller caller = new Caller();
  caller.call(() -> System.out.println("doing"));
}

// 结果：
before
doing
after

是不是很简单~

当然，上面的例子只是一个简单的示例，回调有一个非常好的好处是，可以在某个事件发生的时候再调用我们定义的回调：

@FunctionalInterface
interface Callback {
  void do();
}

class Event {
  private String name;
  public String getName() { return name; }
}

class Caller {
  
  private BlockingQueue<Event> queue;
  public void setQueue(BlockingQueue<Event> queue) { this.queue = queue; }
  
  public void call(Callback callback) {
    Event event = queue.take();
    if("click".equals(event.getName()))
      callback.do();
  }
}

public static void main(String[] args) {
  Caller caller = new Caller();
  caller.call(() -> System.out.println("click done"));
}

假设在其他地方会不定时的产生各种event，这些event会被一个producer加入到queue中，我们的方法中，会使用Event event = queue.take()去阻塞的获取各种产生的event，当event的类型是”click”时，调用Callback中定义的方法，打印”click done”。这种实现方式就是一种最原始的监听器（Listener）编程模式（貌似不是设计模式，待确认）。

欢迎交流~