SpringBoot2.x参考指南（中文版） 第二部分 开始入门

转载请注明出处：http://blog.csdn.net/hitliuxiaodong/article/details/53259797
本人水平有限，翻译中的错误还请多多指教
　如果你第一次使用SpringBoot或者刚接触Spring，这部分就是为你准备哒。在这里我们将回答：是什么？为什么？怎么做？三个基本的问题。随着SpringBoot的安装，你将对SpringBoot有一个基本的印象。我们接下来将开始构建我们第一个SpringBoot项目，也会讨论一下核心准则。
　
　8.SpringBoot的介绍
　
　SpringBoot使得构建可以直接运行的独立、可发布的Spring项目变得非常容易。我们将Spring库和其他第三方库整合进来，使你可以没有很多疑惑的开始构建项目。大部分SpringBoot项目需要很少的Spring配置就够了。
　你可以使用SpringBoot构建通过java -jar运行的java项目，也可以构建相对传统的war项目。我们也提供了一个命令行工具以便运行”Spring脚本”
　我们的初级目标是：

• 提供一个从根本上快速简洁的Spring开发体验
• 提供诸多非必须的但是在大型的项目中很常见的功能（比如：整合的服务器，安全等）

• 无须生成代码和xml配置

  9.系统要求
  默认情况下，SpringBoot2.0.0.Build-SnapShot需要java7和SpringFramework5.0.0Build-Snapshot或者更高的版本。你也可以使用java6，不过需要一些额外的配置。请看第 Section 80.11。构建工具需要Maven（3.2+）或者Gradle2(2.9+)。Gradle3不提供支持。

  尽管你可以使用java6或者java7,不过我们还是建议你尽可能的使用java8

  9.1 Servlet容器
  下面的容器是SpringBoot内部整合的

Name	ServletVersion	Java version
Tomcat8	3.1	java7+
Tomcat7	3.0	java6+
Jetty9.3	3.1	java8+
Jetty9.2	3.1	java7+
Jetty8	3.1	java6+
Undertow 1.3	3.1	java7+

你也可以在任何支持Servlet 3.0+的容器中部署SpringBoot项目

10.安装SpringBoot
SpringBoot可以使用传统的Java开发工具或者命令行工具。但是无论如何你需要使用java1.6或者更高版本。你可以使用以下命令检查java版本
$java -version
如果你是一枚Java开发新手，或者你只是想体验一下SpringBoot，你可以尝试使用 SpringBootCLI 工具，或者阅读一下安装指南。

尽管SpringBoot可以在java1.6上运行良好，如果可能的话还是要用Java的最新版本

10.SpringBoot安装指南

你可以像使用传统的Java库一样使用SpringBoot，也就是把sping-boot-*.jar放到你的classpath中。SpringBoot不需要额外的插件整合，因此你可以使用任何IDE或者文本编辑器。另外SpringBoot项目和普通的java项目没有什么区别，因此你可以向运行调试普通java项目一样运行调试SpringBoot项目。

尽管你可以只把jar包拷贝到构建路径，不过我们还是强烈建议你使用构建工具（比如Maven或者Gradle）

10.1.1 Maven配置
SpringBoot可以和ApacheMaven3.2及以上版本正常工作。如果你没有安装Maven，可以参考 教程

在大多数操作系统上，可以通过包管理工具安装Maven。如果你是 OSx系统，可以使用 brew install maven Ubuntu系统可以使用 sudo apt-get install maven

SpringBoot的依赖使用 org.springframework.boot groupId。一个典型的SpringBoot项目的pom需要继承 spring-boot-starter-parent 依赖于 一个或者多个 “Starters”.SpringBoot也提供 Maven plugin 来创建可执行jar包。
下面是一个典型的 pom.xml 文档

