白话Spring源码（十四）：Spring Context源码分析-事件机制

末蓝、 2022-02-16 19:13 285阅读 0赞

这篇博客主要给大家介绍ApplicationContext的另外一个核心功能：**事件机制**。

### 为什么要使用事件机制？ ###

使用事件机制可以解耦代码，观察者与被观察者可以分开开发，中间只有事件作为联系，不用关心另一方如何实现。观察者可以有多个，所以对于同一个事件可以有多种不同的处理方式，不过要确保不依赖处理的顺序。使用事件后，观察者可以单独开发，对主流程没有任何影响，可以简化主流程的开发。

事件可以用于各种场景的消息通知，比如系统收到停机指令后，可以发出停机事件，这样相关的子系统就可以进行停机前的各种处理。那么 Spring 中的事件是如何实现的呢？

ApplicationContext中事件处理是由ApplicationEvent类和ApplicationListener接口来提供的。如果一个Bean实现了ApplicationListener接口，并且已经发布到容器中去，每次ApplicationContext发布一个ApplicationEvent事件，这个Bean就会接到通知。Spring事件机制是观察者模式的实现。

### Spring中提供的标准事件： ###

*  ContextRefreshEvent，当ApplicationContext容器初始化完成或者被刷新的时候，就会发布该事件。比如调用ConfigurableApplicationContext接口中的refresh()方法。此处的容器初始化指的是所有的Bean都被成功装载，后处理（post-processor）Bean被检测到并且激活，所有单例Bean都被预实例化，ApplicationContext容器已经可以使用。只要上下文没有被关闭，刷新可以被多次触发。XMLWebApplicationContext支持热刷新，GenericApplicationContext不支持热刷新。
 *  ContextStartedEvent，当ApplicationContext启动的时候发布事件，即调用ConfigurableApplicationContext接口的start方法的时候。这里的启动是指，所有的被容器管理生命周期的Bean接受到一个明确的启动信号。在经常需要停止后重新启动的场合比较适用。
 *  ContextStoppedEvent，当ApplicationContext容器停止的时候发布事件，即调用ConfigurableApplicationContext的close方法的时候。这里的停止是指，所有被容器管理生命周期的Bean接到一个明确的停止信号。
 *  ContextClosedEvent，当ApplicationContext关闭的时候发布事件，即调用ConfigurableApplicationContext的close方法的时候，关闭指的是所有的单例Bean都被销毁。关闭上下后，不能重新刷新或者重新启动。
 *  RequestHandledEvent，只能用于DispatcherServlet的web应用，Spring处理用户请求结束后，系统会触发该事件。

### spring事件机制的使用 ###

1.定义自己的监听事件

