java调用回调机制详解

调用和回调机制

在一个应用系统中, 无论使用何种语言开发, 必然存在模块之间的调用, 调用的方式分为几种:

1.同步调用

同步调用是最基本并且最简单的一种调用方式, 类A的方法a()调用类B的方法b(), 一直等待b()方法执行完毕, a()方法继续往下走. 这种调用方式适用于方法b()执行时间不长的情况, 因为b()方法执行时间一长或者直接阻塞的话, a()方法的余下代码是无法执行下去的, 这样会造成整个流程的阻塞.

2.异步调用

异步调用是为了解决同步调用可能出现阻塞, 导致整个流程卡住而产生的一种调用方式. 类A的方法方法a()通过新起线程的方式调用类B的方法b(), 代码接着直接往下执行, 这样无论方法b()执行时间多久, 都不会阻塞住方法a()的执行. 但是这种方式, 由于方法a()不等待方法b()的执行完成, 在方法a()需要方法b()执行结果的情况下(视具体业务而定, 有些业务比如启异步线程发个微信通知、刷新一个缓存这种就没必要), 必须通过一定的方式对方法b()的执行结果进行监听. 在Java中, 可以使用Future+Callable的方式做到这一点, 具体做法可以参见文章Java多线程21:多线程下其他组件之CyclicBarrier、Callable、Future和FutureTask.

3.回调:

如下图所示, 回调是一种双向的调用方式, 其实而言, 回调也有同步和异步之分, 讲解中是同步回调, 第二个例子使用的是异步回调

回调的思想是:

  • 类A的a()方法调用类B的b()方法
  • 类B的b()方法执行完毕主动调用类A的callback()方法

通俗而言: 就是A类中调用B类中的某个方法C, 然后B类中反过来调用A类中的方法D, D这个方法就叫回调方法, 这样子说你是不是有点晕晕的, 其实我刚开始也是这样不理解, 看了人家说比较经典的回调方式:

  1. class A实现接口CallBack callback——背景1
  2. class A中包含一个class B的引用b ——背景2
  3. class B有一个参数为callback的方法f(CallBack callback) ——背景3
  4. A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C
  5. 然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D

回调的种类

回调分为同步回调和异步回调, 假如以买彩票的场景来模拟, 我买彩票, 调用彩票网,给我返回的结果确定是否中奖,同步回调就是,我买了彩票之后, 需要等待彩票网给我返回的结果, 这个时候我不能做其他事情, 我必须等待这个结果, 这就叫同步回调, 同步, 就意味着等待, 我不能去做其他事情, 必须等待, 异步回调就是, 我买了彩票之后, 可以去做其他事情, 然后当彩票网有了结果和消息, 再给我返回消息, 其中最明显的方式就是在得到彩票结果的函数之中, 添加一个其他的方法, 如果我的其他方法可以立即执行, 那么就是异步的(给出是否中奖需要花费很长的时间), 而在测试函数之中, 前后两个, 那是发生在测试函数的线程之中的, 肯定是一前一后按照次序的, 在这个地方不是显示同步异步的地点.

同步回调

同步回调和异步回调, 主要体现在其是否需要等待. 同步调用, 如果被调用一方的APi(第三方API), 处理问题需要花很长时间, 我们需要等待, 那就是同步回调, 如果调用完之后不需要理解得到结果, 我们调完就走, 去做其他事情, 那就是异步调用, 异步调用需要在我们调用第三方API处, 开启一个新的线程即可, 而同步调用和平常的调用没有任何区别.
例子
OrderResult接口, 其中的方法getOrderResult

public interface OrderResult {
 /**
  * 订购货物的状态
  *
  * @param state
  * @return
  */
 //参数可以不用, 用不用按照自己的实际需求决定
 public String getOrderResult(String state);
}

Store类, 商店提供会无预定消息返回的接口, 回调OrderResult接口的方法, 给其返回预订商品的状态, 重点是returnOrderGoodsInfo(OrderResult order)方法, 体现了回调的回. Store是被调用的一方, 被调用的一方, 要回过去调用调用一方的方法, 这个方法实际上是回调接口的方法.

public class Store {
 @Getter
 @Setter
 private String name;

 Store(String name) {
  this.name = name;
 }

 /*回调函数, 将结构传给那个我们不能直接调用的方法, 然后获取结果*/
 public String returnOrderGoodsInfo(OrderResult order) {
  String[] s = {"订购中...", "订购失败", "即将发货!", "运输途中...", "已在投递"};
  Random random = new Random();
  int temp = random.nextInt(5);
  String s1 = s[temp];
  return order.getOrderResult(s1);
 }
}