<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.0modelVersion>

    <groupId>com.examplegroupId>
    <artifactId>myprojectartifactId>
    <version>0.0.1-SNAPSHOTversion>

    
    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.0.BUILD-SNAPSHOTversion>
    parent>

    
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

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

    
    
    <repositories>
        <repository>
            <id>spring-snapshotsid>
            <url>http://repo.spring.io/snapshoturl>
            <snapshots><enabled>trueenabled>snapshots>
        repository>
        <repository>
            <id>spring-milestonesid>
            <url>http://repo.spring.io/milestoneurl>
        repository>
    repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshotsid>
            <url>http://repo.spring.io/snapshoturl>
        pluginRepository>
        <pluginRepository>
            <id>spring-milestonesid>
            <url>http://repo.spring.io/milestoneurl>
        pluginRepository>
    pluginRepositories>
project>

使用SpringBoot的最好方法是 继承 spring-boot-starter-parent,不过有时候并不合适。有时需要使用继承自其他 父 pom ，或者不想使用默认的设置。这时候 请看下面 的教程

10.1.2 Gradle配置

SpringBoot兼容Gradle2(2.9+).推荐 Gradle2.14.1,Gradle3是不支持的。如果你没有安装Gradle，请参照Gradle官方安装教程www.gradle.org

SpringBoot的依赖需要用 org.springframework.boot groupId。你的项目可能需要声明一个或者多个 “Starters”的依赖。SpringBoot也提供了一个插件Gradle plugin供生成可执行的jar包

Gradle Wrapper
GradleWrapper提供一个很简洁的方法来生成一个项目。它包含一些脚本和一些库以供启动构建线程。详情请见 https://docs.gradle.org/2.14.1/userguide/gradle_wrapper.html

下面是一个典型的 build.gradle 脚本

buildscript {
    repositories {
        jcenter()
        maven { url "http://repo.spring.io/snapshot" }
        maven { url "http://repo.spring.io/milestone" }
    }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.0.BUILD-SNAPSHOT")
    }
}

apply plugin: 'java'
apply plugin: 'org.springframework.boot'

jar {
    baseName = 'myproject'
    version =  '0.0.1-SNAPSHOT'
}

repositories {
    jcenter()
    maven { url "http://repo.spring.io/snapshot" }
    maven { url "http://repo.spring.io/milestone" }
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

10.2 安装 SpringBootCLI 工具
SpringBootCLI是一个命令行工具，使用该工具可以快速体验Spring的原型，它允许你运行 Groovy 脚本，意味着你可以使用java相似的语法

你工作时无需使用 SpringBootCLI ，不过它定义了一种新的快速构建Spring项目的方法

10.2.1 安装手册

你可以从下面两个分支下载 Sping-boot-cli

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip
• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

下载完成后，就可以按照压缩包中的 INSTALL.txt 中的步骤进行安装。

10.2.2 安装 SDKMAN!
SDKMAN! (The Software Development Kit Manager) 可以用来管理多个 不同的 SDK,包括 Groovy 和 SpringBootCLI.可以从 sdkman.io 进行下载,然后执行下面的命令进行安装

$ sdk install springboot
$ spring --version
Spring Boot v2.0.0.BUILD-SNAPSHOT

如果你想为CLI 增强功能，想更快的使用你编译的版本，你可以使用如下的方法:

$ sdk install springboot dev /path/to/spring-boot/spring-boot-cli/target/spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin/spring-2.0.0.BUILD-SNAPSHOT/
$ sdk default springboot dev
$ spring --version
Spring CLI v2.0.0.BUILD-SNAPSHOT

这样就会安装一个叫做 dev 的实例，它指向你编译的位置，这样每次重新编译SpringBoot，Spring都会是最新的。
你可以使用如下命令查看

$ sdk ls springboot

================================================================================
Available Springboot Versions
================================================================================
> + dev
* 2.0.0.BUILD-SNAPSHOT

================================================================================
+ - local version
* - installed
> - currently in use
================================================================================

10.2.3 OSX Homebrew 安装

如果你正在使用 MAC 并且在使用 Homebrew，那么你执行如下命令就可以安装SpringBootCLI:

$ brew tap pivotal/tap
$ brew install springboot

Homebrew就会把 spring 安装到 usr/local/bin

如果你看不到这样的提示，可能是你的brew不够新，执行 brew update 进行更新，重试一下就好

10.2.4 MacPorts安装
如果你正在使用mac,并且在使用 MacPorts,你只需要执行：

$ sudo port install spring-boot-cli

10.2.5 命令行自动补全

SpringBootCLI 为 BASH 和 zsh shells提供有自动补全功能。你可以在任何 shell中使用，或者把放在个人或者系统自动补全字典里。在Debian系统里，system-wide scripts（这个我不太知道是什么意思）在 /shell-completion/bash，这里的脚本在新的shelli启动时都会执行。如果想手动执行，可以使用 SDKMAN!

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

如果你在使用Homebrew 或者 MacPorts，那么SpringBootCLI就会自动和Shell绑定。

10.2.6 一个SpringCLI的例子

下面是一个非常简单的Web项目，你可用它来测试是否安装成功。创建一个名称为 app.groovy 的文件:

@RestController
class ThisWillActuallyRun {

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

}

然后通过shell执行：

$ spring run app.groovy

第一次执行可能会慢一点，因为需要下载相关的依赖库，下次就快了

在浏览器中 输入 localhost:8080 你就可以看到：

Hello World!

10.3 从早期版本升级

如果你想从早期版本进行升级，请查看 project wiki 中的 “release notes”.你将在那里看到相关的升级指南

如果你想升级早期的 CLI工具，可以使用上面的包管理工具（比如:brew upgrade)。如果是手动安装的，请参照 指南 进行升级，记得更改环境变量。

