1.5.2.RELEASE

Part I. Spring Boot 文檔

本節簡要介紹了Spring Boot文檔，是整個文檔的參考指南。 您可以完整閱讀本參考指南，或者如果您不感興趣的話可以跳過該部分。

1. 關于文檔

Spring Boot參考指南可以以?html，pdf?和?epub?文檔的形式獲取。文檔， 最新版本的文檔可在http://docs.spring.io/spring-boot/docs/current/reference?中找到。

本文檔您可以自己使用，或發布給別人，印刷版還是以電子形式都可以，但必須包含本版權聲明，不可進行盈利。

2. 獲得幫助

如果使用 Spring Boot 時遇到問題，可以在下面獲取幫助：

• 嘗試?How-to’s?- 這里為最常見的問題提供解決方案。Springboot教程？
• 了解Spring的基礎知識 - Spring Boot建立在許多其他Spring項目上，請查看?spring.io?網站以獲取其他項目的參考文檔。 如果您剛剛開始使用Spring，請閱讀這個指南。
• 在stackoverflow上提問題 - 我們會一起關注?stackoverflow.com?上有spring-boot標簽的問題。Springboot框架？
• 在Github上報告bug。

Spring Boot 所有的東西都是開源的，包括文檔！ 如果您發現文檔有問題; 或者如果你想改進他們，歡迎參與。

3. 第一步

如果你剛剛開始使用 Spring Boot，或剛剛開始使用“Spring”，請從這里開始！

• 從頭開始：概述?|?要求?|?安裝
• 教程：Part 1?|?Part 2
• 運行你的例子：Part 1?|?Part 2

4. 使用 Spring Boot

• 構建系統:?Maven?|?Gradle?|?Ant?|?Starters
• 最佳做法：代碼結構?|?@Configuration?|?@EnableAutoConfiguration?|?Beans 和依賴注入
• 運行代碼：IDE?|?Packaged?|?Maven?|?Gradle
• 打包應用程序：?Production jars
• Spring Boot CLI：使用CLI

5. 了解Spring Boot功能

需要有關Spring Boots核心功能的更多細節？請看這里

• 核心功能:?SpringApplication?|?External Configuration?|?Profiles?|?Logging
• Web 應用:?MVC?|?Embedded Containers
• 數據處理:?SQL?|?NO-SQL
• 消息處理:?Overview?|?JMS
• 測試:?Overview?|?Boot Applications?|?Utils
• 擴展:?Auto-configuration?|?@Conditions

6. 轉移到生產環境

當您準備好將Spring Boot 應用程序放到生產環境時，我們有一些您可能會喜歡的技巧！

• 部署 Spring Boot 應用程序:?Cloud Deployment?|?OS Service
  構建工具插件：Maven?|?Gradle
  附錄:?Application Properties?|?自動配置類?|?可執行 Jars

Part II. 入門指南

如果你剛剛開始使用Spring Boot，這是你的一部分內容！ 在這里我們將會回答一些基本的what?”, “how?” 和 “why?”的問題。 在這里你會找到一個詳細的介紹Spring Boot和安裝說明。 然后，我們將構建我們的第一個Spring Boot應用程序，并討論一些核心原則。

8. Spring Boot 介紹

Spring Boot可以基于Spring輕松創建可以“運行”的、獨立的、生產級的應用程序。 對Spring平臺和第三方類庫我們有一個自己看法，所以你最開始的時候不要感到奇怪。 大多數Spring Boot應用程序需要很少的Spring配置。

您可以使用Spring Boot創建可以使用java -jar或傳統 war 包部署啟動的Java應用程序。 我們還提供一個運行“spring腳本”的命令行工具。

我們的主要目標是：

• 為所有的Spring開發者提供一個更快，更廣泛接受的入門體驗。
• Be opinionated out of the box, but get out of the way quickly as requirements start to diverge from the defaults.
• 提供大量項目中常見的一系列非功能特征（例如嵌入式服務器，安全性，指標，運行狀況檢查，外部化配置）。
• 絕對沒有代碼生成，也不需要XML配置。

9. 系統要求

