Spring Bean 方法自动触发的N种方式

有时候咱们须要在系统启动后自动执行一些初始化动做，如加载自定义的资源，启动业务相关定时器，或是在bean初始化后执行一些其余的注册动做。这里面有个核心的要素就是方法的执行时机，总结来说spring里面有两大类的方法执行时机：

1. 生命周期回调触发。
2. spring 事件触发。

经过生命周期回调触发

spring官网中的有对生命周期回调的总结了初始化回调的三种方式：

1. Methods annotated with @PostConstruct
2. afterPropertiesSet() as defined by the InitializingBean callback interface
3. A custom configured init() method，一般用在xml配置中，在bean标签中配置一个init-method实现

对应的注销回调的三种方式：

1. Methods annotated with @PreDestroy
2. destroy() as defined by the DisposableBean callback interface
3. A custom configured destroy() method，一般用在xml配置中，在bean标签中配置一个destroy-method实现

这三种方式的执行时机如上述的顺序。

PostConstruct的执行时机

afterPropertiesSet的执行时机

afterPropertiesSet是在AbstractAutowireCapableBeanFactory的initializeBean中调用的，也就是bean的实例化流程中的初始化bean的时候，这个时候spring已经对bean完成了代理、依赖注入，开始执行一些初始化方法。

具体执行的方法以下，注意启动的invokeInitMethods，就是调用afterPropertiesSet的入口，这个方法的执行时机是后置处理器执行postProcessBeforeInitialization 和applyBeanPostProcessorsAfterInitialization之间。

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
		if (System.getSecurityManager() != null) {
			AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
				invokeAwareMethods(beanName, bean);
				return null;
			}, getAccessControlContext());
		}
		else {
			invokeAwareMethods(beanName, bean);
		}

		Object wrappedBean = bean;
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
		}

		try {
			invokeInitMethods(beanName, wrappedBean, mbd);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(
					(mbd != null ? mbd.getResourceDescription() : null),
					beanName, "Invocation of init method failed", ex);
		}
		if (mbd == null || !mbd.isSynthetic()) {
			wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
		}

		return wrappedBean;
	}
复制代码

再看看invokeInitMethods的具体实现

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
			throws Throwable {

		boolean isInitializingBean = (bean instanceof InitializingBean);
		if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
			if (System.getSecurityManager() != null) {
				try {
					AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}, getAccessControlContext());
				}
				catch (PrivilegedActionException pae) {
					throw pae.getException();
				}
			}
			else {
				((InitializingBean) bean).afterPropertiesSet();
			}
		}
	}
复制代码

经过spring事件来触发

这种触发方式是经过使用@EventListener注解来监听spring发布的事件，收到事件后执行某些业务操做。好比但愿spring容器初始化完成后才开始咱们的业务逻辑，以下是一个代码示例：

@EventListener(classes = ContextRefreshedEvent.class)
public void enableSchedule() {  
    this.scheduleFlag = true;
}
复制代码

spring官网的1.15.2 standard and custom events 中提到了spring的內建事件，详细介绍以下：

ontextRefreshedEvent	Published when the ApplicationContext is initialized or refreshed (for example, by using the refresh() method on the ConfigurableApplicationContext interface). Here, “initialized” means that all beans are loaded, post-processor beans are detected and activated, singletons are pre-instantiated, and the ApplicationContext object is ready for use. As long as the context has not been closed, a refresh can be triggered multiple times, provided that the chosen ApplicationContext actually supports such “hot” refreshes. For example, XmlWebApplicationContext supports hot refreshes, but GenericApplicationContext does not.
ContextStartedEvent	Published when the ApplicationContext is started by using the start() method on the ConfigurableApplicationContext interface. Here, “started” means that all Lifecycle beans receive an explicit start signal. Typically, this signal is used to restart beans after an explicit stop, but it may also be used to start components that have not been configured for autostart (for example, components that have not already started on initialization).
ContextStoppedEvent	Published when the ApplicationContext is stopped by using the stop() method on the ConfigurableApplicationContext interface. Here, “stopped” means that all Lifecycle beans receive an explicit stop signal. A stopped context may be restarted through a start() call.
ContextClosedEvent	Published when the ApplicationContext is being closed by using the close() method on the ConfigurableApplicationContext interface or via a JVM shutdown hook. Here, "closed" means that all singleton beans will be destroyed. Once the context is closed, it reaches its end of life and cannot be refreshed or restarted.
RequestHandledEvent	A web-specific event telling all beans that an HTTP request has been serviced. This event is published after the request is complete. This event is only applicable to web applications that use Spring’s DispatcherServlet.
ServletRequestHandledEvent	A subclass of RequestHandledEvent that adds Servlet-specific context information.

spring应用上下文启动事件——ontextRefreshedEvent

这个事件是在AbstractApplicationContext#finishRefresh方法中执行，执行到这里的时候整个spring容器的初始化、实例化（单例）已经完成，具体代码以下：

protected void finishRefresh() {
		......

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

		// Participate in LiveBeansView MBean, if active.
		LiveBeansView.registerApplicationContext(this);
	}
复制代码

若是应用系统中，须要在容器初始化完成后（对应用bean有依赖）当即执行某些操做，能够监听这个事件，绝对不会出现依赖的bean未初始化的问题。