java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Spring中SmartLifecycle和Lifecycle

Spring中SmartLifecycle和Lifecycle的作用和区别

作者:brucelwl

这篇文章主要介绍了Spring中SmartLifecycle和Lifecycle的作用和区别,本文通过实例代码给大家介绍的非常详细对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下

本文基于SpringBoot 2.5.0-M2讲解Spring中LifecycleSmartLifecycle的作用和区别,以及如何控制SmartLifecycle的优先级。
并讲解SpringBoot中如何通过SmartLifecycle来启动/停止web容器.

 SmartLifecycle和Lifecycle作用

都是让开发者可以在所有的bean都创建完成(getBean) 之后执行自己的初始化工作,或者在退出时执行资源销毁工作

SmartLifecycle和Lifecycle区别

 1.SmartLifecycle接口继承Lifecycle接口,同时继承了org.springframework.context.Phased接口用于控制多个SmartLifecycle实现之间的优先级。

2.在SpringBoot应用中,或在Spring应用中没有调用AbstractApplicationContext#start方法,如果一个Bean只是实现了Lifecycle接口的情况下:

不会执行Lifecycle接口中的启动方法,包括Lifecycle#isRunning方法也不会被执行。

但是在应用 退出时 会执行Lifecycle#isRunning方法判断该Lifecycle是否已经启动,如果返回true则调用Lifecycle#stop()停止方法

3. 如果一个Bean实现了SmartLifecycle接口,则会执行启动方法。先会被根据Phased接口优先级分组,封装在LifecycleGroup,然后循环调用LifecycleGroup#start()方法,SmartLifecycle#isRunning判断是否已经执行,返回false表示还未执行,则调用SmartLifecycle#start()执行。Phased返回值越小,优先级越高。

4.SmartLifecycle中还有个isAutoStartup方法,如果返回false,在启动时也不会执行start方法,默认返回true

源码分析

SmartLifecycleLifecycle都是在org.springframework.context.support.DefaultLifecycleProcessor中被调用,
DefaultLifecycleProcessor#onRefresh方法在执行AbstractApplicationContext#finishRefresh时会被调用,调用栈如下:

startBeans:142, DefaultLifecycleProcessor (org.springframework.context.support)
onRefresh:123, DefaultLifecycleProcessor (org.springframework.context.support)
finishRefresh:934, AbstractApplicationContext (org.springframework.context.support)
refresh:585, AbstractApplicationContext (org.springframework.context.support)
refresh:144, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context)
refresh:755, SpringApplication (org.springframework.boot)
refreshContext:426, SpringApplication (org.springframework.boot)
run:326, SpringApplication (org.springframework.boot)
run:1299, SpringApplication (org.springframework.boot)
run:1288, SpringApplication (org.springframework.boot)
main:31, DemoApplication (com.example.demo)

DefaultLifecycleProcessor#onRefresh源码:

@Override
public void onRefresh() {
	startBeans(true); //autoStartupOnly = true
	this.running = true;
}

DefaultLifecycleProcessor#startBeans源码如下:
autoStartupOnly 在onRefresh时传入的是true,表示只执行可以自动启动的bean,即为:SmartLifecycle的实现类,并且SmartLifecycle#isAutoStartup返回值必须为true。

private void startBeans(boolean autoStartupOnly) {
	Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
	Map<Integer, LifecycleGroup> phases = new TreeMap<>();

	lifecycleBeans.forEach((beanName, bean) -> {
		if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
			int phase = getPhase(bean);
			phases.computeIfAbsent(phase, p -> 
			 new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly)
			).add(beanName, bean);
		}
	});
	if (!phases.isEmpty()) {
		phases.values().forEach(LifecycleGroup::start);
	}
}

而Spring AbstractApplicationContext#doClose退出时,无论是SmartLifecycleLifecycle都会执行isRunning方法,判断是否已经启动,返回true表示已经启动,则执行SmartLifecycleLifecyclestop方法。
源码见:org.springframework.context.support.DefaultLifecycleProcessor#doStop方法。

而执行AbstractApplicationContext#doClose一般是应用进程退出,通过jvm注册的钩子方法,或者应用程序编码调用。
AbstractApplicationContext#registerShutdownHook源码

@Override
public void registerShutdownHook() {
	if (this.shutdownHook == null) {
		// No shutdown hook registered yet.
		this.shutdownHook = new Thread(SHUTDOWN_HOOK_THREAD_NAME) {
			@Override
			public void run() {
				synchronized (startupShutdownMonitor) {
					doClose();
				}
			}
		};
		Runtime.getRuntime().addShutdownHook(this.shutdownHook);
	}
}

自定义LifecycleProcessor处理Lifecycle

