深入浅出java回调

一句话,回调是一种双向调用模式,什么意思呢,就是说,被调用方在被调用时也会调用对方,这就叫回调。“If you call me, i will call back”。 
不理解?没关系,先看看这个可以说比较经典的使用回调的方式

  • class A实现接口InA ——背景1
  • class A中包含一个class B的引用b ——背景2
  • class B有一个参数为InA的方法test(InA a) ——背景3
  • A的对象a调用B的方法传入自己,test(a) ——这一步相当于you call me
  • 然后b就可以在test方法中调用InA的方法 ——这一步相当于i call you back

是不是清晰一点了?下面再来看一个完全符合这个方式模板的例子 
(PS:这个例子来源于网络,由于这个例子表现的功能极度拉风,令我感觉想想出一个超越它的例子确实比较困难,所以直接搬过来)

Java代码  

  1. //相当于接口InA
  2. public interface BoomWTC{
  3. //获得拉登的决定
  4. public benLaDengDecide();
  5. // 执行轰炸世贸
  6. public void boom();
  7. }
  8. //相当于class A
  9. public class At$911 implements BoomWTC{//相当于【背景1】
  10. private boolean decide;
  11. private TerroristAttack ta;//相当于【背景2】
  12. public At$911(){
  13. Date now=new Date();
  14. SimpleDateFormat myFmt1=new SimpleDateFormat("yy/MM/dd HH:mm");
  15. this.dicede= myFmt.format(dt).equals("01/09/11 09:44");
  16. this.ta=new TerroristAttack();
  17. }
  18. //获得拉登的决定
  19. public boolean benLaDengDecide(){
  20. return decide;
  21. }
  22. // 执行轰炸世贸
  23. public void boom(){
  24. ta.attack(new At$911);//class A调用class B的方法传入自己的对象,相当于【you call me】
  25. }
  26. }
  27. //相当于class B
  28. public class TerroristAttack{
  29. public TerroristAttack(){
  30. }
  31. public attack(BoomWTC bmw){——这相当于【背景3】
  32. if(bmw.benLaDengDecide()){//class B在方法中回调class A的方法,相当于【i call you back】
  33. //let‘s go.........
  34. }
  35. }
  36. }

现在应该对回调有一点概念了吧。 
可是问题来了,对于上面这个例子来说,看不出用回调有什么好处,直接在调用方法不就可以了,为什么要使用回调呢? 
事实上,很多需要进行回调的操作是比较费时的,被调用者进行费时操作,然后操作完之后将结果回调给调用者。看这样一个例子:

Java代码  

  1. //模拟Spring中HibernateTemplate回调机制的代码
  2. interface CallBack{
  3. public void doCRUD();
  4. }
  5. public class HibernateTemplate {
  6. public void execute(CallBack action){
  7. getConnection();
  8. action.doCRUD();
  9. releaseConnection();
  10. }
  11. public void add(){
  12. execute(new CallBack(){
  13. public void doCRUD(){
  14. System.out.println("执行add操作...");
  15. }
  16. });
  17. }
  18. public void getConnection(){
  19. System.out.println("获得连接...");
  20. }
  21. public void releaseConnection(){
  22. System.out.println("释放连接...");
  23. }
  24. }

可能上面这个例子你不能一眼看出个所以然来,因为其实这里A是作为一个内部匿名类存在的。好,不要急,让我们把这个例子来重构一下:

Java代码  

  1. interface CallBack{   //相当于接口InA
  2. public void doCRUD();
  3. }
  4. public class A implements CallBack{//【背景1】
  5. private B b;//【背景2】
  6. public void doCRUD(){
  7. System.out.println("执行add操作...");
  8. }
  9. public void add(){
  10. b.execute(new A());//【you call me】
  11. }
  12. }
  13. public class B{
  14. public void execute(CallBack action){  //【背景3】
  15. getConnection();
  16. action.doCRUD();  //【i call you back】
  17. releaseConnection();
  18. }
  19. public void getConnection(){
  20. System.out.println("获得连接...");
  21. }
  22. public void releaseConnection(){
  23. System.out.println("释放连接...");
  24. }
  25. }

好了,现在就明白多了吧,完全可以转化为上面所说的回调使用方式的模板。 
现在在来看看为什么要使用回调,取得连接getConnection();是费时操作,A希望由B来进行这个费时的操作,执行完了之后通知A即可(即所谓的i call you back)。这就是这里使用回调的原因。

在网上看到了一个比喻,觉得很形象,这里借用一下: 
你有一个复杂的问题解决不了,打电话给你的同学,你的同学说可以解决这个问题,但是需要一些时间,那么你不可能一直拿着电话在那里等,你会把你的电话号码告诉他,让他解决之后打电话通知你。回调就是体现在你的同学又反过来拨打你的号码。 
结合到前面所分析的,你打电话给你同学就是【you call me】,你同学解决完之后打电话给你就是【i call you back】。

怎么样,现在理解了吧?

---------------------------------以下为更新----------------------------------

