Spring的事件監聽機制

  最近公司在重構廣告系統，其中核心的打包功能由廣告系統調用，即對apk打包的調用和打包完成之后的回調，需要提供相應的接口給廣告系統。因此，為了將apk打包的核心流程和對接廣告系統的業務解耦，利用了spring的事件監聽特性來滿足需求。以下說明spring的事件機制的相關內容。

  1.觀察者模式

   Spring的事件監聽（也稱事件驅動）是觀察者模式的一種實現，比較常見的有發布-訂閱模型。通常我們利用消息隊列來實現不同系統之間的解耦，如用戶注冊完成后，可以向消息隊列發布一條消息，然后訂閱了此topic的子系統（如郵件服務，積分服務）收到發布的消息之后，就會做相應的處理。這樣做的好處是避免了在注冊服務里耦合其他服務的代碼，並且，執行子系統的業務將會異步執行，互不影響。下圖是一個經典的觀察者模式的結構。

 

以下為上述觀察者模式的java簡單實現：

  （1）Subject.java

package observerPattern;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by jy on 2018/11/28.
 */
public abstract class Subject {

    //維護一個所有觀察者集合
    private List<Observer> list = new ArrayList<>();

    //新注冊一個觀察者
    public void attach(Observer observer){
        list.add(observer);
        System.out.println("新注冊一個觀察者");
    }

    //刪除一個已注冊的觀察者
    public void detach(Observer observer){
        list.remove(observer);
        System.out.println("刪除一個已注冊的觀察者");
    }


    //通知所有已經注冊的觀察者
    public void notifyObservers(String state){
        for (int i = 0; i < list.size(); i++) {
            list.get(i).update(state);
        }
    }
}

   

  (2)Observer.java

package observerPattern;

/**
 * Created by jy on 2018/11/28.
 */
public interface Observer {

    // 抽象出的更新行為
    public void update(String state);
}

 

  (3)ConcreteSubject.java

package observerPattern;

/**
 * Created by jy on 2018/11/28.
 */
public class ConcreteSubject extends Subject{

    //真實主題內維護一個狀態
    private String state;

    public String getState() {
        return state;
    }

    public void change(String state){
        this.state = state;
        System.out.println("真實主題狀態變化為:"+state);
        this.notifyObservers(state);
    }
}

 

  (4)ConcreteObserver.java

package observerPattern;

/**
 * Created by jy on 2018/11/28.
 */
public class ConcreteObserver implements Observer {

    //具體觀察者的狀態
    private String observerState;

    @Override
    public void update(String state) {
        //這里可以根據傳遞過來的主題的狀態作出相應的業務
      observerState = state;
        System.out.println("觀察者的狀態跟着變化為："+observerState);
    }
}

 

  (5)Main.java

package observerPattern;

/**
 * Created by jy on 2018/11/28.
 */
public class Main {
    public static void main(String[] args) {
        //真實主題
        ConcreteSubject concreteSubject = new ConcreteSubject();
        //真實觀察者
        ConcreteObserver concreteObserver = new ConcreteObserver();
        //觀察者先注冊
        concreteSubject.attach(concreteObserver);

        //改變真實主題狀態
        concreteSubject.change("2");

    }
}

結果：在執行了main方法之后，我們可以看到控制台輸出結果，表明，真實觀察者的狀態是會根據真實主題的狀態變化而變化的：

 

  2. Spring事件監聽

  spring也對事件驅動模型提供了支持，該模型主要由三部分組成：

  （1）  事件（ApplicationEvent）：繼承了jdk的EventObject，在spring項目中可以繼承ApplicationEvent，來自定義自己的事件。

           spring容器內部對ApplicationEvent有着下面幾個實現，通過名字可以很清楚事件所描述的行為。

 

  （2）發布者（ApplicationEventPublisher）：實現這個接口，就可以使得spring組件有發布事件的能力。

         可以看到，ApplicationContext實現了此接口，因此，可以spring組件可以通過實現ApplicationContextAware接口，注入ApplicationContext，然后，通過ApplicationContext的publishEvent()方法來實現事件傳播，

         當然，也可以直接實現ApplicationEventPublisher接口，重寫publishEvent()方法，同樣可以實現事件傳播。

 

      通過閱讀源碼發現，在AbstractApplicationContext類中，定義了針對觀察者的增加，get，注冊等方法。下面代碼中的addApplicationListener()是向ApplicationEventMulticaster類中維護的一個set中添加listener。這個set存儲了該發布者所有的觀察者（listener）。