默認情況下，Spring Boot 1.5.2.RELEASE需要Java 7和Spring Framework 4.3.7.RELEASE或更高版本。 您可以進行一些其他配置在Java 6上使用Spring Boot。 有關詳細信息，請參見第84.11節“如何使用Java 6”。 為Maven（3.2+）和Gradle 2（2.9或更高版本）和3提供了顯式構建支持。

雖然您可以在Java 6或7上使用 Spring Boot，但我們通常推薦Java 8。

9.1 Servlet容器

以下嵌入式servlet容器可以直接使用：

您還可以將Spring Boot應用程序部署到任何兼容Servlet 3.0+ 的容器中。

10. 安裝 Spring Boot

Spring Boot可以與“經典(classic)”Java開發工具一起使用或作為命令行工具安裝。 無論如何，您將需要Java SDK v1.6或更高版本。 在開始之前檢查當前的Java安裝：

1

$ java -version

如果您是Java開發的新手，或者您只想嘗試一下 Spring Boot，您可能需要首先嘗試使用?Spring Boot CLI，如果想正式使用Spring Boot，請閱讀“經典(classic)”安裝說明。

雖然Spring Boot 與Java 1.6兼容，但我們建議使用最新版本的Java。

10.1 Java開發程序員安裝說明

Spring Boot的使用方式與標準Java庫的使用相同，只需在類路徑中包含適當的spring-boot-*.jar文件。Spring Boot不需要任何特殊的集成工具，所以可以使用任何IDE或文本編輯器進行開發；并且Spring Boot 應用程序沒有什么特殊的地方，因此您可以像其他Java程序一樣運行和調試。雖然您可以直接復制Spring Boot 的jar包，但我們通常建議您使用依賴關系管理的構建工具（如Maven或Gradle）。

10.1.1 Maven安裝

Spring Boot 兼容 Apache Maven 3.2。 如果您還沒有安裝Maven，可以按照?https://maven.apache.org/?上的說明進行安裝。

在許多操作系統上，Maven可以通過軟件包管理器進行安裝。 如果您是OSX Homebrew用戶，請嘗試使用命令：brew install maven。 Ubuntu用戶可以運行命令：sudo apt-get install maven。

Spring Boot 依賴 org.springframework.boot groupId。通常，您的Maven POM文件將從 spring-boot-starter-parent 項目繼承，并聲明一個或多個“啟動器(啟動器)”的依賴關系。Spring Boot還提供了一個可選的Maven插件來創建可執行的jar包。

典型的pom.xml文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

<?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.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <!-- Inherit defaults from Spring Boot -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>
    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    <!-- Package as an executable jar -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

spring-boot-starter-parent是使用Spring Boot的一個很好的方式，但它并不是所有的時候都適合。有時您可能需要從不同的父POM繼承，或者您可能不喜歡我們的默認設置。 請參見第13.2.2節“使用不帶父POM的Spring Boot”作為使用導入作用域(import scope)的替代解決方案。

10.1.2 Gradle 安裝

Spring Boot 兼容 Gradle 2（2.9或更高版本）和Gradle 3。如果您尚未安裝Gradle，您可以按照http://www.gradle.org/?上的說明進行操作。

可以使用org.springframework.boot 組(group)聲明Spring Boot 的依賴項。 通常，您的項目將聲明一個或多個“啟動器(Starters)”的依賴。Spring Boot提供了一個有用的Gradle插件，可用于簡化依賴關系聲明和創建可執行 jar包。

Gradle Wrapper

當您需要構建項目時，Gradle Wrapper提供了一種“獲取(obtaining)”Gradle的更好的方式。 它是一個小腳本和庫，它與代碼一起引導構建過程。 有關詳細信息，請參閱https://docs.gradle.org/2.14.1/userguide/gradle_wrapper.html?。

典型的 build.gradle 文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

plugins {
id 'org.springframework.boot' version '1.5.2.RELEASE'
id 'java'
}
jar {
baseName = 'myproject'
version =  '0.0.1-SNAPSHOT'
}
repositories {
jcenter()
}
dependencies {
compile("org.springframework.boot:spring-boot-starter-web")
testCompile("org.springframework.boot:spring-boot-starter-test")
}

