欢迎访问Spring Cloud中国社区

《重新定义Spring Cloud实战》由Spring Cloud中国社区倾力打造,基于Spring Cloud的Finchley.RELEASE版本,本书内容宽度足够广、深度足够深,而且立足于生产实践,直接从生产实践出发,包含大量生产实践的配置。欢迎加微信Software_King进群答疑,国内谁在使用Spring Cloud?欢迎登记

如何在生产环境中重启Spring Boot应用?

谭朝红 · 6月前 · 1757 ·

通过HTTP重启Spring Boot应用程序

需求背景

在一个很奇葩的需求下,要求在客户端动态修改Spring Boot配置文件中的属性,例如端口号、应用名称、数据库连接信息等,然后通过一个Http请求重启Spring Boot程序。这个需求类似于操作系统更新配置后需要进行重启系统才能生效的应用场景。

动态配置系统并更新生效是应用的一种通用性需求,实现的方式也有很多种。例如监听配置文件变化、使用配置中心等等。网络上也有很多类似的教程存在,但大多数都是在开发阶段,借助Spring Boot DevTools插件实现应用程序的重启,或者是使用spring-boot-starter-actuator和spring-cloud-starter-config来提供端点(Endpoint)的刷新。

第一种方式无法在生产环境中使用(不考虑),第二种方式需要引入Spring Cloud相关内容,这无疑是杀鸡用了宰牛刀。

接下来,我将尝试采用另外一种方式实现HTTP请求重启Spring Boot应用程序这个怪异的需求。

尝试思路

重启Spring Boot应用程序的关键步骤是对主类中SpringApplication.run(Application.class,args);方法返回值的处理。SpringApplication#run()方法将会返回一个ConfigurableApplicationContext类型对象,通过查看官方文档可以看到,ConfigurableApplicationContext接口类中定义了一个close()方法,可以用来关闭当前应用的上下文:

  1. package org.springframework.context;
  2. import java.io.Closeable;
  3. import org.springframework.beans.BeansException;
  4. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
  5. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
  6. import org.springframework.core.env.ConfigurableEnvironment;
  7. import org.springframework.core.io.ProtocolResolver;
  8. import org.springframework.lang.Nullable;
  9. public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
  10. void close();
  11. }

继续看官方源码,AbstractApplicationContext类中实现close()方法,下面是实现类中的方法摘要:

  1. public void close() {
  2. Object var1 = this.startupShutdownMonitor;
  3. synchronized(this.startupShutdownMonitor) {
  4. this.doClose();
  5. if (this.shutdownHook != null) {
  6. try {
  7. Runtime.getRuntime().removeShutdownHook(this.shutdownHook);
  8. } catch (IllegalStateException var4) {
  9. ;
  10. }
  11. }
  12. }
  13. }

#close()方法将会调用#doClose()方法,我们再来看看#doClose()方法做了哪些操作,下面是doClose()方法的摘要:

  1. protected void doClose() {
  2. if (this.active.get() && this.closed.compareAndSet(false, true)) {
  3. ...
  4. LiveBeansView.unregisterApplicationContext(this);
  5. ...
  6. this.destroyBeans();
  7. this.closeBeanFactory();
  8. this.onClose();
  9. if (this.earlyApplicationListeners != null) {
  10. this.applicationListeners.clear();
  11. this.applicationListeners.addAll(this.earlyApplicationListeners);
  12. }
  13. this.active.set(false);
  14. }
  15. }

#doClose()方法中,首先将应用上下文从注册表中清除掉,然后是销毁Bean工厂中的Beans,紧接着关闭Bean工厂。

官方文档看到这里,就产生了解决一个结局重启应用应用程序的大胆猜想。在应用程序的main()方法中,我们可以使用一个临时变量来存放SpringApplication.run()返回的ConfigurableApplicationContext对象,当我们完成对Spring Boot应用程序中属性的设置后,调用ConfigurableApplicationContext#close()方法,最后再调用SpringApplication.run()方法重新给ConfigurableApplicationContext对象进行赋值已达到重启的效果。

