Ò»ÎĶÁ¶®ÄÚ²¿×é¼þ½âñîÉñÆ÷ Spring Event£¨Spring ʼþ£©

public class LogonEvent extends ApplicationEvent {

    private final String userName;

    public LogonEvent(Object source, String username) {
        super(source);
        this.userName = username;
    }

    public String getUserName() {
        return userName;
    }
}

@Service
public class LoginEventPublisher {

    private final ApplicationEventPublisher applicationEventPublisher;

    public LoginEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        this.applicationEventPublisher = applicationEventPublisher;
    }

    public void publishLoginEvent(String username) {
        LogonEvent loginEvent = new LogonEvent(this, username);
        applicationEventPublisher.publishEvent(loginEvent);
    }
}

// ÈÕÖ¾´¦Àíʼþ¼àÌýÆ÷
@Component
public class LoginEventPrintLogListener {

    @EventListener
    public void handleUserLoginEvent(LogonEvent event) {
        String username = event.getUserName();
        // ÔÚÕâÀïÖ´Ðд¦ÀíÓû§µÇ¼Ê¼þµÄÂß¼­£¬ÀýÈç¼Ç¼ÈÕÖ¾»ò´¥·¢ÆäËû²Ù×÷
        System.out.println("User logged in: " + username);
    }
}

// µÇ¼ÏûϢ֪ͨʼþ¼àÌýÆ÷
@Component
public class LoginEventMessageNoticeListener {

    @EventListener
    public void LoginEventMessageNoticeListener(LogonEvent event) {
        String username = event.getUserName();
        // ·¢ËÍÏûϢ֪ͨÓû§
        System.out.println("message send User logged in: " + username);
    }
}

@Component
public class MyCommandLineRunner implements CommandLineRunner {

    private final LoginEventPublisher loginEventPublisher;

    public MyCommandLineRunner(LoginEventPublisher loginEventPublisher) {
        this.loginEventPublisher = loginEventPublisher;
    }

    @Override
    public void run(String... args) {
        // ÔÚÓ¦ÓóÌÐòÆô¶¯ºóÖ´ÐеÄ×Ô¶¨ÒåÂß¼­
        System.out.println("MyCommandLineRunner executed!");

        // µÇ¼³É¹¦
        // µÇ¼ִÐкóÂß¼­
        loginEventPublisher.publishLoginEvent("СÍõ");
    }
}

2023-10-13 16:04:02.021  INFO 5356 --- [           main] w.s.c.ServletWebServerApplicationContext : Root WebApplicationContext: initialization completed in 1250 ms
2023-10-13 16:04:02.382  INFO 5356 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2023-10-13 16:05:31.792  INFO 5356 --- [           main] c.e.s.SpringBootTestMavenApplication     : Started SpringBootTestMavenApplication in 200.49 seconds (JVM running for 201.165)

MyCommandLineRunner executed!
message send User logged in: СÍõ
User logged in: СÍõ

@SpringBootApplication
// ¿ªÆô Async
@EnableAsync
public class SpringBootTestMavenApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringBootTestMavenApplication.class, args);
    }
}


@Component
public class LoginEventPrintLogListener {

    @EventListener
    // ÅäÖÃÈÎÎñÒì²½
    @Async
    public void handleUserLoginEvent(LogonEvent event) throws Exception {
        String username = event.getUserName();
        // ÔÚÕâÀïÖ´Ðд¦ÀíÓû§µÇ¼Ê¼þµÄÂß¼­£¬ÀýÈç¼Ç¼ÈÕÖ¾»ò´¥·¢ÆäËû²Ù×÷
        System.out.println("User logged in: " + username);
    }
}

@FunctionalInterface
public interface ApplicationEventPublisher {

	default void publishEvent(ApplicationEvent event) {
		publishEvent((Object) event);
	}

	void publishEvent(Object event);
}

public interface ApplicationEventMulticaster {

	void addApplicationListener(ApplicationListener<?> listener);

	void addApplicationListenerBean(String listenerBeanName);

	void removeApplicationListener(ApplicationListener<?> listener);

	void removeApplicationListenerBean(String listenerBeanName);

	void removeApplicationListeners(Predicate<ApplicationListener<?>> predicate);

	void removeApplicationListenerBeans(Predicate<String> predicate);

	void multicastEvent(ApplicationEvent event);

	void multicastEvent(ApplicationEvent event, @Nullable ResolvableType eventType);
}

public abstract class ApplicationEvent extends EventObject {

	/** use serialVersionUID from Spring 1.2 for interoperability. */
	private static final long serialVersionUID = 7099057708183571937L;

	/** System time when the event happened. */
	private final long timestamp;


	public ApplicationEvent(Object source) {
		super(source);
		this.timestamp = System.currentTimeMillis();
	}
}