看了有些朋友的回帖,我又思考了一下,感觉自己之前对回调作用的理解的确存在偏差。 
下面把自己整理之后的想法共享一下,如果有错误希望指出!多谢!

先说上面这段代码,本来完全可以用模板模式来进行实现:

Java代码  

  1. public abstract class B{
  2. public void execute(){
  3. getConnection();
  4. doCRUD();
  5. releaseConnection();
  6. }
  7. public abstract void doCRUD();
  8. public void getConnection(){
  9. System.out.println("获得连接...");
  10. }
  11. public void releaseConnection(){
  12. System.out.println("释放连接...");
  13. }
  14. }
  15. public class A extends B{
  16. public void doCRUD(){
  17. System.out.println("执行add操作...");
  18. }
  19. public void add(){
  20. doCRUD();
  21. }
  22. }
  23. public class C extends B{
  24. public void doCRUD(){
  25. System.out.println("执行delete操作...");
  26. }
  27. public void delete(){
  28. doCRUD();
  29. }
  30. }

如果改为回调实现是这样的:

Java代码  

  1. interface CallBack{
  2. public void doCRUD();
  3. }
  4. public class HibernateTemplate {
  5. public void execute(CallBack action){
  6. getConnection();
  7. action.doCRUD();
  8. releaseConnection();
  9. }
  10. public void add(){
  11. execute(new CallBack(){
  12. public void doCRUD(){
  13. System.out.println("执行add操作...");
  14. }
  15. });
  16. }
  17. public void delete(){
  18. execute(new CallBack(){
  19. public void doCRUD(){
  20. System.out.println("执行delete操作...");
  21. }
  22. });
  23. }
  24. public void getConnection(){
  25. System.out.println("获得连接...");
  26. }
  27. public void releaseConnection(){
  28. System.out.println("释放连接...");
  29. }
  30. }

可见摒弃了继承抽象类方式的回调方式更加简便灵活。不需要为了实现抽象方法而总是继承抽象类,而是只需要通过回调来增加一个方法即可,更加的直观简洁灵活。这算是回调的好处之一。

下面再给出一个关于利用回调配合异步调用的很不错的例子,来源于http://kt8668.iteye.com/blog/205739 
回调接口:

Java代码  

  1. public interface CallBack {
  2. /**
  3. * 执行回调方法
  4. * @param objects   将处理后的结果作为参数返回给回调方法
  5. */
  6. public void execute(Object... objects );
  7. }

消息的发送者:

Java代码  

  1. /**
  2. * 这个类相当于你自己
  3. */
  4. public class Local implements CallBack,Runnable{
  5. private Remote remote;
  6. /**
  7. * 发送出去的消息
  8. */
  9. private String message;
  10. public Local(Remote remote, String message) {
  11. super();
  12. this.remote = remote;
  13. this.message = message;
  14. }
  15. /**
  16. * 发送消息
  17. */
  18. public void sendMessage()
  19. {
  20. /**当前线程的名称**/
  21. System.out.println(Thread.currentThread().getName());
  22. /**创建一个新的线程发送消息**/
  23. Thread thread = new Thread(this);
  24. thread.start();
  25. /**当前线程继续执行**/
  26. System.out.println("Message has been sent by Local~!");
  27. }
  28. /**
  29. * 发送消息后的回调函数
  30. */
  31. public void execute(Object... objects ) {
  32. /**打印返回的消息**/
  33. System.out.println(objects[0]);
  34. /**打印发送消息的线程名称**/
  35. System.out.println(Thread.currentThread().getName());
  36. /**中断发送消息的线程**/
  37. Thread.interrupted();
  38. }
  39. public static void main(String[] args)
  40. {
  41. Local local = new Local(new Remote(),"Hello");
  42. local.sendMessage();
  43. }
  44. public void run() {
  45. remote.executeMessage(message, this);  //这相当于给同学打电话,打完电话之后,这个线程就可以去做其他事情了,只不过等到你的同学打回电话给你的时候你要做出响应
  46. }
  47. }

消息的接收者:

Java代码  

  1. /**
  2. * 这个类相当于你的同学
  3. */
  4. public class Remote {
  5. /**
  6. * 处理消息
  7. * @param msg   接收的消息
  8. * @param callBack  回调函数处理类
  9. */
  10. public void executeMessage(String msg,CallBack callBack)
  11. {
  12. /**模拟远程类正在处理其他事情,可能需要花费许多时间**/
  13. for(int i=0;i<1000000000;i++)
  14. {
  15. }
  16. /**处理完其他事情,现在来处理消息**/
  17. System.out.println(msg);
  18. System.out.println("I hava executed the message by Local");
  19. /**执行回调**/
  20. callBack.execute(new String[]{"Nice to meet you~!"});  //这相当于同学执行完之后打电话给你
  21. }
  22. }

由上面这个例子可见,回调可以作为异步调用的基础来实现异步调用。

时间: 2024-10-13 08:49:37

深入浅出java回调的相关文章

深入浅出Java回调机制

