spring事件通知機制詳解

優勢

• 解耦
• 對同一種事件有多種處理方式
• 不干擾主線(main line)

起源

要講spring的事件通知機制，就要先了解一下spring中的這些接口和抽象類：

• ApplicationEventPublisherAware        接口:用來 publish event

• ApplicationEvent                  抽象類，記錄了source和初始化時間戳：用來定義Event

• ApplicationListener<E extends ApplicationEvent>  :用來監聽事件

構建自己的事件機制案例

測試案例

測試入口

package com.meituan.spring.testcase.listener;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.concurrent.TimeUnit;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:40.
 * -----------------------------
 * Desc:
 */
public class TestPortal {
   public static void main(String[] args) throws InterruptedException {

      final ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-config.xml");

      String[] definitionNames = applicationContext.getBeanDefinitionNames();
      System.out.println("==============bean====start=================");
      for (String definitionName : definitionNames) {
         System.out.println("bean----:" + definitionName);
      }
      System.out.println("==============bean====end=================");
      System.out.println();
      final CustomizePublisher customizePublisher = applicationContext.getBean(CustomizePublisher.class);


      Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
            try {
               System.out.println("開始吃飯：");

               MealEvent lunchEvent = new MealEvent("A吃午飯了", MealEnum.lunch);
               MealEvent breakfastEvent = new MealEvent("B吃早飯了", MealEnum.breakfast);
               MealEvent dinnerEvent = new MealEvent("C吃晚飯了", MealEnum.dinner);
               customizePublisher.publish(lunchEvent);
               TimeUnit.SECONDS.sleep(1l);
               customizePublisher.publish(breakfastEvent);
               TimeUnit.SECONDS.sleep(1l);
               customizePublisher.publish(dinnerEvent);
               TimeUnit.SECONDS.sleep(1l);

               System.out.println("他們吃完了！");
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
         }
      });
      thread.setName("meal-thread");
      thread.start();

      System.out.println(Thread.currentThread().getName() + " is waiting for ....");
      thread.join();
      System.out.println("Done!!!!!!!!!!!!");
   }
}

測試結果

測試成員

• MealListener ：MealEvent                  演員

• TroubleListener ：TroubleEvent         演員

• AllAcceptedListener                            演員

• MealEnum                                          道具

• TestPortal                                           入口

• CustomizePublisher                           導演

成員代碼

接受全部事件的演員（很負責任啊）

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:27.
 * -----------------------------
 * Desc:
 */
@Component
public class AllAcceptedListener implements ApplicationListener<ApplicationEvent> {
   @Override
   public void onApplicationEvent(ApplicationEvent event) {
      System.out.println(">>>>>>>>>>>>>>>>event:" + event);
   }
}

導演負責分發事件

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
import org.springframework.stereotype.Component;

/**
 * Created by zhangxiaoguang on 16/1/28 上午1:41.
 * -----------------------------
 * Desc:
 */
@Component
public class CustomizePublisher implements ApplicationEventPublisherAware {

   private ApplicationEventPublisher applicationEventPublisher;

   public void publish(MealEvent event) {
      applicationEventPublisher.publishEvent(event);
   }

   @Override
   public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
      this.applicationEventPublisher = applicationEventPublisher;
   }
}

負責處理吃飯事件的演員

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:27.
 * -----------------------------
 * Desc:
 */
@Component
public class MealListener implements ApplicationListener<MealEvent> {
   @Override
   public void onApplicationEvent(MealEvent event) {
      System.out.println(String.format(">>>>>>>>>>>thread:%s,type:%s,event:%s",
            Thread.currentThread().getName(), event.getMealEnum(), event));

      dispatchEvent(event);
   }

   private void dispatchEvent(MealEvent event) {
      switch (event.getMealEnum()) {
         case breakfast:
            System.out.println(event.getMealEnum() + " to handle!!!");
            break;
         case lunch:
            System.out.println(event.getMealEnum() + " to handle!!!");
            break;
         case dinner:
            System.out.println(event.getMealEnum() + " to handle!!!");
            break;
         default:
            System.out.println(event.getMealEnum() + " error!!!");
            break;
      }
   }
}

吃飯消息

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationEvent;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:24.
 * -----------------------------
 * Desc:吃飯事件
 */
public class MealEvent extends ApplicationEvent {