// org.springframework.context.support.AbstractApplicationContext#publishEvent
	protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
		Assert.notNull(event, "Event must not be null");

		// Decorate event as an ApplicationEvent if necessary
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		else {
			applicationEvent = new PayloadApplicationEvent<>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent<?>) applicationEvent).getResolvableType();
			}
		}

		// Multicast right now if possible - or lazily once the multicaster is initialized
		// ApplicationEventMulticaster δ³õʼ»¯Íê³Éʱ½« applicationEvent ÔÝ´æ
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		else {
		    // »ñÈ¡¼àÌý¹ÜÀíÆ÷²¢½øÐй㲥
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// Publish event via parent context as well...
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}

// org.springframework.context.event.SimpleApplicationEventMulticaster#multicastEvent

	@Override
	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();
		// ÊÇ·ñ´æÔÚ ErrorHandler 
		if (errorHandler != null) {
			try {
				doInvokeListener(listener, event);
			}
			catch (Throwable err) {
				errorHandler.handleError(err);
			}
		}
		else {
			doInvokeListener(listener, event);
		}
	}

// org.springframework.context.event.ApplicationListenerMethodAdapter#onApplicationEvent
	@Override
	public void onApplicationEvent(ApplicationEvent event) {
		processEvent(event);
	}

	public void processEvent(ApplicationEvent event) {
		Object[] args = resolveArguments(event);
		if (shouldHandle(event, args)) {
		    // µ÷ÓüàÌýÆ÷
			Object result = doInvoke(args);
			if (result != null) {
				handleResult(result);
			}
			else {
				logger.trace("No result object given - no result to handle");
			}
		}
	}

	protected Object doInvoke(Object... args) {
	    // ´Ó spring ÈÝÆ÷ÖÐͨ¹ý getBean() ·½·¨»ñÈ¡¼àÌýÆ÷Bean
	    // Òò´ËÖ§³Ö¼àÌýÆ÷¶¯Ì¬¼ÓÔØ
		Object bean = getTargetBean();
		// Detect package-protected NullBean instance through equals(null) check
		if (bean.equals(null)) {
			return null;
		}

		ReflectionUtils.makeAccessible(this.method);
		try {
			return this.method.invoke(bean, args);
		}
		catch (IllegalArgumentException ex) {
			assertTargetBean(this.method, bean, args);
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (IllegalAccessException ex) {
			throw new IllegalStateException(getInvocationErrorMessage(bean, ex.getMessage(), args), ex);
		}
		catch (InvocationTargetException ex) {
			// Throw underlying exception
			Throwable targetException = ex.getTargetException();
			if (targetException instanceof RuntimeException) {
				throw (RuntimeException) targetException;
			}
			else {
				String msg = getInvocationErrorMessage(bean, "Failed to invoke event listener method", args);
				throw new UndeclaredThrowableException(targetException, msg);
			}
		}
	}

# ÔÚºËÐÄ·½·¨refreshÖн¨Á¢applicationEventMulticaster
// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
// ÔÚSpringÈÝÆ÷Öгõʼ»¯Ê¼þ¹ã²¥Æ÷£¬Ê¼þ¹ã²¥Æ÷ÓÃÓÚʼþµÄ·¢²¼
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
// °ÑSpringÈÝÆ÷ÄÚµÄʼþ¼àÌýÆ÷ºÍBeanFactoryÖеÄʼþ¼àÌýÆ÷¶¼Ìí¼ÓµÄʼþ¹ã²¥Æ÷ÖС£
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishrefresh();

# Ö÷ÒªÂß¼­ÔÚ initApplicationEventMulticaster ºÍ registerListeners
// ³õʼ»¯Ê¼þ¹ã²¥Æ÷
protected void initApplicationEventMulticaster() {
    ConfigurableListableBeanFactory beanFactory = getBeanFactory();
    // Èç¹ûÓû§ÊÖ¶¯Ð½¨ÁËÒ»¸öÃûΪapplicationEventMulticasterÀàÐÍΪApplicationEventMulticasterµÄbean£¬Ôò½«Õâ¸öbean×÷Ϊʼþ¹ã²¥Æ÷
    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 {
        // ·ñÔòн¨Ò»¸öSimpleApplicationEventMulticaster×÷ΪĬÈϵÄʼþ¹ã²¥Æ÷
        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() + "]");
        }
    }
}

// ×¢²á¼àÌýÆ÷
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!
    // »ñÈ¡ÀàÐÍÊÇApplicationListenerµÄbeanName¼¯ºÏ£¬´Ë´¦²»»áȥʵÀý»¯bean
    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;
    // Èç¹û´æÔÚearlyEventsToProcess£¬ÌáÇ°´¦ÀíÕâЩʼþ
    if (earlyEventsToProcess != null) {
        for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
            getApplicationEventMulticaster().multicastEvent(earlyEvent);
        }
    }
}