本文主要來自：https://blog.csdn.net/zongzhankui/article/details/78681942
前言：
Spring Boot如何解決項目啓動時初始化資源，在我們實際工作中，總會遇到這樣需求，在項目啓動的時候需要做一些初始化的操作，比如初始化線程池，提前加載好加密證書等。
爲了達到這個目的，我們需要使用CommandLineRunner或ApplicationRunner接口創建bean，spring boot會自動監測到它們。這兩個接口都有一個run()方法，在實現接口時需要覆蓋該方法，並使用@Component註解使其成爲bean。
CommandLineRunner和ApplicationRunner的作用是相同的。不同之處在於CommandLineRunner接口的run()方法接收String數組作爲參數，即是最原始的參數，沒有做任何處理；而ApplicationRunner接口的run()方法接收ApplicationArguments對象作爲參數，是對原始參數做了進一步的封裝。
當程序啓動時，我們傳給main()方法的參數可以被實現CommandLineRunner和ApplicationRunner接口的類的run()方法訪問，即可接收啓動服務時傳過來的參數。我們可以創建多個實現CommandLineRunner和ApplicationRunner接口的類。爲了使他們按一定順序執行，可以使用@Order註解或實現Ordered接口。
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(String... args)
參數爲String數組。
CommandLineRunnerBean.java：
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);
@Override
public void run(String... args) {
String strArgs = Arrays.stream(args).collect(Collectors.joining("|"));
logger.info("Application started with arguments:" + strArgs);
}
}
MyApplication.java：
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());
}
}
我們也可以創建一個service。一旦Spring boot啓動完成service就會執行。這意味着SpringApplication.run()執行完成後service的方法就會執行。
HelloService.java：
import org.springframework.stereotype.Service;
@Service
public class HelloService {
public String getMessage(){
return "Hello World!";
}
}
現在使用帶有參數的可執行jar運行程序。spring-boot-demo-0.0.1-SNAPSHOT.jar爲生成的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：
run(ApplicationArguments args)
可以看到，CommandLineRunner.run()接收String數組作爲參數，而ApplicationRunner.run()接收ApplicationArguments作爲參數。這些參數是啓動spring boot程序時傳給main()方法的。
ApplicationRunnerBean.java：
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!
ApplicationArguments是對參數（main方法）做了進一步的處理，可以解析–name=value的，我們就可以通過name來獲取value（而CommandLineRunner只是獲取–name=value），可以接收–foo=bar這樣的參數。
–getOptionNames()方法可以得到foo這樣的key的集合。
–getOptionValues(String name)方法可以得到bar這樣的集合的value。
看一個demo：
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;
import java.util.Arrays;
@Component
public class MyApplicationRunner implements ApplicationRunner{
@Override
public void run(ApplicationArguments args) throws Exception {
System.out.println("===MyApplicationRunner==="+ Arrays.asList(args.getSourceArgs()));
System.out.println("===getOptionNames========"+args.getOptionNames());
System.out.println("===getOptionValues======="+args.getOptionValues("foo"));
System.out.println("==getOptionValues========"+args.getOptionValues("developer.name"));
}
}
配置參數啓動：
運行結果：
===MyApplicationRunner===[--foo=bar, --developer.name=xiao.qiang]
===getOptionNames========[foo, developer.name]
===getOptionValues=======[bar]
==getOptionValues========[xiao.qiang]
CommandLineRunner和ApplicationRunner的執行順序：
在spring boot程序中，我們可以使用不止一個實現CommandLineRunner和ApplicationRunner的bean。爲了有序執行這些bean的run()方法，可以使用@Order註解或Ordered接口。例子中我們創建了兩個實現CommandLineRunner接口的bean和兩個實現ApplicationRunner接口的bean。我們使用@Order註解按順序執行這四個bean。
CommandLineRunnerBean1.java
@Component
@Order(1)
public class CommandLineRunnerBean1 implements CommandLineRunner {
@Override
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 {
@Override
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