在源码分析中提到了DefaultLifecycleProcessor,其实现了LifecycleProcessor接口。然而我们自己也可以实现该接口,替换默认的DefaultLifecycleProcessor。SpringBoot中则是自己配置了DefaultLifecycleProcessor,我们可以按照同样的方式,覆盖默认的实现。例如可以让Lifecycle中的start()方法在onRefresh()时也能被执行。

org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration源码:

/**
 * {@link EnableAutoConfiguration Auto-configuration} relating to the application
 * context's lifecycle.
 *
 * @author Andy Wilkinson
 * @since 2.3.0
 */
@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(LifecycleProperties.class)
public class LifecycleAutoConfiguration {

	@Bean(name = AbstractApplicationContext.LIFECYCLE_PROCESSOR_BEAN_NAME)
	@ConditionalOnMissingBean(name = AbstractApplicationContext.LIFECYCLE_PROCESSOR_BEAN_NAME,
			search = SearchStrategy.CURRENT)
	public DefaultLifecycleProcessor defaultLifecycleProcessor(LifecycleProperties properties) {
		DefaultLifecycleProcessor lifecycleProcessor = new DefaultLifecycleProcessor();
		lifecycleProcessor.setTimeoutPerShutdownPhase(properties.getTimeoutPerShutdownPhase().toMillis());
		return lifecycleProcessor;
	}
}

SpringBoot中内嵌web容器启动时机

SpringBoo中就是通过实现SmartLifecycle来启动内嵌的web容器,实现类为WebServerStartStopLifecycle

ServletWebServerApplicationContextonRefresh方法中调用createWebServercreateWebServer方法中创建org.springframework.boot.web.server.WebServer实例,该对象则包含了控制web容器(tomcatjetty)的启动与停止方法。

@Override
protected void onRefresh() {
	super.onRefresh();
	try {
		createWebServer();
	}catch (Throwable ex) {
		throw new ApplicationContextException("Unable to start web server", ex);
	}
}

ServletWebServerApplicationContext#createWebServer源码:

private void createWebServer() {
	WebServer webServer = this.webServer;
	ServletContext servletContext = getServletContext();
	if (webServer == null && servletContext == null) {
		StartupStep createWebServer = this.getApplicationStartup().start("spring.boot.webserver.create");
		ServletWebServerFactory factory = getWebServerFactory();
		createWebServer.tag("factory", factory.getClass().toString());
		this.webServer = factory.getWebServer(getSelfInitializer());
		createWebServer.end();
		getBeanFactory().registerSingleton("webServerGracefulShutdown",
				new WebServerGracefulShutdownLifecycle(this.webServer));
		getBeanFactory().registerSingleton("webServerStartStop",
				new WebServerStartStopLifecycle(this, this.webServer));
	}
	else if (servletContext != null) {
		try {
			getSelfInitializer().onStartup(servletContext);
		}
		catch (ServletException ex) {
			throw new ApplicationContextException("Cannot initialize servlet context", ex);
		}
	}
	initPropertySources();
}

createWebServer方法会将创建的webServer封装在WebServerStartStopLifecycle对象中,并注册到Spring容器中。

org.springframework.boot.web.servlet.context.WebServerStartStopLifecycle源码如下:

class WebServerStartStopLifecycle implements SmartLifecycle {

	private final ServletWebServerApplicationContext applicationContext;
	private final WebServer webServer;
	private volatile boolean running;

	WebServerStartStopLifecycle(ServletWebServerApplicationContext applicationContext, WebServer webServer) {
		this.applicationContext = applicationContext;
		this.webServer = webServer;
	}

	@Override
	public void start() {
		this.webServer.start();
		this.running = true;
		this.applicationContext
				.publishEvent(new ServletWebServerInitializedEvent(this.webServer, this.applicationContext));
	}

	@Override
	public void stop() { this.webServer.stop(); }

	@Override
	public boolean isRunning() {	return this.running; }

	@Override
	public int getPhase() { return Integer.MAX_VALUE - 1; }
}

WebServerStartStopLifecycle则实现了SmartLifecycle接口,当Spring回调到SmartLifecycle接口方法时则调用this.webServer.start();启动web容器,web容器启动完成之后会通过applicationContext发布ServletWebServerInitializedEvent事件,表示web容器启动成功,可以接收http请求。

和SmartInitializingSingleton区别

相同点:SmartInitializingSingletonLifecycleSmartLifecycle都是在所有的单实例bean创建(getBean方法)之后执行。

不同点:

到此这篇关于Spring中SmartLifecycle和Lifecycle的作用和区别的文章就介绍到这了,更多相关Spring中SmartLifecycle和Lifecycle内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

您可能感兴趣的文章:
阅读全文