11.开发第一个SpringBoot项目

让我们通过一个简单的 “hello world” 项目来看看 SpringBoot的一些动人的特点。我们将使用Maven来构建，因为大多数IDE都支持Maven。
在开始之前，请打开一个终端，确保我们有正确的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

本例子需要在一个单独的文件夹里。下面的流程默认你已经创建了一个合适的文件夹，并且是你的当前目录。

11.1 创建 pom.xml 文件
我们需要创建一个 pom.xml 文件。这个文件是项目的清单。打开你的文本编辑器，然后输入一下文本：

<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.0modelVersion>

    <groupId>com.examplegroupId>
    <artifactId>myprojectartifactId>
    <version>0.0.1-SNAPSHOTversion>

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.0.0.BUILD-SNAPSHOTversion>
    parent>

    

    
    <repositories>
        <repository>
            <id>spring-snapshotsid>
            <url>http://repo.spring.io/snapshoturl>
            <snapshots><enabled>trueenabled>snapshots>
        repository>
        <repository>
            <id>spring-milestonesid>
            <url>http://repo.spring.io/milestoneurl>
        repository>
    repositories>
    <pluginRepositories>
        <pluginRepository>
            <id>spring-snapshotsid>
            <url>http://repo.spring.io/snapshoturl>
        pluginRepository>
        <pluginRepository>
            <id>spring-milestonesid>
            <url>http://repo.spring.io/milestoneurl>
        pluginRepository>
    pluginRepositories>
project>

然后运行 mvn package ,可以忽略”jar will be empty - no content was marked for inclusion!”的提示

此时你可以把它导入你的常用IDE中。为了简单，我们还用文本编辑器

11.2 添加classpath依赖
SpringBoot提供有许多的 “Starters” 来使构建变得简单。我们的例子已经在POM的 parent 中使用了
spring-boot-starter-parent 。这个 spring-boot-starter-parent 是一个特殊的 starter 提供有maven的默认配置。它也提供有 dependency-management 模块 来省略 version 标签

其他的 “starters” 也提供有一些依赖以供你开发特殊的程序是使用。因为我们在开发一个 web项目，所有我们需要添加上 spring-boot-starter-web 依赖。但是在这之前，让我们看看现在已经拥有的依赖

$ 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 依赖：

<dependencies>
    <dependency>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-webartifactId>
    dependency>
