自定义事件需要继承ApplicationEvent：

package com.morris.spring.event;  import org.springframework.context.ApplicationEvent;  public lass CustomEvent extends ApplicationEvent { 
        

	public CustomEvent(Object source) { 
        
		super(source);
	}
}

监听的时候使用ApplicationEvent的子类CustomEvent：

package com.morris.spring.listener;

import com.morris.spring.event.CustomEvent;
import org.springframework.context.ApplicationListener;

public class CustomEventListener implements ApplicationListener<CustomEvent> { 
        

	@Override
	public void onApplicationEvent(CustomEvent event) { 
        
		System.out.println("custom event: " + event.getSource());
	}
}

可以使用AnnotationConfigApplicationContext发布事件：

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
applicationContext.register(CustomEventListener.class);
applicationContext.refresh();
applicationContext.publishEvent(new CustomEvent("custom event"));

可以向bean中注入一个ApplicationEventPublisher来发布事件：

package com.morris.spring.service;

import com.morris.spring.event.CustomEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;

public class CustomEventService { 
        

	@Autowired
	private ApplicationEventPublisher applicationEventPublisher;

	public void publishEvent() { 
        
		applicationEventPublisher.publishEvent(new CustomEvent("自定义事件"));
	}
}

可以通过实现ApplicationEventPublisherAware接口注入ApplicationEventPublisher来发布事件：

package com.morris.spring.service;

import com.morris.spring.event.CustomEvent;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;

public class CustomEventService2 implements ApplicationEventPublisherAware { 
        

	private ApplicationEventPublisher applicationEventPublisher;

	public void publishEvent() { 
        
		applicationEventPublisher.publishEvent(new CustomEvent("自定义事件"));
	}

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

由于ApplicationContext实现了ApplicationEventPublisher接口，也可以直接注入ApplicationContext来发布事件。

在监听事件时，由于类需要实现ApplicationListener接口，对代码有很大的侵入性，可以使用@EventListener注解随时随地监听事件，这样一个Service中可以监听多个事件：

package com.morris.spring.listener;

import com.morris.spring.event.CustomEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;

public class CustomEventListener2 { 
        

	@EventListener
	public void listenContextRefreshedEvent(ContextRefreshedEvent event) { 
        
		System.out.println("context refresh");
	}

	@EventListener
	public void listenCustomEvent(CustomEvent event) { 
        
		System.out.println("custom event: " + event.getSource());
	}

}

还可以在@EventListener注解上指定监听的事件类型：

package com.morris.spring.listener;

import com.morris.spring.event.CustomEvent;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;

public class CustomEventListener3 { 
        

	@EventListener({ 
        ContextRefreshedEvent.class, CustomEvent.class})
	public void listenEvent(ApplicationEvent event) { 
        
		System.out.println(event);
	}
}

spring消息的发送默认都是同步的，如果要异步发送消息，首先要在配置类上开启异步功能@EnableAsync：

package com.morris.spring.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync // 开启异步
public class EventListenerConfig { 
        
}

在监听的方法上加上@Async：

package com.morris.spring.listener;

import com.morris.spring.event.CustomEvent;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEvent;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;

@Slf4j
public class AsyncCustomEventListener { 
        
	@EventListener({ 
        ContextRefreshedEvent.class, CustomEvent.class})
	@Async // 异步
	public void listenEvent(ApplicationEvent event) { 
        
		log.info("receive event: {}", event);
	}
}

也可以自定义执行异步消息的线程池（默认就是SimpleAsyncTaskExecutor）：

@Bean
public TaskExecutor executor() { 
        
	return new SimpleAsyncTaskExecutor("eventListen-");
}

异步消息只是借用spring的异步执行机制，在方法上加上@Async注解，方法都会异步执行。

发布消息入口：
org.springframework.context.support.AbstractApplicationContext#publishEvent(org.springframework.context.ApplicationEvent)

public void publishEvent(ApplicationEvent event) { 
        
    publishEvent(event, null);
}

protected void publishEvent(Object event, @Nullable ResolvableType eventType) { 
        
...
        /** * @see SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent, org.springframework.core.ResolvableType) */
        // 发布消息
        getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    }
... ...
}

然后调用SimpleApplicationEventMulticaster来进行广播消息：

// org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent(org.springframework.context.ApplicationEvent, org.springframework.core.ResolvableType)
public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) { 
        
    ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
    // 如果有线程池，将会异步执行
    Executor executor = getTaskExecutor();
    for (ApplicationListener<?> listener : getApplicationListeners(event, type)) { 
        
        if (executor != null) { 
        
            executor.execute(() -> invokeListener(listener, event));
        }
        else { 
        
            invokeListener(listener, event);
        }
    }
}

