什么是事件回调？

灰太狼 2021-11-05 02:32 365阅读 0赞

第一次听见事件回调是在看netty那本书时书中所提到的，这一次又看到了相关概念，决定进行一个挖掘和学习：

回调的分类：

同步回调

异步回调

同步回调是在事件发生后顺序调用回调接口方法，该种调用在事件调用触发之后，会顺序的调用回调方法；（什么是回调方法，回调可以简单理解为一种约定机制，假设有类A和类B,约定就是，当类B的方法被调用之后，就通知类A的某个方法），该种机制在实际开发中会有很多的用途，例如某些事件的监听机制的实现，在NIO中的监听，在gui开发中对按钮事件的监听以及处理等等；

回过来再理解同步回调机制，这个机制就是在同步的调用结束后顺序的调用要回调的方法，这就出现一个不友好的问题，在B中该方法被调用没有触发回调的时候，主线程就无法正常进行业务的处理工作，一直在等待回调，这种在大部分情况之下是不友好的；

异步回调，异步回调在B执行自己的方法时候，采用异步的方式去执行A方法，这样就可以以并行的方式去进行回调的触发，不影响主流程中的业务进行

（后续继续补充）

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

1 /**
     2  * @ClassName CallBackInf
     3  * @Description 这个接口定义统一回调的接口
     4  * @Author bo.chang
     5  * @Date 2019/7/31 10:45
     6  * @Version 1.0
     7  **/
     8 public interface CallBackInf {
     9 
    10     /**
    11       * @title TODO
    12       * @useScene 这个方法是回调的目标方法
    13       * @parameterExample TODO入参示例
    14       * @returnExample TODO出参示例
    15       * @param []没有参数，只做回调测试
    16       * @return void
    17       */
    18     void call();
    19 }

/**
     * @ClassName CallBackA
     * @Description TODO
     * @Author bo.chang
     * @Date 2019/7/31 13:34
     * @Version 1.0
     **/
    public class CallBackA implements CallBackInf {
        /**
          * @title TODO
          * @useScene 这个是回调需要执行的方法
          * @parameterExample TODO入参示例
          * @returnExample TODO出参示例
          * @param []
          * @return void
          */
        @Override
        public void call() {
            System.out.println("执行回调方法结束");
        }
    }

/**
     * @ClassName CallBackB
     * @Description 该类是主入口
     * @Author bo.chang
     * @Date 2019/7/31 13:35
     * @Version 1.0
     **/
    public class CallBackB {
        /**
          * @title TODO
          * @useScene 这个是需要执行的主方法
          * @parameterExample TODO入参示例
          * @returnExample TODO出参示例
          * @param [callBackInf, parm]
          * @return void
          */
        public void testCallBack(final CallBackInf callBackInf, String param){
            //执行B的主任务
            System.out.println("B任务开始执行");
    
            //一般采用异步的方式执行A的回调
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    System.out.println("开始执行回调");
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    callBackInf.call();
    
                }
            }).start();
        }
    }

转载于:https://www.cnblogs.com/carrollbo/p/11276054.html