总结!!!总结!!!java回调以及future模式

疑问:什么是回调

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

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

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

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

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

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

1.同步调用

直接上代码 b方法调用a方法

package java.lang;/**
 * @author: zhangzeli
 * @date 16:02 2018/4/20
 * <P></P>
 */public class Test {    public String a(){
        System.out.println("i am a");        return "a";
    }    public String b(){
        a();
        System.out.println("i am b");        return "b";
    }
}

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

接下来看一下回调的代码示例，代码模拟的是这样一种场景：老师问学生问题，学生思考完毕回答老师。 首先定义一个回调接口，只有一个方法tellAnswer(int answer)，即学生思考完毕告诉老师答:

/**
 * 回调接口
 */public interface Callback {    public void tellAnswer(int answer);
}

定义一个老师对象，实现Callback接口：

/**
 * 老师对象
 */public class Teacher implements Callback {    private Student student;    
    public Teacher(Student student) {        this.student = student;
    }    public void askQuestion() {
        student.resolveQuestion(this);
    }    @Override
    public void tellAnswer(int answer) {
        System.out.println("知道了，你的答案是" + answer);
    }
    
}

老师对象有两个public方法：

1. 回调接口tellAnswer(int answer)，即学生回答完毕问题之后，老师要做的事情

2. 问问题方法askQuestion()，即向学生问问题

接着定义一个学生接口，学生当然是解决问题，但是接收一个Callback参数，这样学生就知道解决完毕问题向谁报告：

/**
 * 学生接口
 */public interface Student {    public void resolveQuestion(Callback callback);
}

最后定义一个具体的学生叫Ricky：

/**
 * 一个名叫Ricky的同学解决老师提出的问题
 */public class Ricky implements Student {    @Override
    public void resolveQuestion(Callback callback) {        // 模拟解决问题
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            
        }        // 回调，告诉老师作业写了多久
        callback.tellAnswer(3);
    }

}

写一个测试类，比较简单：

/**
 * 回调测试
 */public class CallbackTest {    @Test
    public void testCallback() {
        Student student = new Ricky();
        Teacher teacher = new Teacher(student);
        
        teacher.askQuestion();
        
    }
    
}

代码分析

分析一下上面的代码，上面的代码我这里做了两层的抽象：

（1）将老师进行抽象

• 将老师进行抽象之后，对于学生来说，就不需要关心到底是哪位老师询问我问题，只要我根据询问的问题，得出答案，然后告诉提问的老师就可以了，即使老师换了一茬又一茬，对我学生而言都是没有任何影响的

（2）将学生进行抽象

• 将学生进行抽象之后，对于老师这边来说就非常灵活，因为老师未必对一个学生进行提问，可能同时对Ricky、Jack、Lucy三个学生进行提问，这样就可以将成员变量Student改为List<Student>，这样在提问的时候遍历Student列表进行提问，然后得到每个学生的回答即可

这个例子是一个典型的体现接口作用的例子，之所以这么说是因为我想到有些朋友可能不太明白接口的好处，不太明白接口好处的朋友可以重点看一下这个例子，多多理解。

总结起来，回调的核心就是回调方将本身即this传递给调用方，这样调用方就可以在调用完毕之后告诉回调方它想要知道的信息。回调是一种思想、是一种机制，至于具体如何实现，如何通过代码将回调实现得优雅、实现得可扩展性比较高，一看开发者的个人水平，二看开发者对业务的理解程度。

上面的例子，可能有人会提出这样的疑问：

这个例子需要用什么回调啊，使用同步调用的方式，学生对象回答完毕问题之后直接把回答的答案返回给老师对象不就好了？

这个问题的提出没有任何问题，可以从两个角度去理解这个问题。

    首先，老师不仅仅想要得到学生的答案怎么办？可能这个老师是个更喜欢听学生解题思路的老师，在得到学生的答案之前，老师更想先知道学生姓名和学生的解题思路，当然有些人可以说，那我可以定义一个对象，里面加上学生的姓名和解题思路不就好了。这个说法在我看来有两个问题：

（1）如果老师想要的数据越来越多，那么返回的对象得越来越大，而使用回调则可以进行数据分离，将一批数据放在回调方法中进行处理，至于哪些数据依具体业务而定，如果需要增加返回参数，直接在回调方法中增加即可

（2）无法解决老师希望得到学生姓名、学生解题思路先于学生回答的答案的问题

因此我认为简单的返回某个结果确实没有必要使用回调而可以直接使用同步调用，但是如果有多种数据需要处理且数据有主次之分，使用回调会是一种更加合适的选择，优先处理的数据放在回调方法中先处理掉。

另外一个理解的角度则更加重要，就是标题说的同步回调和异步回调了。例子是一个同步回调的例子，意思是老师向Ricky问问题，Ricky给出答案，老师问下一个同学，得到答案之后继续问下一个同学，这是一种正常的场景，但是如果我把场景改一下：

老师并不想One-By-One这样提问，而是同时向Ricky、Mike、Lucy、Bruce、Kate五位同学提问，让同学们自己思考，哪位同学思考好了就直接告诉老师答案即可。

这种场景相当于是说，同学思考完毕完毕问题要有一个办法告诉老师，有两个解决方案：

1. 使用Future+Callable的方式，等待异步线程执行结果，这相当于就是同步调用的一种变种，因为其本质还是方法返回一个结果，即学生的回答

2. 使用异步回调，同学回答完毕问题，调用回调接口方法告诉老师答案即可。由于老师对象被抽象成了Callback接口，因此这种做法的扩展性非常好，就像之前说的，即使老师换了换了一茬又一茬，对于同学来说，只关心的是调用Callback接口回传必要的信息即可

先讲异步回调Callback,和future模式,这个文章后面给出方案

3.异步回调---CS中的异步回调（java案例)

比如这里模拟个场景：客户端发送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(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
客户端：服务端回调状态为：

一步一步分析下代码，核心总结如下

1、接口作为方法参数，其实际传入引用指向的是实现类

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

3、调用server的getClientMsg()，参数传入了Client本身（对应第一点）。上面的同步回调也说过了

解惑:回调的应用场景

1. Windows平台的消息机制

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

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

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

作者：张泽立

来源：https://my.oschina.net/u/3703858/blog/1798627