   private MealEnum mealEnum;

   /**
    * @param mealContent
    *        吃什么
    * @param mealEnum
    *        早餐還是午餐？
    */
   public MealEvent(String mealContent, MealEnum mealEnum) {
      super(mealContent);
      this.mealEnum = mealEnum;
   }

   public MealEnum getMealEnum() {
      return mealEnum;
   }
}

工具

package com.meituan.spring.testcase.listener;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:29.
 * -----------------------------
 * Desc:
 */
public enum MealEnum {
   breakfast,
   lunch,
   dinner
}

令人厭煩的演員

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:27.
 * -----------------------------
 * Desc:
 */
@Component
public class TroubleListener implements ApplicationListener<TroubleEvent> {
   @Override
   public void onApplicationEvent(TroubleEvent event) {
      System.out.println(">>>>>>>>>>>>>>>>event:" + event);
   }
}

令人厭煩的事件

package com.meituan.spring.testcase.listener;

import org.springframework.context.ApplicationEvent;

/**
 * Created by zhangxiaoguang on 16/1/27 下午11:24.
 * -----------------------------
 * Desc:令人厭煩的事件
 */
public class TroubleEvent extends ApplicationEvent {
   public TroubleEvent(Object source) {
      super(source);
   }
}

總結

詳細定制 event 類型的，則相關定制的listener會處理對應的消息，其他listener不會管閑事；

制定頂級 event 類型的，ApplicationEvent的，則會處理所有的事件。

ApplicationEvent

依賴關系

ContextEvent事件機制簡介

ContextRefreshedEvent:當整個ApplicationContext容器初始化完畢或者刷新時觸發該事件；

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      ......

      try {
         
         ......

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         ......
      }
   }
}
protected void finishRefresh() {
   // Initialize lifecycle processor for this context.
   initLifecycleProcessor();

   // Propagate refresh to lifecycle processor first.
   getLifecycleProcessor().onRefresh();

   // Publish the final event.
   publishEvent(new ContextRefreshedEvent(this));

   // Participate in LiveBeansView MBean, if active.
   LiveBeansView.registerApplicationContext(this);
}

ContextClosedEvent:當ApplicationContext doClose時觸發該事件,這個時候會銷毀所有的單例bean； 

@Override
public void registerShutdownHook() {
   if (this.shutdownHook == null) {
      // No shutdown hook registered yet.
      this.shutdownHook = new Thread() {
         @Override
         public void run() {
            doClose();
         }
      };
      Runtime.getRuntime().addShutdownHook(this.shutdownHook);
   }
}
@Override
public void close() {
   synchronized (this.startupShutdownMonitor) {
      doClose();
      // If we registered a JVM shutdown hook, we don't need it anymore now:
      // We've already explicitly closed the context.
      if (this.shutdownHook != null) {
         try {
            Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
         }
         catch (IllegalStateException ex) {
            // ignore - VM is already shutting down
         }
      }
   }
}
protected void doClose() {
   if (this.active.get() && this.closed.compareAndSet(false, true)) {
      ......
 
      try {
         // Publish shutdown event.
         publishEvent(new ContextClosedEvent(this));
      }
      catch (Throwable ex) {
         logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);
      }
 
      ......
   }
}

ContextStartedEvent:當ApplicationContext start時觸發該事件； 

@Override
public void start() {
   getLifecycleProcessor().start();
   publishEvent(new ContextStartedEvent(this));
}

ContextStoppedEvent:當ApplicationContext stop時觸發該事件； 

@Override
public void stop() {
   getLifecycleProcessor().stop();
   publishEvent(new ContextStoppedEvent(this));
}

ApplicationListener 

依賴關系

帶你一步步走向源碼的世界

從上邊打印的線程信息可以知道，spring處理事件通知采用的是當前線程，並沒有為為我們啟動新的線程，所以，如果需要，你要自己處理線程信息哦，當然也可以設定（如何設置？）！

AbstractApplicationContext

補齊：同一個event，被多個listener監聽，先被哪個listener執行是由下邊的代碼決定的：

如何設置線程池？

回到上邊的問題，到底該如何設置線程池呢？

AbstractApplicationEventMulticaster 是private的，並且沒有提供寫入方法...

實際案例

用在自己的代碼里就是最好的例子了 ^_^