dependencies>

如果你再运行mvn dependency:tree，就可以看到项目多了很多依赖，包括tomcat服务器和SpringBoot自身的依赖。

11.3写代码
为了完成我们的项目，我们还需要创建一个java file。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 注释
我们例子中的第一个注释是 @RestController。这个注释在Spring中有特殊的涵义，意味着这是一个控制器，因此Spring会用它来处理web请求。
@RequestMapping 这个注释提供有路由信息。它告诉Spring 凡是请求路径为 “/”的Http请求都应该由 home 方法来处理。同时这个注释也告诉Spring 直接渲染结果的 string 给调用者。

@RestController和@RequestMapping是SpringMVC中的注释。可以通过 MVC section来了解更多信息

11.3.2 @EnableAutoConfiguration 注释
第二个类级别的注释是 @EnableAutoConfiguration。这个注释告诉SpringBoot去猜测你想如何配置Spring，主要根据你添加的jar包。因为 spring-boot-starter-web添加有tomcat和SpringMVC，所以SpringBoot会认为你在开发一个web项目，并以此进行配置。

Starters and Auto-Configuration
Auto-Configuration设计用来更好的和 "Starters" 协同工作。不过这两个概念并不直接相连。你可以自由选择jar包依赖，并且spring-boot仍然会很好的自动配置你的项目。

11.3.3 “main” 方法
最后的部分是应用的main方法。这是标准的java程序入口方法。我们的主方法委托给SpringBoot的SpringApplication类的run方法。SpringApplication会启动我们的程序，启动自动配置的tomcat。我们需要把Example.class作为参数传递给SpringApplication。

11.4 运行实例

这时候我们的程序就可以工作了。因为我们配置了 spring-boot-starter-parent POM,我们就可以运行我们的程序了。在控制台输入 mvn spring-boot:run 来启动应用程序

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

此时我们就可以在浏览器中输入 localhost:8080 看到相关输出：

Hello World!

可以通过 ctrl+c 实现优雅退出程序

11.5 生成可执行jar文件
最后让我们通过生成可执行jar包来结束例子。可执行jar包中包含执行所需的所有类和依赖。

可执行jar包和java
java 本身没有提供一个标准的方法生成可执行jar。这会在我们分发应用时造成问题。

为了解决这个问题，许多开发者使用 “uber” jars。“uber” jars只是把生成的类简单的打成一个压缩包。这样的问题是没法看到程序中应用了哪些类。这样还有一个问题，就是多个相同的文件名的文件（内容不同）被使用了

SpringBoot采用不同的方法允许你直接打包

为了创建一个可执行的 jar 包，我们需要在 pom文件中添加 spring-boot-maven-plugin。

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

spring-boot-starter-parent POM 包含 配置 来绑定打包。如果你没有使用给定的父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:2.0.0.BUILD-SNAPSHOT:repackage (default) @ myproject --- [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------

如果你看 target目录 你就可以看到 myproject-0.0.1-SNAPSHOT.jar文件。这个文件大约10M。如果你想看文件内部，你就可以使用 jar tvf:
$ jar tvf target/myproject-0.0.1-SNAPSHOT.jar
你也可以在target里看到一个相对小很多的文件，文件名为 myproject-0.0.1-SNAPSHOT.jar.original。这个原始文件是由SpringBoot打包前，由maven创建的。
为了运行该应用，可以使用 java -jar命令：

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

最后，可以通过ctrl+c 优雅退出

12.接下来
本部分提供了一些SpringBoot的基础知识，也带领你开始写自己的程序。如果你是一个任务驱动型的开发者，你也许想跳到 http://spring.io 看看”Spring 能够做什么的问题 “’ 我们也提供有 SpringBoot How-to 的参考文档

Spring Boot repository中有一些例子可以学习。这些例子都是彼此独立的。

另外，接下来的步骤是阅读 第三部分 使用 SpringBoot.如果你实在没有耐心，你也可以调到前面阅读 Spring特点一章。