10.2 安裝Spring Boot CLI

Spring Boot CLI是一個命令行工具，如果要使用Spring快速原型(quickly prototype)，可以使用它。 它允許您運行Groovy腳本，這意味著會有您熟悉的類似Java的語法，沒有太多的樣板代碼(boilerplate code)。

您也不必要通過CLI來使用Spring Boot，但它絕對是開始Spring應用程序最快方法。

10.2.1 手動安裝

您可以從Spring軟件版本庫下載Spring CLI發行版：

• spring-boot-cli-1.5.2.RELEASE-bin.zip
• spring-boot-cli-1.5.2.RELEASE-bin.tar.gz

各發布版本的快照。

下載完成后，請按照解壓縮后文件中的INSTALL.txt的說明進行操作。 總而言之：在.zip文件的bin/目錄中有一個spring腳本（Windows的spring.bat），或者你可以使用java -jar（腳本可以幫助您確保類路徑設置正確）。

10.2.2 使用SDKMAN!安裝

SDKMAN!（軟件開發套件管理器）可用于管理各種二進制SDK的多個版本，包括Groovy和Spring Boot CLI。從http://sdkman.io/?獲取SDKMAN！并安裝Spring Boot。

1
2
3

$ sdk install springboot
$ spring --version
Spring Boot v1.5.2.RELEASE

如果您正在開發CLI的功能，并希望輕松訪問剛創建的版本，請遵循以下額外說明。

1
2
3
4

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-1.5.2.RELEASE-bin/spring-1.5.2.RELEASE/
$ sdk default springboot dev
$ spring --version
Spring CLI v1.5.2.RELEASE

這將安裝一個稱為dev的spring的本地實例(instance)。 它指向您構建位置的target，所以每次重建(rebuild)Spring Boot時，Spring 將是最新的。

你可以看到：

1
2
3
4
5
6
7
8
9
10
11
12
13

$ sdk ls springboot
================================================================================
Available Springboot Versions
================================================================================
> + dev
* 1.5.2.RELEASE
================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

10.2.3 OSX Homebrew 安裝

如果您在Mac上使用?Homebrew，安裝Spring Boot CLI 只需要下面命令：

1
2

$ brew tap pivotal/tap
$ brew install springboot

Homebrew會將Spring 安裝到 /usr/local/bin。

如果您沒有看到公式(formula)，您的安裝可能會過期。 只需執行brew更新，然后重試。

10.2.4 MacPorts安裝

如果您在Mac上使用?MacPorts，安裝Spring Boot CLI 只需要下面命令：

1

$ sudo port install spring-boot-cli

10.2.5 命令行補全

Spring Boot CLI為BASH和zsh shell提供命令補全的功能。 您可以在任何shell中引用腳本（也稱為spring），或將其放在您的個人或系統范圍的bash完成初始化中。 在Debian系統上，系統范圍的腳本位于 /shell-completion/bash 中，當新的shell啟動時，該目錄中的所有腳本將被執行。 手動運行腳本，例如 如果您使用SDKMAN安裝了！

1
2
3

$ . ~/.sdkman/candidates/springboot/current/shell-completion/bash/spring
$ spring <HIT TAB HERE>
grab  help  jar  run  test  version

如果使用Homebrew或MacPorts安裝Spring Boot CLI，則命令行補全腳本將自動注冊到您的shell。

10.2.6 快速啟動Spring CLI示例

這是一個非常簡單的Web應用程序，可用于測試您的安裝是否正確。 創建一個名為app.groovy的文件：

1
2
3
4
5
6
7
8
9

@RestController
class ThisWillActuallyRun {
    @RequestMapping("/")
String home() {
        "Hello World!"
}
}

然后從shell運行它：

1

$ spring run app.groovy

因為下載依賴的庫，首次運行應用程序需要一些時間，。 后續運行將會更快。

在瀏覽器中打開?http://localhost:8080?，您應該會看到以下輸出：

1

Hello World!

10.3 從早期版本的Spring Boot升級

如果您從早期版本的 Spring Boot 升級，請檢查項目wiki上托管的“發行說明”。 您將找到升級說明以及每個版本的“新的和值得注意的”功能的列表。