protected void invokeListener(ApplicationListener<?> listener, ApplicationEvent event) { 
        
    ErrorHandler errorHandler = getErrorHandler();
    if (errorHandler != null) { 
        
        try { 
        
            doInvokeListener(listener, event);
        }
        catch (Throwable err) { 
        
            errorHandler.handleError(err);
        }
    }
    else { 
        
        // ApplicationListener.调用onApplicationEvent
        doInvokeListener(listener, event);
    }
}

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) { 
        
    try { 
        
        listener.onApplicationEvent(event);
    }
    catch (ClassCastException ex) { 
        
        String msg = ex.getMessage();
        if (msg == null || matchesClassCastMessage(msg, event.getClass())) { 
        
            // Possibly a lambda-defined listener which we could not resolve the generic event type for
            // -> let's suppress the exception and just log a debug message.
            Log logger = LogFactory.getLog(getClass());
            if (logger.isTraceEnabled()) { 
        
                logger.trace("Non-matching event type for listener: " + listener, ex);
            }
        }
        else { 
        
            throw ex;
        }
    }
}

从上面的源码可以发现spring是通过SimpleApplicationEventMulticaster事件多播器来发布消息的，那么这个类是何时注入的呢？容器refresh()时。

org.springframework.context.support.AbstractApplicationContext#initApplicationEventMulticaster

protected void initApplicationEventMulticaster() { 
        
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) { 
        
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isTraceEnabled()) { 
        
			logger.trace("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else { 
        
		// 直接new，然后放入到spring一级缓存中
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isTraceEnabled()) { 
        
			logger.trace("No '" + APPLICATION_EVENT_MULTICASTER_BEAN_NAME + "' bean, using " +
					"[" + this.applicationEventMulticaster.getClass().getSimpleName() + "]");
		}
	}
}

spring在发布消息时，会从SimpleApplicationEventMulticaster中拿出所有的ApplicationListener，那么这些ApplicationListener何时被注入的呢？容器refresh()时。

org.springframework.context.support.AbstractApplicationContext#registerListeners

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) { 
        
		// 添加到SimpleApplicationEventMulticaster中
		getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
	}

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

@EventListener注解的功能是通过EventListenerMethodProcessor来实现的，EventListenerMethodProcessor这个类在AnnotationConfigApplicationContext的构造方法中被注入。

EventListenerMethodProcessor主要实现了两个接口：SmartInitializingSingleton和BeanFactoryPostProcessor。

先来看看BeanFactoryPostProcessor的postProcessBeanFactory()，这个方法主要是保存beanFactory和eventListenerFactories，后面的方法将会使用到：

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
        
    // 保存beanFactory
    this.beanFactory = beanFactory;

    /** * EventListenerFactory[DefaultEventListenerFactory]在何处被注入？ * @see AnnotationConfigUtils#registerAnnotationConfigProcessors(org.springframework.beans.factory.support.BeanDefinitionRegistry, java.lang.Object) */
    Map<String, EventListenerFactory> beans = beanFactory.getBeansOfType(EventListenerFactory.class, false, false);
    List<EventListenerFactory> factories = new ArrayList<>(beans.values());
    AnnotationAwareOrderComparator.sort(factories);
    // 保存eventListenerFactories
    this.eventListenerFactories = factories;
}

再来看看SmartInitializingSingleton的afterSingletonsInstantiated()方法，这个方法会在所有的bean初始化完后执行。

public void afterSingletonsInstantiated() { 
        
	ConfigurableListableBeanFactory beanFactory = this.beanFactory;
	Assert.state(this.beanFactory != null, "No ConfigurableListableBeanFactory set");
	String[] beanNames = beanFactory.getBeanNamesForType(Object.class);
	for (String beanName : beanNames) { 
        
		if (!ScopedProxyUtils.isScopedTarget(beanName)) { 
        
			// 目标类的类型
			Class<?> type = null;
			try { 
        
				type = AutoProxyUtils.determineTargetClass(beanFactory, beanName);
			}
			catch (Throwable ex) { 
        
				// An unresolvable bean type, probably from a lazy bean - let's ignore it.
				if (logger.isDebugEnabled()) { 
        
					logger.debug("Could not resolve target class for bean with name '" + beanName + "'", ex);
				}
			}
			if (type != null) { 
        
				if (ScopedObject.class.isAssignableFrom(type)) { 
        
					try { 
        
						Class<?> targetClass = AutoProxyUtils.determineTargetClass(
								beanFactory, ScopedProxyUtils.getTargetBeanName(beanName));
						if (targetClass != null) { 
        
							type = targetClass;
						}
					}