（二）Spring Boot 起步入门（翻译自Spring Boot官方教程文档）1.5.9.RELEASE-CSDN博客

查看本文英文文档，请点击 me！
本文将在对原英文文档进行翻译的基础上，结合作者动手实践一步步图文并茂展示给大家！
小弟学识尚浅，若文章有不对的地方，请帮小弟指出，非常感谢！

第二部分 Spring Boot 入门

如果你正准备入门 Spring Boot，或者通常说是‘Spring’，那这章节将是你学习的好材料。本章节将回答诸如 Spring Boot 是什么？怎么做？为什么？等基本问题。你将会得到一个优雅的、关于 Spring Boot 的介绍说明以及安装文档。紧接着我们将一起构建我们的第一个 Spring Boot 应用程序并讨论一些核心的原则。

8、介绍 Spring Boot

Spring Boot 使你可以轻松地创建一个仅仅运行 java run(main方法) 的独立的、生产级的基于 Spring 的应用程序。我们对Spring平台和第三方库有自己的看法，所以你可以从最小的错误代价开始学习 Spring Boot。大多数 Spring Boot 应用程序只需要很少的Spring配置。
你可以使用 Spring Boot 创建一个使用 java -jar 运行的 Java 应用程序或者传统的 war 包。我们还提供了一个运行 “spring scripts” 的命令行工具。
我们的主要目标是:
1. 为所有Spring开发提供一个更快，更广泛的入门体验。
2. 开箱即用，但随着需求开始偏离默认设置，快速退出(也就是自己做些其他配置)。
3. 提供大量广泛使用的非功能特性（如嵌入式服务器，安全、指标、运行状态检查、外部配置等）
4. 没有代码生成也不需要xml配置

9、系统要求

默认情况下，Spring Boot 1.5.9.RELEASE需要 Java 7 和Spring Framework 4.3.13.RELEASE或更高版本。您可以使用带有Java 6的Spring Boot以及其他一些配置。有关更多详细信息，请参见 Section 84.11, “How to use Java 6"。为Maven（3.2+）和Gradle 2（2.9或更高版本）和3提供了明确的构建支持。

虽然可以使用Java 6或7的构建Spring Boot，但是我们通常推荐使用Java 8。

9.1 Servlet 容器

以下嵌入式servlet容器是开箱即用的：

名称	Servlet版本	Java版本
Tomcat 8	3.1	Java 7+
Tomcat 7	3.0	Java 6+
Jetty 9.3	3.1	Java 8+
Jetty 9.2	3.1	Java 7+
Jetty 8	3.0	Java 6+
Undertow 1.3	3.1	Java 7+

您也可以将Spring Boot应用程序部署到任何与Servlet 3.0+兼容的容器。

10、安装 Spring Boot

Spring Boot可以与“经典”Java开发工具一起使用，也可以作为命令行工具安装。无论如何，您将需要Java SDK v1.6或更高版本。在开始之前，您应该检查您当前的Java安装版本：

java -version
如果您对Java开发不熟悉，或者您只是想尝试 Spring Boot，则可能需要先尝试 Spring Boot CLI，否则请阅读'经典'安装说明。

尽管Spring Boot与Java 1.6兼容，但如果可能的话，应该考虑使用最新版本的Java。

10.1、给Java开发人员的安装说明

您可以像使用任何标准Java库一样使用Spring Boot。你只需在你的类路径中包含相应的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，您可以按照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项目继承，并将依赖项声明为一个或多个“启动器Starters”。Spring Boot还提供了一个可选的Maven插件来创建可执行的jar文件。
这是一个典型的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.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.9.RELEASE</version>
    </parent>

    <!-- Add typical dependencies for a web application -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId><!-- web支持 -->
        </dependency>
    </dependencies>

    <!-- Package as an executable jar 打包成可执行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文件中继承，或者您可能不喜欢我们的默认设置。有关使用import范围的替代解决方案，请参见Section 13.2.2, “Using Spring Boot without the parent POM”

10.1.2、Gradle安装

Spring Boot与Gradle 2（2.9或更高版本）和Gradle 3兼容。如果您尚未安装Gradle，则可以按照www.gradle.org/上的说明进行操作。
Spring Boot 依赖可以使用 org.springframework.boot group进行声明。通常，您的项目将声明依赖关系到一个或多个Starters。 Spring Boot提供了一个有用的Gradle插件，可以用来简化依赖声明和创建可执行的jar。

Gradle Wrapper