要升級現有的CLI安裝，請使用包管理工具相應的package manager命令（例如brew upgrade），如果您手動安裝了CLI，請按照標準說明記住更新PATH環境變量以刪除任何舊的引用。

11. 開發您的第一個Spring Boot應用程序

讓我們在Java中開發一個簡單的“Hello World！”Web應用程序，突顯Spring Boot一些主要的功能。 我們將使用Maven構建該項目，因為大多數IDE支持它。

https://spring.io/?包含許多使用Spring Boot的“入門指南”。 如果您正在尋求解決一些具體問題; 可以先看一下那里。

您可以在?https://start.spring.io/?的依賴關系搜索器中選擇Web啟動器來快速完成以下步驟。
這會自動生成一個新的項目結構，方便您立即開始編碼。 查看文檔了解更多詳細信息。

在開始之前，打開終端來檢查您是否安裝了有效的Java和Maven版本。

1
2
3
4
5
6
7
8
9
10

$ java -version
java version "1.7.0_51"
Java(TM) SE Runtime Environment (build 1.7.0_51-b13)
Java HotSpot(TM) 64-Bit Server VM (build 24.51-b03, mixed mode)
$ mvn -v
Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebad2656a31e8fdf4; 2014-08-11T13:58:10-07:00)
Maven home: /Users/user/tools/apache-maven-3.1.1
Java version: 1.7.0_51, vendor: Oracle Corporation

這個示例需要在其自己的文件夾中創建。 后面我們假設您在當前目錄已經創建了一個正確的文件夾。

11.1 創建POM

我們需要先創建一個Maven pom.xml文件。 pom.xml是用于構建項目的配置文件。打開編輯器并添加以下內容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?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.example</groupId>
    <artifactId>myproject</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
    </parent>
    <!-- Additional lines to be added here... -->
</project>

這應該給你一個工作構建(working build)，你可以通過運行 mvn package 進行測試（你可以暫時忽略警告：“jar will be empty - no content was marked for inclusion!”）。

現在，您可以將項目導入到IDE中（最新的Java IDE內置對Maven的支持）。 為了簡單起見，這個示例我們繼續使用純文本編輯器。

11.2 添加類路徑依賴關系

Spring Boot提供了一些“啟動器(Starters)”，可以方便地將jar添加到類路徑中。我們的示例應用程序已經在POM的父部分使用了spring-boot-starter-parent。spring-boot-starter-parent是一個特殊啟動器，提供一些Maven的默認值。它還提供依賴管理?dependency-management?標簽，以便您可以省略子模塊依賴關系的版本標簽。

其他“啟動器(Starters)”只是提供您在開發特定類型的應用程序時可能需要的依賴關系。 由于我們正在開發Web應用程序，所以我們將添加一個spring-boot-starter-web依賴關系，但在此之前，我們來看看我們目前的依賴。

1
2
3

$ mvn dependency:tree
[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

mvn dependency:tree：打印項目依賴關系的樹形表示。 您可以看到spring-boot-starter-parent本身不在依賴關系中。 編輯pom.xml并在 parent 下添加spring-boot-starter-web依賴關系：

1
2
3
4
5
6

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

如果您再次運行 mvn dependency:tree ，您將看到現在有許多附加依賴關系，包括Tomcat Web服務器和Spring Boot本身。

11.3 編寫代碼

要完成我們的應用程序，我們需要創建一個的Java文件。 默認情況下，Maven將從src/main/java編譯源代碼，因此您需要創建該文件夾結構，然后添加一個名為src/main/java/Example.java的文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
    @RequestMapping("/")
    String home() {
        return "Hello World!";
}
    public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
}
}

雖然這里沒有太多的代碼，但是有一些重要的部分。

11.3.1 @RestController和@RequestMapping 注解

我們的Example類的第一個注解是@RestController。 這被稱為 stereotype annotation。它為人們閱讀代碼提供了一些提示，對于Spring來說，這個類具有特定的作用。在這里，我們的類是一個web @Controller，所以Spring在處理傳入的Web請求時會考慮這個類。

