Java中的回调函数

ioc-aop

1
2
3
4
5
6
7
8
9
10
11

function foo(callback) {
    callback();
}

function bar() {
    // do something ...
}

foo(bar);

相信你一定看过上面这种形式的代码，没错，这就是在动态语言中被频繁运用到的回调函数。

C、C++和Pascal中也允许将函数作为指针传递

那么问题来了，如何使用没有函数类型的Java语言，写出一个回调函数呢？

Why Callback?

为什么要使用回调函数呢？或者换个方式提问，使用回调函数有什么好处呢？

事件回调

定义一个Person 的类，调用它的 greeting() 方法。

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
27

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这个方法重写一下，让一个函数传入，看看会有什么不一样的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 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() 方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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()

# 执行结果
>>> 小明说: 你好

这个时候，如果小明想要记下自己打招呼的时间，就有了

1
2
3
4
5
6
7
8
9

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这个类中所有方法的执行时间。是不是要在所有方法里添加这行代码呢？

使用回调函数来处理这件事情，会有什么不同呢？

1
2
3
4
5
6
7
8
9
10
11

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给了这种代理函数一个好听的名字，叫做 装饰器 ，并且赋予了它特殊的书写样式。

现在我就来修改一下上述的代码，让它在调用时变得更加符合直觉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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中可以很容易地实现”多态“。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

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这个对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public static void main(String args[]){

    new Thread(new Runnable() {

        @Override
        public void run() {
            // your codes here
        }

    }).start(););

}

当然，在Java程序规范中并不鼓励以上这种写法。面向对象的观点倾向于抽象出一个具体的实现类，然后调用这个具体的实现类。（除非是用完之后就被使用者抛弃）

基于此，我们可以很容易的写出这种类似回调函数的东西。

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

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接口为例。

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
27
28
29
30
31
32
33
34
35
36
37
38

@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表达式替代。

1
2
3
4
5
6

ming.greeting(person -> {
    System.out.println(person.name + "没有出门");
    return false;
});

Function接口，允许我们在编写具体业务代码的同时，声明传入的参数和返回值类型。而我们也不必花费额外的开销去声明一个接口。这种书写方式看上去和接口重载很像，但绝不一样。

Java中的动态代理

前面我们已经提到过AOP编程。

而一提到AOP，就让人联想到Java中声名显赫的Spring框架。Spring带来了管家式的编程体验，几乎接管了J2EE世界里的一切组件。在某种程度上，我们讨论Java Web编程的时候，就是在讨论Spring框架。

而在这里，我们脱离Spring框架，使用原生的Java代码来实现动态代理。

定义接口和实现

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
27
28

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的实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

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织入到原有的接口中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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 时:
小明说: 你好!

受限于笔者自身水平，文章可能含有技术性或描述上的错误。 欢迎指出问题、提出问题和制造问题。

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

                  jsonContent:
                meta: false
                pages: false
                posts:
                  title: true
                  date: true
                  path: true
                  text: false
                  raw: false
                  content: false
                  slug: false
                  updated: false
                  comments: false
                  link: false
                  permalink: false
                  excerpt: false
                  categories: false
                  tags: true