SyncBuyer类, 同步顾客类, 其中获取商品的订购状态,orderGoods(), 调用了store返回商品调用信息的returnOrderGoodsInfo()方法, 但是在Store类的returnOrderGoodsInfo()方法之中, 以OrderResult接口为参数, 反过来调用了OrderResult接口, 相当于调用了其子类SyncBuyer本身, 以他为参数, 调用了getOrderResult(String state)方法, 也就是OrderResult接口的方法, 相当于就完成了一个调用的循环, 然后取到了我们自己无法给出的结果.

这个地方的"循环", 是回调的关键所在, 需要正常调用其他外接提供方法来获取结果的一方, 继承一个回调接口, 实现它, 然后调用第三方的API方法, 第三方在我们调用的方法之中, 以回调结构为参数, 然后调用了接口中的方法, 其中可以返回相应的结果给我们, 需要说明的是, 我们虽然实现了这个接口的方法, 但是我们自己的类之中, 或者说此类本身, 却没法调用这个方法, 也可以说, 此类调用这个方法是不会产生有效的结果的. 回调的回, 就体现在此处, 在Store类之中的returnOrderGoodsInfo(OrderResult order)方法之中, 得到了很好的体现.

/*同步, 顾客在商店预订商品, 商店通知顾客预订情况*/
public class SyncBuyer implements OrderResult {
 @Getter
 @Setter
 private Store store;//商店
 @Getter
 @Setter
 private String buyerName;//购物者名
 @Getter
 @Setter
 private String goodsName;//所购商品名

 SyncBuyer(Store store, String buyerName, String goodsName) {
  this.store = store;
  this.buyerName = buyerName;
  this.goodsName = goodsName;
 }

 /*调用从商店返回订购物品的信息*/
 public String orderGoods() {
  String goodsState = store.returnOrderGoodsInfo(this);
  System.out.println(goodsState);
  myFeeling();// 测试同步还是异步, 同步需要等待, 异步无需等待
  return goodsState;

 }

 public void myFeeling() {
  String[] s = {"有点小激动", "很期待!", "希望是个好货!"};
  Random random = new Random();
  int temp = random.nextInt(3);
  System.out.println("我是" + this.getBuyerName() + ", 我现在的感觉: " + s[temp]);
 }

 /*被回调的方法, 我们自己不去调用, 这个方法给出的结果, 是其他接口或者程序给我们的, 我们自己无法产生*/
 @Override
 public String getOrderResult(String state) {
  return "在" + this.getStore().getName() + "商店订购的" + this.getGoodsName() + "玩具, 目前的预订状态是: " + state;
 }
}

Test2Callback类, 测试同步回调的结果,

public class Test2Callback {
 public static void main(String[] args) {
  Store wallMart = new Store("沙中路沃尔玛");
  SyncBuyer syncBuyer = new SyncBuyer(wallMart, "小明", "超能铁扇公主");
  System.out.println(syncBuyer.orderGoods());
 }
}

异步回调

同步回调和异步回调的代码层面的差别就是是否在我们调用第三方的API处, 为其开辟一条新的线程, 其他并无差异
例子
OrderResult接口, 其中的方法getOrderResult

public interface OrderResult {
 /**
  * 订购货物的状态
  *
  * @param state
  * @return
  */
 //参数可以不用, 用不用按照自己的实际需求决定
 public String getOrderResult(String state);
}

Store类, 商店提供会无预定消息返回的接口, 回调OrderResult接口的方法, 给其返回预订商品的状态.

public class Store {
 @Getter
 @Setter
 private String name;

 Store(String name) {
  this.name = name;
 }

 /*回调函数, 将结构传给那个我们不能直接调用的方法, 然后获取结果*/
 public String returnOrderGoodsInfo(OrderResult order) {
  String[] s = {"订购中...", "订购失败", "即将发货!", "运输途中...", "已在投递"};
  Random random = new Random();
  int temp = random.nextInt(5);
  String s1 = s[temp];
  return order.getOrderResult(s1);
 }
}

NoSyncBuyer类, 异步调用Store类的returnOrderGoodsInfo(OrderResult order)方法, 来返回商品转改的结果.

/*异步*/
@Slf4j
public class NoSyncBuyer implements OrderResult {
 @Getter
 @Setter
 private Store store;//商店
 @Getter
 @Setter
 private String buyerName;//购物者名
 @Getter
 @Setter
 private String goodsName;//所购商品名

