Java回调函数详解

什么是回调函数（CallBack）

在编写程序时，有时候会调用许多API中实现实现的函数，但某些方法需要我们传入一个方法，以便在需要的时候调用我们传入进去的函数。这个被传入的函数称为回调函数（Callback function）。
打个比方，有一个餐馆，提供炒菜的服务，但是会让我们选择做菜的方式，我们去这家餐馆里面吃饭，想吃小龙虾，我们告诉他想吃小龙虾后，他询问我们要以何种方式去进行烹饪，是煎炒烹炸还是避风塘。
在上面的例子中，炒菜是我们需要调用的方法，也是API库中所提供的，而炒菜的方式，则是我们去选择的，可以我们自己去定义的。
这个这个就可以回调函数，有库函数（Librart function）来执行我们传入的回调函数（Callback function）

在Java中实现回调函数

Callable接口

Interface Callable< V >
在Java1.8官方文档中给出的内容为

1. 参数类型：V - 回调方法的返回值类型
2. 已经实现的子接口：DocumentationTool.DocumentationTask, JavaCompiler.CompilationTask
3. 这个接口位函数试接口

   @FunctionalInterface
   public interface Callable<V>
   1
   2

4. 返回结果可能引发异常，这个接口与Runnable非常相似，这两个接口的设计可以在实例化后，开启新的线程，与Runnable的差别是，Runnable不能返回参数也不能抛出异常。

代码示例

import java.util.Random;
import java.util.concurrent.Callable;

public class CallableExample  implements Callable {
    @Override
    public Object call() throws Exception {
        Random generator = new Random();

        Integer randomNumber = generator.nextInt(5);

        Thread.sleep(randomNumber * 1000);

        return randomNumber;
    }
}

    @Test
   public void callabledTest(){
        ExecutorService executorService = Executors.newCachedThreadPool();
        CallableExample callableExample = new CallableExample();
        Future<Object> future = executorService.submit(callableExample);
        executorService.shutdown();
        try{
            System.out.println(future.get());
        }catch (Exception e){
            e.printStackTrace();
        }
   }

返回值

3
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

Callback接口

已知实现此接口的类
AuthorizeCallback, ChoiceCallback, ConfirmationCallback, LanguageCallback, NameCallback, PasswordCallback, RealmCallback, RealmChoiceCallback, TextInputCallback, TextOutputCallback

这个接口的实现了会被传递给CallbackHandler，允许有能力的底层服务去回应这个回调方法，已便进行诸如数据检索等信息。回调函数不检索或显示底层安全服务请求的信息。回调实现只是提供了将这些请求传递给应用程序的方法，并且对于应用程序，如果合适的话，可以将请求的信息返回给底层的安全服务。

这个接口是可以自己定义的，定制适用于当前业务的callback接口类型来表示不同类型的回调函数

callback接口的源码

public interface Callback { }

## CallbackHandler接口
方法：handle(Callback [] callbacks)
这个方法是用来处理处理callback类型的
官方实例：
```java
 public void handle(Callback[] callbacks)
 throws IOException, UnsupportedCallbackException {

   for (int i = 0; i < callbacks.length; i++) {
      if (callbacks[i] instanceof TextOutputCallback) {

          // display the message according to the specified type
          TextOutputCallback toc = (TextOutputCallback)callbacks[i];
          switch (toc.getMessageType()) {
          case TextOutputCallback.INFORMATION:
              System.out.println(toc.getMessage());
              break;
          case TextOutputCallback.ERROR:
              System.out.println("ERROR: " + toc.getMessage());
              break;
          case TextOutputCallback.WARNING:
              System.out.println("WARNING: " + toc.getMessage());
              break;
          default:
              throw new IOException("Unsupported message type: " +
                                  toc.getMessageType());
          }

      } else if (callbacks[i] instanceof NameCallback) {

          // prompt the user for a username
          NameCallback nc = (NameCallback)callbacks[i];

          // ignore the provided defaultName
          System.err.print(nc.getPrompt());
          System.err.flush();
          nc.setName((new BufferedReader
                  (new InputStreamReader(System.in))).readLine());

      } else if (callbacks[i] instanceof PasswordCallback) {

          // prompt the user for sensitive information
          PasswordCallback pc = (PasswordCallback)callbacks[i];
          System.err.print(pc.getPrompt());
          System.err.flush();
          pc.setPassword(readPassword(System.in));

      } else {
          throw new UnsupportedCallbackException
                  (callbacks[i], "Unrecognized Callback");
      }
   }
 }

 // Reads user password from given input stream.
 private char[] readPassword(InputStream in) throws IOException {
    // insert code to read a user password from the input stream
 }
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

通过传入不同的已经实现了Callback接口的实现类，通过分析不同实现类的类型来进行不同的处理，调用形参实现类内的方法（回调）。

一般来说如何使用

在一般工作中，我们都是自己定义接口，写实现类，来进行回调的
自定义的回调函数实例：

这个是Callback接口类，我们一会儿要是用它来创造内部匿名类，来实现这个接口，完成字表的筛选工作

import java.util.List;

public interface CallBackInterface {
    Object process(List<String> list);
}

1
2
3
4
5
6

这个是处理端，通过handler方法，调用传入的CallBackInterface类型中的方法，来对字表进行操作

import lombok.Data;

import java.util.ArrayList;
import java.util.List;
@Data
public class WorldListHandler {
    List<String> stringList = new ArrayList<>();
    public void execute(CallBackInterface callBackInterface){
        Object process = callBackInterface.process(stringList);
        System.out.println(process);
    }

}

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

使用CallBackInterface接口并实现它，来让Handler来调用它其中的process方法来完成对字表的筛选

    @Test
    public void callableTest2(){
        List<String> list = Arrays.asList("123","asd","1432","fsd","543","987","tre");
        WorldListHandler worldListHandler = new WorldListHandler();
        worldListHandler.setStringList(list);
        worldListHandler.execute(new CallBackInterface() {
            @Override
            public Object process(List<String> list) {
                List<String> collect = list.stream().filter(e -> e.contains("1")).collect(Collectors.toList());
                worldListHandler.setStringList(collect);
                return true;
            }
        });
        worldListHandler.getStringList().forEach(e-> System.out.println(e));
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果：true为process的返回值，剩下的为我们筛选出字表中包含有1的字符串。
true
123
1432