Gradle Wrapper提供了一种在需要构建项目时“获取”Gradle的好方法。这是一个小脚本和库，与代码一起提交以引导构建过程。有关详细信息，请参阅docs.gradle.org/2.14.1/user…。

这是一个典型的build.gradle文件：

plugins {
    id 'org.springframework.boot' version '1.5.9.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来快速创建原型，可以使用它。它允许你运行Groovy脚本，这意味着你有一个熟悉的类Java语法，没有太多的样板代码。
您可以不需要使用CLI来使用Spring Boot，但它绝对是创建Spring应用程序的最快捷方式。

10.2.1、手动安装

您可以从Spring软件仓库中下载Spring CLI发行版：
- spring-boot-cli-1.5.9.RELEASE-bin.zip
- spring-boot-cli-1.5.9.RELEASE-bin.tar.gz
最前沿的snapshot distributions也是可用的。
下载之后，请按照解压缩归档中的 INSTALL.txt 说明进行操作。总结：在.zip文件的bin /目录下有一个spring脚本（适用于Windows的spring.bat），或者可以使用带有.jar文件的java -jar（该脚本可以帮助您确定类路径是否设置正确）。

10.3、从早期版本的Spring Boot升级（即Spring Boot 版本的升级）

如果您是从早期版本的Spring Boot进行升级，请查看project wiki上托管的“release notes”。您会发现升级说明以及每个版本的‘新增加、值得注意’的特性列表。
要升级现有的CLI安装，请使用相应的package manager命令（例如brew upgrade），或者如果您手动安装了CLI，请按照standard instructions记住更新PATH环境变量以删除所有旧的引用。

11、开发我们的第一个 Spring Boot 应用程序

我们用Java开发一个简单的“Hello World！”Web应用程序，重点介绍Spring Boot的一些关键特性。我们将使用Maven来构建这个项目，因为大多数IDE都支持它。

spring.io网站包含许多使用Spring Boot的“入门指南”。如果你想解决一个特定的问题，先在那里检查。您可以通过转到start.spring.io并从依赖关系搜索器中选择Webstarter来快速执行以下步骤。这将自动生成一个新的项目结构，以便您可以立即开始编码。检查文档以获取更多详细信息。
在我们开始之前，请打开命令终端，检查是否安装了Java和Maven的有效版本。
```
$ 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
复制代码
```
此示例需要在其自己的文件夹中创建。后续的说明假定你已经创建了一个合适的文件目录（其实就是标准的maven，我们也可以通过start.spring.io自动生成项目目录，小编接下来会截图给大家看），并且保证命令行终端是你的“当前目录”（也就是项目根目录,小编是在boot目录下）。

小编的目录结构如下：

- boot
    - src
        - main
            - java
                - Example.java
        - test
            - java
    - pom.xml
    
复制代码

11.1、创建POM文件

我们需要从创建一个Maven pom.xml文件开始。 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.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.9.RELEASE</version>
</parent>

<!-- Additional lines to be added here... -->

</project>
复制代码

你可以通过运行mvn package来测试构建是否正确，但注意目前所打包出来是空的包，你可以忽略譬如“jar will be empty - no content was marked for inclusion!”的警告。

此时，您可以将项目导入IDE（大多数现代Java IDE包含对Maven的内置支持）。为了简单起见，我们将继续在这个例子中使用纯文本编辑器。

11.2、添加classpath依赖关系

Spring Boot提供了许多starters，我们可以很方便地将jar添加到你的classpath中。我们的示例应用程序已经在POM的父节点中使用了spring-boot-starter-parent。 spring-boot-starter-parent是一个特别的starter，提供了有用的Maven默认值。它还提供了一个dependency-management 功能，以便您可以省略version标记以获得“blessed(好的意思吧！)”的依赖关系。
其他“starter”只是提供开发特定类型的应用程序(比如web嘛！)时可能需要的依赖关系。由于我们正在开发一个Web应用程序，我们将添加一个spring-boot-starter-web依赖项，但在此之前，我们来看看我们目前拥有的。
```
$ mvn dependency:tree

[INFO] com.example:myproject:jar:0.0.1-SNAPSHOT

复制代码
```
mvn dependency:tree命令打印项目依赖项的树形表示。你可以看到spring-boot-starter-parent本身不提供依赖关系。(也就是父项目不提供其他如web的依赖，也不管理依赖，web依赖需要我们在自己的子项目POM文件中添加) 让我们编辑我们的pom.xml，并在父节的下面添加spring-boot-starter-web依赖项：
```
<dependencies>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
</dependencies>
复制代码
```
如果你再次运行 mvn dependency:tree 命令，你会发现多出了很多的依赖项，其中就包括内嵌的 Tomcat服务器和Spring Boot本身。

11.3、开始写代码

为了完成我们的应用程序，我们需要创建一个Java文件。 Maven默认会从src / main / java编译源代码，所以你需要创建这个文件夹结构，然后添加一个名为src / main / java / Example.java的文件：

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`注解

在我们的class中，第一个注解就是@RestController。这是一个stereotype（好像是API中的一个包名）注解。这个注解给阅读这个class代码的开发人员一种提示（简单地讲就是表明这个类是什么），但对于 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依赖来“猜测”你将如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以自动配置会假定你正在开发一个Web应用程序并相应地配置Spring。
> Starters and Auto-Configuration
自动配置旨在与starters配合使用，但这两个概念并不直接相关。您可以自由选择和选择starter之外的jar依赖项，并且Spring Boot将尽其所能地自动配置到您的应用程序当中。

11.3.3、main 方法

我们的应用程序的最后一部分是 main 方法。这只是一个遵循Java约定的应用程序入口点的标准方法。我们的 main 方法通过调用run来委托Spring Boot的SpringApplication类。 SpringApplication将引导我们的应用程序，开启Spring并继而转向启动自动配置的Tomcat Web服务器。我们需要将Example.class作为参数传递给run方法，以告知SpringApplication是Spring的主要组件。 args数组也被传递以暴露任何命令行参数。

11.4、运行我们的应用程序

到这里我们的应用程序应该是可以运行了。由于我们使用了spring-boot-starter-parent POM，所以我们知道怎样找到程序运行的入口（main方法），所以我们可以使用它来启动应用程序。

$ mvn spring-boot:run

.   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
    '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.222 seconds (JVM running for 6.514)
复制代码

如果你打开一个web浏览器到localhost：8080你应该看到下面的输出：
```
Hello World!
复制代码
```
要正常退出应用，按住键盘ctrl+c即可。

11.5、创建一个可执行的 jar 文件

让我们通过创建一个完全独立的可执行jar文件来完成我们的例子，我们可以在生产环境中运行它。可执行jar（有时也称为“fat jars”）是包含您编译的类以及您的代码需要运行的所有jar依赖项的归档文件。

可执行的 jars and Java

Java不提供任何标准的方式来加载嵌套的jar文件（即jar文件本身包含在jar中）。如果您正在分发自包含的应用程序，这可能会有问题。为解决这个问题，很多开发者开发了如uber jars.一个uber jar将来自不同 jar包的类打包成一个可发布的archive。这种方法的问题在于，很难在应用程序中看到项目实际使用的库。如果在多个jar中使用相同的文件名（但具有不同的内容,即不同jar种类名有可能相同嘛！），则也可能是有问题的。 Spring Boot采用了不同的方法，可以直接嵌入jar。
要创建一个可执行的jar文件，我们需要将spring-boot-maven-plugin添加到我们的pom.xml中。在依赖关系部分下面插入以下几行：
```
<build>
<plugins>
    <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
    </plugin>
</plugins>
</build>
复制代码
```
spring-boot-starter-parent POM中包含<executions>配置来绑定repackage目标。如果您不使用父POM，则需要自行声明此配置。有关详细信息，请参阅插件文档。

保存你的pom.xml并从命令行运行mvn package：

$ 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.9.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
复制代码

如果您查看target(注：在项目目录下会生成一个target目录)目录，则应该看到myproject-0.0.1-SNAPSHOT.jar。该文件大小应该在10 MB左右。如果你想偷看里面到底是什么东西，你可以使用jar tvf：

$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
您还应该在target目录中看到一个名为myproject-0.0.1-SNAPSHOT.jar.original的小得多的文件。这是Maven在被Spring Boot重新包装之前创建的原始jar文件。

要运行该应用程序，请使用java -jar命令：

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

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::  (v1.5.9.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)
复制代码

像以前一样，要优雅地退出应用程序点击ctrl-c。

12、接下来要读什么？

希望本节为您提供了一些Spring Boot的基础知识，并帮助您编写自己的应用程序。如果您是面向任务的开发人员，则可能需要跳至spring.io，并查看一些入门指南，以解决具体的“如何使用Spring”问题; 我们也有Spring Boot特定的How - to指南文档。
Spring Boot版本库也有一些你可以运行的例子。例子独立于代码的其余部分（也就是说，您不需要构建其余的代码来运行或使用例子）。
否则，下一个逻辑步骤是阅读第三部分“使用Spring Boot”。如果你真的不耐烦，也可以跳过来阅读Spring Boot的特性。