理解Java编程中的Callback设计模式

Github原文

java-design-patterns/callback

意图

将Callback(回调)函数作为其他函数的参数传入，以便在某个时间点调用这个方法。

解释

Callback(回调)函数，听起来高大上，其实跟其他函数没有什么区别，就是一个函数。我们将它作为参数传给另一个函数，这在函数作为一等公民的JavaScript中非常常见，Java8引入了Lambda表达式后也可以做到。

举个栗子，

IntStream.range(0, 3)
.forEach((i) -> System.out.println(String.format("%d号机.", i)));

代码中的forEach括号中的代码可以看作是它的参数，即是函数做了参数。

难以理解的是某个时间点这个词。
为什么一定会在那个时间点？
谁运行了这段代码？

答案是 ——函数不可能平白无故地自动运行，一定有谁call了它——其实就是更底层的代码或是框架call了它。在接下来的代码中，你会自己实现一份底层代码。

UML

代码

public interface Callback {
    void call();
}

public abstract class Task {
    /**
     * 这就是我们自己的底层代码
     * 在这里，‘某个时刻’代表了在execute()结束之后
     */
    public final void executeWith(Callback callback) {
        execute();
        if (callback != null) callback.call();
    }

    protected abstract void execute();
}

public class SimpleTask extends Task {
    protected void execute() {
        System.out.println("Do some tasks before the callback method.");
    }
}

public class App {
    public static void main(String[] args) {
        Task task = new SimpleTask();
        Callback callback = new Callback() {
            public void call() {
                System.out.println("The callback method has been called!");
            }
        };
        task.executeWith(callback);
    }
}

扩展

Spring中的Bean(即为被Spring容器管理的POJO)是有其生命周期的。
而Spring会提供生命周期回调函数的接口，以便我们可以在Bean生命中的特定时间点做一些自定义的操作。示例代码如下，

两个接口

• @PostConstruct——接下来的方法会在Bean创建以后执行。
• @PreDestroy——接下来的方法会在Bean被销毁之前执行。

注意方法名本身不重要！

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

public class MyBean {
    
    @PostConstruct
    public void doYourTaskAfterConstruction() {
        System.out.println("I have been constructed!");
    }

    @PreDestroy
    public void doYourTaskBeforeDestroy() {
        System.out.println("I will be destroyed, bye bye.");
    }
}

然后定义一下元数据，表明上面的POJO是个Bean。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

最后用Spring容器来加载元数据。

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext applicationContext = 
                new AnnotationConfigApplicationContext(AppConfig.class);
        applicationContext.close();
    }
}

运行main函数的结果

I have been constructed!
I will be destroyed, bye bye.

结论

如何使用Callback模式？

• 作为开发者——我们可以规定在代码执行到某个时间点时，向外暴露出一些接口，以便用户自定义地实现这些接口。
  比如上文中的executeWith(callback)

• 作为用户——我们应该知道开发者为我们在哪些时间点提供了接口。通过实现这些接口，我们可以保证代码在约定好的时间点被运行。
  比如我们知道了在Spring中，@PostConstruct和 @PreDestroy分别表示Bean被创建之后和Bean被销毁之前这两个时间点。