java回调机制

一.经典的回调方式

所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法。经典的回调方式:

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

二.回调机制的实现方式

大家都喜欢用打电话的例子,好吧,为了跟上时代,我也用这个例子好了,我这个例子采用异步加回调

有一天小王遇到一个很难的问题,问题是“1 + 1 = ?”,就打电话问小李,小李一下子也不知道,就跟小王说,等我办完手上的事情,就去想想答案,小王也不会傻傻的拿着电话去等小李的答案吧,于是小王就对小李说,我还要去逛街,你知道了答案就打我电话告诉我,于是挂了电话,自己办自己的事情,过了一个小时,小李打了小王的电话,告诉他答案是2

/** 
 * 这是一个回调接口 
 * @author xiaanming 
 * 
 */  
public interface CallBack {  
    /** 
     * 这个是小李知道答案时要调用的函数告诉小王,也就是回调函数 
     * @param result 是答案 
     */  
    public void solve(String result);  
} 
/** 
 * 这个是小王 
 * @author xiaanming 
 * 实现了一个回调接口CallBack,相当于----->背景一 
 */  
public class Wang implements CallBack {  
    /** 
     * 小李对象的引用 
     * 相当于----->背景二 
     */  
    private Li li;   
  
    /** 
     * 小王的构造方法,持有小李的引用 
     * @param li 
     */  
    public Wang(Li li){  
        this.li = li;  
    }  
      
    /** 
     * 小王通过这个方法去问小李的问题 
     * @param question  就是小王要问的问题,1 + 1 = ? 
     */  
    public void askQuestion(final String question){  
        //这里用一个线程就是异步,  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                /** 
                 * 小王调用小李中的方法,在这里注册回调接口 
                 * 这就相当于A类调用B的方法C 
                 */  
                li.executeMessage(Wang.this, question);   
            }  
        }).start();  
          
        //小网问完问题挂掉电话就去干其他的事情了,诳街去了  
        play();  
    }  
  
    public void play(){  
        System.out.println("我要逛街去了");  
    }  
  
    /** 
     * 小李知道答案后调用此方法告诉小王,就是所谓的小王的回调方法 
     */  
    @Override  
    public void solve(String result) {  
        System.out.println("小李告诉小王的答案是--->" + result);  
    }  
      
} 
/** 
 * 这个就是小李啦 
 * @author xiaanming 
 * 
 */  
public class Li {  
    /** 
     * 相当于B类有参数为CallBack callBack的f()---->背景三 
     * @param callBack   
     * @param question  小王问的问题 
     */  
    public void executeMessage(CallBack callBack, String question){  
        System.out.println("小王问的问题--->" + question);  
          
        //模拟小李办自己的事情需要很长时间  
        for(int i=0; i<10000;i++){  
              
        }  
          
        /** 
         * 小李办完自己的事情之后想到了答案是2 
         */  
        String result = "答案是2";  
          
        /** 
         * 于是就打电话告诉小王,调用小王中的方法 
         * 这就相当于B类反过来调用A的方法D 
         */  
        callBack.solve(result);   
  
          
          
    }  
      
} 

/** 
 * 测试类 
 * @author xiaanming 
 * 
 */  
public class Test {  
    public static void main(String[]args){  
        /** 
         * new 一个小李 
         */  
        Li li = new Li();  
  
        /** 
         * new 一个小王 
         */  
        Wang wang = new Wang(li);  
          
        /** 
         * 小王问小李问题 
         */  
        wang.askQuestion("1 + 1 = ?");  
    }  
}  

三.回调机制的应用例子

通过上面的那个例子你是不是差不多明白了回调机制呢,上面是一个异步回调,我们看看同步回调吧,onClick()方法

现在来分析分析下Android View的点击方法onclick();我们知道onclick()是一个回调方法,当用户点击View就执行这个方法,我们用Button来举例好了。

//这个是View的一个回调接口  
/** 
 * Interface definition for a callback to be invoked when a view is clicked. 
 */  
public interface OnClickListener {  
    /** 
     * Called when a view has been clicked. 
     * 
     * @param v The view that was clicked. 
     */  
    void onClick(View v);  
}  
package com.example.demoactivity;  
  
import android.app.Activity;  
import android.os.Bundle;  
import android.view.View;  
import android.view.View.OnClickListener;  
import android.widget.Button;  
import android.widget.Toast;  
  
/** 
 * 这个就相当于Class A 
 * @author xiaanming 
 * 实现了 OnClickListener接口---->背景一 
 */  
public class MainActivity extends Activity implements OnClickListener{  
    /** 
     * Class A 包含Class B的引用----->背景二 
     */  
    private Button button;  
  
