Java的回调机制


一、回调(Callback)

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
@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,这里删除了一些注释:

1
2
3
4
5
@FunctionalInterface
public interface TransactionCallback<T> {
@Nullable
T doInTransaction(TransactionStatus status);
}

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

1
result = action.doInTransaction(status);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
@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,也没有任何影响,因为它的作用仅仅是提醒编译器去检查一下。

二、自己写一个回调

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@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

是不是很简单~

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
@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)编程模式(貌似不是设计模式,待确认)。

欢迎交流~

我不喝咖啡,但是我相信知识有价。