模块间接口调用的方式——回调

软件模块之间经常存在接口之间的调用，接口的调用方式可以分为三类：同步调用、回调和异步调用。

 

同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；

回       调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；

异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。

 

同步调用和回调都是同步执行的，即同步调用是需要等待被调接口返回结果之后，才能往下执行的，回调也是一样，只有等回调处理结束后主调方法才能继续往下执行的。

下面是一个回调例子：

public class CallBackTest 
{
	public static void main(String[] args) 
	{
		A a = new A();
		a.add();
	}
}

interface CallBack
{ 
    public void doCRUD();   
}  

class A implements CallBack{
    private B b = new B();
    public void doCRUD()
    {
    	System.out.println("执行add操作..."); 
    }  

    public void add()
    {
    	//A类实例的函数调用B类实例的方法
    	b.execute(this);
    	System.out.println("add方法执行结束...");
    }  
}

class B
{
	public void execute(CallBack action)
	{
		getConnection();  
		//B类的实例回调A类实例的方法
        action.doCRUD();  
        releaseConnection();  
    }  

	public void getConnection()
	{
		System.out.println("获得连接...");  
	}  
          
	public void releaseConnection()
	{
		System.out.println("释放连接...");   
	}  
}

执行结果如下：

获得连接...
执行add操作...
释放连接...
add方法执行结束...

从上面打印信息可以看出A类的add方法是在回调结束后才执行，那么有了同步调用，为什么还需要回调呢？

下面先看一个例子：

import java.text.DecimalFormat;

public class CallBackTest 
{
	public static void main(String[] args) 
	{
		A a = new A();
		a.add();
	}
}

interface CallBack
{ 
    public String doPercent(double random);   
}  

class A implements CallBack{
    private B b = new B();
    public String doPercent(double random)
    {
    	DecimalFormat df = new DecimalFormat("0.00");
    	String rst = df.format(random*100) + "%";
    	System.out.println("执行doPercent操作..."); 
    	return rst;
    }  

    public void add()
    {
    	//A类实例的函数调用B类实例的方法
    	b.execute(this);
    	System.out.println("doPercent方法执行结束...");
    }  
}

class B
{
	public void execute(CallBack action)
	{
		getConnection();  
		//B类的实例回调A类实例的方法
		double random = Math.random();
        String result = action.doPercent(random);  
        printResult(result);
        releaseConnection();  
    }  

	public void getConnection()
	{
		System.out.println("获得连接...");  
	}  
          
	public void releaseConnection()
	{
		System.out.println("释放连接...");   
	}  
	
	private void printResult(String result)
	{
		System.out.println("计算结果:" + result);
	}
}

执行结果如下：

获得连接...
执行doPercent操作...
计算结果:53.12%
释放连接...
doPercent方法执行结束...

从上面的例子可以看出，对于这种主调类和被调类在一次接口调用过程中，需要反复依赖对方的数据进行运算的，回调方式是一个很不错的选择。

 

另外，回调可以作为异步调用的基础来实现异步调用，如下代码：

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

消息的发送者：

/**
 * 这个类相当于你自己
 */
public class Local implements CallBack,Runnable{  
   
    private Remote remote;  
      
    /** 
     * 发送出去的消息 
     */  
    private String message;  
      
    public Local(Remote remote, String message) {  
        super();  
        this.remote = remote;  
        this.message = message;  
    }  
  
    /** 
     * 发送消息 
     */  
    public void sendMessage()  
    {  
        /**当前线程的名称**/  
        System.out.println(Thread.currentThread().getName());  
        /**创建一个新的线程发送消息**/  
        Thread thread = new Thread(this);  
        thread.start();  
        /**当前线程继续执行**/  
        System.out.println("Message has been sent by Local~!");  
    }  
  
    /** 
     * 发送消息后的回调函数 
     */  
    public void execute(Object... objects ) {  
        /**打印返回的消息**/  
        System.out.println(objects[0]);  
        /**打印发送消息的线程名称**/  
        System.out.println(Thread.currentThread().getName());  
        /**中断发送消息的线程**/  
        Thread.interrupted();  
    }  
      
    public static void main(String[] args)  
    {  
        Local local = new Local(new Remote(),"Hello");  
          
        local.sendMessage();  
    }  
  
    public void run() {  
        remote.executeMessage(message, this);  //这相当于给同学打电话，打完电话之后，这个线程就可以去做其他事情了，只不过等到你的同学打回电话给你的时候你要做出响应
          
    }  
}  

消息的接收者：

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