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

老是忘记,我这里直接写实际的东西,看其余的博客都是类图,文字描述,这里直接用代码描述.

疑问:什么是回调

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

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

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

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

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

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

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";
    }
}

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

接下来看一下回调的代码示例，代码模拟的是这样一种场景：老师问学生问题，学生思考完毕回答老师。 首先定义一个回调接口，只有一个方法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
客户端：服务端回调状态为：

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

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

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

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

解惑:回调的应用场景

1. Windows平台的消息机制
2. 异步调用微信接口，根据微信返回状态对出业务逻辑响应。
3. Servlet中的Filter(过滤器)是基于回调函数，需容器支持。

补充：其中 Filter(过滤器)和Interceptor(拦截器)的区别，拦截器基因而Java的反射机制，和容器无关。但与回调机制有殊途同归之妙。

这边篇幅过长省得你们看的糊涂future模式下篇讲,上文的问题个人<码云上面的test包>

说实话,我如今面临的挑战特别大,要理解的东西愈来愈多.可是我听过以前一个老师说的话,我以为颇有道理,心烦意乱的时候写代码,写代码,写代码,失恋了写代码,写代码.不知道怎么办了,写写代码.都能解决

本人qq853089986