java中的回调，监听器，观察者

回调：

函数回调接口：

public interface ICallBack {
    public void callBack();
    default void defaultCallBack() {
        System.out.println("我是函数接口的默认函数");
    }
}

回调者以及测试

public class Caller {
    public void call(ICallBack callBack){
        System.out.println("start...");
//        callBack.callBack();
        callBack.defaultCallBack();
        System.out.println("end...");
    }
    public static void main(String[] args) {
           Caller call = new Caller();
           call.call(()->{
               System.out.println("函数接口回调成功");//这里是对接口的实现
           });
    }
}
根据调用callBack还是defaultCallBack来判断输出什么，这里输出我是函数接口的默认函数

事件监听器

设计事件源，事件监听器（相当于回调接口），事件对象

当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去

事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理

简单描述就是：

事件源注册监听器，把事件对象丢给监听器，监听器除了可以去执行事件对象中的方法还可以实现自己的方法。

监听器接口：

public interface EventListener extends java.util.EventListener {
    //事件处理
    public void handleEvent(EventObject event);
}

事件对象：

public class EventObject extends java.util.EventObject{
    private static final long serialVersionUID = 1L;
    public EventObject(Object source){
        super(source);
    }
    public void doEvent(){
        System.out.println("通知一个事件源 source :"+ this.getSource());
    }
}

事件源：

public class EventSource {
    //监听器列表，监听器的注册则加入此列表
    private Vector<EventListener> ListenerList = new Vector<EventListener>();
    //注册监听器
    public void addCloseListener(EventListener eventListener){
        System.out.println("事件源关注closeWindows事件");
        ListenerList.add(eventListener);
    }
    public void addOpenListener(EventListener eventListener){
        System.out.println("事件源关注openWindows事件");
        ListenerList.add(eventListener);
    }
    //撤销注册
    public void removeListener(EventListener eventListener){
        ListenerList.remove(eventListener);
    }
    //接受外部事件
    public void notifyListenerEvents(EventObject event){        
        for(EventListener eventListener:ListenerList){
                eventListener.handleEvent(event);
        }
    }
    public static void main(String[] args) {
        EventSource eventSource = new EventSource();     
        eventSource.addCloseListener((event)->{
            event.doEvent();
            if(event.getSource().equals("closeWindows")){
                System.out.println("监听器监听到并执行doClose");
            }
            else
            {
                System.out.println("监听器没有监听到closeWindows");
            }
        });
        
        eventSource.addOpenListener((event)->{
            event.doEvent();
            if(event.getSource().equals("openWindows")){
                System.out.println("监听器监听到并执行doOpen");
            }
            else
            {
                System.out.println("监听器没有监听到openWindows");
            }
        });
        eventSource.notifyListenerEvents(new EventObject("openWindows"));     
        eventSource.notifyListenerEvents(new EventObject("closeWindows"));     
    }        
}

执行结果：

每一个通知都会通知到每一个监听器

观察者：

观察者相当于事件监听器，

被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时，将会回调观察者的回调方法。

 观察者：

public class WatcherDemo implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        if(arg.toString().equals("openWindows")){
            System.out.println("已经打开窗口");
        }
    }
    public static void main(String[] args) {
        Watched watched = new Watched();
        WatcherDemo watcherDemo = new WatcherDemo();
        watched.addObserver(watcherDemo);//被观察者注册打开观察者
        watched.addObserver((Observable o, Object arg)->{//被观察者注册关闭观察者,Observer接口
            if(arg.toString().equals("closeWindows")){
                System.out.println("已经关闭窗口");
            }
        });
        //触发打开窗口事件，通知观察者
        watched.notifyObservers("openWindows");
        //触发关闭窗口事件，通知观察者
        watched.notifyObservers("closeWindows");
    }
}

被观察者：

public class Watched extends Observable {

    public void notifyObservers(Object arg) {      
        /**
         * 为避免并发冲突，设置了changed标志位changed =true，则当前线程可以通知所有观察者，内部同步块会完了会设置为false；
       通知过程中，正在新注册的和撤销的无法通知到。
         */
        super.setChanged();
        super.notifyObservers(arg);   
    }   
}

执行结果：

已经打开窗口
已经关闭窗口

参考：https://my.oschina.net/u/923324/blog/792857

• ServletContext对象的监听器
• HttpSession对象的监听器
• ServletRequest对象的监听器

这三个等待完成：

https://www.jianshu.com/p/1f83181112de

https://segmentfault.com/a/1190000013240470