回调方法Callbak方法的理解——Java中回调的实现方式 & 从系统调用角度理解回调

青旅半醒 2024-02-17 08:28 4阅读 0赞

![在这里插入图片描述][5d19dd98c33145ae9e07a8294178b13f.png]

#### 目录 ####

*  回调方法实现
 *   *  用反射实现
     *  直接调用callback
     *   *  进化：接口实现分离
     *  匿名内部类 到 函数式编程
 *  从系统调用角度理解回调
 *   *  同步调用
     *  异步调用
     *   *  不需要对方结果
         *  需要对方的结果
 *  菜鸡问大佬问题案例
 *   *  同步回调
     *  异步回调
     *  基于Future的半同步

--------------------

回调方法就是一个参数,将一个A方法作为参数传到B方法里面,当B方法执行完之后,再执行传进去的这个A方法,这个过程就叫做回调。

回调方法是类A调用类B的方法,然后B又在某个时候反过来调用类B的方法a,这个a就是回调方法.

## 回调方法实现 ##

回调方法就是一个参数,将一个A方法作为参数传到B方法里面,当B方法执行完之后,再执行传进去的这个A方法,这个过程就叫做回调。

回调方法是类A调用类B的方法,然后B又在某个时候反过来调用类B的方法a,这个a就是回调方法.

### 用反射实现 ###

![在这里插入图片描述][8af7603db2ba41ba931821539c48f4ee.png]

main方法

package com.tianju.callback;
    
    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) {
        
                    throw new RuntimeException(e);
                }
            }).start();
    
            System.out.println("[Main]:请求发送完毕，do other things");
            Thread.sleep(10000);
        }
    }

![在这里插入图片描述][011015f970674878ae0dec76634c13ef.png]

package com.tianju.callback;
    
    import java.lang.reflect.Method;
    
    public class Request {
        
        public void send(Class clazz, Method method) throws Exception{
        
            // wait for response
            Thread.sleep(3000); // 模拟等待响应
            System.out.println("[Response ]: 收到响应");
            method.invoke(clazz.newInstance());
        }
    }

callback

package com.tianju.callback;
    
    public class Callback {
        
    
        // callback details
        public void processResponse(){
        
            System.out.println("[callback]: 处理响应");
        }
    }

### 直接调用callback ###

![在这里插入图片描述][6590ad94860f453e835a5316de6d0426.png]

main

package com.tianju.dirctCall;
    
    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) {
        
                    throw new RuntimeException(e);
                }
            }).start();
    
    
            System.out.println("[Main]:请求发送完毕，do other things");
            Thread.sleep(10000);
        }
    }

request

package com.tianju.dirctCall;
    
    
    public class Request {
        
        public void send(Callback callback) throws Exception{
        
            // wait for response
            Thread.sleep(3000); // 模拟等待响应
            System.out.println("[Response ]: 收到响应");
            callback.processResponse();
        }
    }

#### 进化：接口实现分离 ####

![在这里插入图片描述][b74ba1247880434791fbba4baf28a9e7.png]

### 匿名内部类 到 函数式编程 ###

可以实现匿名内部类

![在这里插入图片描述][7052dad7a79d49b18ea8221baa677202.png]

package com.tianju.lamda;
    
    public class Main {
        
        public static void main(String[] args) throws InterruptedException {
        
            Request request = new Request();
            System.out.println("[Main]:我开了一个线程去异步发送请求");
            new Thread(()->{
        
                try {
        
                    request.send(new Callback() {
        
                        @Override
                        public void processResponse() {
        
                            System.out.println("[callback]: 处理响应");
                        }
                    });
                } catch (Exception e) {
        
                    throw new RuntimeException(e);
                }
            }).start();
            System.out.println("[Main]:请求发送完毕，do other things");
            Thread.sleep(10000);
        }
    }

> 最终进化的形态，函数式编程

![在这里插入图片描述][c4a5e9c3b05c458face1f08a44b36042.png]

main

package com.tianju.lamda;
    
    public class Main {
        
        public static void main(String[] args) throws InterruptedException {
        
            Request request = new Request();
            System.out.println("[Main]:我开了一个线程去异步发送请求");
            new Thread(()->{
        
                try {
        
                    request.send(()->{
        
                        System.out.println("[Callback]: 处理响应");
                    });
                } catch (Exception e) {
        
                    throw new RuntimeException(e);
                }
            }).start();
            System.out.println("[Main]:请求发送完毕，do other things");
            Thread.sleep(10000);
        }
    }

