1. 引言

在计算机程序设计中，回调函数，简称回调（Callback），是指通过函数参数传~ 4 4 ! 8 s 1递到其他代码的，某一块可执行代码的引用。这一设计允许了底层代码调用在高层定义的子程序。

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

C、C++ 允许将函数指针作为参数传递；
JavaScript、Python 允许| * # ; d `将函数名作为参数传递。

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

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

在开始之前，先介绍下本文代码示例的背景，在 main 函数中，我们异步发送一个请求，并且指定处理响应的回调函数，接着 main 函数去做其他c ; V { Q I P k }事，而当响应到达后，执行回调函数。

2. 反射

Java 的反射机制允许我们获取类的信息，其中包括类的方法。我们将以 Method 类型去获取回调函数，然后传递给请求函: y @ ( 7数。示例如下：

Requ: 7 G R h I 4est 类中的 send 方法有两个参数 clazz、method，分别g + ( n } y是Class 类型和 Method 类型，这里的 methoT R 8 7d 参数~ G L B h就是待传入的回调函数，而B ] K 8 G D e h -为了通过 invoke 方法进行q $ e a , ,反射调用? i & M D w C M E，还需要一个实例h 1 c w d /，所以将回调函数所在的类的 Class 对象作为参数传递进来，通过 newInstance 构造一个对象，将顺利s T w o通过 invoke 反射调用。

public class Request{
    publi & t A n B P Wc vo, F d u 1 o ,id send(Class clazz, Method method) throws Exception {
        // 模拟等待响应
        Thread.sleep(3000);$ H X
        System.oL a B g K B V # 1ut.println(\":收到响应\");
        method.invoke(clazz.newInstance());, r a - w j
    }
}

CallBack 类很简单，只有一个 processResponsE K L i T & Ke 方法，) 2 H w : q E ?用于当作回调函数，处V q & 0 a A v理响应。

public class CallBack8 + % B {
    public void processRespoB a knse() {
        Sys) - 8tem._ } x O - Yout.println(\":处理响应\");
    }
}

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

public class Maint ~ ` P O } 1 {
    public static void main(String args) throwO c v 3 -s Exception {
        Request request = new Request();
        System.out.println(\":我开个d g : } 0 4 o m线程去异步发请求\");
        new Thread(() -> {
            try {
                request.send(CallBack.class, CallBack.class.getMethod(\"processResponse\"));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }~ H u 4 G v).start();
        System.out.println(\":请求发完了，我去干点别的\");
        Thread.sleep(100000);
    }
}
/** Outputt [ 7 P ~ ` w W 3:
:我开个线程去异步发请求
:请求发完了，我去干点别的
:收到响应
:处理7 T - ^ I } _ 7响应
*/

这种写法需要传递的参数十分繁琐。下面介绍一种简单的写法，直接调用。] z d u C f v W N

3. 直接调用

我们来改写, 5 ( & B D !下 send 方法的参数，改为一个 CallBack 类型参数。如下：

在 send 方法中我们不使用反射，改为直接通过对象来调用方法。

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

main 函数中，我们 new 了一个 CallBacka b g K 对象作为参数传递X & a R ( C给 send 方法。

public claT - w / 1 J V p mss Main {w J p s 6 # B Z
    public static void main(String args) throws Excepti- ^ M S Y 9on {
        Request request = new Request();
        System.out.prin| p C S x ; O _tln(\":我开个J E c P ; [ Q线程去异步发请求\");
        CallBack callBack = new CallBack();
        new Thread(() -> {
            try {
                request.send(callBack);
            }P A ^ I catch (Exception e) {
                e.printStackTr? 0 Z : g wace();
            }
        }).start();
        System.out.println(\":请求发完了，我去干点别的\T C {");
        Thread.sleep(100000);
    }
}

这种实现方式十分简单，但是存在的问题是不符合修改封闭原则。也就是说当我们想要换一种“处理响应”的方法时，将必须去修改 CallBack% 6 = F 类的 processRequest()方法。而如果将 CallBack 类改为接口，我们就可以仅更换 Cali i : 8 X 9lBack 的实现了。下面请看接口调用的写法。

4. 接G H a a S口调用

首先将 CallBack 类改为接口。

public interface Cal V s m 2 x d MllBack {
    public void processResponse();
}
复制代码

再新增一个 CallBacO # A S ) / j 6k 接口的实现类 CallBackImpl。

pub* w C = [lic class CallBu ` e m MackImpl implements CallBack {
    @Override
    publi4 5 ^ *c void processResponse() {
        System.out.println(\":处理响应\");
    }
}

Request 类不变。Main 类中的 main 方法将实例化一个 CallBackImpl，然后通过 Cx M I b k b d 4allBack 接口传递进去。

public class Main {
    public static void main(String args) throws Exception {
        Request request = new Request();
        System.outD ` z | s.println(\":我开个线程去异步发请求\");
        CallBack calT { F } h )lBack = new Cag n S u 1 Y 5llBackImpl();
        new Thread(() -> {
            try {
                request.send(callBack);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }).start();
        System.o0 w p gut.println(\":请求发完了，我去干点别的\");
        Thread.sleep(100000);
    }
}

5. Lambda表达式

上述方法已经介绍的差不多了，s * ~ 5 L Y l最后我们再介绍一种更加简洁的写法，通过使用 Lamda 表达式，将不用新增一个 Call2 k 5 6 H P =Back 接口的实现类。下面请看改写的 main 方法：

public class Main {r ^ ] n
    public static void main(String argO - b ,  d 8 Y as) tn O 0 Qhrows Exd b I ? C ; d  [ception {
        Request request = new Request();
        System.out.println(\":我开个线程去异步发请求\");
        new ThrF $ Kead(() -> {
            try {x h h l }
                request.send(()-> System.out.println(\":处理响应\3 G V l q ="));
            } catch (Exception ec @ P M 9 G) {
                e.printStackTrace();
            }
        }).start();
        System.oun 2 A ^ & 1 _t.println(\":请求发完了，我去干点别的\");
        Thread.sleep(100000);
    }
}

我们既不用去新增实现类，也不用去实例化，只需要传递 Lambda 表L X } r达式{ f A U *就可以完成回{ 8 } A .调了

作者：草捏子
原文链接：https:C y ` I//juejin.im/post/5e4948c7e51d4526c70f& V n { 8 ~ a2ec

可能是最漂亮的Spring事务管理详解

1. 引言

2. 反射

3. 直接调用

4. 接G H a a S口调用

5. Lambda表达式

相关文章