Java中的回调函数

• Class A实现接口CallBack callback——背景1
• class A中包含一个class B的引用b ——背景2
• class B有一个参数为callback的方法f(CallBack callback) ——背景3
• A的对象a调用B的方法 f(CallBack callback) ——A类调用B类的某个方法 C
• 然后b就可以在f(CallBack callback)方法中调用A的方法 ——B类调用A类的某个方法D

熟知的打电话的例子采用异步加回调

有一天小王遇到一个很难的问题，问题是“1 + 1 = ?”，就打电话问小李，小李一下子也不知道，

就跟小王说，等我办完手上的事情，就去想想答案，小王也不会傻傻的拿着电话去等小李的答案吧，

于是小王就对小李说，我还要去逛街，你知道了答案就打我电话告诉我，于是挂了电话，

自己办自己的事情，过了一个小时，小李打了小王的电话，告诉他答案是2

异步回调函数:
角色 : 老板Boss 员工Employee 回调接口 CallBack Boss实现CallBack接口
场景 : 老板雇员工,老板让员工去工作,老板去玩了,员工去工作,员工工作完成向老板汇报
解决方案: 老板持有员工对象,老板让员工去工作时传入Boss的引用,即调用CallBack接口,员工使用CallBack完成回调

package lao.na.callback.asyn.callback;

/**
 * <p>
 * Description: 回调接口
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午10:25:14
 *
 * @Email [e-mail]
 */
public interface CallBack {

    public void execute(String result);
}

package lao.na.callback.asyn.entity;

import lao.na.callback.asyn.callback.CallBack;

/**
 * <p>
 * Description: 员工
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午10:22:37
 *
 */

public class Employee {

    // 员工含有接收老板引用的方法
    public void doWork(CallBack callBack, String work) {
        try {
            // 员工睡了10秒
            Thread.sleep(10000l);
            // 告诉老板说工作完成了
            callBack.execute("老板让我" + work + "老板,我的工作已经做完!!");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }

}

package lao.na.callback.asyn.entity;

import lao.na.callback.asyn.callback.CallBack;

/**
 * <p>
 * Description: 老板
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午10:22:22
 *
 */
public class Boss implements CallBack{

    // 老板 持有 员工 对象
    private Employee emp;

    public Boss(Employee emp) {
        this.emp = emp;
    }

    public void doWork(final String work) {
        
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 想员工方法中注入具体回调对象
                emp.doWork(Boss.this, work);
            }
        }).start();
        // 老板去玩了...
        this.play();
    }

    private void play() {
        System.out.println("老板去玩了...");
    }

    /**
     * 回调函数
     */
    @Override
    public void execute(String result) {

        System.out.println(result);
    }

}

package lao.na.callback.asyn.client;

import lao.na.callback.asyn.entity.Boss;
import lao.na.callback.asyn.entity.Employee;

/** <p>Description: 异步回调函数测试</p>
 *
 * @author laona
 *
 * @Date 2017年12月20日  上午10:20:58
 *
 */
public class AsynClient {

    public static void main(String[] args) {
        // Boss持有emp
        Boss boss = new Boss(new Employee());
        // boss让emp去工作  然后向boss报告
        boss.doWork("去工作...");
        
    }
}

同步回调函数:
角色 : 老板Boss 员工Employee 回调接口 CallBack Boss实现CallBack接口
场景: 员工去工作,工作完成之后向老板汇报,员工工作完成去玩了
解决方案 : 员工持有老板引用(即CallBack接口),员工工作完成,调CallBack接口完成回到

package lao.na.callback.syn.callback;

/**
 * <p>
 * Description: 老板引用
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午11:00:21
 *
 */
public interface CallBack {

    // 老板引用 
    public void execute(String result);

}

package lao.na.callback.syn.entity;

import lao.na.callback.syn.callback.CallBack;

/**
 * <p>
 * Description: 员工
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午11:02:57
 *
 */
public class Employee {

    // 员工持有老板引用 
    private CallBack callBack;

    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
    }

    public void doWork(String work) {

        System.out.println("emp 工作是: " + work);

        String result = "工作已完成!!!";

        callBack.execute(result);

        this.play();
    }

    private void play() {
        System.out.println("工作汇报完毕,员工去玩了...");
    }

}

package lao.na.callback.syn.entity;

import lao.na.callback.syn.callback.CallBack;

/**
 * <p>
 * Description: 老板
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午11:01:44
 *
 */
public class Boss implements CallBack {

    @Override
    public void execute(String result) {
        System.out.println("老板收到结果是 : " + result);
    }

}

package lao.na.callback.syn.client;

import lao.na.callback.syn.entity.Boss;
import lao.na.callback.syn.entity.Employee;

/**
 * <p>
 * Description: 同步回调函数测试
 * </p>
 *
 * @author laona
 *
 * @Date 2017年12月20日 上午10:59:42
 *
 */
public class synClient {

    public static void main(String[] args) {

        Employee emp = new Employee();
        emp.setCallBack(new Boss());
        emp.doWork("去打印文件");
    }
}

我们在使用Struts时，当我们编写Action时，就需要继承Action类，然后实现execute()方法，在execute()方法中写咱们自己的业务逻辑代码，
完成对用户请求的处理。 由此可以猜测，框架和容器中会提供大量的回调接口，以满足个性化的定制。

-- laona 2017-12-20