## 从系统调用角度理解回调 ##

应用系统模块之间的调用，通常分为：同步调用，异步调用，回调。

### 同步调用 ###

![在这里插入图片描述][2f6d33d6842a4d8bafff59de82f42e2a.png]

同步调用是最基本的调用方式。类A的a()方法调用类B的b()方法，类A的方法需要等到B类的方法执行完成才会继续执行。如果B的方法长时间阻塞，就会导致A类方法无法正常执行下去。

### 异步调用 ###

如果A调用B，B的执行时间比较长，那么就需要考虑进行异步处理，使得B的执行不影响A。通常在A中新起一个线程用来调用B，然后A中的代码继续执行。

异步通常分两种情况：第一，不需要调用结果，直接调用即可，比如发送消息通知；第二，需要异步调用结果，在Java中可使用Future+Callable实现。

#### 不需要对方结果 ####

![在这里插入图片描述][dbb54961606b47bea8d9e4f295f60de8.png]

#### 需要对方的结果 ####

回调属于一种双向的调用方式。回调的基本上思路是：A调用B，B处理完之后再调用A提供的回调方法（通常为callbakc()）通知结果。

![在这里插入图片描述][14763390964c4f30901311c0c174f2fd.png]

## 菜鸡问大佬问题案例 ##

### 同步回调 ###

![在这里插入图片描述][6b41105d7ab0443ea25d71b6dac1c414.png]

package com.tianju.sycCallback;
    
    public interface Callback {
        
        void callback(String str);
    }

package com.tianju.sycCallback;
    
    public class Person implements Callback{
        
    
        // @Autowired
        private Genius genius = new Genius();
    
    
        @Override
        public void callback(String str) {
        
            System.out.println("收到了答案："+str);
        }
    
        public void ask(){
        
            System.out.println("菜鸡向大佬请教问题：");
            genius.answer(this);
        }
    
        public static void main(String[] args) {
        
            Person person = new Person();
            person.ask();
        }
    }

![在这里插入图片描述][c3a4b0a156fd4f7b8699b247c3ca614d.png]

