文章目录

• 写在前面
• 一、直接在启动类中写逻辑
• • 一般主启动类
  • 改良后的主启动类
  • 总结
• 二、使用ApplicationRunner或CommandLineRunner
• • 使用CommandLineRunner
  • 使用ApplicationRunner
  • 设置执行顺序
  • 原理分析
  • 总结
• 三、使用@PostConstruct 注解
• • 使用@PostConstruct
  • 分析
• 四、使用ApplicationContextInitializer
• 五、（重点）使用SpringApplicationRunListener
• • 使用SpringApplicationRunListener
  • SpringApplicationRunListener原理
• 六、（重点）使用ApplicationListener
• • 使用ApplicationListener
  • ApplicationListener原理

写在前面

使用Springboot开发时，想要项目启动完成后立马初始化某些数据或者方法，需要怎么做呢？

或者说，我想在springboot启动的任意一个时间节点，想插入一段自己的方法，需要怎么做呢？

在这之前，我们应该了解一下Springboot启动的整个过程和Spring容器启动的整个过程：

springboot启动流程，手把手打断点一步步看运行步骤
spring系列-注解驱动原理及源码-spring容器创建流程

一、直接在启动类中写逻辑

直接在主启动类中写逻辑是最简单的方式，可以在springboot启动前、启动后写一些自己的业务逻辑，或者说设置某些参数。

一般主启动类

我们平常的主启动类一般都是这样写的：

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

改良后的主启动类

@SpringBootApplication
public class DemoApplication {public static void main(String[] args) {SpringApplication springApplication = new SpringApplication(DemoApplication.class);// TODO springboot启动之前执行某些逻辑，或者使用springApplication初始化某些参数ConfigurableApplicationContext run = springApplication.run(args);// TODO springboot启动之后执行某些逻辑，可以使用ConfigurableApplicationContext获取运行时上下文以及运行环境}}

其中，springApplication有许多方法：

而springboot启动后的返回值，也有很多方法：

总结

使用springboot的主启动类，启动前、启动后的参数，可以为所欲为~

不过，这种方式总归并不是很优雅，启动类做的事有点多了~或许有更好的方式来实现springboot启动前我想做的事、启动后我想做的事，

二、使用ApplicationRunner或CommandLineRunner

如果在SpringApplication启动后需要运行一些特定的代码，可以实现ApplicationRunner或CommandLineRunner接口。这两个接口的工作方式相同，都提供了一个run方法，这个方法在SpringApplication.run(…)完成之前被调用。

该方式非常适合于应该在应用程序启动之后但在它开始接受流量之前运行的任务。

使用CommandLineRunner

CommandLineRunner是个接口，有一个run()方法。为了使用CommandLineRunner我们需要创建一个类实现该接口并覆盖run()方法。使用@Component注解实现类。当SpringApplication.run()启动spring boot程序时，启动完成之前，CommandLineRunner.run()会被执行。CommandLineRunner的run()方法接收启动服务时传过来的参数。

CommandLineRunner接口的run()方法接收String数组作为参数。

import java.util.Arrays;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;@Component
public class CommandLineRunnerBean implements CommandLineRunner {private static final Logger logger = LoggerFactory.getLogger(CommandLineRunnerBean.class);  public void run(String... args) {// TODO 我们自己的业务逻辑String strArgs = Arrays.stream(args).collect(Collectors.joining("|"));logger.info("Application started with arguments:" + strArgs);}
} 

使用ApplicationRunner

ApplicationRunner和CommandLineRunner的作用相同。在SpringApplication.run()完成spring boot启动之前，ApplicationRunner的run()方法会被执行。

ApplicationRunner接口的run()方法接收ApplicationArguments对象作为参数。

import java.util.Arrays;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;@Component
public class ApplicationRunnerBean implements ApplicationRunner {private static final Logger logger = LoggerFactory.getLogger(ApplicationRunnerBean.class);  @Overridepublic void run(ApplicationArguments arg0) throws Exception {String strArgs = Arrays.stream(arg0.getSourceArgs()).collect(Collectors.joining("|"));logger.info("Application started with arguments:" + strArgs);}
} 

设置执行顺序

可以使用@Order注解或Ordered接口，来设置ApplicationRunner或CommandLineRunner的执行顺序。

@Component
public class CommandLineRunnerBean implements CommandLineRunner, Ordered {private static final Logger logger = LoggerFactory.getLogger(CommandLineRunnerBean.class);  public void run(String... args) {String strArgs = Arrays.stream(args).collect(Collectors.joining("|"));logger.info("Application started with arguments:" + strArgs);}/*** 数字越小优先级越高*/@Overridepublic int getOrder() {return 0;}
}

@Component
@Order(0) // 默认是最低优先级（数字为Integer.MAX_VALUE），数字越小优先级越高
public class CommandLineRunnerBean implements CommandLineRunner {private static final Logger logger = LoggerFactory.getLogger(CommandLineRunnerBean.class);  public void run(String... args) {String strArgs = Arrays.stream(args).collect(Collectors.joining("|"));logger.info("Application started with arguments:" + strArgs);}
} 

原理分析

1、在启动类SpringApplication的run方法中，我们一直找下去可以看到核心方法：

// org.springframework.boot.SpringApplication#run(java.lang.String...)
public ConfigurableApplicationContext run(String... args) {long startTime = System.nanoTime();DefaultBootstrapContext bootstrapContext = createBootstrapContext();ConfigurableApplicationContext context = null;configureHeadlessProperty();SpringApplicationRunListeners listeners = getRunListeners(args);listeners.starting(bootstrapContext, this.mainApplicationClass);try {ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);ConfigurableEnvironment environment = prepareEnvironment(listeners, bootstrapContext, applicationArguments);configureIgnoreBeanInfo(environment);Banner printedBanner = printBanner(environment);context = createApplicationContext();context.setApplicationStartup(this.applicationStartup);prepareContext(bootstrapContext, context, environment, listeners, applicationArguments, printedBanner);refreshContext(context);afterRefresh(context, applicationArguments);Duration timeTakenToStartup = Duration.ofNanos(System.nanoTime() - startTime);if (this.logStartupInfo) {new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), timeTakenToStartup);}listeners.started(context, timeTakenToStartup);callRunners(context, applicationArguments); // 关键！调用所有的Runner}catch (Throwable ex) {handleRunFailure(context, ex, listeners);throw new IllegalStateException(ex);}try {Duration timeTakenToReady = Duration.ofNanos(System.nanoTime() - startTime);listeners.ready(context, timeTakenToReady);}catch (Throwable ex) {handleRunFailure(context, ex, null);throw new IllegalStateException(ex);}return context;
}

2、callRunners方法

// org.springframework.boot.SpringApplication#callRunners
private void callRunners(ApplicationContext context, ApplicationArguments args) {List