 NoSyncBuyer(Store store, String buyerName, String goodsName) {
  this.store = store;
  this.buyerName = buyerName;
  this.goodsName = goodsName;
 }

 /*调用从商店返回订购物品的信息*/
 public String orderGoods() {
  String goodsState = "--";
  MyRunnable mr = new MyRunnable();
  Thread t = new Thread(mr);
  t.start();
  System.out.println(goodsState);
  goodsState = mr.getResult();// 得到返回值
  myFeeling();// 用来测试异步是不是还是按顺序的执行
  return goodsState;
 }

 public void myFeeling() {
  String[] s = {"有点小激动", "很期待!", "希望是个好货!"};
  Random random = new Random();
  int temp = random.nextInt(3);
  System.out.println("我是" + this.getBuyerName() + ", 我现在的感觉: " + s[temp]);
 }

 /*被回调的方法, 我们自己不去调用, 这个方法给出的结果, 是其他接口或者程序给我们的, 我们自己无法产生*/
 @Override
 public String getOrderResult(String state) {
  return "在" + this.getStore().getName() + "商店订购的" + this.getGoodsName() + "玩具, 目前的预订状态是: " + state;
 }

 // 开启另一个线程, 但是没有返回值, 怎么回事
 // 调试的时候, 等待一会儿, 还是可以取到值, 但不是立即取到, 在print显示的时候, 却是null, 需要注意?
 private class MyRunnable implements Runnable {
  @Getter
  @Setter
  private String result;

  @Override
  public void run() {
   try {
    Thread.sleep(10000);
    result = store.returnOrderGoodsInfo(NoSyncBuyer.this);// 匿名函数的时候, 无法return 返回值
   } catch (InterruptedException e) {
    log.error("出大事了, 异步回调有问题了", e);
   }
  }
 }
}

Test2Callback类, 测试同步回调和异步回调的结果.

public class Test2Callback {
 public static void main(String[] args) {
  Store wallMart = new Store("沙中路沃尔玛");
  SyncBuyer syncBuyer = new SyncBuyer(wallMart, "小明", "超能铁扇公主");
  System.out.println(syncBuyer.orderGoods());

  System.out.println("\n");
  Store lawson = new Store("沙中路罗森便利店");
  NoSyncBuyer noSyncBuyer = new NoSyncBuyer(lawson, "cherry", "变形金刚");
  System.out.println(noSyncBuyer.orderGoods());
 }
}