在网上看到了一个比喻,觉得很形象,这里借用一下: 你有一个复杂的问题解决不了,打电话给你的同学,你的同学说可以解决这个问题,但是需要一些时间,那么你不可能一直拿着电话在那里等,你会把你的电话号码告诉他,让他解决之后打电话通知你.回调就是体现在你的同学又反过来拨打你的号码. 结合到前面所分析的,你打电话给你同学就是[you call me],你同学解决完之后打电话给你就是[i call you back]. 下面再给出一个关于利用回调配合异步调用的很不错的例子,来源于http://kt8668.i

Java回调函数详解

为了了解什么是回调函数,在网上查阅了如下资料,整理如下: 资料一: 首先说说什么叫回调函数? 在WINDOWS中,程序员想让系统DLL调用自己编写的一个方法,于是利用DLL当中回调函数(CALLBACK)的接口来编写程序,使它调用,这个就 称为回调.在调用接口时,需要严格的按照定义的参数和方法调用,并且需要处理函数的异步,否则会导致程序的崩溃. 这样的解释似乎还是比较难懂,这里举个简 单的例子: 程序员A写了一段程序(程序a),其中预留有回调函数接口,并封装好了该程序.程序员B要让a调用自己的程

一个简单的java回调函数的实现

回调函数 回调函数涉及的3个函数 登记回调函数 回调函数 响应回调函数 简单的解释 你到一个商店买东西,刚好你要的东西没有货,于是你在店员那里留下了你的电话,过了几天店里有货了,店员就打了你的电话,然后你接到电话后就到店里去取了货.在这个例子里,你的电话号码就叫回调函数,你把电话留给店员就叫登记回调函数,店里后来有货了叫做触发了回调关联的事件,店员给你打电话叫做调用回调函数,你到店里去取货叫做响应回调事件.回答完毕.来自知乎点击打开链接 代码的实现 首先有一个接口 interface CallB

【Servlet】深入浅出Java重定向和请求转发

import java.text.*; import java.util.*; import java.io.*; import javax.servlet.http.*; import javax.servlet.*; import com.bjpowernode.exam.model.*; import com.bjpowernode.exam.manager.*; public class SearchStudentServlet extends HttpServlet { public

一个例子教你理解java回调机制

网上很多例子都写的很难理解,笔者刚开始都已经弄晕菜了. 这个例子,应该是再简单,再简洁不过的了,例子目的是测试某个方法的执行时间.这里就写三个java类,一个接口,一个实现,还有一个用于测试时间的类. 要测试的方法,尽量占用执行的时间,这样明显一些,这里测试循环1000000次,并且打印出来. 测试类: public class MyMethod { public void mytest() { // TODO Auto-generated method stub for (int i = 0;

Java 回调机制详解

一.说明 最近在写代码,发现 Java 回调机制蛮实用.在网上搜索部分资料以后,现在按照自己的理解进行归纳总结 ,有理解错的地方,希望大家能够帮忙指正! 先从一个很简单的 Android 开发例子说起.我们在界面上使用 Button 时,为其增加点击事件监听大概需要以下几个步骤 : ① 实例化 Button 对象,如 btn_call_back: ② btn_call_back.setOnClickListener(MainActivity.this); ③本类实现 OnClickListene

RPC框架研究(一)Java回调机制

报名了阿里中间件性能大赛,我来说是一个全新的挑战,一切从空白学起,比赛的过程也是学习的过程 是的,想让自己学好,给自己报一个比赛吧~ 就像当初学围棋,也是报了围棋比赛,为了不至于输的太惨,一个星期里学了好多东西 第一天 Java回调机制 晴 首先还是来看看赛事介绍 比赛总共分为两道题:"RPC"与"MOM",两题都需完成.我们会对"RPC"成绩(qps)进行排名,排名前100位的队伍有资格进入MOM的比赛环节,若未进入前100名直接淘汰,最终名次

java回调函数机制

Java回调函数机制 参考了网上的一些资料,下面也做出一些总结,供初学者了解学习. 一. 概述 软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用.回调.异步调用 . 同步调用:一种阻塞式调用,调用方要等待对方执行完毕才返回,它是一种单向调用: 回调:一种双向调用模式,也就是说,被调用方在接口被调用时也会调用对方的接口: 异步调用:一种类似消息或事件的机制,解决了同步阻塞的问题,它的调用方向刚好相反,接口的服务在收到某种讯息或发生某种事件时,会主动通知客户方(即调用客户

(CZ深入浅出Java基础)设计模式笔记

一.面向对象思想设计原则 1.单一职责原则 其实就是开发人员经常说的"高内聚,低耦合",也就是说,每个类应该只有一个职责,对外只能提供一种功能,而引起类变化的原因应该只有一个.在设计模式中,所有的设计模式都遵循这一原则. 2.开闭原则 核心思想是:一个对象对扩展开放,对修改关闭.其实开闭原则的意思就是:对类的改动是通过增加代码进行的,而不是修改现有代码.也就是说软件开发人员一旦写出了可以运行的代码,就不应该去改动它,而是要保证它能一直运行下去,如何能够做到这一点呢?这就需要借助于抽象和