@RequestMapping注解提供“路由”信息。 告訴Spring，任何具有路徑“/”的HTTP請求都應映射到home方法。 @RestController注解告訴Spring將生成的字符串直接返回給調用者。

@RestController和@RequestMapping注解是Spring MVC 的注解（它們不是Spring Boot特有的）。 有關更多詳細信息，請參閱Spring參考文檔中的MVC部分。

11.3.2 @EnableAutoConfiguration注解

第二個類級別的注釋是@EnableAutoConfiguration。 這個注解告訴 Spring Boot 根據您添加的jar依賴關系來“猜(guess)”你將如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，自動配置將假定您正在開發Web應用程序并相應地配置Spring。

啟動器和自動配置

自動配置旨在與“起動器”配合使用，但兩個概念并不直接相關。 您可以自由選擇啟動器之外的jar依賴項，Spring Boot仍然會自動配置您的應用程序。

11.3.3 “main”方法

我們的應用程序的最后一部分是main()方法。 這只是一個遵循Java慣例的應用程序入口點的標準方法。 我們的main()方法通過調用run()委托(delegates)給Spring Boot的SpringApplication類。 SpringApplication將引導我們的應用程序，啟動Spring，然后啟動自動配置的Tomcat Web服務器。 我們需要將Example.class作為一個參數傳遞給run方法來告訴SpringApplication，它是主要的Spring組件。 還傳遞了args數組以傳遞命令行參數。

11.4 運行示例

由于我們使用了spring-boot-starter-parent POM，所以我們有一個可用的運行目標，我們可以使用它來啟動應用程序。 鍵入mvn spring-boot：從根目錄運行以啟動應用程序：

1
2
3
4
5
6
7
8
9
10
11
12
13

$ mvn spring-boot:run
.   ____          _            __ _ _
/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
'  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::  (v1.5.2.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)

如果你用瀏覽器打開?http://localhost:8080?你應該看到以下輸出：

1

Hello World!

ctrl-c 正常(gracefully)退出應用程序。

11.5 創建可執行的jar

讓我們完成我們的例子，創建一個完全自包含的可執行jar文件，我們可以在生產環境中運行。 可執行的jar（有時稱為“fat jars”）是包含編譯的類以及代碼運行所需要的所有jar包依賴的歸檔(archives)。

可執行jar和Java

Java不提供任何標準的方法來加載嵌套的jar文件（即本身包含在jar中的jar文件）。 如果您正在尋找可以發布自包含的應用程序，這可能是有問題的。
為了解決這個問題，許多開發人員使用“uber” jars。 一個uber jar簡單地將所有類、jar包進行檔案。 這種方法的問題是，很難看到您在應用程序中實際使用哪些庫。 如果在多個jar中使用相同的文件名（但具有不同的內容），也可能會出現問題。
Spring Boot采用一個不同的方法這樣可以直接對jar進行嵌套。

要創建可執行的jar，我們需要將spring-boot-maven-plugin添加到我們的pom.xml中。 在下方插入以下行：

1
2
3
4
5
6
7
8

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

spring-boot-starter-parent POM 包括綁定重新包裝目標的?配置。 如果您不使用該父POM，您將需要自己聲明此配置。 有關詳細信息，請參閱插件文檔。

保存您的pom.xml并從命令行運行 mvn package：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$ mvn package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building myproject 0.0.1-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO] .... ..
[INFO] --- maven-jar-plugin:2.4:jar (default-jar) @ myproject ---
[INFO] Building jar: /Users/developer/example/spring-boot-example/target/myproject-0.0.1-SNAPSHOT.jar
[INFO]
[INFO] --- spring-boot-maven-plugin:1.5.2.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

如果你看看target目錄，你應該看到myproject-0.0.1-SNAPSHOT.jar。 該文件的大小約為10 MB。 如果你想查看里面，可以使用jar tvf：

1

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar

您還應該在target目錄中看到一個名為myproject-0.0.1-SNAPSHOT.jar.original的較小文件。 這是Maven在Spring Boot重新打包之前創建的原始jar文件。

使用java -jar命令運行該應用程序：

