This article brings you an introduction to CommandLineRunner and ApplicationRunner. It has certain reference value. Friends in need can refer to it. I hope it will be helpful to you.
CommandLineRunner and ApplicationRunner are interfaces provided by Spring Boot. They both have a run() method. All beans that implement them will be automatically called after the Spring Boot service is started.
Due to this feature, they are an ideal place to do some initialization work, or write some test code.
CommandLineRunner
Use Application to implement
After we create a new project, for simplicity, we directly use the Application class to implement the CommandLineRunner interface. Annotations for this class @SpringBootApplication will automatically configure it for us.
package cn.examplecode.sb2runner;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Sb2runnerApplication implements CommandLineRunner {
private static Logger logger = LoggerFactory.getLogger(Sb2runnerApplication.class);
public static void main(String[] args) {
SpringApplication.run(Sb2runnerApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
logger.info("服务已启动，执行command line runner。");
for (int i = 0; i <p>Next we start the service directly, check the log as follows, and find that the run() method is executed normally: </p><pre class="brush:php;toolbar:false">Tomcat started on port(s): 8080 (http) with context path ''
Started Sb2runnerApplication in 2.204 seconds (JVM running for 3.161)
服务已启动，执行command line runner。The run() method has Variable parameter args, this parameter is used to receive command line parameters. Let’s add parameters to test:
Then restart the service and observe the log, You can see that the parameters are received normally:
Tomcat started on port(s): 8080 (http) with context path '' Started Sb2runnerApplication in 1.888 seconds (JVM running for 2.41) 服务已启动，执行command line runner。 args[0]: --param=sth
Command line parameter transfer
We said before that a major advantage of using Spring Boot is that the project can be packaged directly into a jar package without the need to deploy it separately. After packaging into a jar package, you can directly execute the jar package to start the service. In this way, when executing the jar package, we can pass in the command line parameters and let CommandLineRunner receive the parameters.
This scenario is particularly common on servers. For example, if we want to perform an operation without exposing it to the outside world, we can use CommandLineRunner as the entry point for the operation.
Let’s create a jar package to demonstrate.
#You can see from the log that we also obtained the parameters normally. By passing parameters, we can perform different operations based on different parameters in business logic.
What we mentioned above is just one CommandLineRunner. What if we have multiple CommandLineRunner? How to control the order in which they are executed?
Now we will introduce how to specify the order of execution.
Spring Boot provides us with an annotation "@Order", which can be used to specify the order of execution. For example, there are three CommandLineRunners in our project:
@Component
@Order(1)
public class CommandRunner1 implements CommandLineRunner {
private static Logger logger = LoggerFactory.getLogger(CommandRunner1.class);
@Override
public void run(String... args) throws Exception {
logger.info("执行第一个command line runner...");
}
}
@Component
@Order(2)
public class CommandRunner2 implements CommandLineRunner {
private static Logger logger = LoggerFactory.getLogger(CommandRunner2.class);
@Override
public void run(String... args) throws Exception {
logger.info("执行第二个command line runner...");
}
}
@Component
@Order(3)
public class CommandRunner3 implements CommandLineRunner {
private static Logger logger = LoggerFactory.getLogger(CommandRunner3.class);
@Override
public void run(String... args) throws Exception {
logger.info("执行第三个command line runner...");
}
}We can directly add the @Order annotation to this class, and then Spring Boot will execute it in the order specified by our annotation from small to large. Pretty simple, isn't it?
Tomcat started on port(s): 8080 (http) with context path '' Started Sb2runnerApplication in 1.764 seconds (JVM running for 2.292) 执行第一个command line runner... 执行第二个command line runner... 执行第三个command line runner...
ApplicationRunner and CommandLineRunner do the same thing. Its run() method will be automatically called after the service is started. The only difference is that ApplicationRunner will encapsulate the command line parameters. , you can easily obtain command line parameters and parameter values.
@Component
public class ApplicationRunner1 implements ApplicationRunner {
private static Logger logger = LoggerFactory.getLogger(ApplicationRunner1.class);
@Override
public void run(ApplicationArguments args) throws Exception {
logger.info("执行application runner...");
logger.info("获取到参数: " + args.getOptionValues("param"));
}
}Execution results:
#We can find that the command line parameters can be easily obtained through the parameter ApplicationArguments of the run() method. value.
So if your project needs to obtain command line parameters, it is recommended that you use ApplicationRunner.
Summary
Whether it is CommandLineRunner or ApplicationRunner, their purpose is to perform some operations after the service is started. If you need to obtain command line parameters, it is recommended to use ApplicationRunner.
Another scenario is that we need to perform an operation on the server, such as modifying database user data, but cannot find a suitable execution entry, then this is their ideal usage scenario.
The above is the detailed content of Introduction to CommandLineRunner and ApplicationRunner. For more information, please follow other related articles on the PHP Chinese website!