设计模式_CallBack

一.基本概念

  if you call me, i will call back

  什么是回调函数
  回调函数（callback Function），顾名思义，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分，由工作流来决定函数的调用（回调）时机。回调函数包含下面几个特性：
  1、属于工作流的一个部分；
  2、必须按照工作流指定的调用约定来申明（定义）；
  3、他的调用时机由工作流决定，回调函数的实现者不能直接调用回调函数来实现工作流的功能；

  回调机制
   回调机制是一种常见的设计模型，他把工作流内的某个功能，按照约定的接口暴露给外部使用者，为外部使用者提供数据，或要求外部使用者提供数据。
　java回调机制：
   软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。
　　同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；
　　回 调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；
　　异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。
   回调和异步调用的关系非常紧密：使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。

二.举例说明

  1.简单调用

　(1) 接口实现需要回调的方法

public interface  CallBack  {
    //需要回调的方法 String event
    public void postExec();
}

   (2) 最终实现类 FooBar。 拥有参数为CallBack接口类型的函数，setCallBack(ICallBack   o)

public class FooBar {
    // 组合聚合原则
    private CallBack callBack;
    //设置接口函数
    public void setCallBack(CallBack callBack) {
        this.callBack = callBack;
        doSth();
    }
    //执行接口函数
    public void doSth() {
        System.out.println("FooBar 执行 ");
        callBack.postExec();
    }
}

   (3) test

public class CallBackTest {
    public static void main(String[] args) {
        FooBar foo = new FooBar();
        foo.setCallBack(new CallBack() {
            @Override
            public void postExec() {
                System.out.println(" 在Test类中实现但不能被Test的对象引用,而由FooBar对象调用");
            }
        });
    }
}

  2.使用已实现的类调用

　(1) 接口实现需要回调的方法

public interface ServiceProvider {
     public void customHintCallBack();
}

   (2) 最终实现类 ChinaTelecom

public class ChinaTelecom {
    private ServiceProvider sp;  //callback接口作为属性
    private boolean isHappened=true;
    
    public void setSp(ServiceProvider sp) {
        this.sp = sp;
    }

    public void doWork() {
        System.out.println("Welcome, This is ChinaTelecom! ");
        if (isHappened) {
            // 事件发生时，通过调用接口的这个方法来通知
            sp.customHintCallBack();//sp自定义的操作
        }        
    }
}

   (3) 接口实现需要回调的方法

//实现接口
class KongNet implements ServiceProvider {

    @Override
    public void customHintCallBack() {
        System.out.println("优惠活动开始啦!");
    }
}

   (4) Test

    public static void main(String[] args) {
        ChinaTelecom ct = new ChinaTelecom();
        //使用匿名类，调用自定义方法
        ct = new ChinaTelecom();
        ct.setSp(new ServiceProvider() {
            @Override
            public void customHintCallBack() {
                System.out.println("优惠活动开始啦  test1! ");
            }
        });
        ct.doWork();       
        //使用已实现的类实现回调        
        ct.setSp(new KongNet());        
        ct.doWork();

        //使用已实现的类实现回调，自定义方法
        ct = new ChinaTelecom();
        ct.setSp(new KongNet() {
            @Override
            public void customHintCallBack() {
                super.customHintCallBack(); 
                System.out.println("优惠活动开始啦!  end back!!!");
            }
        });
        ct.doWork();
    }

  3.设计模式实现消息通知

   (1) 定义一个接口InterestingEvent ，回调方法nterestingEvent(String event) 简单接收一个String 参数

public interface  InterestingEvent {
    // 这只是一个普通的方法，可以接收参数、也可以返回值
    public void interestingEvent(String event);
}

   (2) 实现InterestingEvent接口，事件处理类

class CallMe implements InterestingEvent {
    private String name;
    public CallMe(String name){
        this.name = name;
    }    

    @Override
    public void interestingEvent(String event) {
        System.out.println(name + ":[" +event  + "] happened");
    }
    
}

   (3) 事件管理者，或事件通知者

public class EventNotifier {
    private List<CallMe> callMes = new ArrayList<CallMe>();
    
    public void regist(CallMe callMe){
        callMes.add(callMe);
    }
    
    public void doWork(){
        for(CallMe callMe: callMes) {
            callMe.interestingEvent("sample event");
        }
    }  
}

   (4) 测试

public class CallMeTest {
    public static void main(String[] args) {
        EventNotifier ren = new EventNotifier();
        CallMe a = new CallMe("CallMe A");
        CallMe b = new CallMe("CallMe B");

        // regiest
        ren.regist(a);
        ren.regist(b);
        
        // test
        ren.doWork();        
    }
}