// 把事件事件監(jiān)聽者加入集合
 	void addApplicationListener(ApplicationListener<?> listener);
 	// 把事件事件監(jiān)聽者加入集合
    void removeApplicationListener(ApplicationListener<?> listener);
    /**
     *  最終推送時間消息也會經(jīng)過這個接口方法來處理誰該接收事件
     *
     * @param event
     */
    void multicastEvent(ApplicationEvent event);

public abstract class AbstractApplicationEventMulticaster implements ApplicationEventMulticaster, BeanFactoryAware {
	// 存放所有ApplicationListener的集合
 public final LinkedHashSet<ApplicationListener<ApplicationEvent>>
            applicationListeners =  new LinkedHashSet();

	/**
     * 方法主要是摘取符合廣播事件中的監(jiān)聽處理器，具體過濾動作在 supportsEvent 方法中。
     * @param event
     * @return
     */
 	protected Collection<ApplicationListener> getApplicationListeners(ApplicationEvent event){
        LinkedList<ApplicationListener> allListeners = new LinkedList<>();
        for (ApplicationListener<ApplicationEvent> listener : applicationListeners){
            if(supportsEvent(listener, event)) allListeners.add(listener);
        }
        return allListeners;
    }
    /**
     * 監(jiān)聽器是否對該事件感興趣
     * 主要包括對 Cglib、Simple 不同實例化需要獲取目標(biāo)
     * Class，Cglib 代理類需要獲取父類的 Class，普通實例化的不需要。接下來就是通過
     * 提取接口和對應(yīng)的 ParameterizedType 和 eventClassName，方便最后確認(rèn)是否為
     * 子類和父類的關(guān)系，以此證明此事件歸這個符合的類處理。
     * @param applicationListener
     * @param event
     * @return
     */
    private boolean supportsEvent(ApplicationListener<ApplicationEvent> applicationListener, ApplicationEvent event) {

        Class<? extends ApplicationListener> listenerClass = applicationListener.getClass();
        // 按照 CglibSubclassingInstantiationStrategy、
        // SimpleInstantiationStrategy 不同的實例化類型，需要判斷后獲取目標(biāo) class
        Class<?> targetClass = ClassUtils.isCglibProxyClass(listenerClass) ?
                listenerClass.getSuperclass() : listenerClass;
        Type genericInterface = targetClass.getGenericInterfaces()[0];

        Type actualTypeArgument = ((ParameterizedType) genericInterface).getActualTypeArguments()[0];
        String className = actualTypeArgument.getTypeName();

        Class<?> eventClassName;
        try {
            eventClassName = Class.forName(className);
        } catch (ClassNotFoundException e) {
            throw new BeansException("wrong event class name: " + className);
        }
        // 判定此 eventClassName 對象所表示的類或接口與指定的 event.getClass() 參數(shù)所
        // 示的類或接口是否相同，或是否是其超類或超接口。
        // isAssignableFrom 是用來判斷子類和父類的關(guān)系的，或者接口的實現(xiàn)類和接口的關(guān)系的，
        // 默認(rèn)所有的類的終極父類都是 Object。如果 A.isAssignableFrom(B)結(jié)果是 true，證明 B 可以轉(zhuǎn)換成
        // 為 A,也就是 A 可以由 B 轉(zhuǎn)換而來。
        return eventClassName.isAssignableFrom(event.getClass());
    }
	......
}

public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
	@Override
    public void multicastEvent(ApplicationEvent event) {
        for(final ApplicationListener listener : getApplicationListeners(event)){
            listener.onApplicationEvent(event);
        }
    }
    .......
}

public abstract class AbstractApplicationContext extends DefaultResourceLoader implements ConfigurableApplicationContext {
	private ApplicationEventMulticaster applicationEventMulticaster;
	@Override
    public void refresh() throws BeansException {
    	.....
    	// 一開始就創(chuàng)建了事件廣播器
    	// 6. 初始化事件發(fā)布者
        initApplicationEventMulticaster();
	    .......
	    // 9. 發(fā)布容器刷新完成事件（發(fā)布是容器刷新事件）
        finishRefresh();
    }
    // 創(chuàng)建事件廣播器
    private void initApplicationEventMulticaster() {
        ConfigurableListableBeanFactory beanFactory = getBeanFactory();
        this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    }
    private void finishRefresh() {
        publishEvent(new ContextRefreshedEvent(this));
    }

    @Override
    public void publishEvent(ApplicationEvent event) {
        applicationEventMulticaster.multicastEvent(event);
    }
	.......
}

public class ContextRefreshedEventListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("刷新事件（容器刷新完成）：" + this.getClass().getName());
    }
}

public class CustomEvent extends ApplicationContextEvent {

    private Long id;
    private String message;

    /**
     * Constructs a prototypical Event.
     *
     * @param source The object on which the Event initially occurred.
     * @throws IllegalArgumentException if source is null.
     */
    public CustomEvent(Object source,Long id, String message) {
        super(source);
        this.id = id;
        this.message = message;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

@Test
    public void test_event(){
        ClassPathXmlApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("classpath:spring.xml");

        applicationContext.publishEvent(new CustomEvent(applicationContext, 101912455552221L, "事件發(fā)布成功！"));
        //applicationContext.registerShutdownHook();
    }

public class CustomEventListener implements ApplicationListener<CustomEvent> {
    @Override
    public void onApplicationEvent(CustomEvent event) {
        System.out.println("收到：" + event.getSource() + "消息;時間：" + new Date());
        System.out.println("消息：" + event.getId() + ":" + event.getMessage());
    }
}