Javayibi回调接口Demo

java中存在三种调用机制

1：同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用 
2：回调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口； 
3：异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口 
具体说来：就是A类中调用B类中的某个方法C，然后B类中反过来调用A类中的方法D，D这个方法就叫回调方法，

Demo1：

老师平时学生布置任务后不可能一直等待和监督学生完成，老师通常会告诉学生，任务完成后给他打个电话或者发个信息，那么学生给老师返回结果的过程需要老师信息，这就是一个回调的过程。

定义回调接口：

public interface Callback {

    public void taskResult(String name);
}

、

实现回调接口：

public class Teacher implements Callback{

    @Override
    public void taskResult(String name) {
        System.out.println("Hi,teacher: " + name + " done work.");
    }
}

定义调用方：

public class Student {

    private String name;

    Callback callback;

    public Student(String name, Callback callback) {
        this.name = name;
        this.callback = callback;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setCallback(Callback callback) {
        this.callback = callback;
    }

    //Key Method
    public void notifyResult() {
        //处理一系列事情，处理完再回调
        callback.taskResult(name);
    }
}

测试：

public class Main1 {
    public static void main(String[] args) {
        Student student = new Student("John", new Teacher());
        student.notifyResult();
    }
}

输出：

Hi,teacher: John done work.

可以定义很多调用方Student，回调Teacher的回调方法。

Demo2:

回调的原理可以简单理解为：A发送消息给B，B处理完后告诉A处理结果。再简单点就是A调用B，B调用A。

那么是如何实现的呢？一般而言，处理消息的类是唯一的，而发送消息的类却是各种各样的，所以一般的做法是将回调方法做成一个接口，不同的发送者去实现该接口，并且把自己的接口实现类的对象在发送消息时传递给消息处理者。

现在以一个CS结构的示例来说明回调的过程：

Client类：

package com.test.callback;

/**
 * Created by puyangsky on 2016/6/13.
 */
public class Client {
    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() {
                try {
　　　　　　　　　　　　//调用server类的获取消息方法，并且传入myCallback对象
                    server.getMsg(new myCallback(), msg);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
　　
　　//实现Callback接口
    private class myCallback implements Callback {
        @Override
        public void process(int status) {
            System.out.println("处理成功，返回状态为：" + status);
        }
    }
}

回调接口类：

interface Callback {
    void process(int status);
}

Server类：

package com.test.callback;

/**
 * Created by puyangsky on 2016/6/13.
 */
public class Server {
    public void getMsg(Callback callback, String msg) throws InterruptedException {
        System.out.println("服务端获得消息：" + msg);
        //模拟处理消息过程，等待两秒
　　　　 Thread.sleep(2000);
        System.out.println("服务端处理成功，返回状态为200");
　　　　 //处理完消息，调用回调方法，告知客户端
        callback.process(200);
    }
}

测试类：

package com.test.callback;

/**
 * Created by Administrator on 2016/6/13.
 */
public class CallbackTest {
    public static void main(String[] args) {
        Server server = new Server();
        Client client = new Client(server);
        client.sendMsg("hello");
    }
}

输出结果：