Shulou(Shulou.com)06/02 Report--

This article mainly introduces the ways in which the Spring Boot application executes the code in the startup phase. It is very detailed and has a certain reference value. Friends who are interested must read it!

Spring Boot provides at least five ways to execute code when the application starts. How should we choose? This article will explain and analyze these different ways step by step.

CommandLineRunner

CommandLineRunner is an interface, and by implementing it, we can execute some code snippets after the Spring application starts successfully

@ Slf4j @ Component @ Order (2) public class MyCommandLineRunner implements CommandLineRunner {@ Override public void run (String... Args) throws Exception {log.info ("MyCommandLineRunner order is 2"); if (args.length > 0) {for (int I = 0; I)

< args.length; i++) { log.info("MyCommandLineRunner current parameter is: {}", args[i]); } } } } 当 Spring Boot 在应用上下文中找到 CommandLineRunner bean，它将会在应用成功启动之后调用 run() 方法，并传递用于启动应用程序的命令行参数 通过如下 maven 命令生成 jar 包: mvn clean package 通过终端命令启动应用，并传递参数: java -jar springboot-application-startup-0.0.1-SNAPSHOT.jar --foo=bar --name=rgyb 查看运行结果:

Here we can see several problems:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

The parameters passed in on the command line are not parsed, but just show the contents of the string we passed in-- foo=bar,--name=rgyb, which we can parse through ApplicationRunner, which we'll see later.

There is a throws Exception tag on the overridden run () method. Spring Boot will take CommandLineRunner as part of the application startup. If Exception is thrown when the run () method is run, the application will terminate the startup.

We have added @ Order (2) annotations to the class, and when there is more than one CommandLineRunner, it will be sorted from small to large according to the numbers in the @ Order annotation (numbers can also be plural, of course).

Don't use @ Order too much.

When we see the "cool techs" of order, we will find it very convenient to execute the startup logic in a specified order, but if you write it this way, it shows that multiple code fragments are interdependent. In order to make our code easier to maintain, we should reduce this dependency.

Summary

If we just want to simply get command-line arguments separated by spaces, then MyCommandLineRunner is sufficient

ApplicationRunner

As mentioned above, through the command line to start and pass parameters, MyCommandLineRunner can not parse parameters, if you want to parse parameters, then we need to use the ApplicationRunner parameter

Component @ Slf4j @ Order (1) public class MyApplicationRunner implements ApplicationRunner {@ Override public void run (ApplicationArguments args) throws Exception {log.info ("MyApplicationRunner order is 1"); log.info ("MyApplicationRunner Current parameter is {}:", args.getOptionValues ("foo"));}}

Re-type the jar package and run the following command:

Java-jar springboot-application-startup-0.0.1-SNAPSHOT.jar-- foo=bar,rgyb

The running results are as follows:

Here we can see:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Similar to MyCommandLineRunner, but ApplicationRunner can parse command-line arguments through the ApplicationArguments object of the run method, and each parameter can have multiple values in it, because the getOptionValues method returns an array of List

two。 There is a throws Exception tag on the overridden run () method. Spring Boot will take CommandLineRunner as part of the application startup. If Exception is thrown when the run () method is run, the application will terminate the startup.

3. ApplicationRunner can also be sorted using the @ Order annotation. From the startup result, it shares the order of order with CommandLineRunner. Later, we use the source code to verify this conclusion.

Summary

If we want to get complex command-line arguments, we can use ApplicationRunner

ApplicationListener

If we do not need to get command line arguments, we can bind the startup logic to the ApplicationReadyEvent of Spring

Slf4j @ Component @ Order (0) public class MyApplicationListener implements ApplicationListener {@ Override public void onApplicationEvent (ApplicationReadyEvent applicationReadyEvent) {log.info ("MyApplicationListener is started up");}}

Run the program to view the results:

Here we can see:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

ApplicationReadyEvent is triggered only after the application is ready, or even the above Listener will not be triggered until all the solutions mentioned in this article have been implemented. Please see the final conclusion later.

I marked it with Order (0) in the code, and obviously ApplicationListener can also be sorted with this annotation, sorted by number size, and should be executed first. However, this order is only used for sorting between ApplicationListener of the same type and is not shared with the sorting of ApplicationRunners and CommandLineRunners mentioned earlier.

Summary

