在本文中,我们将提供spring boot CommandLineRunner和ApplicationRunner的例子。在spring boot应用程序中,我们可以在spring boot完成其启动之前执行任何任务。要做到这一点,我们需要使用CommandLineRunner
或ApplicationRunner
接口创建spring bean,spring boot会自动检测它们。这两个接口都有run()
方法,需要在实现类中重载,并通过使用spring stereotype(如@Component
)使该类成为bean。CommandLineRunner
和ApplicationRunner
的区别在于,CommandLineRunner
的run()
方法接受String
的数组作为参数,ApplicationRunner
的run()
方法接受spring ApplicationArguments
作为参数。我们在启动spring boot时传递给main()
方法的参数,可以在CommandLineRunner
和ApplicationRunner
实现类的run()
方法中访问。我们可以创建一个以上的CommandLineRunner
和ApplicationRunner
实现类的bean。为了按顺序执行它们,我们使用spring @Order
注释或Ordered
接口。CommandLineRunner
和ApplicationRunner
的run()
方法在SpringApplication
完成启动之前被执行。启动完成后,应用程序开始运行。CommandLineRunner
和ApplicationRunner
的实用性在于,我们可以在应用程序开始运行之前启动任何调度程序或记录任何信息。现在让我们讨论一下如何在我们的应用程序中使用CommandLineRunner
和ApplicationRunner
的例子。
在我们的例子中,我们使用了以下软件。
找到我们例子中使用的maven文件。
pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.concretepage</groupId>
<artifactId>spring-boot-demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>spring-demo</name>
<description>Spring Boot Demo Project</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.2.RELEASE</version>
</parent>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
CommandLineRunner
是一个接口,它有一个方法是run( )
。为了使用CommandLineRunner
,我们将创建一个类,实现它并重写其run()
方法。现在用spring刻板印象注释这个类,如@Component
。当SpringApplication.run()
启动spring boot应用程序时,在完成启动之前,CommandLineRunner.run()
将被执行。CommandLineRunner
的run()
方法接受启动服务器时传递的参数。找到这个方法。
run(String... args)
我们得到的参数是String
的一个数组。现在找到这个例子。
CommandLineRunnerBean.java
package com.concretepage.bean;
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) {
String strArgs = Arrays.stream(args).collect(Collectors.joining("|"));
logger.info("Application started with arguments:" + strArgs);
}
}
MyApplication.java
package com.concretepage;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import com.concretepage.service.HelloService;
@SpringBootApplication
public class MyApplication {
private static final Logger logger = LoggerFactory.getLogger(MyApplication.class);
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(MyApplication.class, args);
HelloService service = context.getBean(HelloService.class);
logger.info(service.getMessage());
}
}
我们也在创建一个服务。服务将在spring boot完成启动后执行。这意味着我们的服务方法将在SpringApplication.run()
完成其执行后运行。找到我们例子中使用的服务。
HelloService.java
package com.concretepage.service;
import org.springframework.stereotype.Service;
@Service
public class HelloService {
public String getMessage(){
return "Hello World!";
}
}
现在使用带参数的可执行JAR来运行该应用程序。构建项目,假设我们得到的JAR名称为spring-boot-demo-0.0.1-SNAPSHOT.jar。
java -jar spring-boot-demo-0.0.1-SNAPSHOT.jar data1 data2 data3
输出结果将如下。
2017-03-19 13:38:38.909 INFO 1036 --- [ main] c.c.bean.CommandLineRunnerBean : Application started with arguments:data1|data2|data3
2017-03-19 13:38:38.914 INFO 1036 --- [ main] com.concretepage.MyApplication : Started MyApplication in 1.398 seconds (JVM running for 1.82)
2017-03-19 13:38:38.915 INFO 1036 --- [ main] com.concretepage.MyApplication : Hello World!
ApplicationRunner
的作用与CommandLineRunner
相同。run()
的ApplicationRunner
方法在SpringApplication.run()
完成spring boot启动之前被执行。找到ApplicationRunner
的run()
方法签名。
run(ApplicationArguments args)
我们将观察到,CommandLineRunner.run()
接受数组String
,ApplicationRunner.run()
接受ApplicationArguments
作为参数。这些参数是在启动spring boot应用程序时传递给main()
方法的那些参数。找到这个例子。
ApplicationRunnerBean.java
package com.concretepage.bean;
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);
@Override
public void run(ApplicationArguments arg0) throws Exception {
String strArgs = Arrays.stream(arg0.getSourceArgs()).collect(Collectors.joining("|"));
logger.info("Application started with arguments:" + strArgs);
}
}
创建可执行的JAR并运行,参数如下。
java -jar spring-boot-demo-0.0.1-SNAPSHOT.jar data1 data2 data3
输出结果将如下。
2017-03-19 16:26:06.952 INFO 5004 --- [ main] c.c.bean.ApplicationRunnerBean : Application started with arguments:data1|data2|data3
2017-03-19 16:26:06.956 INFO 5004 --- [ main] com.concretepage.MyApplication : Started MyApplication in 1.334 seconds (JVM running for 1.797)
2017-03-19 16:26:06.957 INFO 5004 --- [ main] com.concretepage.MyApplication : Hello World!
在我们的spring boot应用程序中,我们可以使用一个以上的bean来实现CommandLineRunner
和ApplicationRunner
。为了按顺序执行这些Bean的run()
方法,我们可以使用@Order
注解或Ordered
接口。在我们的例子中,我们已经创建了两个实现CommandLineRunner
接口的bean和两个实现ApplicationRunner
接口的bean。为了按顺序执行这四个Bean,我们使用了@Order
注解。找到这个例子。
CommandLineRunnerBean1.java
@Component
@Order(1)
public class CommandLineRunnerBean1 implements CommandLineRunner {
public void run(String... args) {
System.out.println("CommandLineRunnerBean 1");
}
}
ApplicationRunnerBean1.java
@Component
@Order(2)
public class ApplicationRunnerBean1 implements ApplicationRunner {
@Override
public void run(ApplicationArguments arg0) throws Exception {
System.out.println("ApplicationRunnerBean 1");
}
}
CommandLineRunnerBean2.java
@Component
@Order(3)
public class CommandLineRunnerBean2 implements CommandLineRunner {
public void run(String... args) {
System.out.println("CommandLineRunnerBean 2");
}
}
ApplicationRunnerBean2.java
@Component
@Order(4)
public class ApplicationRunnerBean2 implements ApplicationRunner {
@Override
public void run(ApplicationArguments arg0) throws Exception {
System.out.println("ApplicationRunnerBean 2");
}
}
当我们运行该应用程序时,我们将得到以下输出。
CommandLineRunnerBean 1
ApplicationRunnerBean 1
CommandLineRunnerBean 2
ApplicationRunnerBean 2
版权说明 : 本文为转载文章, 版权归原作者所有 版权申明
原文链接 : https://www.concretepage.com/spring-boot/spring-boot-commandlinerunner-and-applicationrunner-example
内容来源于网络,如有侵权,请联系作者删除!