    @Override  
    public void onCreate(Bundle savedInstanceState) {  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity_main);  
        button = (Button)findViewById(R.id.button1);  
          
        /** 
         * Class A 调用View的方法,而Button extends View----->A类调用B类的某个方法 C 
         */  
        button.setOnClickListener(this);  
    }  
  
    /** 
     * 用户点击Button时调用的回调函数,你可以做你要做的事 
     * 这里我做的是用Toast提示OnClick 
     */  
    @Override  
    public void onClick(View v) {  
        Toast.makeText(getApplication(), "OnClick", Toast.LENGTH_LONG).show();  
    }  
  
} 

下面是View类的setOnClickListener方法,就相当于B类咯,只把关键代码贴出来
/** 
 * 这个View就相当于B类 
 * @author xiaanming 
 * 
 */  
public class View implements Drawable.Callback, KeyEvent.Callback, AccessibilityEventSource {  
    /** 
     * Listener used to dispatch click events. 
     * This field should be made private, so it is hidden from the SDK. 
     * {@hide} 
     */  
    protected OnClickListener mOnClickListener;  
      
    /** 
     * setOnClickListener()的参数是OnClickListener接口------>背景三 
     * Register a callback to be invoked when this view is clicked. If this view is not 
     * clickable, it becomes clickable. 
     * 
     * @param l The callback that will run 
     * 
     * @see #setClickable(boolean) 
     */  
      
    public void setOnClickListener(OnClickListener l) {  
        if (!isClickable()) {  
            setClickable(true);  
        }  
        mOnClickListener = l;  
    }  
      
      
    /** 
     * Call this view's OnClickListener, if it is defined. 
     * 
     * @return True there was an assigned OnClickListener that was called, false 
     *         otherwise is returned. 
     */  
    public boolean performClick() {  
        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);  
  
        if (mOnClickListener != null) {  
            playSoundEffect(SoundEffectConstants.CLICK);  
              
            //这个不就是相当于B类调用A类的某个方法D,这个D就是所谓的回调方法咯  
            mOnClickListener.onClick(this);  
            return true;  
        }  
  
        return false;  
    }  
} 

这个例子就是Android典型的回调机制,看完这个你是不是更进一步的理解了回调机制呢? 线程run()也是一个回调方法,当执行Thread的start()方法就会回调这个run()方法,还有处理消息都比较经典等等。

四.回调机制的应用:网络编程的最佳实践

以下摘自《第一行代码》 9.2 网络编程的最佳实践

前面的博客已经讲解了HttpURLConnection和HttpClient的用法,知道了如何发起HTTP请求,以及解析服务器返回
 的数据。但是可能你发现了,因为一个应用程序很多地方都可能使用网络功能,而发送HTTP请求的代码基本相同,如果每次我们都去编写一遍发送HTTP请求的代码,这显然不太好。
    通常情况下我们都应该将这些通用的网络操作提取到一个公共的类里,并提供一个静态方法,当想要发起网络请求的时候只需简单地调用一下这个方法即可。比如下面的写法:


package com.jack.networktest;  
  
import java.io.BufferedReader;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.net.HttpURLConnection;  
import java.net.URL;  
  
public class HttpUtil {  
  
    public static String sendHttpRequest(String address){  
        HttpURLConnection connection=null;  
        try{  
            URL url=new URL(address);  
            connection = (HttpURLConnection) url.openConnection();  
            connection.setRequestMethod("GET");  
            connection.setConnectTimeout(8000);  
            connection.setReadTimeout(8000);  
            connection.setDoInput(true);  
            connection.setDoOutput(true);  
            InputStream in=connection.getInputStream();  
            BufferedReader reader=new BufferedReader(new InputStreamReader(in));  
            StringBuilder response=new StringBuilder();  
            String line;  
            while((line=reader.readLine())!=null){  
                response.append(line);  
            }  
            return response.toString();  
        }catch(Exception e){  
            e.printStackTrace();  
            return e.getMessage();  
        }finally{  
            if(connection!=null){  
                connection.disconnect();  
            }  
        }  
    }  
} 

