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();          }      }  }