If we don't need to get command-line arguments, we can create some global startup logic through ApplicationListener, and we can also get configuration properties environment variable parameters supported by Spring Boot through it

If you have read my previous Spring Bean Life cycle Trilogy:

The Origin of Spring Bean Lifecycle

The fate of the life cycle of Spring Bean

What on earth is Spring Aware?

Then you will be very familiar with the following two ways

@ PostConstruct

Another simple solution to creating startup logic is to provide an initialization method that is called by Spring during bean creation. All we have to do is add the @ PostConstruct annotation to the method:

Component @ Slf4j @ DependsOn ("myApplicationListener") public class MyPostConstructBean {@ PostConstruct public void testPostConstruct () {log.info ("MyPostConstructBean");}}

View the running results:

As can be seen from the running results above:

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

Immediately after Spring creates the bean (before starting it), the method of the @ PostConstruct annotation tag is called, so we cannot freely sort it using the @ Order annotation, because it may depend on other Spring bean that @ Autowired inserts into our bean.

two。 Instead, it will be called after all the bean that depends on it has been initialized, and if you want to add artificial dependencies and create a sort from it, you can use the @ DependsOn annotation (although it can be sorted, it is not recommended for the same reason as @ Order)

Summary

The @ PostConstruct method is inherently bound to an existing Spring bean, so it should only be used for the initialization logic of this single bean

InitializingBean

Very similar to the @ PostConstruct solution, we can implement the InitializingBean interface and have Spring call some initialization method:

@ Component @ Slf4j public class MyInitializingBean implements InitializingBean {@ Override public void afterPropertiesSet () throws Exception {log.info ("MyInitializingBean.afterPropertiesSet ()");}}

View the running results:

From the above running result, we get the same effect as @ PostConstruct, but there is a difference between the two.

The difference between @ PostConstruct and afterPropertiesSet

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

AfterPropertiesSet, as the name implies, "after property setting", when the method is called, all the properties of the bean have been populated with Spring. If we use @ Autowired on some attributes (regular operations should use constructor injection), Spring will inject bean into those attributes before calling afterPropertiesSet. But @ PostConstruct does not have these attribute fill restrictions

two。 So the InitializingBean.afterPropertiesSet solution is more secure than using @ PostConstruct, because if we rely on @ Autowired fields that have not been automatically injected, the @ PostConstruct method may encounter NullPointerExceptions.

Summary

If we use constructor injection, both solutions are equivalent

Source code analysis

Please open your IDE (key code has been marked and commented):

When were MyCommandLineRunner and ApplicationRunner called?

Open the SpringApplication.java class, which contains the callRunners method

Private void callRunners (ApplicationContext context, ApplicationArguments args) {List runners = new ArrayList (); / / get bean runners.addAll of type ApplicationRunner (context.getBeansOfType (ApplicationRunner.class). Values ()) from context; / / get bean runners.addAll of type CommandLineRunner (context.getBeansOfType (CommandLineRunner.class). Values ()) from context / / sort the two, which is why the order of the two can be shared AnnotationAwareOrderComparator.sort (runners); / / call for (Object runner: new LinkedHashSet (runners)) {if (runner instanceof ApplicationRunner) {callRunner ((ApplicationRunner) runner, args) } if (runner instanceof CommandLineRunner) {callRunner ((CommandLineRunner) runner, args);}

It is strongly recommended to take a complete look at all the code of SpringApplication.java. The process and principle of Spring Boot startup can find some answers from this class.

Summary

Finally, draw a picture to summarize these methods (please see the original text for a high-definition picture: https://dayarch.top/p/spring-...)

Soul questioning

Hongmeng official Strategic Cooperation to build HarmonyOS Technology Community

As a result of the above program, the afterPropertiesSet method calls precede the @ PostConstruct method, but this is the opposite of the order in which we called the Spring Bean lifecycle. Do you know why?

MyPostConstructBean relies on MyApplicationListener through @ DependsOn ("myApplicationListener"), so why does the call result in the former versus the latter?

Why not recommend @ Autowired formal dependency injection

When writing the Spring Bean lifecycle, a friend asked me questions related to it, and they obviously have some ambiguity in the concept, so a careful understanding of the above questions will help you deepen your understanding of the Spring Bean lifecycle.

The above is all the contents of the article "how do Spring Boot applications execute code in the startup phase?" Thank you for reading! Hope to share the content to help you, more related knowledge, welcome to follow the industry information channel!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.