以后每当要发起一条HTTP请求的时候就可以这样写:
  String address="http://www.baidu.com";
  String response=HttpUtil.sendHttpRequest(address);


         在获取到服务器响应的数据后我们就可以对它进行解析和处理了。但是需要注意,网络请求通常都是属于耗时操作,而 sendHttpRequest方法的内部并没有开启线程,这样就可能导致在调用sendHttpRequest方法的时候使得主线程阻塞住。你可能说,在sendHttpRequest方法内部开启一个线程不就解决了阻塞这个问题了嘛。其实没那么简单,因为如果我们在sendHttpRequest方法中开启了一个线程来发起HTTP请求,那么服务器响应的数据是无法进行返回的,所有的耗时逻辑都是在子线程里进行的,sendHttpRequest方法会在服务器还来得及响应的时候就执行结束了,当然也就无法返回响应的数据了。
  那么这种情况该如何解决?其实解决方法可以使用Java的回调机制,下面就让我们来学习一下回调机制到底如何使用的。
  首先需要定义一个接口,比如将它命名成HttpCallbackListener,代码如下所示:
  public interfac HttpCallbackListener{
  void onFinish(String response);
  void onError(Exception e);
  }
  可以看到,我们在接口中定义了两个方法,onFinish(String response)方法表示当服务器成功响应我们请求
  的时候调用,onError(Exception e)表示当进行网络操作出现错误的时候调用。这两个方法都带有参数,
  onFinish(String response)方法中的参数代表着服务器返回的数据,而onError(Exception e)方法
  中的参数记录着错误的详细信息。

       接着修改HttpUtil中的代码:

import java.io.BufferedReader;  
import java.io.InputStream;  
import java.io.InputStreamReader;  
import java.net.HttpURLConnection;  
import java.net.URL;  
  
public class HttpUtil {  
  
    public static void sendHttpRequest(final String address,  
            final HttpCallbackListener listener){  
        new Thread(new Runnable(){  
  
              
            @Override  
            public void run() {  
                // TODO Auto-generated method stub  
                HttpURLConnection connection=null;  
                try{  
                    URL url=new URL(address);  
                    connection = (HttpURLConnection) url.openConnection();  
                    connection.setRequestMethod("GET");  
                    connection.setConnectTimeout(8000);  
                    connection.setReadTimeout(8000);  
                    connection.setDoInput(true);  
                    connection.setDoOutput(true);  
                    InputStream in=connection.getInputStream();  
                    BufferedReader reader=new BufferedReader(new InputStreamReader(in));  
                    StringBuilder response=new StringBuilder();  
                    String line;  
                    while((line=reader.readLine())!=null){  
                        response.append(line);  
                    }  
                    if(listener!=null){  
                        //回调onFinish()方法  
                        listener.onFinish(response.toString());  
                    }  
                }catch(Exception e){  
                    if(listener!=null){  
                        //回调onError()方法  
                        listener.onError(e);  
                    }  
                      
                }finally{  
                    if(connection!=null){  
                        connection.disconnect();  
                    }  
                    }  
            }  
                }).start();  
          
          
    }  
}  

我们首先给sendHttpRequest方法添加了一个HttpCallbackListener参数,并在方法的内部开启了一个子线程,然后
在子线程里去执行具体的网络操作。注意子线程中是无法通过return语句来返回数据的,因此这里我们将服务器响应的数据传入了HttpCallbackListener的onFinish()方法中,如果出现了异常就将异常原因传入到onError()方法中。
  现在sendHttpRequest方法接收两个参数了,因此我们在调用它的时候还需要将HttpCallbackListener的实例传入
  如下所示:
HttpUtil.sendHttpRequest(address,new HttpCallbackListener(){  
   public void onFinish(String response){  
   //在这里根据返回内容执行具体的逻辑  
   }  
     
   public void onError(Exception e){  
      //在这里对异常进行处理  
   }  
     
  });  

这样的话,当服务器成功响应的时候我们就可以在onFinish方法里对响应数据进行处理了,类似地,如果出现了异常,就可以在onError方法里对异常情况进行处理。如此一来,我们就巧妙的利用回调机制将响应数据成功返回给调用方了。
  另外需要注意的是,onFinish方法和onError方法最终还是在子线程中运行的,因此我们不可以在这里执行任何的

  UI操作,如果需要根据返回的结果来更新UI,则仍然要使用异步消息处理机制。

五.回调机制的应用:spring、hibernate等的应用

看过spring、hibernate源码的朋友对callback回调模式应该并不陌生,用一句话来概括就是:“if you call me, i will call back”,说白了,就是有相互依赖关系的两个类之间的互相调用,现在看看下面的代码模型:

package com.cuishen.callback;  
  
public class Context implements A.Callback {  
  
    private A a;  
      
    public void begin() {  
        System.out.println("begin ...");  
    }  
  
    public void end() {  
        System.out.println("end ...");  
    }  
      
    public Context() {  
        this.a = new A(this);  
    }  
      
    public void doSomething() {  
        this.a.doIt();  
    }  
      