现在,我们再来看一下SpringApplication.run()方法中是如何重新创建ConfigurableApplicationContext对象的。在SpringApplication类中,run()方法会调用createApplicationContext()方法来创建一个ApplicationContext对象:

  1. protected ConfigurableApplicationContext createApplicationContext() {
  2. Class<?> contextClass = this.applicationContextClass;
  3. if (contextClass == null) {
  4. try {
  5. switch(this.webApplicationType) {
  6. case SERVLET:
  7. contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
  8. break;
  9. case REACTIVE:
  10. contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
  11. break;
  12. default:
  13. contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
  14. }
  15. } catch (ClassNotFoundException var3) {
  16. throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
  17. }
  18. }
  19. return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
  20. }

createApplicationContext()方法会根据WebApplicationType类型来创建ApplicationContext对象。在WebApplicationType中定义了三种种类型:NONESERVLETREACTIVE。通常情况下,将会创建servlet类型的ApplicationContext对象。

接下来,我将以一个简单的Spring Boot工程来验证上述的猜想是否能够达到重启Spring Boot应用程序的需求。

编码实现

首先,在application.properties文件中加入如下的配置信息,为动态修改配置信息提供数据:

  1. spring.application.name= SPRING-BOOT-APPLICATION

接下来,在Spring Boot主类中定义两个私有变量,用于存放main()方法的参数和SpringApplication.run()方法返回的值。下面的代码给出了主类的示例:

  1. public class ExampleRestartApplication {
  2. @Value ( "${spring.application.name}" )
  3. String appName;
  4. private static Logger logger = LoggerFactory.getLogger ( ExampleRestartApplication.class );
  5. private static String[] args;
  6. private static ConfigurableApplicationContext context;
  7. public static void main(String[] args) {
  8. ExampleRestartApplication.args = args;
  9. ExampleRestartApplication.context = SpringApplication.run(ExampleRestartApplication.class, args);
  10. }
  11. }

最后,直接在主类中定义用于刷新并重启Spring Boot应用程序的端点(Endpoint),并使用@RestController注解对主类进行注释。

  1. @GetMapping("/refresh")
  2. public String restart(){
  3. logger.info ( "spring.application.name:"+appName);
  4. try {
  5. PropUtil.init ().write ( "spring.application.name","SPRING-DYNAMIC-SERVER" );
  6. } catch (IOException e) {
  7. e.printStackTrace ( );
  8. }
  9. ExecutorService threadPool = new ThreadPoolExecutor (1,1,0, TimeUnit.SECONDS,new ArrayBlockingQueue<> ( 1 ),new ThreadPoolExecutor.DiscardOldestPolicy ());
  10. threadPool.execute (()->{
  11. context.close ();
  12. context = SpringApplication.run ( ExampleRestartApplication.class,args );
  13. } );
  14. threadPool.shutdown ();
  15. return "spring.application.name:"+appName;
  16. }

说明:为了能够重新启动Spring Boot应用程序,需要将close()和run()方法放在一个独立的线程中执行。

为了验证Spring Boot应用程序在被修改重启有相关的属性有没有生效,再添加一个获取属性信息的端点,返回配置属性的信息。

  1. @GetMapping("/info")
  2. public String info(){
  3. logger.info ( "spring.application.name:"+appName);
  4. return appName;
  5. }

完整的代码

