springboot之事件监听机制

一、观察者模式

1.涉及到的类

public interface Observer {
    /*
        观察者必须要实现这个接口，其实就相当于，A实现了这个接口，B发生改变的时候，顺便调用一下A的update方法。
    */
    void update(Observable o, Object arg);
}
//可以理解为，事件源和通知者的结合体
//用大白话讲就是，我的XXX被改变了，然后我要通知一下所有观察我的人
public class Observable {
    ……
    public void notifyObservers(Object arg) {
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged(); //只是简单的将标志位置为false，表示消费了这个事件
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            //就是这里！会回调update这个方法
            ((Observer)arrLocal[i]).update(this, arg);
    }
    protected synchronized void setChanged() {
        changed = true; //想通知观察者，这个方法必须调用
    }
    protected synchronized void clearChanged() {
        changed = false;
    }
    ……
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33

2.观察者模式极简单的例子

public class TestEvent {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new A();
        B b = new B();
        //添加两个观察者
        b.addObserver(a1);
        b.addObserver(a2);
        //改变B中的XXX
        b.set("A1");
        b.set("A2");
    }

    static class A implements Observer {

        @Override
        public void update(Observable o, Object arg) {
            System.out.println(arg);
        }
    }

    static class B extends Observable {
        public void set(String name){
            setChanged();
            //通知所有观察者，notifyObservers可以传参，也可以不传参
            notifyObservers(name);
        }
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29

二、事件监听机制

1.涉及到的类

//就是一个事件类型，规范是，任何自定义类型都需要继承它
public class EventObject implements java.io.Serializable {    
    ……
}

//事件监听器，无任何实现方法，按照规范，任何监听器都需要继承或实现它
public interface EventListener {
}

    1
    2
    3
    4
    5
    6
    7
    8

抛开spring中的广播者不说，这个其实和观察者模式原理一毛一样。
a.首先A维护者一个监听器链表
b.然后当A中XXX发生变化的时候，调用所有监听器的处理方法，并将XXX事件当做参数传进去即可。

2.事件监听机制极简单的例子

public class TestEvent2 {
    public static void main(String[] args) {
        C c = new C();
        //这里注册了两个监听器，相当于，这两个东西想时刻知道C的变化，当C中的XXX变化的时候，会去调用监听器的方法进行处理
        c.register(new MyListener("Listener1"));
        c.register(new MyListener("Listener2"));
        c.set(new MyEvent("A"));
    }

    //自定义监听器，一定要实现EventListener，虽然不实现也没事，但是都按照规范来会使代码易读
    static class MyListener implements EventListener{
        String name;
        public MyListener(String name){
            this.name = name;
        }
        public void handle(EventObject eventObject){
           System.out.println(name + ":" + ((MyEvent)eventObject).getName());
        }
    }

    //自定义事件类型
    static class MyEvent extends EventObject{
        String name;
        public String getName() {
            return name;
        }
        public MyEvent(Object source) {
            super(source);
            name = (String)source;
        }
    }

    //一个普通的类，可能有N个监听器想监视这个类
    static class C{
        List<MyListener> myListeners = new ArrayList<>();
        public void register(MyListener a){
            myListeners.add(a);
        }

        public void set(EventObject eventObject){
            for (MyListener myListener : myListeners){
                //当发生变化的时候，去调用监听器的方法处理这个事件
                myListener.handle(eventObject);
            }
        }
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47

三、观察者模式和事件监听机制对比(java 原生)
观察者模式     事件监听机制
需要将所有观察者加入A中     需要将所有监听器加入到A中
当A中的XXX发生变化，通知（调用）所有观察者     当A中的XXX发生变化，通知（调用）所有监听器

四、springboot中的事件监听机制

1.涉及到的类

//就是springboot自定义的一个事件类型而已
public abstract class ApplicationEvent extends EventObject {
}

//就是springboot自定义的一个事件监听器，并且指定唯一处理事件的方法
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
    void onApplicationEvent(E event);
}

//springboot自己新弄的一个事件广播器，说白了它就是依次调用它里面的监听器中的onApplicationEvent方法
public interface ApplicationEventMulticaster {

    void addApplicationListener(ApplicationListener<?> listener);

    void addApplicationListenerBean(String listenerBeanName);

    void removeApplicationListener(ApplicationListener<?> listener);

    void removeApplicationListenerBean(String listenerBeanName);

    void removeAllListeners();

    void multicastEvent(ApplicationEvent event);

    void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);

}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27

2.事件监听机制极简单的例子

public class TestEvent3 {
    public static void main(String[] args) {
        MyMulticaster myMulticaster = new MyMulticaster();
        //这里注册了两个监听器
        myMulticaster.addApplicationListener(new MyListener("Listener1"));
        myMulticaster.addApplicationListener(new MyListener("Listener2"));
        //将事件广播出去，凡是在这个广播器注册了监听器，那么就可以收到这个事件消息（其实就是这个广播器，回调它们的接口）
        myMulticaster.multicastEvent(new MyEvent("A"));
    }

    //自定义监听器，一定要实现EventListener，虽然不实现也没事，但是都按照规范来会使代码易读
    static class MyListener implements ApplicationListener {
        String name;
        public MyListener(String name){
            this.name = name;
        }
        @Override
        public void onApplicationEvent(ApplicationEvent event) {
            System.out.println(name + ":" + event);
        }
    }

    //自定义事件类型
    static class MyEvent extends ApplicationEvent{
        String name;
        public String getName() {
            return name;
        }
        public MyEvent(Object source) {
            super(source);
            name = (String)source;
        }
    }

    //广播器，负责管理监听器，广播消息
    static class MyMulticaster implements ApplicationEventMulticaster {

        List<ApplicationListener> applicationListeners = new ArrayList<>();

        @Override
        public void addApplicationListener(ApplicationListener<?> listener) {
            applicationListeners.add(listener);
        }

        @Override
        public void addApplicationListenerBean(String listenerBeanName) {
        }

        @Override
        public void removeApplicationListener(ApplicationListener<?> listener) {
            applicationListeners.remove(listener);
        }

        @Override
        public void removeApplicationListenerBean(String listenerBeanName) {
        }

        @Override
        public void removeAllListeners() {
        }

        @Override
        public void multicastEvent(ApplicationEvent event) {
            //一个个遍历监听器，然后调用它们的处理方法
            for (ApplicationListener listener : applicationListeners){
                listener.onApplicationEvent(event);
            }
        }

        @Override
        public void multicastEvent(ApplicationEvent event, ResolvableType eventType) {
        }
    }
}

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75

五、总结
一开始我看到这个观察者模式，我还不知道是什么鬼，听着太别扭了。然后看到事件监听机制，才有点感觉，因为这个和C/C++的CALLBACK机制有点像。但是看了一下源码，我又开始疑惑，就觉得，为什么感觉有些绕，没有想象中的简洁。这是因为我把这个用户回调和系统回调搞混了。之前接触过的回调都是C/C++的系统回调，都是系统自动的帮你调用这些方法，这会让人感觉到真的是事件监听机制。然后看了java的，原来这些都得自己撸一遍。总之原理都一样，只是一个是用户自己实现的回调，一个是系统实现的回调。