欢迎光临我的个人博客：https://www.jelliclecat.cn/
一、回调（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）编程模式（貌似不是设计模式，待确认）。
欢迎交流~
欢迎光临我的个人博客：https://www.jelliclecat.cn/