    public static void main(String args[]) {  
        new Context().doSomething();  
    }  
}  
  
  
package com.cuishen.callback;  
  
public class A {  
      
    private final Callback callback;  
      
    public static interface Callback {  
        public void begin();  
        public void end();  
    }  
    public A(Callback callback) {  
        this.callback = callback;  
    }  
    public void doIt() {  
        callback.begin();  
        System.out.println("do something ...");  
        callback.end();  
    }  
}  
上面的代码模型其原型是出自hibernate里的org.hibernate.jdbc.JDBCContext 和 org.hibernate.jdbc.ConnectionManager两个类,从上面的模型不难看出:Context类实现了A类的Callback接口,在Context类的构造器里将自己注入了A类,在Context类里调用A类的doIt()方法,这时就是:you call me;在doIt()方法体里调用了Context类的begin()和end()方法,这时就是:i call back。Context类 和 A类相互依赖,互相调用 

在hibernate的源代码里大量使用了上面的callback回调模型,又如:org.hibernate.jdbc.JDBCContext 和 org.hibernate.impl.SessionImpl等等,可以自己去看源代码,这里不再赘述。 

当然上面提到的模型中的两个类也可以写在同一个类里面,定义的Callback接口可以用内部匿名类来实现,比如下面的一个简单的dao实现:
package com.cuishen.callback;  
  
import java.sql.Connection;  
import java.sql.DriverManager;  
import java.sql.SQLException;  
  
public class Dao {  
    private interface Callback {  
        Object doIt(Connection conn) throws SQLException;  
    }  
    private Object execute(Callback callback) throws SQLException {  
        Connection conn = openConnection(); // 开启数据库连接  
        try { return callback.doIt(conn); } // 执行具体操作并返回操作结果  
        finally { closeConnection(conn); } // 关闭数据库连接  
    }  
      
    public Object sqlQuery(final String sql) throws SQLException {  
        return execute(  
            new Callback() {  
                public Object doIt(Connection conn) throws SQLException {  
                    return conn.createStatement().executeQuery(sql);  
                }  
            }  
        );  
    }  
      
    public Connection openConnection() throws SQLException {  
        return DriverManager.getConnection("", null);  
    }  
    public void closeConnection(Connection conn) throws SQLException {  
        if(conn != null && !conn.isClosed()) {  
            conn.close();  
        }  
    }  
}



  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
本火锅店点餐系统采用Java语言和Vue技术,框架采用SSM,搭配Mysql数据库,运行在Idea里,采用小程序模式。本火锅店点餐系统提供管理员、用户两种角色的服务。总的功能包括菜品的查询、菜品的购买、餐桌预定和订单管理。本系统可以帮助管理员更新菜品信息和管理订单信息,帮助用户实现在线的点餐方式,并可以实现餐桌预定。本系统采用成熟技术开发可以完成点餐管理的相关工作。 本系统的功能围绕用户、管理员两种权限设计。根据不同权限的不同需求设计出更符合用户要求的功能。本系统中管理员主要负责审核管理用户,发布分享新的菜品,审核用户的订餐信息和餐桌预定信息等,用户可以对需要的菜品进行购买、预定餐桌等。用户可以管理个人资料、查询菜品、在线点餐和预定餐桌、管理订单等,用户的个人资料是由管理员添加用户资料时产生,用户的订单内容由用户在购买菜品时产生,用户预定信息由用户在预定餐桌操作时产生。 本系统的功能设计为管理员、用户两部分。管理员为菜品管理、菜品分类管理、用户管理、订单管理等,用户的功能为查询菜品,在线点餐、预定餐桌、管理个人信息等。 管理员负责用户信息的删除和管理,用户的姓名和手机号都可以由管理员在此功能里看到。管理员可以对菜品的信息进行管理、审核。本功能可以实现菜品的定时更新和审核管理。本功能包括查询餐桌,也可以发布新的餐桌信息。管理员可以查询已预定的餐桌,并进行审核。管理员可以管理公告和系统的轮播图,可以安排活动。管理员可以对个人的资料进行修改和管理,管理员还可以在本功能里修改密码。管理员可以查询用户的订单,并完成菜品的安排。 当用户登录进系统后可以修改自己的资料,可以使自己信息的保持正确性。还可以修改密码。用户可以浏览所有的菜品,可以查看详细的菜品内容,也可以进行菜品的点餐。在本功能里用户可以进行点餐。用户可以浏览没有预定出去的餐桌,选择合适的餐桌可以进行预定。用户可以管理购物车里的菜品。用户可以管理自己的订单,在订单管理界面里也可以进行查询操作。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值