@Override
    public void addApplicationListener(ApplicationListener<?> listener) {
        Assert.notNull(listener, "ApplicationListener must not be null");
        //listener傳入持有的一個的applicationEventMulticaster類中
        if (this.applicationEventMulticaster != null) {
            this.applicationEventMulticaster.addApplicationListener(listener);
        }
        this.applicationListeners.add(listener);
    }

//省略部分代碼

protected void registerListeners() {
        // Register statically specified listeners first.
        for (ApplicationListener<?> listener : getApplicationListeners()) {
            getApplicationEventMulticaster().addApplicationListener(listener);
        }

        // Do not initialize FactoryBeans here: We need to leave all regular beans
        // uninitialized to let post-processors apply to them!
        String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
        for (String listenerBeanName : listenerBeanNames) {
            getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
        }

        // Publish early application events now that we finally have a multicaster...
        Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
        this.earlyApplicationEvents = null;
        if (earlyEventsToProcess != null) {
            for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
                getApplicationEventMulticaster().multicastEvent(earlyEvent);
            }
        }
    }

     

      在AbstractApplicationContext中publishEvent：

protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
        //.....
        // Multicast right now if possible - or lazily once the multicaster is initialized
        if (this.earlyApplicationEvents != null) {
            this.earlyApplicationEvents.add(applicationEvent);
        }
        else {
            getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);  //事件廣播
        //....
    }

 

      具體的發布事件的方法都在上面提到的ApplicationEventMulticaster這個類型的類中去實現的，在AbstractApplicationContext中，會先嘗試從ConfigurableListableBeanFactory中去加載這個類，如果不存在，則會默認new 一個SimpleApplicationEventMulticaster：

protected void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {   //嘗試加載  4             this.applicationEventMulticaster =
                    beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
            if (logger.isTraceEnabled()) {
                logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
            }
        }
        else {
            this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);   //不存在則默認使用SimpleApplicationEventMulticaster

            beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster); 

 

      看看SimpleApplicationEventMulticaster 是怎么廣播事件的，由代碼可知，在線程池不為空的情況下，異步發布特定類型的事件。

@Override
    public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
        ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
        for (final ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            Executor executor = getTaskExecutor();
            if (executor != null) {
                executor.execute(() -> invokeListener(listener, event));
            }
            else {
                invokeListener(listener, event);
            }
        }
    //....

 

      將invokeListener方法點擊到最后，發現調用了listener的onApplicationEvent(),實現了事件的發布。

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
        try {
            listener.onApplicationEvent(event);
        }
        catch (ClassCastException ex) {
            //....
        }
    }

 

  （3）事件訂閱者（ApplicationListener）：實現這個接口，就可以監聽ApplicationListener發布的特定的事件。

         實現ApplicationListener這個接口，重寫onApplicationEvent()方法，來處理監聽到的ApplicationEvent，這里可以監聽特定類型的事件。

  3. 基於注解的事件監聽    

      spring也為發布者和監聽者提供了相應的注解支持，只需要在對應的觀察者類的對應方法上加上@EventListener：

      對於發布者，可以直接在service通過@Autowired注入ApplicationEventPublisher。

 

   4.小結

      文章主要介紹了spring中事件驅動的模型。主要運用了觀察者模式的思想，隨后介紹了spring中事件發布的機制。