Java回调的四种写法（反射、直接调用、接口调用、Lambda表达式）

1. 引言

在计算机程序设计中，回调函数，简称回调（Callback），是指经过函数参数传递到其余代码的，某一块可执行代码的引用。这一设计容许了底层代码调用在高层定义的子程序。

以上是维基百科对“回调函数”的定义。对于回调，不一样的语言有不一样的回调形式，例如：

• C、C++ 容许将函数指针做为参数传递；
• JavaScript、Python 容许将函数名做为参数传递。

本文将介绍 Java 实现回调的四种写法：

• 反射；
• 直接调用；
• 接口调用；
• Lambda表达式。

在开始以前，先介绍下本文代码示例的背景，在 main 函数中，咱们异步发送一个请求，而且指定处理响应的回调函数，接着 main 函数去作其余事，而当响应到达后，执行回调函数。

2. 反射

Java 的反射机制容许咱们获取类的信息，其中包括类的方法。咱们将以 Method 类型去获取回调函数，而后传递给请求函数。示例以下：

Request 类中的 send 方法有两个参数 clazz、method，分别是Class 类型和 Method 类型，这里的 method 参数就是待传入的回调函数，而为了经过 invoke 方法进行反射调用，还须要一个实例，因此将回调函数所在的类的 Class 对象做为参数传递进来，经过 newInstance 构造一个对象，将顺利经过 invoke 反射调用。

public class Request{
    public void send(Class clazz, Method method) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);
        System.out.println("[Request]:收到响应");
        method.invoke(clazz.newInstance());
    }
}
复制代码

CallBack 类很简单，只有一个 processResponse 方法，用于看成回调函数，处理响应。

public class CallBack {
    public void processResponse() {
        System.out.println("[CallBack]:处理响应");
    }
}
复制代码

咱们在 main 方法中，新开了一个线程去发送请求，而且把须要的 CallBack.class 和 processResponse 方法传递进去。

public class Main {
    public static void main(String[] args) throws Exception {
        Request request = new Request();
        System.out.println("[Main]:我开个线程去异步发请求");
        new Thread(() -> {
            try {
                request.send(CallBack.class, CallBack.class.getMethod("processResponse"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        System.out.println("[Main]:请求发完了，我去干点别的");
        Thread.sleep(100000);
    }
}
/** Output: [Main]:我开个线程去异步发请求 [Main]:请求发完了，我去干点别的 [Request]:收到响应 [CallBack]:处理响应 */
复制代码

这种写法须要传递的参数十分繁琐。下面介绍一种简单的写法，直接调用。

3. 直接调用

咱们来改写下 send 方法的参数，改成一个 CallBack 类型参数。以下：

在 send 方法中咱们不使用反射，改成直接经过对象来调用方法。

public class Request{
    public void send(CallBack callBack) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);
        System.out.println("[Request]:收到响应");
        callBack.processResponse();
    }
}
复制代码

main 函数中，咱们 new 了一个 CallBack 对象做为参数传递给 send 方法。

public class Main {
    public static void main(String[] args) throws Exception {
        Request request = new Request();
        System.out.println("[Main]:我开个线程去异步发请求");
        CallBack callBack = new CallBack();
        new Thread(() -> {
            try {
                request.send(callBack);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        System.out.println("[Main]:请求发完了，我去干点别的");
        Thread.sleep(100000);
    }
}
复制代码

这种实现方式十分简单，可是存在的问题是不符合修改封闭原则。也就是说当咱们想要换一种“处理响应”的方法时，将必须去修改 CallBack 类的 processRequest()方法。而若是将 CallBack 类改成接口，咱们就能够仅更换 CallBack 的实现了。下面请看接口调用的写法。

4. 接口调用

首先将 CallBack 类改成接口。

public interface CallBack {
    public void processResponse();
}
复制代码

再新增一个 CallBack 接口的实现类 CallBackImpl。

public class CallBackImpl implements CallBack {
    @Override
    public void processResponse() {
        System.out.println("[CallBack]:处理响应");
    }
}
复制代码

Request 类不变。Main 类中的 main 方法将实例化一个 CallBackImpl，而后经过 CallBack 接口传递进去。

public class Main {
    public static void main(String[] args) throws Exception {
        Request request = new Request();
        System.out.println("[Main]:我开个线程去异步发请求");
        CallBack callBack = new CallBackImpl();
        new Thread(() -> {
            try {
                request.send(callBack);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        System.out.println("[Main]:请求发完了，我去干点别的");
        Thread.sleep(100000);
    }
}
复制代码

5. Lambda表达式

上述方法已经介绍的差很少了，最后咱们再介绍一种更加简洁的写法，经过使用 Lamda 表达式，将不用新增一个 CallBack 接口的实现类。下面请看改写的 main 方法：

public class Main {
    public static void main(String[] args) throws Exception {
        Request request = new Request();
        System.out.println("[Main]:我开个线程去异步发请求");
        new Thread(() -> {
            try {
                request.send(()-> System.out.println("[CallBack]:处理响应"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        System.out.println("[Main]:请求发完了，我去干点别的");
        Thread.sleep(100000);
    }
}
复制代码

咱们既不用去新增实现类，也不用去实例化，只须要传递 Lambda 表达式就能够完成回调了。

6. 总结

为了让你们更好的理解回调，本文一共介绍了 4 种写法，你们均可以根据本身的须要自取。

喜欢我文章的小伙伴，能够扫码关注下个人公众号：“草捏子”