定义

天天说回调回调，真的了解吗?
消息异步为什么要传入回调接口，真的了解了吗?
前端 axios 发送请求写的箭头函数全都是回调函数，真的理解了吗?
其实回调很简单，就是比如 A 中的方法 a1() 调用了 B 中的方法 b1()，然后 b1() 方法执行完后(一般是执行完)再调用 a1() 方法传入的回调接口的回调方法将结果返回。回调方法一般都定义在接口当中，通用性更强。
那么肯定会有人说，直接通过 b1() 方法返回不就行了，为啥还要去搞什么回调去返回，这不脱裤子放屁?
其实不尽然，如果 a1() 方法调用 b1() 方法，b1() 方法阻塞了，一直重试，那么 a1() 方法也就无法继续向下执行，这种情况不是我们想要见到的。
一般使用回调方法的场景就是调用的方法十分耗时，或者追求效率，不太在意调用方法的结果。因此调用方不会去等，采用异步调用的方式，然后将回调接口通过方法传给被调用方。被调用操作执行完后，再调用接口中的回调方法通知调用方。

讯享网

多说无益，举几个例子。

举例

场景一

现在有这么一个场景：老师上课提问学生，学生一时半会想不出来，老师不会一直等，而是转而问其他同学其他问题。随后该学生想出来了，告诉老师结果。
现在来编码实现一下。
先定义一个回调接口 CallBack

/ * @author zxb 2022/9/23 20:43 */ public interface CallBack { 
    / * 回调接口 * @param answer 收到的答案 */ public void receive(String answer); } 

再定义一个 Teacher 类，teacher 类需要关联 student 类，因为要调用 student 的方法。并且调用时开启了一个新的线程，体现了异步调用。

讯享网package com.zxb.callback; import lombok.extern.slf4j.Slf4j; / * @author zxb 2022/9/24 8:49 */ @Slf4j public class Teacher implements CallBack { 
    private Student student; public Teacher() { 
    } public Teacher(Student student) { 
    this.student = student; } public void askQuestion(String question, CallBack callBack) { 
    log.info("听好了，我的问题是:" + question); new Thread(() -> student.thinkQuestion(question, callBack)).start(); try { 
    // 这个睡眠只是为了日志打印更好看 Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } log.info("那你先想，我问其他同学问题。"); } @Override public void receive(String answer) { 
    if ("2".equals(answer)) { 
    log.info("答对了"); } else { 
    log.info("答错了"); } } } 

最后定义一个 Student 类，这里模拟学生想了 5 秒，然后调用 Teacher 传入的回调接口的回调方法告诉老师答案。

package com.zxb.callback; import lombok.extern.slf4j.Slf4j; / * @author zxb 2022/9/24 8:49 */ @Slf4j public class Student { 
    public void thinkQuestion(String question, CallBack callback) { 
    log.info("老师" + question + "有点难，我先站着想想。"); try { 
    Thread.sleep(5000); } catch (InterruptedException e) { 
    e.printStackTrace(); } log.info("老师我想到了"); callback.receive("2"); } } 测试 public class CallbackTest { 
    public static void main(String[] args) { 
    Student student = new Student(); Teacher teacher = new Teacher(student); teacher.askQuestion("1 + 1 等于几", teacher); } } 

分析
这里老师问学生问题，学生要想很久，老师不想影响上课进度，故让学生自己先想，然后老师继续问其他同学问题，但是老师需要留一个口子给该学生，能让该学生通知自己，这是基于代码方面的思想。而这个留给学生通知自己的方式就是回调接口中的回调方法。
在这个例子中，Teacher 作为调用方自身实现了回调接口，重写了回调方法，老师实现了自己的逻辑，传给同学的回调接口实际上就是自己本身，然后学生调用老师重写的回调方法得以通知老师。
而调用方也可以不实现回调接口，这个回调接口由用户自己指定，比如场景二。

场景二

讯享网package com.zxb.callback; / * @author zxb 2022/9/24 17:19 */ public interface SendCallback { 
    / * 发送成功 * @param sendResult 结果 */ public void onSuccess(SendResult sendResult); / * 发送失败 * @param exception 失败信息 */ public void onFail(Exception exception); } 

再定义一个生产者。

package com.zxb.callback; import lombok.extern.slf4j.Slf4j; / * @author zxb 2022/9/24 17:31 */ @Slf4j public class Producer { 
    final private MsgCenter msgCenter = new MsgCenter(); public void send(String msg, SendCallback callback) { 
    log.info("开始发送消息"); new Thread(() ->{ 
   msgCenter.receiveMsg(msg, callback);}).start(); log.info("执行其他逻辑"); } } 

定义消息中心。

讯享网package com.zxb.callback; import java.util.Date; / * @author zxb 2022/9/24 17:39 */ public class MsgCenter { 
    public void receiveMsg(String msg, SendCallback sendCallback){ 
    try { 
    // 模拟延迟 Thread.sleep(3000); } catch (InterruptedException e) { 
    e.printStackTrace(); } if (msg == null || msg.length() == 0) { 
    sendCallback.onFail(new Exception("消息不能为空")); } else if (msg.contains("窝草")) { 
    sendCallback.onFail(new Exception("此条消息被和谐")); } else { 
    SendResult sendResult = new SendResult(); sendResult.setStatus(SendResult.Status.ACK); sendResult.setMsg(msg); sendResult.setSendDate(new Date()); sendCallback.onSuccess(sendResult); } } } 

定义发送结果类:

package com.zxb.callback; import lombok.Data; import lombok.Getter; import java.util.Date; / * @author zxb 2022/9/24 17:20 */ @Data public class SendResult { 
    private Status status; private String msg; private Date sendDate; public enum Status { 
    ACK(1, "成功"), NACK(-1, "失败"); @Getter private Integer flag; @Getter private String msg; private Status(Integer flag, String msg) { 
    this.flag = flag; this.msg = msg; } @Override public String toString() { 
    return "Status{" + "flag=" + flag + ", msg='" + msg + '\'' + '}'; } } } 

测试:

讯享网package com.zxb.callback; / * @author zxb 2022/9/24 17:49 */ public class SendTest { 
    public static void main(String[] args) { 
    Producer producer = new Producer(); producer.send("Hello World", new SendCallback() { 
    @Override public void onSuccess(SendResult sendResult) { 
    System.out.println("结果为" + sendResult); } @Override public void onFail(Exception exception) { 
    System.out.println(exception.getMessage()); } }); } } 

分析
生产者生产消息并发送，我们可以理解为发送异步消息，生产者无需等待消息中心给我们返回 ACK，而是继续走下面的逻辑或者继续发送消息。这里生产者发送消息调用了消息中心的 receiveMsg 方法，并将方法和回调接口传给了消息中心，消息中心就可以通过这个回调接口来通知生产者消息发送的情况。
这里生产者不是回调接口的实现类，回调接口的实现类通过匿名内部类的方式实现，由用户指定，形参通过消息中心回调传过来，然后生产者可以根据结果做一些其他的判断等操作。