新手也能看懂的Java“回调函数”大揭秘！
为什么要推荐这篇文章？
平时我们写代码以及源码阅读中Java“回调函数”的使用太常见了，可能你还没有发现。
作者：Evink
地址：https://www.jianshu.com/p/e57f3cf0a67f
function foo(callback) {
callback();
}
function bar() {
// do something ...
}
foo(bar);
相信你一定看过上面这种形式的代码，没错，这就是在动态语言中被频繁运用到的回调函数。C、C++和Pascal中也允许将函数作为指针传递
那么问题来了，如何使用没有函数类型的Java语言，写出一个回调函数呢？
Why Callback?
为什么要使用回调函数呢？或者换个方式提问，使用回调函数有什么好处呢？
事件回调
定义一个Person 的类，调用它的 greeting()方法。
let Person = (function() {
// 构造
function Person(name) {
this.name = name;
}
Person.prototype.name;
Person.prototype.say = () => {
return "说："
};
Person.prototype.greeting = () => {
let greets = "你好!";
console.log(this.name + this.say() + greets);
};
return Person;
}());
let ming = new Person("小明");
ming.greeting();
// 执行结果
> 小明说：你好!
如果天气会影响到小明的心情，那么也许打招呼的方式也会不同。我把greeting这个方法重写一下，让一个函数传入，看看会有什么不一样的地方。
// override
Person.prototype.greeting = (greetingByWeather) => {
let greets = "你好!";
greetingByWeather(greets);
};
ming.greeting((greets) => {
console.log("今天是个大晴天！");
console.log(ming.name + ming.say + greets);
});
ming.greeting((greets) => {
console.log("今天下了小雨！");
console.log(ming.name + "没有出门");
});
// 执行结果
> 今天是个大晴天！
> 小明说：你好!
> 今天下了小雨！
> 小明没有出门
OMG！很明显，小雨天对小明来说不太友好了，所以他选择宅在家里。这次，两个不同回调函数导致了这个打招呼的行为改变。这种回调方式在JavaScript中被称作同步回调
这种把自身的全部或部分逻辑交给回调函数处理的方式，可以让写代码的人摆脱繁琐的if……else……代码块，带来简洁、灵活、高效的书写体验。但是，这种方法也会带来可读性差等缺点。不过，这个不在这篇文章的讨论范围中。
相同的对象，调用其相同的方法，参数也相同时，但表现的行为却不同。是不是让你浮想连篇……这不就是Java中常说的多态嘛！
代理回调
重新再定义一个Person的类，调用它的 greeting()方法。
class Person(object):
# 构造函数
def __init__(self, name):
self.name = name;
def greeting(self):
print(self.name + self.say(), "你好")
def say(self):
return "说:"
ming = Person("小明")
ming.greeting()
# 执行结果
>>> 小明说: 你好
这个时候，如果小明想要记下自己打招呼的时间，就有了
def greeting(self):
print("在", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "时:")
print(self.name + self.say(), "你好")
# 输出
>>> 在 2018-07-12 17:06:38 时:
>>> 小明说: 你好
但是，如果需要记录 Person这个类中所有方法的执行时间。是不是要在所有方法里添加这行代码呢？
使用回调函数来处理这件事情，会有什么不同呢？
def record_time(func):
print("在", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "时:")
return func()
record_time(ming.greeting)
# 输出
>>> 在 2018-07-12 17:19:54 时:
>>> 小明说: 你好
这样一来，我们重复性的代码能减少许多，我们使用record_time()作为一个代理，去调用我们真正的业务代码。
Python给了这种代理函数一个好听的名字，叫做 装饰器 ，并且赋予了它特殊的书写样式。
现在我就来修改一下上述的代码，让它在调用时变得更加符合直觉。
def record_time(func):
def wrapper(*args, **kwargs):
print("在", datetime.now().strftime("%Y-%m-%d %H:%M:%S"), "时:")
return func(*args, **kwargs)
return wrapper
def greeting(self):
print(self.name + record_time_v2(self.say), "你好")
@record_time
def greeting_v2(self):
print(self.name + self.say_v2(), "你好")
ming.greeting = record_time(ming.greeting)
ming.greeting()
ming.greeting_v2()
把方法greeting_v2()想象成一张自左向右滚动的纸带，然后用剪刀在纸带上任意位置裁开一道口子，把我们所需要的东西织入纸带。以满足我们日益增多的变态需求。
这些开口，就被称之为程序切面(Aspect)，这种编程的思维被称作面向切面编程(Aspect Oriented Programming)。
aop.png
Java 8 的函数指针
接口重载
通过接口重载，Java中可以很容易地实现”多态“。
public interface MyInterface {
void greeting();
}
public class MyInterfaceImpl implements MyInterface {
@Override
void greeting() {
System.out.println("你好");
}
}
public static void main(String args[]) {
MyInterface i = new MyInterfaceImpl();
i.greeting();
}
接口MyInterface无法被实例化，但是被允许以参数的形式传入方法中。在调用该方法时，调用方不得不去实现该接口内定义的方法。
Java中使用这种方法进行回调的例子很多，最典型的就是Thread这个对象。
public static void main(String args[]){
new Thread(new Runnable() {
@Override
public void run() {
// your codes here
}
}).start(););
}
当然，在Java程序规范中并不鼓励以上这种写法。面向对象的观点倾向于抽象出一个具体的实现类，然后调用这个具体的实现类。（除非是用完之后就被使用者抛弃）
基于此，我们可以很容易的写出这种类似回调函数的东西。
interface GreetingByWeather {
void greeting(Person person);
}
class Person {
public String name;
public Person () {};
public Person (String name) {
this.name = name;
}
public void greeting (GreetingByWeather greetingByWeather) {
greetingByWeather.greeting(this);
}
public String say() {
return "说：";
}
}
public static void main(String args[]) {
Person ming = new Person("小明");
ming.greeting(new GreetingByWeather {
@Override
public void greeting(Person person) {
System.out.println("今天是个大晴天！");
System.out.print(person.name);
System.out.print(person.say());
System.out.println("你好！");
}
});
ming.greeting(new GreetingByWeather {
@Override
public void greeting(Person person) {
System.out.println("今天下起了雨！");
System.out.print(person.name);
System.out.println("没有出门。");
}
});
}
// 运行结果
今天是个大晴天！
小明说：你好！
今天下去了雨！
小明没有出门。
通过上面的例子，我们发现，接口GreetingByWeather定义了一个方法，传入了一个Person参数，返回了一个结果（void）。这也意味着，如果我们没有对接口进行声明，那么我们也无法正常地调用该函数（废话blabla……）
如果，能在业务调用的时候声明参数和返回值的类型，该有多好啊。
函数接口
Java 8 带来了许多新特性，诸如枚举类、lambda表达式、接口默认方法和函数接口等。其中，大部分都是基于原有的Java特性的增强和补充。而像lambda表达式之类的，更像是一种函数式编程的语法糖，它让原有的函数式编程代码更加简洁。
java.util.function包下，多了许多函数式的接口声明，它们也可以被近似地看做是一种语法糖。而事实上，Java8为了在函数式编程的方向上有所发展，放弃了简单的接口重载，而是通过动态调用 **[invokeddynamic](https://stackoverflow.com/questions/30002380/why-are-java-8-lambdas-invoked-using-invokedynamic)** 来实现的。
下面以Function接口为例。
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
public class Person {
...
public void greeting(Function<Person, Boolean> function) {
boolean result = function.apply(this);
// do sth with result ……
}
...
}
public static void main(String args[]) {
Person ming = new Person("小明");
ming.greeting(new Function<Person, String>() {
@Override
public String apply(Person person) {
System.out.println(person.name + person.say() + "你好");
return true;
}
});
}
上面的实现还可以轻易被lambda表达式替代。
ming.greeting(person -> {
System.out.println(person.name + "没有出门");
return false;
});
Function接口，允许我们在编写具体业务代码的同时，声明传入的参数和返回值类型。而我们也不必花费额外的开销去声明一个接口。这种书写方式看上去和接口重载很像，但绝不一样。
Java中的动态代理
前面我们已经提到过AOP编程。
而一提到AOP，就让人联想到Java中声名显赫的Spring框架。Spring带来了管家式的编程体验，几乎接管了J2EE世界里的一切组件。在某种程度上，我们讨论Java Web编程的时候，就是在讨论Spring框架。
而在这里，我们脱离Spring框架，使用原生的Java代码来实现动态代理。
“定义接口和实现
”
public interface GreetingService {
void greeting(Person person);
}
public class GreetingServiceImpl implements GreetingService {
@Override
void greeting(Person person) {
System.out.println(person.name + person.say() + "你好！");
}
}
public class Person {
...
public void greeting(greetingService greetingService) {
greetingService.greeting(this);
}
...
}
自jdk1.3版本以来，反射机制被引入Java体制内，它可以获取到被编译完成的类中之属性、方法或注解等元素。
“定义一个
”InvocationHandler的实现类
private class GreetingIHImpl implements InvocationHandler {
private Object obj;
GreetingIHImpl(Object obj) {
this.obj = obj;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("在 " + DateFormat.getDateTimeInstance().format(new Date()) + " 时:");
Object reflectObj = method.invoke(obj, args);
return reflectObj;
}
}
最后，我们在调用greetingService.greeting()方法的时候，将代理中的实现GreetingIHImpl织入到原有的接口中。
GreetingService greetingService = (GreetingService) Proxy.newProxyInstance(
GreetingService.class.getClassLoader(),
new Class[]{GreetingService.class},
new GreetingIHImpl(new GreetingServiceImpl())
);
...
ming.greeting(greetingService);
// 输出
在 2018-07-12 17:19:54 时:
小明说: 你好!
受限于笔者自身水平，文章可能含有技术性或描述上的错误。欢迎指出问题、提出问题和制造问题。
文章推荐
武汉加油！中国加油！