到此这篇关于java调用回调机制详解的文章就介绍到这了,更多相关java调用回调机制内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • 详解java 三种调用机制(同步、回调、异步)

    1:同步调用:一种阻塞式调用,调用方要等待对方执行完毕才返回,它是一种单向调用 2:回调:一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口: 3:异步调用:一种类似消息或事件的机制,不过它的调用方向刚好相反,接口的服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用客户方的接口 具体说来:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法, 实例1:使用java中Timer来在给定时间间隔发送通知,每隔十秒打印一次数据 Tim

  • java调用回调机制详解

    调用和回调机制 在一个应用系统中, 无论使用何种语言开发, 必然存在模块之间的调用, 调用的方式分为几种: 1.同步调用 同步调用是最基本并且最简单的一种调用方式, 类A的方法a()调用类B的方法b(), 一直等待b()方法执行完毕, a()方法继续往下走. 这种调用方式适用于方法b()执行时间不长的情况, 因为b()方法执行时间一长或者直接阻塞的话, a()方法的余下代码是无法执行下去的, 这样会造成整个流程的阻塞. 2.异步调用 异步调用是为了解决同步调用可能出现阻塞, 导致整个流程卡住而产

  • java 接口回调实例详解

    java 接口回调实例详解 首先官方对接口回调的定义是这样的,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法.这样听起来有点绕,我们可以这么理解接口回调:比如我们想知道隔壁老王啥时候回家?但是我们有自己的事情做不能一直监视着老王,那么我们可以雇员小区的保安来完成这个任务,当老王回家口,保安就给我们打电话告诉我们,老王回来了!这样就完成了一个事件的传递: 首先我们定义了一个接口: public interface DynamicMessage

  • Java try-catch-finally异常处理机制详解

    Java中的try-catch-finally异常处理 一.异常处理 异常(Exception):是在运行发生的不正常情况. 原始异常处理: if(条件) { 处理办法1 处理办法2 处理办法3 } if(条件) { 处理办法4 处理办法5 处理办法6 } 代码阅读性差,臃肿不堪,与正常流程代码结合的很紧密,所以,在JAVA中进行一系列的改良,将一系列常见的问题,用面向对象的思考方式,对其进行了描述.封装. class 处理办法 { 处理办法1() { 举例1 } 处理办法2() { 举例2 }

  • Java调用Oracle存储过程详解

    Java调用Oracle存储过程详解 步骤: 1.编写Oracle存储过程 2.编写数据库获取连接工具类 3.编写简单应用调用存储过程 实现: 1.Oracle存储过程: /*测试表*/ create table test( id varchar2(32), name varchar2(32) ); /*存储过程 插入数据*/ CREATE OR REPLACE PROCEDURE insert_procedure( PARA1 IN VARCHAR2, PARA2 IN VARCHAR2 )

  • Java 垃圾回收机制详解及实例代码

     Java 垃圾回收机制详解 乍一看,垃圾回收所做的事情应当恰如其名--查找并清除垃圾.事实上却恰恰相反.垃圾回收会跟踪所有仍在使用的对象,然后将剩余的对象标记为垃圾.牢记了这点之后,我们再来深入地了解下这个被称为"垃圾回收"的自动化内存回收在JVM中到底是如何实现的. 手动管理内存 在介绍现代版的垃圾回收之前,我们先来简单地回顾下需要手动地显式分配及释放内存的那些日子.如果你忘了去释放内存,那么这块内存就无法重用了.这块内存被占有了却没被使用.这种场景被称之为内存泄露. 下面是用C写

  • Java 调用天气Webservice详解及实例代码

    Java调用天气Webservice的小应用 废话不多说,直接贴代码: CityReq.java package com.weather; import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlRootElement; @XmlRootElement(name="getWeatherbyCityName",namespace="http://WebXml.com.cn/

  • Java 垃圾回收机制详解(动力节点Java学院整理)

    1. 垃圾回收的意义 在C++中,对象所占的内存在程序结束运行之前一直被占用,在明确释放之前不能分配给其它对象:而在Java中,当没有对象引用指向原先分配给某个对象的内存时,该内存便成为垃圾.JVM的一个系统级线程会自动释放该内存块.垃圾回收意味着程序不再需要的对象是"无用信息",这些信息将被丢弃.当一个对象不再被引用的时候,内存回收它占领的空间,以便空间被后来的新对象使用.事实上,除了释放没用的对象,垃圾回收也可以清除内存记录碎片.由于创建对象和垃圾回收器释放丢弃对象所占的内存空间,

  • Java动态代理机制详解_动力节点Java学院整理

    class文件简介及加载 Java编译器编译好Java文件之后,产生.class 文件在磁盘中.这种class文件是二进制文件,内容是只有JVM虚拟机能够识别的机器码.JVM虚拟机读取字节码文件,取出二进制数据,加载到内存中,解析.class 文件内的信息,生成对应的 Class对象: class字节码文件是根据JVM虚拟机规范中规定的字节码组织规则生成的.具体class文件是怎样组织类信息的,可以参考 此博文:深入理解Java Class文件格式系列.或者是Java虚拟机规范. 下面通过一段代

  • Java的内存机制详解

    Java把内存分为两种:一种是栈内存,另一种是堆内存.在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配,当在一段代码块定义一个变量时,Java 就在栈中为这个变量分配内存空间,当超过变量的作用域后(比如,在函数A中调用函数B,在函数B中定义变量a,变量a的作用域只是函数B,在函数B运行以后,变量a会自动被销毁.分配给它的内存会被回收),Java会自动释放掉为该变量分配的内存空间,该内存空间可以立即另做他用. 堆内存用来存放由new创建的内存数组,在堆中分配的内存,由Jav

  • Java调用外接设备详解(制卡机)

    最近在开发的系统中,有一个接入外接设备制卡机更换,之前用的制卡机要重新采购,所以导致之前的调用接口方法无效,要用新的设备接口来进行调用.可是这个设备是外国进口过来的,资料很少.想要百度的话,网上资料都没有,中间经过了几天的摸索,最终还是弄了出来,所以把详细的分析及解决方法记录下来. 这个制卡机是打印磁卡/智能卡的,像我们常用的银行卡.饭卡.购物卡都可以用这个机器来进行设计并制卡,并最终发放给消费者使用.简要说下解决的思路吧,最开始拿到这个机器的时候,我是一头的雾水,也不知道从何下手,我当时最最简

随机推荐