java回调和hook函数_Java的回调机制

一、回调(Callback)

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

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

@Override

@Nullable

public T execute(TransactionCallback 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 action，这里删除了一些注释：

@FunctionalInterface

public interface TransactionCallback {

@Nullable

T doInTransaction(TransactionStatus status);

}

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

result = action.doInTransaction(status);

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

@FunctionalInterface

public interface TransactionCallback {

@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 queue;

public void setQueue(BlockingQueue 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)编程模式(貌似不是设计模式，待确认)。

欢迎交流~