下面给出了主类的全部代码:

  1. package com.ramostear.application;
  2. import org.slf4j.Logger;
  3. import org.slf4j.LoggerFactory;
  4. import org.springframework.beans.factory.annotation.Value;
  5. import org.springframework.boot.SpringApplication;
  6. import org.springframework.boot.autoconfigure.SpringBootApplication;
  7. import org.springframework.context.ConfigurableApplicationContext;
  8. import org.springframework.web.bind.annotation.GetMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10. import java.io.IOException;
  11. import java.util.concurrent.*;
  12. /**
  13. * @author ramostear
  14. */
  15. @SpringBootApplication
  16. @RestController
  17. public class ExampleRestartApplication {
  18. @Value ( "${spring.application.name}" )
  19. String appName;
  20. private static Logger logger = LoggerFactory.getLogger ( ExampleRestartApplication.class );
  21. private static String[] args;
  22. private static ConfigurableApplicationContext context;
  23. public static void main(String[] args) {
  24. ExampleRestartApplication.args = args;
  25. ExampleRestartApplication.context = SpringApplication.run(ExampleRestartApplication.class, args);
  26. }
  27. @GetMapping("/refresh")
  28. public String restart(){
  29. logger.info ( "spring.application.name:"+appName);
  30. try {
  31. PropUtil.init ().write ( "spring.application.name","SPRING-DYNAMIC-SERVER" );
  32. } catch (IOException e) {
  33. e.printStackTrace ( );
  34. }
  35. ExecutorService threadPool = new ThreadPoolExecutor (1,1,0, TimeUnit.SECONDS,new ArrayBlockingQueue<> ( 1 ),new ThreadPoolExecutor.DiscardOldestPolicy ());
  36. threadPool.execute (()->{
  37. context.close ();
  38. context = SpringApplication.run ( ExampleRestartApplication.class,args );
  39. } );
  40. threadPool.shutdown ();
  41. return "spring.application.name:"+appName;
  42. }
  43. @GetMapping("/info")
  44. public String info(){
  45. logger.info ( "spring.application.name:"+appName);
  46. return appName;
  47. }
  48. }

接下来,运行Spring Boot程序,下面是应用程序启动成功后控制台输出的日志信息:

  1. [2019-03-12T19:05:53.053z][org.springframework.scheduling.concurrent.ExecutorConfigurationSupport][main][171][INFO ] Initializing ExecutorService 'applicationTaskExecutor'
  2. [2019-03-12T19:05:53.053z][org.apache.juli.logging.DirectJDKLog][main][173][INFO ] Starting ProtocolHandler ["http-nio-8080"]
  3. [2019-03-12T19:05:53.053z][org.springframework.boot.web.embedded.tomcat.TomcatWebServer][main][204][INFO ] Tomcat started on port(s): 8080 (http) with context path ''
  4. [2019-03-12T19:05:53.053z][org.springframework.boot.StartupInfoLogger][main][59][INFO ] Started ExampleRestartApplication in 1.587 seconds (JVM running for 2.058)

在测试修改系统配置并重启之前,使用Postman测试工具访问:http://localhost:8080/info ,查看一下返回的信息:

成功返回SPRING-BOOT-APPLICATION提示信息。

然后,访问:http://localhost:8080/refresh ,设置应用应用程序spring.application.name的值为SPRING-DYNAMIC-SERVER,观察控制台输出的日志信息:

可以看到,Spring Boot应用程序已经重新启动成功,最后,在此访问:http://localhost:8080/info ,验证之前的修改是否生效:

请求成功返回了SPRING-DYNAMIC-SERVER信息,最后在看一眼application.properties文件中的配置信息是否真的被修改了:

配置文件的属性也被成功的修改,证明之前的猜想验证成功了。

本次内容所描述的方法不适用于以JAR文件启动的Spring Boot应用程序,以WAR包的方式启动应用程序亲测可用。┏ (^ω^)=☞目前该药方副作用未知,如有大牛路过,还望留步指点迷津,不胜感激。

结束语

本次内容记录了自己验证HTTP请求重启Spring Boot应用程序试验的一次经历,文章中所涉及到的内容仅代表个人的一些观点和不成熟的想法,并未将此方法应用到实际的项目中去,如因引用本次内容中的方法应用到实际生产开发工作中所带来的风险,需引用者自行承担因风险带来的后遗症(๑→ܫ←)——此药方还有待商榷(O_o)(o_O)。

作者:谭朝红
原文:如何在生产环境中重启Spring Boot应用?