1
2
3
4
5
6
7
8
9
10
11
12
13

$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
.   ____          _            __ _ _
/\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
\\/  ___)| |_)| | | | | || (_| |  ) ) ) )
'  |____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::  (v1.5.2.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)

像之前一樣，ctrl+c正常退出應用程序。

12. 接下來讀什么

希望本節能為您提供一些Spring Boot基礎知識，并讓您準備編寫自己的應用程序。 如果你是一個面向具體任務的開發人員，你可能想跳過?https://spring.io/?，看看一些解決具體的“如何用Spring”問題的入門指南; 我們還有Spring Boot-specific?How-to參考文檔。

Spring Boot庫還有一大堆可以運行的示例。 示例與代碼的其余部分是獨立的（這樣您不需要構建多余的代碼來運行或使用示例）。

下一個是第三部分“使用 Spring Boot”。 如果你真的沒有這個耐心，也可以跳過去閱讀Spring Boot功能。

Part III. 使用 Spring Boot

本部分將詳細介紹如何使用Spring Boot。 這部分涵蓋諸如構建系統，自動配置以及如何運行應用程序等主題。 我們還介紹了一些Spring Boot的最佳實踐(best practices)。 雖然Spring Boot沒有什么特殊之處（它只是一個可以使用的庫），但是有一些建議可以讓您的開發過程更容易一些。

如果您剛剛開始使用Spring Boot，那么在深入本部分之前，您應該閱讀入門指南。

13. 構建系統

強烈建議您選擇一個支持依賴管理并可以使用“Maven Central”存儲庫的構建系統。 我們建議您選擇Maven或Gradle。 Spring Boot 可以與其他構建系統（例如 Ant ）配合使用，但是它們不會得到很好的支持。

13.1 依賴管理

每個版本的Spring Boot提供了一個它所支持的依賴關系列表。 實際上，您不需要為構建配置文件中的這些依賴關系提供版本，因為Spring Boot會為您進行管理這些依賴的版本。 當您升級Spring Boot本身時，這些依賴關系也將以一致的進行升級。

如果您覺得有必要，您仍然可以指定一個版本并覆蓋Spring Boot建議的版本。

管理的列表中包含可以使用Spring Boot的所有Spring模塊以及第三方庫的精簡列表。 該列表可作為標準的物料(Materials)清單（spring-boot-dependencies）使用，并且還提供了對?Maven?和?Gradle?的額外支持。

Spring Boot的每個版本與Spring Framework的基本版本相關聯，因此我們強烈建議您不要自己指定其版本。

13.2 Maven

Maven用戶可以從 spring-boot-starter-parent-parent 項目中繼承，以獲得合理的默認值。 父項目提供以下功能：

• Java 1.6作為默認編譯器級別。
• 源代碼UTF-8編碼。
• 依賴關系管理，允許您省略常見依賴的標簽，其默認版本繼承自spring-boot-dependencies POM。
• 更合理的資源過濾。
• 更合理的插件配置（exec plugin，surefire，Git commit ID，shade）。
• 針對application.properties和application.yml的更合理的資源過濾，包括特定的文件（例如application-foo.properties和application-foo.yml）
• 最后一點：由于默認的配置文件接受Spring樣式占位符（${…}），Maven過濾更改為使用 @..@ 占位符（您可以使用Maven屬性resource.delimiter覆蓋它）。

13.2.1 繼承啟動器parent

要將項目配置為繼承spring-boot-starter-parent，只需設置標簽如下：

1
2
3
4
5
6

<!-- Inherit defaults from Spring Boot -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.2.RELEASE</version>
</parent>

您只需要在此依賴項上指定Spring Boot版本號。 如果您導入其他起始器，則可以放心地省略他們的版本號。

通過該設置，您還可以通過覆蓋自己的項目中的屬性來覆蓋單個依賴。 例如，要升級到另一個 Spring Data 版本序列，您需要將以下內容添加到您的pom.xml中。

1
2
3

<properties>
    <spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
</properties>

檢查?spring-boot-dependencies pom?以獲取支持的屬性列表。

13.2.2 使用沒有父POM的 Spring Boot