package com.test.eventListener;
    
    import org.springframework.context.ApplicationEvent;
    
    
    public class StudentAddEvent extends ApplicationEvent {
    
        private static final long serialVersionUID = 20L;
    
        /**
         * 学生姓名
         */
        private String name;
    
        /**
         * @param source
         */
        public StudentAddEvent(Object source, String name) {
            super(source);
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }

2.定义自己的监听器（负责处理自己的监听事件）

package com.test.eventListener;
    
    import org.springframework.context.ApplicationEvent;
    import org.springframework.context.ApplicationListener;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public class StudentAddListener implements ApplicationListener {
    
        public void onApplicationEvent(ApplicationEvent event) {
            // 1.判断是否是增加学生对象的事件
            if (!(event instanceof StudentAddEvent)) {
                return;
            }
    
            // 2.是增加学生事件的对象，进行逻辑处理，比如记日志、积分等
            StudentAddEvent studentAddEvent = (StudentAddEvent) event;
            System.out.println("增加了学生:" + studentAddEvent.getName());
        }
    }

3.定义一个bean触发监听事件

package com.test.eventListener;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;
    
    
    @Component
    public class StudentAddBean implements ApplicationContextAware {
        /**
         * 定义Spring上下文对象
         */
        private ApplicationContext applicationContext = null;
    
        /*
         * (non-Javadoc)
         *
         * @see
         * org.springframework.context.ApplicationContextAware#setApplicationContext
         * (org.springframework.context.ApplicationContext)
         */
        public void setApplicationContext(ApplicationContext applicationContext)
                throws BeansException {
            this.applicationContext = applicationContext;
    
        }
    
        /**
         * 增加一个学生
         *
         * @param studentName
         */
        public void addStudent(String studentName) {
            // 1.构造一个增加学生的事件
            StudentAddEvent aStudentEvent = new StudentAddEvent(
                    applicationContext, studentName);
            // 2.触发增加学生事件
            applicationContext.publishEvent(aStudentEvent);
        }
    
    }

4.测试

package com.test.eventListener;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    
    public class EventListenerTest {
        public static void main(String[] args) {
            String[] xmlConfig = new String[] { "spring/spring.xml" };
            // 使用ApplicationContext来初始化系统
            ApplicationContext context = new ClassPathXmlApplicationContext(xmlConfig);
            StudentAddBean studentBean = (StudentAddBean) context.getBean("studentAddBean");
            studentBean.addStudent("张三");
            studentBean.addStudent("李四");
        }
    }

上面就是事件的简单例子。

### 源码分析 ###

那我们来看一下事件机制在spring里是怎么实现的。

ApplicationEvent：事件抽象类

public abstract class ApplicationEvent extends EventObject {
    
    	private long timestamp;
    
    
    	public ApplicationEvent(Object source) {
    		super(source);
    		timestamp = System.currentTimeMillis();
    	}
    
    
    	public long getTimestamp() {
    		return timestamp;
    	}
    
    }

ApplicationListener ：事件监听接口

public interface ApplicationListener extends EventListener {
    
        //处理事件
        void onApplicationEvent(ApplicationEvent e);
    
    }

ApplicationEventMulticaster ：事件广播接口

public interface ApplicationEventMulticaster extends ApplicationListener {
    
    	/**
    	 * Add a listener to be notified of all events
    	 * @param listener listener to add
    	 */
    	void addApplicationListener(ApplicationListener listener);
    
    	/**
    	 * Remove a listener in the notification list]
    	 * @param listener listener to remove
    	 */
    	void removeApplicationListener(ApplicationListener listener);
    
    	/**
    	 * Remove all listeners registered with this multicaster.
    	 * It will perform no action on event notification until more
    	 * listeners are registered.
    	 */
    	void removeAllListeners();
    
    }

ApplicationEventMulticasterImpl：事件广播实现类

public class ApplicationEventMulticasterImpl implements ApplicationEventMulticaster {
    
    	/** Set of listeners */
    	private Set eventListeners = new HashSet();
    
    	public void addApplicationListener(ApplicationListener l) {
    		eventListeners.add(l);
    	}
    
    	public void removeApplicationListener(ApplicationListener l) {
    		eventListeners.remove(l);
    	}
    
    	public void onApplicationEvent(ApplicationEvent e) {
    		Iterator i = eventListeners.iterator();
    		while (i.hasNext()) {
    			ApplicationListener l = (ApplicationListener) i.next();
    			l.onApplicationEvent(e);
    		}
    	}
    
    	public void removeAllListeners() {
    		eventListeners.clear();
    	}
    
    }

那Listener是怎么加到广播里的呢？

refresh()方法里有个refreshListeners()方法

/**
    	 * Add beans that implement ApplicationListener as listeners.
    	 * Doesn't affect other listeners, which can be added without being beans.
    	 */
    	private void refreshListeners() throws BeansException {
    		logger.info("Refreshing listeners");
    		Collection listeners = getBeansOfType(ApplicationListener.class, true, false).values();
    		logger.debug("Found " + listeners.size() + " listeners in bean factory");
    		for (Iterator it = listeners.iterator(); it.hasNext();) {
    			ApplicationListener listener = (ApplicationListener) it.next();
    			addListener(listener);
    			logger.info("Application listener [" + listener + "] added");
    		}
    	}
    
    	/**
    	 * Subclasses can invoke this method to register a listener.
    	 * Any beans in the context that are listeners are automatically added.
    	 * @param listener the listener to register
    	 */
    	protected void addListener(ApplicationListener listener) {
    		this.eventMulticaster.addApplicationListener(listener);
    	}

好了，到现在我们也应该清楚事件机制的简单使用和怎么实现的了！