在本文中，我们将提供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的例子。

使用的软件

在我们的例子中，我们使用了以下软件。

1. Java 8
2. Spring Boot 1.5.2.RELEASE
3. Maven 3.3
4. Eclipse Mars

Maven文件

找到我们例子中使用的maven文件。
pom.xml

<?xml version="1.0" encoding="UTF-8"?>
&ltproject 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">
	
	&ltmodelVersion&gt4.0.0</modelVersion>
	&ltgroupId&gtcom.concretepage</groupId>
	&ltartifactId&gtspring-boot-demo</artifactId>
	&ltversion&gt0.0.1-SNAPSHOT</version>
	&ltpackaging&gtjar</packaging>
	&ltname&gtspring-demo</name>
	&ltdescription&gtSpring Boot Demo Project</description>
	&ltparent>
		&ltgroupId&gtorg.springframework.boot</groupId>
		&ltartifactId&gtspring-boot-starter-parent</artifactId>
		&ltversion&gt1.5.2.RELEASE</version>
	</parent>
	&ltproperties>
		&ltjava.version&gt1.8</java.version>
	</properties>
	&ltdependencies>
	    &ltdependency>
		&ltgroupId&gtorg.springframework.boot</groupId>
		&ltartifactId&gtspring-boot-starter</artifactId>
	    </dependency>
	</dependencies> 
	&ltbuild>
	    &ltplugins>
		&ltplugin>
			&ltgroupId&gtorg.springframework.boot</groupId>
			&ltartifactId&gtspring-boot-maven-plugin</artifactId>
		</plugin>
	    </plugins>
	</build>
</project>

CommandLineRunner

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

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!

CommandLineRunner和ApplicationRunner的顺序

在我们的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