不是每個人都喜歡從spring-boot-starter-parent POM繼承。 您公司可能有自己標準的父母，或者您可能只希望明確聲明所有的Maven配置。

如果您不想使用spring-boot-starter-parent，則仍然可以通過使用scope=import依賴來保持依賴管理（但不是插件管理）的好處：

1
2
3
4
5
6
7
8
9
10
11
12

<dependencyManagement>
     <dependencies>
        <dependency>
            <!-- Import dependency management from Spring Boot -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

該設置不允許您使用如上所述的屬性來覆蓋單個依賴關系。 要實現相同的結果，您需要在spring-boot-dependencies條目之前在項目的dependencyManagement中添加一個條目。 例如，要升級到另一個Spring Data發行序列，您需要將以下內容添加到您的pom.xml中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

<dependencyManagement>
    <dependencies>
        <!-- Override Spring Data release train provided by Spring Boot -->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-releasetrain</artifactId>
            <version>Fowler-SR2</version>
            <scope>import</scope>
            <type>pom</type>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.2.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

在上面的例子中，我們指定了一個BOM，但是任何依賴關系類型都可以被這樣覆蓋。

13.2.3 更改Java版本

spring-boot-starter-parent選擇相當保守的Java兼容性版本。 如果要遵循我們的建議并使用更高版本的Java版本，可以添加java.version屬性：

1
2
3

<properties>
    <java.version>1.8</java.version>
</properties>

13.2.4 使用Spring Boot Maven插件

Spring Boot包括一個Maven插件，可以將項目打包成可執行jar。 如果要使用它，請將插件添加到部分：

1
2
3
4
5
6
7
8

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

如果您使用Spring Boot啟動器 parent pom，則只需要添加這個插件，除非您要更改parent中定義的設置，否則不需要進行配置。

13.3 Gradle

Gradle用戶可以直接在其依賴關系部分導入“啟動器”。 不像Maven，沒有“超級父”導入來共享一些配置。

1
2
3
4
5
6
7

repositories {
jcenter()
}
dependencies {
    compile("org.springframework.boot:spring-boot-starter-web:1.5.2.RELEASE")
}

spring-boot-gradle-plugin也是可用的，它提供了從源代碼創建可執行jar并運行項目的任務。 它還提供依賴關系管理，除其他功能外，還允許您省略由Spring Boot管理的任何依賴關系的版本號：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

plugins {
id 'org.springframework.boot' version '1.5.2.RELEASE'
id 'java'
}
repositories {
jcenter()
}
dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
testCompile("org.springframework.boot:spring-boot-starter-test")
}

13.4 Ant

可以使用Apache Ant + Ivy構建Spring Boot項目。 spring-boot-antlib“AntLib”模塊也可用于幫助Ant創建可執行文件。

要聲明依賴關系，典型的ivy.xml文件將如下所示：

1
2
3
4
5
6
7
8
9
10
11

<ivy-module version="2.0">
    <info organisation="org.springframework.boot" module="spring-boot-sample-ant" />
    <configurations>
        <conf name="compile" description="everything needed to compile this module" />
        <conf name="runtime" extends="compile" description="everything needed to run this module" />
    </configurations>
    <dependencies>
        <dependency org="org.springframework.boot" name="spring-boot-starter"
            rev="${spring-boot.version}" conf="compile" />
    </dependencies>
</ivy-module>

典型的build.xml將如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<project
    xmlns:ivy="antlib:org.apache.ivy.ant"
    xmlns:spring-boot="antlib:org.springframework.boot.ant"
    name="myapp" default="build">
    <property name="spring-boot.version" value="1.3.0.BUILD-SNAPSHOT" />
    <target name="resolve" description="--> retrieve dependencies with ivy">
        <ivy:retrieve pattern="lib/[conf]/[artifact]-[type]-[revision].[ext]" />
    </target>
    <target name="classpaths" depends="resolve">
        <path id="compile.classpath">
            <fileset dir="lib/compile" includes="*.jar" />
        </path>
    </target>
    <target name="init" depends="classpaths">
        <mkdir dir="build/classes" />
    </target>
    <target name="compile" depends="init" description="compile">
        <javac srcdir="src/main/java" destdir="build/classes" classpathref="compile.classpath" />
    </target>
    <target name="build" depends="compile">
        <spring-boot:exejar destfile="build/myapp.jar" classes="build/classes">
            <spring-boot:lib>
                <fileset dir="lib/runtime" />
            </spring-boot:lib>
        </spring-boot:exejar>
    </target>
