Spring Boot 提供了一種統一的方式來管理應用的配置，允許開發人員使用屬性properties文件、YAML 文件、環境變量和命令行參數來定義優先級不同的配置值。零XML配置的Spring Boot Application，是基於Spring JavaConfig。
Spring放棄XML配置簡史
Spring IOC有一個非常核心的概念——Bean。由Spring容器來負責對Bean的實例化，裝配和管理。最早XML是用來描述Bean最為流行的配置方式。Spring可以從XML配置文件中讀取任何類型的元數據並自動轉換成相應的Java代碼。隨着Spring的日益發展，越來越多的人對Spring提出了批評。“Spring項目大量的爛用XML”就是最為嚴勵的一個批評。
由於Spring會把幾乎所有的業務類都以Bean的形式配置在XML文件中，造成了大量的XML文件。使用XML來配置Bean失去了編譯時的類型安全檢查。大量的XML配置使得整個項目變得更加復雜。我們使用XML配置的問題之一是要等到運行時的時候來發現Bean里面的錯誤或者其他愚蠢的問題。當然，在使用Spring的IDE插件（或者其他整合了Spring Tools Suite的工具）能在一定程度上發現這方面問題。
- Spring 2.5中我們開始有了面向注解的依賴注入編程（@Component和 @Autowired）。
- Spring 3.0中我們有了 JavaConfig , 它能夠取代 XML。Spring 3.1中又提供了@Enable* 系列的注解，使得基於注解的配置更加自動化。
- 在 Spring 4.0中@Conditional注解（org.springframework.context.annotation.Conditional）實現的基於條件的配置，根據應用的類路徑中的類、環境信息以及其他一些相關信息，在運行時自動化地完成配置，大量省去了程序員們大量樣板化的手工配置工作。
要進一步解決的問題
在有了上面的這些支持后，使用Spring或者SpringMVC的過程中，仍然有很多配置以及繁瑣的操作需要我們手工去完成。例如：
- 單獨部署配置一個 tomcat（tomcat 的相關配置需要單獨去tomcat安裝目錄下配）
- 使用大量依賴庫可能導致的版本沖突
- Spring 集成使用使用模板引擎 Freemarker、velocity、thymeleaf 等需要單獨配置
- Spring 集成使用 MyBatis、JPA 等 ORM 框架需要單獨配置
- Spring 集成使用安全框架 Security 、日志框架等等都需要單獨一套配置
- 配置 SpringMVC 中的 DispatcherServlet 需要在 web.xml 或者在 Servlet 初始化代碼里進行顯式配置
- 靜態資源的處理
- 應用的運維監控工作等
由於這些已經存在的問題，Spring Boot應運而生，使用Spring Boot可以讓我們快速創建一個基於Spring的項目，而讓這個Spring項目跑起來我們只需要很少的配置就可以了。
SpringBoot 的核心功能
Spring Boot主要有如下核心功能：
- 直接創建一個可以獨立運行的Spring項目
Spring Boot可以以jar包的形式來運行，我們可以直接通過 java -jar xx.jar 命令來運行一個Spring Boot項目。
- 內嵌Servlet容器
Spring Boot可以內嵌Tomcat直接一鍵運行 Web 應用。我們不再需要打 war 包，丟到 Tomcat 下面，再啟動 Tomcat 等等一系列操作了。
提供starter簡化 Maven/Gradle 配置
使用Spring或者SpringMVC我們需要添加大量的依賴，而這些依賴很多都是固定的樣板化配置。Spring Boot 通過starter 幫助我們簡化 Maven/Gradle 配置。
-
- 自動配置Spring
SpringBoot 提供了大量超級實用的 starter，大大簡化了我們使用 Spring 開發過程中的配置。
-
- 生產環境的應用監控
使用SpringBoot 提供的 Actuator ，我們可以方便地進行應用程序的監控。
-
- 無代碼生成和xml配置
SpringBoot 沒有引入任何形式的代碼生成，它是使用的 Spring 4.0的條件注解以實現根據條件進行配置；同時使用了 Maven/Gradle 的依賴傳遞解析機制來實現 Spring 應用里面的自動配置。
回顧 Spring
Spring能夠進行自動化的裝配，它使用兩種方式來進行自動化裝配：
1、組件掃描：Spring會自動發現應用上下文中所創建的bean
2、自動裝配：Spring會自動構建bean之間的依賴關系
Spring的自動化裝配使用了零xml配置，也就是使用了全代碼配置（注解配置），其中代碼配置類使用@Configuration注解進行標注。
1、組件掃描：
@Component能給一個類自動生成對象並注入到Spring容器中，比如下面的CDPlayer，會自動new一個CDPlayer的對象並放置到Spring容器中。
public interface Player { void play(); } @Component public class CDPlayer implements Player { public void play() { System.out.print("播放CD"); } }
我們知道，Spring容器中每個bean都有自己唯一的一個id，自動注入的bean的id的規則如下：
1、如果@Component中有值，類似@Compoent("xxx")，那么此bean的id即為xxx 。
2、如果類名為第一個字母大寫，第二個字母小寫，即滿足首字母大寫的駝峰命令規則，比如CdPlayer, 那么其bean的id第一個字母要小寫，其余不變，所以最終為cdplayer。
3、如果不滿足規則1，比如類名是CDPlayer, 那么其bean的id跟類名相同，所以最終為CDPlayer。
2、自動裝配
需要注意的是，配置對象需要 @Configuration和@ComponentScan注解，而@ComponentScan注解是標注Spring掃描的基礎包名的。如果沒有值，默認會掃描自己所在的包的所有類。
其中的Configuration配置對象：
@Configuration @ComponentScan public class PlayerConfig { }
那么如何配置掃描包呢？比如我想掃描 com.easy.springboot 包下的所有類，可以這樣：
@ComponentScan(basePackages = "com.easy.springboot")
我們使用junit4來進行測試，注意在想獲取Spring中bean上加上@Autowired，Spring會自動注入。另外，下面的Player可以換成CDPlayer，因為CDPlayer的對象既是CDPlayer的對象，也是Player的對象。
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = PlayerConfig.class) public class TestCDPlayer { @Autowired private Player cdPlayer; @Test public void testNotNull(){ cdPlayer.play(); } }
另外，我們也可以將一個對象注入到另一個對象中。比如有一個People類，要為其注入一個Player類，然后其跑步的時候會調用Player類的play方法，這樣實現即可：
@Component public class People { @Autowired private Player player; public void run(){ player.play(); System.out.println("正在跑步"); } }
這里的
@Autowired private Player player
Spring會自動把生成的Player對象注入到People類中。
注入的規則分為兩步：
1、Spring會先查找id為player的Bean對象，如果找到，注入進來
2、如果沒有找到id為player的Player對象，那么就去尋找Spring容器中查找Player的對象，如果一個都沒有，或者有兩個或者多個，那么就會報錯。
3、使用用JavaConfig
一般來說，自動裝配bean已經能為我們解決很多問題。但是，有的時候可能我們需要更自動的配置，這個時候我們就可以使用 JavaConfig 來完成。
Spring Boot的零XML配置也是基於 JavaConfig來實現的。
JavaConfig就是使用注釋來描述Bean配置的組件，也就是注解驅動配置（ Annotation-Driven Configuration）。它是從Spring 3.0后嵌入到Spring里的一個以前的獨立項目。JavaConfig能夠等價看成是XML文件，不過它只是用Java編寫的。
提示：JavaConfig 是Spring的一個子項目(詳細了解可參考：http://docs.spring.io/spring-javaconfig/docs/).
比如我想獲取同一個類的多個bean對象，就可以在JavaConfig中聲明方法來裝配bean：
@Bean public Player player(){ return new CDPlayer(); }
此時Spring容器就會生成一個Player的對象，其id為player（注意id與方法名是一樣的）。我們也可以為Player對象指定Bean id：
@Bean(name="firstPlayer") public Player player(){ return new CDPlayer(); }
那么我們在代碼中就可以根據這個id名稱來裝配這個 Bean
@Autowired private Player firstPlayer
不過，要注意的是@Autowired默認按類型(byType)裝配。如果我們想使用名稱裝配，可以結合@Qualifier注解進行使用，如下：
@Autowired @Qualifier("firstPlayer") private Player firstPlayer;
另外，我們還可以使用@Resource（這個注解屬於J2EE的）
@Resource(name="firstPlayer") //在字段上的注入，先按照名字裝配
private Player firstPlayer;
默認按照名稱(byName)進行裝配，名稱可以通過name屬性進行指定， 裝配規則是：
1、如果沒有指定name屬性，當注解寫在字段上時，默認取字段名進行按照名稱查找，如果注解寫在setter方法上默認取屬性名進行裝配。
2、當找不到與名稱匹配的bean時才按照類型進行裝配。但是需要注意的是，如果name屬性一旦指定，就只會按照名稱進行裝配。
Spring的XML配置方式是使用被Spring命名空間的所支持的一系列的XML標簽來實現的。Spring有以下主要的命名空間：context、beans、jdbc、tx、aop、mvc等。
使用XML來配置Bean所能實現的功能，通過JavaConfig同樣可以很好的實現。之前我們都是在xml文件中定義bean的，比如：
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id="helloBean" class="com.hello.impl.HelloWorldImpl">
</beans>
其實我們可以使用注解來完成這些事情，例如下面的代碼，完成的功能和上面的xml配置的功能是一樣的：
import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.hello.HelloWorld; import com.hello.impl.HelloWorldImpl; @Configuration public class AppConfig { @Bean(name="helloBean") public HelloWorld helloWorld() { return new HelloWorldImpl(); } }
使用@Bean注解，來標識此方法構造出一個由Spring容器管理的bean。@Bean聲明所起到的作用與<bean/> 元素類似。
Spring對Java配置的支持是由@Configuration注解和@Bean注解來實現的。由@Bean注解的方法將會實例化、配置和初始化一個新對象，這個對象將由Spring的IoC容器來管理。
4、導入子配置類
其實，Spring 中的 XML 配置文件本質上說是一種編程元數據。在早期Java版本中，應用中的元數據一般使用屬性文件、XML。但是用配置文件不夠靈活而且比較繁瑣。從Spring 3起，JavaConfig功能已經包含在Spring核心模塊，它允許開發者將bean定義和在Spring配置XML文件到Java類中。與此同時仍然允許使用經典的XML方式來定義bean和配置。
一般在一個大型工程項目中，如果將所有的bean都配置在一個xml文件中，那么這個文件就會非常的大。所以一般會將一個大的xml配置文件分割為好幾份。這樣方便管理，最后在總的那個xml文件中導入。比如：
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<import resource="config/customer.xml"/>
<import resource="config/scheduler.xml"/>
</beans>
但是現在我們也可以使用JavaConfig來完成同樣的工作了：
import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Import; @Configuration @Import({ CustomerConfig.class, SchedulerConfig.class }) public class AppConfig { }
@Configuration可以被認為是相當於XML的< bean / >元素。
5、導入XML 配置
在 Spring XML中, 啟動注解注入bean，通過如下標簽實現：
<context:annotation-config/>
在 JavaConfig中, 等同於 @AnnotationDrivenConfig注解。 代碼示例：
@Configuration @AnnotationDrivenConfig public class Config { }
使用@ComponentScan注解，等同於在 Spring XML中的
<context:component-scan/>
代碼示例：
package com.company.foo; @Service public class FooServiceImpl implements FooService { private final FooRepository fooRepository; @Autowired public FooService(FooRepository fooRepository) { this.fooRepository = fooRepository; } // ...
} package com.company.foo; @Repository public class JdbcFooRepository implements FooRepository { private final DataSource dataSource; @Autowired public FooRepository(DataSource dataSource) { this.dataSource = dataSource; } // ...
} @Configuration @ComponentScan("com.company") // search the com.company package for @Component classes
@ImportXml("classpath:com/company/data-access-config.xml") // XML with DataSource bean
public class Config { }
在配置類中使用上述的配置，我們就可以在代碼里調用service方法了：
public class Main { public static void main(String[] args) { JavaConfigApplicationContext ctx = new JavaConfigApplicationContext(Config.class); FooService fooService = ctx.getBean(FooService.class); fooService.doStuff(); } }
一、 application.properties
默認的服務端口是8080，那么如何在配置文件application.properties設置服務端口呢？
很簡單。SpringBootApplication有個系統級的配置文件application.properties
我們只需要在里面加一行配置即可：
server.port=5678
啟動應用，我們將在日志信息中看到：
2017-04-04 23:31:21.673 INFO 90250 --- [ main] o.s.j.e.a.AnnotationMBeanExporter : Registering beans for JMX exposure on startup
2017-04-04 23:31:21.774 INFO 90250 --- [ main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 5678 (http)
2017-04-04 23:31:21.780 INFO 90250 --- [ main] com.example.DemoApplication : Started DemoApplication in 4.712 seconds (JVM running for 5.511)
TomcatEmbeddedServletContainer已經在5678端口監聽請求了。
瀏覽器訪問：http://localhost:5678/hello
你會看到成功輸出：
Hello World! Tue Apr 04 23:32:38 CST 2017
application.properties是Spring Boot約定的配置文件。Spring Boot基於這個配置文件的配置機制充分體現了Spring Boot遵循的“約定優於配置”的原則。
Spring Boot幾乎所有的配置項都可以在這個文件中配置，如果不配置，則使用默認項。Spring Boot會檢測配置項的key，啟動相應的自動配置模塊。
下面具體介紹一些在application.properties配置中的特性和使用方法。
1.數據源datasource配置
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
當Spring Boot一旦檢測到數據庫配置相關的配置項（spring.datasoure.*），Spring Boot會自動根據相應的配置項，建立數據庫連接池。
這個application.properties里面到底有哪些key是可配置的呢？在SpringBoot官網文檔給出了詳盡的配置以及說明。在Appendix A. Common application properties中： http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#common-application-properties
不完全統計，這個完整的application properties文件，有1183行。其中，屬性key有950個。當你看到如此龐大的配置，你一定會被嚇到。不過，在實際項目中，我們如果遵循Spring Boot的約定，通常不需要我們單獨指定太多配置。
雖然是零XML配置，但是“有些配置的事情”，還是必須要做的。這里SpringBoot的實現方案，充分體現了Spring框架的“約定優於配置”理念。通過約定俗成的規范，很多問題的解決講得到大大的簡化。
2.在application.properties自定義屬性與加載
我們可以將自己自定義的屬性配置在application.properties中（注意不要和Spring Boot的默認配置的key重復），然后在java類中通過@Value("${屬性名}")注解來加載對應的配置屬性，例如：application.properties文件中有如下自定義配置項：
com.easy.springboot.h5perf.app.name = H5性能測試平台
則在java中有如下應用：
1 @Component
2 public class TestProperties {
3 @Value("${com.easy.springboot.h5perf.app.name }")
4 private String appName;
5 }
3.配置項值的引用
在application.properties中的各個參數之間可以直接通過“${keyname}”引用來使用。
在application.properties中也可以通過“@keyname@”來引用pom文件中的元素節點值，例如：
pom文件中有如下定義：
<properties>
<project.name>easy-springboot-demo </ project.name >
<project.version>1.0</ project.version >
</properties>
則在application.properties文件中可以通過如下方式引用：
# 項目名稱
com.easy.springboot.project.name = @project.name@
# 項目版本
com.easy.springboot.project.version = @project.version@
4.隨機數屬性value
在一些情況下，有些參數我們需要希望它不是一個固定的值，Spring Boot的屬性配置文件中可以通過${random}來產生int值、long值或者string字符串，來支持屬性的隨機值。
例如：
# 隨機字符串
com.easy.springboot.string=${random.value}
# 隨機int
com.easy.springboot.number=${random.int}
# 隨機long
com.easy.springboot.bignumber=${random.long}
# 100以內的隨機數
com.easy.springboot.range1=${random.int(100)}
# 100-200的隨機數
com.easy.springboot.range2=${random.int[100,200]}
- 屬性配置文件的位置
spring會從classpath下的/config目錄或者classpath的根目錄查找application.properties或application.yml。
/config優先於classpath根目錄。
二、 Spring Boot屬性配置和使用
一般在一個項目中，總是會有好多個環境。比如：開發環境 -> 測試環境 -> 預發布環境 -> 生產環境
在應用中管理配置是一個重要的問題，尤其是在應用需要部署到多個環境中時。通常會需要為每個環境提供一個對應的屬性文件，用來配置各自的數據庫連接信息、服務器信息和第三方服務賬號等。通常的應用部署會包含開發、測試和生產等若干個環境。
常規情況下，我們都知道Spring Boot的配置會從application.properties中讀取。實際上，從resource目錄下的application.properties文件讀取是Spring Boot配置鏈中的一環而已。
2.1、配置的優先級
Spring Boot提供了一種優先級配置讀取的機制來幫助我們從這種困境中走出來。
Spring Boot 所提供的配置優先級順序比較復雜。按照優先級從高到低的順序，具體的列表（從高到低）如下所示。
1.命令行參數（優先級最高）。 2.通過 System.getProperties() 獲取的 Java 系統參數。 3.操作系統環境變量。 4.從java:comp/env 得到的JNDI 屬性。 5.通過 RandomValuePropertySource 生成的random.*屬性。 6.jar包外部的application-{profile}.properties或application.yml(帶spring.profile)配置文件，通過spring.config.location參數指定 7.jar包內部的application-{profile}.properties或application.yml(帶spring.profile)配置文件 8.jar包外部的application.properties或application.yml(不帶spring.profile)配置文件 9.jar包內部的application.properties或application.yml(不帶spring.profile)配置文件 10.應用 Java配置類，包含@Configuration注解的 Java 類，通過@PropertySource注解聲明的屬性文件。 11.通過SpringApplication.setDefaultProperties聲明的默認屬性。
如果Spring Boot在優先級更高的位置找到了配置，那么它就會忽略優先級低的配置。下面我們簡單講講這些優先級。
2.2、命令行參數配置
Spring Boot 的這個配置優先級看似復雜，其實是很合理的。命令行參數的優先級之所以被設置為最高，是因為可以方便我們在測試或生產環境中快速地修改配置參數值，而不需要重新打包和部署應用。
SpringApplication 類默認會把以“--”開頭的命令行參數轉化成應用中可以使用的配置參數，如 “--name=Alex” 會設置配置參數 “name” 的值為 “Alex”。
如果不需要這個功能，可以通過：
SpringApplication.setAddCommandLineProperties(false)
禁用解析命令行參數。
2.3、 random.*屬性配置
RandomValuePropertySource 可以用來生成測試所需要的各種不同類型的隨機值，從而免去了在代碼中生成的麻煩。RandomValuePropertySource 可以生成數字和字符串。數字的類型包含 int 和 long，可以限定數字的大小范圍。以“random.”作為前綴的配置屬性名稱由 RandomValuePropertySource 來生成，代碼示例：
user.id=${random.value}
user.count=${random.int}
user.max=${random.long}
user.number=${random.int(100)}
user.range=${random.int[100, 1000]}
2.4、屬性文件配置
屬性文件是最常見的管理配置屬性的方式。Spring Boot 提供的 SpringApplication 類會搜索並加載 application.properties 文件來獲取配置屬性值。SpringApplication 類會在下面位置搜索該文件：
1.當前目錄的/config子目錄 2.當前目錄 3.classpath中的/config包 4.classpath
上面的順序也表示了該位置上包含的屬性文件的優先級。優先級按照從高到低的順序排列。
可以通過spring.config.name這個key的配置屬性來指定不同的屬性文件名稱。也可以通過spring.config.location來添加額外的屬性文件的搜索路徑。
對於配置屬性，可以在代碼中通過“@Value”來使用，例如：
@RestController @EnableAutoConfiguration public class Application { @Value("${name}") private String name; @RequestMapping("/") String home() { return String.format("Hello %s!", name); } }
其中，@Value("${name}")注解的意思就是，變量 name 的值來自配置屬性中的name屬性。
2.5、 YAML格式的配置文件
相對於屬性文件來說，YAML 是一個更好的配置文件格式。當有前綴的情況下，使用.yml格式的配置文件更簡單。
注意：使用.yml時，屬性名的值和冒號中間必須有空格，如name: SpringBoot正確，SpringBoot就是錯的。
YAML 在 Ruby on Rails 中得到了很好的應用。YAML是JSON的一個超集，也是一種方便的定義層次配置數據的格式。它的基本語法規則如下：
- 大小寫敏感
- 使用縮進表示層級關系
- 縮進時不允許使用Tab鍵，只允許使用空格。
- 縮進的空格數目不重要，只要相同層級的元素左側對齊即可
- # 表示注釋，從這個字符一直到行尾，都會被解析器忽略。
只要你將SnakeYAML 庫放到classpath下，SpringApplication就會自動支持YAML，以作為properties的替換。當然，我們通常不需要這么做，因為我們一般都會使用Starters，在spring-boot-starter里會自動加載SnakeYAML。
Spring框架提供兩個便利的類用於加載YAML文檔，YamlPropertiesFactoryBean會將YAML加載為Properties，YamlMapFactoryBean會將YAML加載為Map。
Spring Boot使用application.properties默認了很多配置。但需要自己添加一些配置的時候，我們應該怎么做呢。
例如，下面這段yml格式的配置
environments: dev: url: http://dev.easy.springboot.com
name: Easy Spring Boot
會轉化為：
environments.url=http://dev.easy.springboot.com
environments.name=Easy Spring Boot
如果我們自定義了屬性key，在代碼中怎樣使用上面的配置信息呢？利用Spring DataBinder工具集，Spring Boot通過注解@ConfigurationProperties 和@EnableConfigurationProperties 來完成這件事情。
在代碼中對應的Bean對象：
@ConfigurationProperties(prefix="environments") public class EnvironmentsConfig { private String url; private String name; public String getUrl(){ return this.url; } public void setUrl(String url){ this.url = url; } public String getName(){ return this.name; } public void setName(){ this.name = name; } }
有些時候，我們還會配置類似下面這樣的列表的屬性
my: servers: - dev1.easy.com - dev2.easy.com
會轉化為：
my.servers[0]=dev1.easy.com my.servers[1]=dev2.easy.com
使用@ConfigurationProperties這個注解來實現屬性Bean的綁定，需要在Bean里面添加一個java.util.List(或者Set)類型的屬性，然后寫好setter（setter也可以換成初始化一個對象），getter：
@ConfigurationProperties(prefix="my") public class ServersConfig { private List<String> servers = new ArrayList<String>();//initialize it with a mutable value， equals a setter
public List<String> getServers() { return this.servers; } }
因為YamlPropertySourceLoader類能夠將YAML作為PropertySource導出到Spring Environment。所以我們可以使用常用的@Value注解配合占位符語法訪問YAML屬性。
另外，當我們使用@ConfigurationProperties注解定義配置的Bean時，需要在SpringBoot Application啟動類上標注@EnableConfigurationProperties。
2.6、使用 Java配置類
Spring 框架本身提供了多種的方式來管理配置屬性文件。Spring 3.1 之前可以使用 PropertyPlaceholderConfigurer。Spring 3.1 引入了新的環境（Environment）和概要信息（Profile）API，是一種更加靈活的處理不同環境和配置文件的方式。
Spring Profiles提供了一種隔離應用程序配置的方式，並讓這些配置只在特定的環境下生效。任何@Component或@Configuration都能注解@Profile，從而限制加載它的環境：
@Configuration @Profile("production") public class ProductionConfiguration { // ... }
指定的屬性方式常用的有2種：
- 配置在application.properties中：
spring.profiles.active=production
- 或使用命令行開關：
--spring.profiles.active=production
如果應用中包含多個 profile，可以為每個 profile 定義各自的屬性文件，按照application-{profile}.properties(.yml)來命名。
三、使用CommandLineRunner執行初始化加載
實際應用中，有時候我們在項目服務啟動的時候就去加載一些數據或做一些事情這樣的需求。 以前比較常見的做法是寫再static代碼塊中。
在Spring Boot中，它提供了一個CommandLineRunner接口，實現這個接口的類總是會被優先啟動，並優先執行CommandLineRunner接口中提供的run()方法。例如
public class ApplicationConfigure implements CommandLineRunner { @Override public void run(String... strings) throws Exception { //TODO : 比如說，在這里預先加載的一些方法，類，屬性等。
} }
如果有多個CommandLineRunner接口實現類，那么可以通過注解@Order來規定所有實現類的運行順序。
小結
Spring Boot 它拋棄了Spring 中繁瑣的xml配置文件的方式，聲明式注解的方法為服務開發提供快速簡潔的配置方式。在Spring Boot 中，我們會發現，我們其實不用做一些基本的配置也能直接運行剛創建好的工程項目，因為它內嵌了很多基本的通用的配置組件而不需要我們自己來做一些重復的配置工作。