Java回调机制（笔记）

什么是回调

回调，回调。要先有调用，才有调用者和被调用者之间的回调。所以在百度百科中是这样的：

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。

回调是一种特殊的调用，至于三种方式也有点不同。

1、同步回调，即阻塞，单向。

2、回调，即双向（类似自行车的两个齿轮）。

3、异步调用，即通过异步消息进行通知。

原理

简而言之，就是，A类调用B类的E方法，然后，因为B类的E方法会调用A类的D方法。所以，称A类的D方法为回调发方法。

而在实现时，一般要满足如下几个条件：

首先会存在三个Object：A 类、B类、接口C。
* A类实现了接口C中的方法D。
* A类有了B类的引用。
* B类中存在一个输入参数的数据类类型为接口C的方法E。
* 且，在B类中对E方法的定义中会存在对接口C的方法D的调用。
* 因为，A类中存在B类的引用。所以， A类的对象 可以调用 B类方法E ，并且传入的参数为A.this。
* 又因为，D是A实现了的接口C的方法。
* 所以，整个过程就出现了，A调用了B的E方法，而B的E方法又回调了A的D方法。

（一个实现了某个接口的类在调用另一个以该类为参的方法时，被调用了实现了的接口方法。而这个方法被成为回调方法。）

正如下文案例中存在三个Object：Client类、Server类、接口CSCallBack。
* Client类实现了接口CSCallBack中的process方法。
* Client类还声明了Server类，拥有Server类的引用。
* Server类中存在方法getClientMsg，接口CSCallBack是其输入参数。
* 并且，在Server类的getClientMsg中存在对接口CSCallBack的process方法的调用。
* 因为，Client类中存在Server类的引用；所以，Client类的对象可以调用Server类的getClientMsg方法，并且传入参数是Client.this。
* 又因为在Client类中实现了接口CSCallBack中的方法；所以，整个过程出现了Client类调用了Server类的getClientMsg方法，而Server类的getClientMsg方法又回调了Client的process方法。

比较同步回调和异步回调

异步回调：发起请求后，不等待响应就先去处理自己的响应，它不是处理整个请求，只是处理一小部分，在Web页上就表现为页面没刷新，却局部更新了数据。
同步回调：必须等到响应该请求后才能做别的事，具体到Web页就是整个页面刷新了，数据才更新。

eg：比如程序调用了一个方法，这个方法要执行很长时间，而且这个时间不确定。

（1）同步调用

private int Func()
{
// 这个方法要执行很长时间，并且返回一个int的值。
}

private void A()
{
int n = Func();
textBox1.Text = n.ToString();
// 这里得到的n就是Func执行出来的结果，并且显示在textBox1中。
}

缺点：Func方法执行的时间过长，程序会阻塞，并且无法继续执行其他的代码，给用户的体验就是整个程序都会僵着，打开任务管理器会提示该程序没有响应，用户以为程序死了，就会手动结束这个程序。

（2）异步调用

在调用完Func这个方法后，不必等待Func执行完，就可以执行其他的代码，直到Func执行完，才把结果返回，

如果Func提供了异步方法FuncAsync()，就可以这样调用：

private void A()
{
FuncAsync();
// 这里执行FuncAsync方法，并不会阻塞，程序会在后台执行完FuncAsync方法后，自动调用FuncCompleted方法，并且把结果传过去。
}

private void FuncCompleted(int n)
{
textBox1.Text = n.ToString();
// 参数n就是异步回调返回的结果，
}

异步回调需要编写代码才能支持，网络传输方面的类库一般都提供异步方法，如socket编程，web服务，ajax，wcf等，有些异步是同一个线程完成的，有些异步是不同的线程，所以回调函数里要更新控件都会提示跨线程访问控件的错误提示。

CS中的异步回调

比如这里模拟个场景：客户端发送msg给服务端，服务端处理后（5秒），回调给客户端，告知处理成功。代码如下：

回调接口类：

/**
* 回调模式-回调接口类
*/
public interface CSCallBack {
public void process(String status);
}

模拟客户端：

/**
* 回调模式-模拟客户端类
*/
public class Client implements CSCallBack {

private Server server;

public Client(Server server) {
this.server = server;
}

public void sendMsg
b109
(final String msg){
System.out.println("客户端：发送的消息为：" + msg);
new Thread(new Runnable() {
@Override
public void run() {
server.getClientMsg(Client.this,msg);
}
}).start();
System.out.println("客户端：异步发送成功");
}

@Override
public void process(String status) {
System.out.println("客户端：服务端回调状态为：" + status);
}
}

模拟服务端:

/**
* 回调模式-模拟服务端类
*/
public class Server {

public void getClientMsg(CSCallBack csCallBack , String msg) {
System.out.println("服务端：服务端接收到客户端发送的消息为:" + msg);

// 模拟服务端需要对数据处理
try {
Thread.sleep(5 * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("服务端:数据处理成功，返回成功状态 200");
String status = "200";
csCallBack.process(status);
}
}

测试类：

/**
* 回调模式-测试类
*/
public class CallBackTest {
public static void main(String[] args) {
Server server = new Server();
Client client = new Client(server);
client.sendMsg("Server,Hello~");
}
}

运行下测试类 — 打印结果如下：

客户端：发送的消息为：Server,Hello~
客户端：异步发送成功
服务端：服务端接收到客户端发送的消息为:Server,Hello~
（这里模拟服务端对数据处理时间，等待5秒）
服务端：数据处理成功，返回成功状态 200
客户端：服务端回调状态为：200

一步一步分析下代码，核心总结如下：
（1）接口作为方法参数，其实际传入引用指向的是实现类；（例子中的getClientMsg方法的参数csCallBack参数就是此种情况）

（2）Client的sendMsg方法中，参数为final，因为要被内部类一个新的线程可以使用。这里就体现了异步；

（3）调用server的getClientMsg()，参数传入了Client本身（对应第一点）。

回调的应用场景

回调目前运用在什么场景比较多呢？从操作系统到开发者调用：

（1）Windows平台的消息机制

（2）异步调用微信接口，根据微信返回状态对出业务逻辑响应。

（3）Servlet中的Filter(过滤器)是基于回调函数，需容器支持。

补充：其中 Filter(过滤器)和Interceptor(拦截器)的区别，拦截器基于是Java的反射机制，和容器无关。但与回调机制有异曲同工之妙。

总之，这设计让底层代码调用高层定义（实现层）的子程序，增强了程序的灵活性。

模式对比 

上面讲了Filter和Intercepter有着异曲同工之妙。其实接口回调机制和一种设计模式—观察者模式也有相似之处：

观察者模式：

GOF说道 — “定义对象的一种一对多的依赖关系，当一个对象的状态发送改变的时候，所有对他依赖的对象都被通知到并更新。”它是一种模式，是通过接口回调的方法实现的，即它是一种回调的体现。

接口回调：

与观察者模式的区别是，它是种原理，而非具体实现。

参考资料

http://ifeve.com/深入浅出：-java回调机制异步/ http://blog.csdn.net/snowlive/article/details/70248254