</project>

請參見第84.10節“從Ant構建可執行存檔，而不使用spring-boot-antlib”如果不想使用spring-boot-antlib模塊，請參閱“操作方法”。

13.5 啟動器

啟動器是一組方便的依賴關系描述符，可以包含在應用程序中。 您可以獲得所需的所有Spring和相關技術的一站式服務，無需通過示例代碼搜索和復制粘貼依賴配置。 例如，如果要開始使用Spring和JPA進行數據庫訪問，那么只需在項目中包含spring-boot-starter-data-jpa依賴關系即可。

啟動器包含許多依賴關系，包括您需要使項目快速啟動并運行，并具有一致的受支持的依賴傳遞關系。

What’s in a name

所有正式起動器都遵循類似的命名模式： spring-boot-starter-?，其中是特定類型的應用程序。 這個命名結構旨在幫助你快速找到一個啟動器。 許多IDE中的Maven插件允許您按名稱搜索依賴項。 例如，安裝Eclipse或STS的Maven插件后，您可以簡單地在POM編輯器中點擊 Dependency Hierarchy，并在filter輸入“spring-boot-starter”來獲取完整的列表。
如創建自己的啟動器部分所述，第三方啟動程序不應該從Spring-boot開始，因為它是為正式的Spring Boot artifacts 保留的。 acme 的 第三方啟動器通常被命名為acme-spring-boot-starter。

Spring Boot在org.springframework.boot組下提供了以下應用程序啟動器：

表13.1. Spring Boot應用程序啟動器

除了應用程序啟動器，以下啟動器可用于添加生產準備(production ready)功能：

表13.2 Spring Boot生產環境啟動器

最后，Spring Boot還包括一些啟動器，如果要排除或替換特定的技術，可以使用它們：

有關社區貢獻的更多啟動器的列表，請參閱GitHub上的spring-boot-startters模塊中的README文件。

14. 構建代碼

Spring Boot不需要任何特定的代碼結構設計，但是有一些最佳實踐可以幫助您。

14.1 使用“default”包

當類不包括包聲明時，它被認為是在“默認包”中。 通常不鼓勵使用“默認包”，并應該避免使用。 對于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot應用程序，可能會有一些特殊的問題，因為每個jar的每個類都將被讀取。

我們建議您遵循Java推薦的軟件包命名約定，并使用反向域名（例如，com.example.project）。

14.2 查找主應用程序類

我們通常建議您將應用程序主類放到其他類之上的根包(root package)中。 @EnableAutoConfiguration注解通常放置在您的主類上，它隱式定義了某些項目的基本“搜索包”。 例如，如果您正在編寫JPA應用程序，則@EnableAutoConfiguration注解類的包將用于搜索@Entity項。

使用根包(root package)還可以使用@ComponentScan注釋，而不需要指定basePackage屬性。 如果您的主類在根包中，也可以使用@SpringBootApplication注釋。

這是一個典型的布局：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

com
+- example
+- myproject
+- Application.java
|
+- domain
|   +- Customer.java
|   +- CustomerRepository.java
|
+- service
|   +- CustomerService.java
|
+- web
+- CustomerController.java

Application.java文件將聲明main方法以及基本的@Configuration。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

package com.example.myproject;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
    public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}

15. 配置類

Spring Boot支持基于Java的配置。雖然可以使用XML配置用SpringApplication.run()，但我們通常建議您的主source是@Configuration類。 通常，定義main方法的類也是作為主要的@Configuration一個很好的選擇。

許多使用XML配置的Spring示例已經在網上發布。 如果可能的話我們建議始終嘗試使用等效的基于Java的配置。 搜索 enable* 注解可以是一個很好的起點。

15.1 導入其他配置類

轉載：Spring Boot中文文檔