[Spring Boot] 2. Spring Boot 启动过程定制化
Posted dm_vincent
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[Spring Boot] 2. Spring Boot 启动过程定制化相关的知识,希望对你有一定的参考价值。
在上一篇文章中,从源码角度介绍了Spring Boot的启动过程。启动的代码虽然只有短短的一行,但是背后所做的工作还真不少,其中有一些可以定制化的部分,主要分为以下几个方面:
- 初始化器(Initializer)
- 监听器(Listener)
- 容器刷新后置Runners(ApplicationRunner或者CommandLineRunner接口的实现类)
- 启动期间在Console打印Banner的具体实现类
本文就来看看如何定制上述几个方面。
初始化器(Initializer)
使用现状
在添加一个定制的初始化器之前,还是先来回顾一下初始化器在Spring Boot启动过程中是如何被使用的:
- 定义:默认的初始化器全部都是定义在每个jar包下的META-INF/spring.factories配置文件中,Key为org.springframework.context.ApplicationContextInitializer
- 添加:在实例化SpringApplication的时候,会读取定义并进行实例化,保存到SpringApplication实例的initializers成员变量中。
- 执行:在刷新容器前置动作的applyInitializers方法中会遍历执行所有初始化器。
添加定制化的初始化器
一个直观的添加方法
可以在实例化SpringApplication,执行其run方法之前,添加定制的初始化器:
public static void main(String[] args)
// 创建SpringApplication的实例
SpringApplication app = new SpringApplication(Application.class);
// 添加定制的初始化器
app.addInitializers(new CustomApplicationContextInitializer());
// 执行SpringApplication实例的run方法
app.run(args);
在定制的初始化器中,打印一条日志:
public class CustomApplicationContextInitializer implements ApplicationContextInitializer
private static final Logger LOGGER = LoggerFactory.getLogger(CustomApplicationContextInitializer.class);
@Override
public void initialize(ConfigurableApplicationContext applicationContext)
LOGGER.info("自定义的初始化器的initialize方法被执行了");
更符合Spring Boot Style的添加方法
前面已经讨论过,Spring Boot是通过读取META-INF/spring.factories配置文件中Key为org.springframework.context.ApplicationContextInitializer的内容来依次加载初始化器的,因此我们也可以创建一个配置文件用来定义需要添加的初始化器:
org.springframework.context.ApplicationContextInitializer=com.example.demo.CustomApplicationContextInitializer
执行入口类,可以看到打印完了Banner后,马上就会输出上面的日志内容。
监听器(Listener)
使用现状
同样地,先回顾一下监听器在Spring Boot启动过程中是如何被使用的:
- 定义:默认的初始化器全部都是定义在每个jar包下的META-INF/spring.factories配置文件中,Key为org.springframework.context.ApplicationContextInitializer
- 添加:在实例化SpringApplication的时候,会读取定义并进行实例化,保存到SpringApplication实例的listeners成员变量中。
- 执行:在容器启动过程中会通过SpringApplicationRunListener发布事件,然后相应的监听器就会被执行。
自定义监听器
下面我们来自定义一个监听器,处理感兴趣的事件类型:
public class CustomApplicationListener implements ApplicationListener
private static final Logger LOGGER = LoggerFactory.getLogger(CustomApplicationListener.class);
public void onApplicationEvent(ApplicationEvent event)
// 监听ApplicationStartingEvent
if (event instanceof ApplicationStartedEvent)
logInfo("ApplicationStartedEvent listened");
// 监听ApplicationEnvironmentPreparedEvent
else if (event instanceof ApplicationEnvironmentPreparedEvent)
logInfo("ApplicationEnvironmentPreparedEvent listened");
// 监听ApplicationPreparedEvent
else if (event instanceof ApplicationPreparedEvent)
logInfo("ApplicationPreparedEvent listened");
// 监听ApplicationReadyEvent
else if (event instanceof ApplicationReadyEvent)
logInfo("ApplicationReadyEvent listened");
// 监听ApplicationFailedEvent
else if (event instanceof ApplicationFailedEvent)
logInfo("ApplicationFailedEvent listened");
private void logInfo(String log)
if (LOGGER.isInfoEnabled())
LOGGER.info(log);
为什么选择监听这几个事件,而不是其它的。主要是因为这几个事件都是由Spring Boot定义的:
以上监听的部分事件在容器启动过程中,会由SpringApplicationRunListener的默认实现EventPublishingRunListener完成事件的派发(关于此部分的详情可以参考前面的一篇文章)。
有了实现类,同样还是需要将它定义到spring.factories中:
# Application Listeners
org.springframework.context.ApplicationListener=\\
com.example.demo.CustomApplicationListener
启动后,可以看到控制台中输出了相关信息(只摘录了相关行):
2017-08-07 23:40:36.705 INFO 40733 --- [ main] c.e.demo.CustomApplicationListener : ApplicationEnvironmentPreparedEvent listened
. ____ _ __ _ _
/\\\\ / ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.5.6.RELEASE)
2017-08-07 23:40:41.858 INFO 40733 --- [ main] c.e.demo.CustomApplicationListener : ApplicationPreparedEvent listened
2017-08-07 23:40:43.109 INFO 40733 --- [ main] c.e.demo.CustomApplicationListener : ApplicationReadyEvent listened
可以看到,监听的三个事件得到了响应:
- ApplicationEnvironmentPreparedEvent
- ApplicationPreparedEvent
- ApplicationReadyEvent
没有得到响应的有两个事件:
- ApplicationStartedEvent
- ApplicationFailedEvent
我们来看看负责事件中转的EventPublishingRunListener,看能够得到一些线索:
- ApplicationStartedEvent
public void starting()
this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));
上述方法确实会派发一个ApplicationStartedEvent事件,但是没有打印出来日志。是因为在尝试打印这条日志的时候LOGGER.isInfoEnabled()调用返回的是false,因此阻止了日志的输出。
这是因为日志系统初始化也是基于事件机制的,监听到ApplicationStartedEvent事件的时候日志对象还没有完成初始化,直到监听到ApplicationEnvironmentPreparedEvent后才会初始化。所以即使我们监听到了ApplicationStartedEvent事件,也没法打印相应日志。如果将LOGGER的输出改成System.out.println,就没有问题了。
- ApplicationFailedEvent
private SpringApplicationEvent getFinishedEvent( ConfigurableApplicationContext context, Throwable exception)
if (exception != null)
return new ApplicationFailedEvent(this.application, this.args, context,
exception);
return new ApplicationReadyEvent(this.application, this.args, context);
可以发现,只有当启动过程中有异常时,才会创建一个ApplicationFailedEvent事件对象。否则创建的是ApplicationReadyEvent。因此,如果想要人为地构造这条日志,可以再启动过程中抛出一个异常,比如就在自定义的初始化器中:
public void initialize(ConfigurableApplicationContext configurableApplicationContext)
if (LOGGER.isInfoEnabled())
LOGGER.info("自定义的初始化器的initialize方法被执行了");
throw new RuntimeException("人为创造的运行时异常");
然后再次启动,就可以看到这条日志被输出了,同时异常堆栈也会被打印出来。
容器刷新后置Runners
Runner的实现分为两种,可以选择下面的接口之一进行实现:
- org.springframework.boot.ApplicationRunner
- org.springframework.boot.CommandLineRunner
它们没有什么本质的区别,除了方法接受的类型不太一样。
Runners的执行时机
这里先回顾一下Runners的执行时机,在容器刷新的后置处理中会找到所有的Runners并依次运行:
protected void afterRefresh(ConfigurableApplicationContext context,
ApplicationArguments args)
callRunners(context, args);
ApplicationRunner自定义实现
@Component
@Order(2)
public class CustomApplicationRunner implements ApplicationRunner
private static final Logger LOGGER = LoggerFactory.getLogger(CustomApplicationRunner.class);
@Override
public void run(ApplicationArguments arg)
if (LOGGER.isInfoEnabled())
LOGGER.info("自定义ApplicationRunner运行了");
CommandLineRunner自定义实现
@Component
@Order(1)
public class CustomCommandLineRunner implements CommandLineRunner
private static final Logger LOGGER = LoggerFactory.getLogger(CustomCommandLineRunner.class);
@Override
public void run(String... strings) throws Exception
if (LOGGER.isInfoEnabled())
LOGGER.info("自定义CommandLineRunner运行了");
自定义Runner的添加方式和上述的初始化器以及监听器有点不同,就是Runners直接通过@Component注解添加即可,借助于包扫描机制,它们会被注册到容器中。至于它们运行的顺序,则可以通过上述的@Order注解来完成标注,数值越小的Runner优先级越高,因此上面代码中,CustomCommandLineRunner将先于CustomApplicationRunner被执行。
启动打印Banner
最后,来看看如何定制Banner,默认的Banner Printer会打印出来Spring Boot的ASCII艺术字:
. ____ _ __ _ _
/\\\\ / ___'_ __ _ _(_)_ __ __ _ \\ \\ \\ \\
( ( )\\___ | '_ | '_| | '_ \\/ _` | \\ \\ \\ \\
\\\\/ ___)| |_)| | | | | || (_| | ) ) ) )
' |____| .__|_| |_|_| |_\\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot :: (v1.5.6.RELEASE)
我们完全根据需求来打印一个更酷炫的图案,作为Gundam爱好者,如果又恰好是做一个相关项目的话,我会选择这样的图案:
扩展的方式也很简单,将需要输出的内容放到resources目录下的banner.txt文件中即可。
当然,这只是最简单的一种扩展方式,如果需要看看还支持什么扩展方式,看看源代码就清楚了:
private Banner printBanner(ConfigurableEnvironment environment)
if (this.bannerMode == Banner.Mode.OFF)
return null;
ResourceLoader resourceLoader = this.resourceLoader != null ? this.resourceLoader
: new DefaultResourceLoader(getClassLoader());
SpringApplicationBannerPrinter bannerPrinter = new SpringApplicationBannerPrinter(
resourceLoader, this.banner);
if (this.bannerMode == Mode.LOG)
return bannerPrinter.print(environment, this.mainApplicationClass, logger);
return bannerPrinter.print(environment, this.mainApplicationClass, System.out);
因此Banner的输出模式也有好几种:
- OFF
- CONSOLE(默认) - 此时对应的输出即为System.out
- LOG
然后,Banner的输出方式也有Image和Text,我们现在使用的是Text的方式。至于使用Image和Text的高级用法,这里就不展开了,有兴趣的话可以去看看官方文档或者深挖一些相关代码即可。
总结
至此,Spring Boot启动过程的定制化就讨论结束了,在本文中,从四个方面介绍了如何定制Spring Boot的启动过程:
- 初始化器(Initializer)
- 监听器(Listener)
- 容器刷新后置Runners(ApplicationRunner或者CommandLineRunner接口的实现类)
- 启动期间在Console打印Banner的具体实现类
希望能够给大家带来一些帮助和启迪。
创作挑战赛 新人创作奖励来咯,坚持创作打卡瓜分现金大奖以上是关于[Spring Boot] 2. Spring Boot 启动过程定制化的主要内容,如果未能解决你的问题,请参考以下文章