package com.tianju.sycCallback;
    
    public class Genius {
        
    
        public void answer(Callback callback){
        
            System.out.println("正在忙别的事情。。。。");
            try {
        
                Thread.sleep(2000);
                System.out.println("忙完了别的事情，开始思考问题。。。。。");
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
    
            System.out.println("思考出了问题的答案！结果为：XXXX");
            callback.callback("XXXX");
        }
    }

![在这里插入图片描述][2a8e9df06f0c4666bcba43cbbaa37da5.png]

![在这里插入图片描述][bf437954c47f482bb99112c3f11f6e3d.png]

### 异步回调 ###

![在这里插入图片描述][b43af4682ed34ecda02cc67b3fb22c34.png]

![在这里插入图片描述][d67317de171d461ab065771062e5ec44.png]

package com.tianju.asyCallback;
    
    public class Person implements Callback {
        
    
        // @Autowired
        private Genius genius = new Genius();
    
    
        @Override
        public void callback(String str) {
        
            System.out.println("收到了答案："+str);
        }
    
        public void askSyn(){
        
            System.out.println("菜鸡向大佬请教问题：");
            System.out.println("大佬收知道了。。。。");
            new Thread(()->{
        
                genius.answer(this);
            }).start();
            System.out.println("菜鸡回到自己的座位");
    
        }
    
        public static void main(String[] args) {
        
            Person person = new Person();
            person.askSyn();
        }
    }

### 基于Future的半同步 ###

在Java使用nio后无法立即拿到真实的数据，而是先得到一个"future"，可以理解为邮戳或快递单，为了获悉真正的数据我们需要不停的通过快递单号"future"查询快递是否真正寄到。

Futures是一个抽象的概念，它表示一个值，在某一点会变得可用。一个Future要么获得计算完的结果，要么获得计算失败后的异常。

通常什么时候会用到Future呢？一般来说，当执行一个耗时的任务时，使用Future就可以让线程暂时去处理其他的任务，等长任务执行完毕再返回其结果。

经常会使用到Future的场景有：1. 计算密集场景。2. 处理大数据量。3. 远程方法调用等。

Java在 java.util.concurrent包中附带了Future接口，它使用Executor异步执行。

例如下面的代码，每传递一个Runnable对象到ExecutorService.submit()方法就会得到一个回调的Future，使用它检测是否执行，这种方法可以是同步等待线处理结果完成

![在这里插入图片描述][d1bdb99700574421adf653867f9ddc52.png]

![在这里插入图片描述][62341b92baf2460290bc107f87a74c73.png]

![在这里插入图片描述][1ece4b4209424b9c98a1edfa93f0ffbc.png]

package com.tianju.future;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class TestFuture {
        
    
        public static void main(String[] args) {
        
    
            //实现一个Callable接口
            Callable<User> c = () -> {
        
                //这里是业务逻辑处理
                System.out.println("开始处理业务了");
    
                //让当前线程阻塞1秒看下效果
                Thread.sleep(2000);
                return new User("张三");
            };
    
            ExecutorService es = Executors.newFixedThreadPool(2);
    
            // 记得要用submit，执行Callable对象
            Future<User> future = es.submit(c);
            // 一定要调用这个方法，不然executorService.isTerminated()永远不为true
            // 在此关闭中执行以前提交的任务，但不接受任何新任务。把当前任务执行完
            es.shutdown();
            // 无限循环等待任务处理完毕  如果已经处理完毕 isDone返回true
            while (!future.isDone()) {
        
                System.out.println("I am try");
                try {
        
                    //处理完毕后返回的结果
                    User nt = future.get();
                    System.out.println("处理完结果了。。。。");
                    System.out.println(nt.name);
                } catch (Exception e) {
        
                    e.printStackTrace();
                }
            }
        }
    
        static class User {
        
            private String name;
    
            private User(String name) {
        
                this.name = name;
            }
        }
    }

参考文章：https://zhuanlan.zhihu.com/p/349951124

[5d19dd98c33145ae9e07a8294178b13f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7f43aec1a8aa48fd914089801afaa0d4.png
[8af7603db2ba41ba931821539c48f4ee.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/51f418f07aa74335bbcc5741192254af.png
[011015f970674878ae0dec76634c13ef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/7ec897b6e7544ffea40604afbc5b526d.png
[6590ad94860f453e835a5316de6d0426.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/29bfc4b8c27d4ba5887e012f50b3f96a.png
[b74ba1247880434791fbba4baf28a9e7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c7534e33df5148ada3f83261829d9ea3.png
[7052dad7a79d49b18ea8221baa677202.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c0e13eca7dbd4da4a173b548a2917210.png
[c4a5e9c3b05c458face1f08a44b36042.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c420fd2ce41349ffbd5bb28197fddbe4.png
[2f6d33d6842a4d8bafff59de82f42e2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/17e5dfc81e6a4a8cad3562a81a67085b.png
[dbb54961606b47bea8d9e4f295f60de8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/8bd71d1d43b64186a1f75ee2ca8697f9.png
[14763390964c4f30901311c0c174f2fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/e9fdfc35b3bb4688b2dc69d3f87875f6.png
[6b41105d7ab0443ea25d71b6dac1c414.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/99c96762b0b54090bd7fce8b0a2dff44.png
[c3a4b0a156fd4f7b8699b247c3ca614d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/15a6b409a48047569bd2ecc29d27b9eb.png
[2a8e9df06f0c4666bcba43cbbaa37da5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/9f5e2b5f33ba408588330e4a15ad55b6.png
[bf437954c47f482bb99112c3f11f6e3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/c9e50f2ed62047bca47ac2967417504e.png
[b43af4682ed34ecda02cc67b3fb22c34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/8a08bb091e6042298cb8628b572580df.png
[d67317de171d461ab065771062e5ec44.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/26166a4afcf54a69a96f1341ecd2edf4.png
[d1bdb99700574421adf653867f9ddc52.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/889d3b5428e04d73b80cb85392601ad2.png
[62341b92baf2460290bc107f87a74c73.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/1c565fb04c8e4913ac7d21d581fc9e05.png
[1ece4b4209424b9c98a1edfa93f0ffbc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/06/994e7351e4ab40d698fd7c3b7c0384e8.png