【Java杂记】回调机制：三种回调方式及代码示例

小鱼儿 2022-12-13 12:58 160阅读 0赞

在看回调之前，我们必须明白什么是同步调用与异步调用。这两个概念其实很好理解，同步与异步是相对时间来说的：

*  同步调用：同一时间只能做一件事
 *  异步调用：同一时间可以做多件事，一般通过以下两种手段实现：
    
     *  多线程：为需要阻塞的方法单独启动一个线程执行
     *  回调：执行完成后通过回调，通知主线程执行完毕或者获取执行结果

多线程大家一看都能明白，那回调到底是什么呢？

## 1.回调机制 ##

回调是实现异步调用的一种手段，是为了异步通信服务的，可以细分为以下几种：

### 1.1 基本回调 ###

基本形式如下：

A对象 ----B.fb(A) -----> B对象  // 调用B的fb()时传入A本身（this）
    A对象 <-----A.fa()------ B对象  // B就可以直接调用A，fa()就是回调方法

### 1.2 接口回调 ###

基于接口回调：若只能给fb()传入A类型那么就是强耦合，所以一般给 fb() 传入的是一个接口，A实现这个接口

AImpl ----B.fb(IA) -----> B对象  // IA是抽象接口，AImpl是IA的实现类
    AImpl <-----IA.fa()------ B对象

### 1.3 异步回调 ###

异步回调就是给B.fb()方法单独起一个线程去执行

*  使用场景：当A要调用B的某个方法，且该方法会产生阻塞，或耗时较长，则可以将该方法做成异步调用
 *  异步通信：通过回调机制进行通信，执行完后告知A

AImpl ----B.fb(IA) -----> B对象  // B.fb(IA)单独起一个线程执行
    AImpl <-----IA.fa()------ B对象

## 2.代码示例 ##

概念说完了，下面就上代码…

### 2.1 同步调用 ###

码农（Programmer）现在需要做几件事情：

1.  敲代码一整天（敲代码）
2.  将今天工作代码上传到Github上（上传代码）
3.  备注一下完成日期（记录下完成的日期）

下面我们用程序去实现：程序一共就三个类：

*  Programmer（码农类）
 *  Github（Github类 用于保存码农提交的代码）
 *  TestDemo（用于测试并显示结果）

如下所示：  
![20201012002321336.png_pic_center][]

public class Programmer {
        
    
        public void code(){
                               
            System.out.println("coding");      //step1.写代码
            new Github().push();               //step2.提交代码 
            recordToday();                     //step3. 记录的日期
        }
    
        public void recordToday(){
        
            System.out.println("i'm done " + new Date());
        }
    }

// 只负责上传代码
    public class Github {
        
        public void push(){
        
            System.out.println("git push");
        }
    }

// 让Programmer工作
    public class TestDemo {
        
        public static void main(String args[]){
        
            Programmer p = new Programmer();
            p.code();
        }
    }

执行结果如下：  
![20201012002550275.png_pic_center][]

### 2.2 基本回调 ###

可否给苦逼程序员一条生路，让他提交代码之后就下班，像记录日期：recodeToday（）这种事让Github类去负责。

换句话说，Github类的push（）函数执行完后，**Github类去调用Programmer类的recodeToday（）方法**，而不是Programmer自己去调用，略微改动后

// A
    public class Programmer {
        
        public void code(){
        
            System.out.println("coding");
            new Github().push(this);   // B.fb(this)
            // 这里没有 step3，码农没有自己调用 recordToday()方法.
        }
    
        // A.fa(),回调方法
        public void recordToday(){
        
            System.out.println("i'm done " + new Date());
        }
    }

// B
    public class Github {
        
        public void push(Programmer p ){
           // push的参数多了Programmer类
            System.out.println("git push");
            p.recordToday();    // 执行回调
        }
    }

最后执行结果不变

### 2.3 接口回调 ###

如果现在不只有Programmer了还有Teacher和Student，那GitHub的push方法难道要再重载？最好的办法是push依赖接口

// IA，回调接口
    public interface RecodeInterface {
        
        public void recode();
    }

// B
    public class Github {
        
        public void push(RecodeInterface r ){
         // 依赖接口
            System.out.println("git push");
            r.recode(); // A.fa()，执行回调
        }
    }

// AImpl，实现了接口
    public class Programmer implements RecodeInterface{
        
        public void code(){
        
             System.out.println("coding");
             new Github().push(this); // B.fb(A)
         }
        
        @Override
        public void recode() {
         // 回调函数
            System.out.println("Programmer done " + new Date());
        }
    }

public class Student {
        
        public void code(){
        
            System.out.println("coding");
            new Github().push(new StudentRecodeToday());
        }
    	
        // AImpl，也可以单独抽象出一个内部类
        public class StudentRecodeToday implements RecodeInterface{
        
            @Override
            public void recode() {
        
                System.out.println("Student done "+ new Date());
            }
        }
    }

### 2.4 异步回调 ###

// IA，回调接口
    public interface mycallback {
        
        void onData(Object message); // 正常处理
        void onError(Exception e); // 异常处理
    }

// AImpl，实现了回到接口
    public class Client implements mycallback{
        
        int count=0;
        @Override
        public void onData(Object message) {
        
            count++;
            System.out.println("received message:"+message.toString());
        }
     
        @Override
        public void onError(Exception e) {
        
            System.out.println("error!");
        }
        public void send(String message){
        
            // 异步回调核心！！！ 为B.fb(IA)单独启动一个线程
            Thread thread=new Thread(new Server(Client.this,message)); 
            thread.start();
        }
    }

// B
    public class Server implements Runnable{
        
        mycallback c;
        Object message;
        public Server(mycallback cl,Object o){
        
            c=cl;
            message=o;
        }
        @Override
        public void run() {
        
            try {
        
                c.onData(message+" after server"); // 执行回调
            }catch (Exception e){
        
                c.onError(e);
            }
        }
    }

启动类

public class Work{
        
     
        public static void main(String[] args){
        
            Client c1=new Client();
            c1.send(hello);
            System.out.println("do others...");
        }
    }

结果

do others...
    received message:hello

[20201012002321336.png_pic_center]: /images/20221123/5e7eb8aed0424cf29d413f8f5037cf2d.png
[20201012002550275.png_pic_center]: /images/20221123/ae45ca4692fb4abb8e85655e64c564a9.png