Tutorialspoint Spring Boot 教程

来源：易百教程

Spring Boot教程™

Spring Team在现有Spring框架的基础上发布了一个创新的主要框架:Spring Boot。这是一个来自Pivotal Team(Spring Team)的全新项目。Spring Boot是他们最新的创新，能够跟上不断变化的技术需求。 开发Spring Boot的主要动机是简化配置和部署spring应用程序的过程。

Spring Boot为开发提供一个具有最小功能的Spring应用程序，并提供了一个新的范例。使用Spring Boot将能够以更灵活的方式开发Spring应用程序，并且能够通过最小(或可能没有)配置Spring来专注于解决应用程序的功能需求。它使用全新的开发模型，通过避免一些繁琐的开发步骤和样板代码和配置，使Java开发非常容易。

Spring Boot可以轻松创建单独的，生产级的基于Spring的应用程序，我们只管“运行”。查看Spring平台和第三方库。大多数Spring Boot应用程序只需要很少的Spring配置。

Spring Boot的主要特点

创建独立的Spring应用程序

直接嵌入Tomcat，Jetty或Undertow（无需部署WAR文件）

提供“初始”的POM文件内容，以简化Maven配置

尽可能时自动配置Spring

提供生产就绪的功能，如指标，健康检查和外部化配置

绝对无代码生成，也不需要XML配置

Spring Boot核心和限制

Spring Boot不是编写应用程序的框架，它可以帮助我们以最少的配置或零配置开发和构建，打包和部署应用程序。

它不是应用程序服务器。但是它是提供应用程序服务器功能的嵌入式servlet容器，而不是Spring Boot本身。
类似地，Spring Boot不实现任何企业Java规范，例如JPA或JMS。 例如，Spring Boot不实现JPA，但它通过为JPA实现(例如Hibernate)自动配置适当的bean来支持JPA。
最后，Spring Boot不使用任何形式的代码生成来完成它的功能。它是利用Spring 4的条件配置功能，以及Maven和Gradle提供的传递依赖关系解析，以在Spring应用程序上下文中自动配置bean。

简而言之，Spring Boot它的核心就是Spring。

Spring Boot优点和缺点

使用Java或Groovy开发基于Spring的应用程序非常容易。

它减少了大量的开发时间并提高了生产力。

它避免了编写大量的样板代码，注释和XML配置。

Spring Boot应用程序与其Spring生态系统(如Spring JDBC，Spring ORM，Spring Data，Spring Security等)集成非常容易。

它遵循“自用默认配置”方法，以减少开发工作量。

它提供嵌入式HTTP服务器，如Tomcat，Jetty等，以开发和测试Web应用程序非常容易。

它提供CLI(命令行界面)工具从命令提示符，非常容易和快速地开发和测试Spring Boot(Java或Groovy)应用程序。

它提供了许多插件来开发和测试Spring启动应用程序非常容易使用构建工具，如Maven和Gradle。

它提供了许多插件，以便与嵌入式和内存数据库工作非常容易。

Spring Boot的限制

将现有或传统的Spring Framework项目转换为Spring Boot应用程序是一个非常困难和耗时的过程。它仅适用于全新Spring项目。

未来的Spring项目不会有任何XML配置作为它的一部分，一切都将由项目Spring Boot处理。

官方参考指南包括所有功能的详细说明，以及常见用法的详细说明。

Spring框架结构图如下所示 -

可以使用Spring Boot创建java -jar或更多传统war部署来启动Java应用程序。还提供了一个运行“spring scripts”的命令行工具。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot教程

Spring Boot是什么？ - Spring Boot教程™

Spring Boot是什么？

首先Spring Boot不是一个框架，它是一种用来轻松创建具有最小或零配置的独立应用程序的方式。这是方法用来开发基于Spring的应用，但只需非常少的配置。它提供了默认的代码和注释配置，快速启动新的Spring项目而不需要太多时间。它利用现有的Spring项目以及第三方项目来开发生产就绪(投入生产)的应用程序。它提供了一组Starter Pom或gradle构建文件，可以使用它们添加所需的依赖项，并且还便于自动配置。

Spring Boot根据其类路径上的库自动配置所需的类。假设应用程序想要与数据库交互，如果在类路径上有Spring数据库，那么它会自动建立与数据源类的连接。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot是什么？

Spring Boot主要目标 - Spring Boot教程™

Spring Boot主要目标

Spring Boot的主要目标是：

为所有Spring开发提供一个基本的，更快，更广泛的入门体验。

开箱即用，但随着需求开始偏离默认值，快速启动。

提供大型项目(例如嵌入式服务器，安全性，度量，运行状况检查，外部化配置)常见的一系列非功能特性。

绝对没有代码生成以及不需要XML配置，完全避免XML配置。

为了避免定义更多的注释配置(它将一些现有的 Spring Framework 注释组合成一个简单的单一注释)

避免编写大量import语句。

提供一些默认值，以便在短时间内快速启动新项目。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot主要目标

新项目为什么需要Spring Boot？ - Spring Boot教程™

假设要在Spring Framework中开发一个Hello World应用程序，因为只有一个项目专用于开发Hello World功能：它就是控制器。其余的是任何使用Spring开发的Web应用程序的通用模板文件。但是如果所有Spring Web应用程序都需要它，为什么都要在每个项目中都必须提供它？ 以下是新项目需要Spring Boot的理由了。

简化基于Java的应用程序开发，单元测试和集成测试过程。

通过提供一些默认值来减少开发，单元测试和集成测试时间。

提高生产力。

当使用默认值时，Spring Boot有自己的看法。如果不指定详细信息，它将使用其自己的默认配置。如果想要持久化，但是没有在POM文件中指定任何东西，那么Spring Boot会将Hibernate带有HSQLDB数据库的配置作为JPA提供者。

为大型项目(例如嵌入式服务器，安全性，度量，健康检查，外部化配置)提供许多非常常见的非功能特性/解决方案。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » 新项目为什么需要Spring Boot？

Spring Boot核心和限制 - Spring Boot教程™

Spring Boot不是编写应用程序的框架，它可以帮助我们以最少的配置或零配置开发和构建，打包和部署应用程序。

它不是应用程序服务器。但是它是提供应用程序服务器功能的嵌入式servlet容器，而不是Spring Boot本身。
类似地，Spring Boot不实现任何企业Java规范，例如JPA或JMS。 例如，Spring Boot不实现JPA，但它通过为JPA实现(例如Hibernate)自动配置适当的bean来支持JPA。
最后，Spring Boot不使用任何形式的代码生成来完成它的功能。它是利用Spring 4的条件配置功能，以及Maven和Gradle提供的传递依赖关系解析，以在Spring应用程序上下文中自动配置bean。

简而言之，Spring Boot它的核心就是Spring。

未来的Spring项目不会有任何XML配置作为它的一部分，一切都将由项目Spring Boot处理。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot核心和限制

Spring Boot优点和缺点 - Spring Boot教程™

Spring Boot优点和缺点

Spring Boot的优点：

使用Java或Groovy开发基于Spring的应用程序非常容易。

它减少了大量的开发时间并提高了生产力。

它避免了编写大量的样板代码，注释和XML配置。

Spring Boot应用程序与其Spring生态系统(如Spring JDBC，Spring ORM，Spring Data，Spring Security等)集成非常容易。

它遵循“自用默认配置”方法，以减少开发工作量。

它提供嵌入式HTTP服务器，如Tomcat，Jetty等，以开发和测试Web应用程序非常容易。

它提供CLI(命令行界面)工具从命令提示符，非常容易和快速地开发和测试Spring Boot(Java或Groovy)应用程序。

它提供了许多插件来开发和测试Spring启动应用程序非常容易使用构建工具，如Maven和Gradle。

它提供了许多插件，以便与嵌入式和内存数据库工作非常容易。

Spring Boot的限制:

将现有或传统的Spring Framework项目转换为Spring Boot应用程序是一个非常困难和耗时的过程。它仅适用于全新Spring项目。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot优点和缺点

Spring Boot入门 - Spring Boot教程™

Spring Boot项目归根只是一个常规的Spring项目，只是利用了Spring Boot启动程序和自动配置。要创建Spring Boot应用程序的方法，Spring团队(The Pivotal Team)提供了以下三种方法。

使用Spring Boot CLI工具

使用Spring STS IDE

使用Spring Initializr (网站 http://start.spring.io/)

可以使用Spring Boot开发两种基于Spring的应用程序：

基于Java的应用程序

基于Groovy的应用程序

我们可以使用Spring Boot CLI或Spring STS IDE或Spring Initializr 网站来开发Spring Boot Groovy应用程序。 但是，我们可以使用Spring STS IDE或Spring Initializr网站来开发Spring Boot Java应用程序。

无论如何，Groovy也是JVM语言几乎类似于Java语言。可以将Groovy和Java组合成一个项目。因为就像Java文件一样，Groovy文件最终只能编译成 *.class 文件。 *.groovy 和 *.java 文件都转换为 *.class 文件(相同字节代码格式)。

Spring Boot框架编程模型的灵感来自Groovy编程模型。 Spring Boot在内部使用一些基于Groovy的技术和工具来提供默认的导入和配置。

Spring Boot框架还将现有的Spring Framework注释组合为一些简单或单个注释。 我们将在后面的帖子中逐个探索这些注释，并附带一些实时示例。

Spring Boot框架将Spring-Java应用程序编程模型彻底改变为新的编程模型。到目前为止，Spring Boot只处于初始阶段，但未来肯定都使用Spring Boot。

Spring Boot CLI

它是使用Spring Boot的最简单和最快速的方法。它是一个用于执行groovy脚本的命令行工具。可以按照以下步骤安装此工具：

从这里下载此项目的二进制发行版。 Spring Boot CLI需要Java JDK V1.6或更高版本才能运行。 Groovy v2.1作为此分发包的一部分进行打包，因此不需要安装(任何现有的Groovy安装都将被忽略)

如果解压zip文件，就会发现spring.bat将检查所有的设置。此脚本可以在目录/bin下找到。

下载Spring Boot CLI Zip文件到本地文件系统，并将spring-boot-cli-1.4.3.RELEASE.zip文件解压缩到本地文件系统中，在本实例中我们解压到 D:\software\yiibai\spring-1.4.3.RELEASE 目录下。

在Windows系统中设置Spring Boot CLI环境变量，如下所示。

set PATH=D:\software\yiibai\spring-1.4.3.RELEASE\bin;%PATH%;

右键“我的电脑”->”高级系统设置”->”高级”->”环境变量”->选择”PATH”并新建并加上面的路径D:\software\yiibai\spring-1.4.3.RELEASE\bin;。如下图所示 -

执行以下命令验证安装结果 -

C:\Users\Administrator>spring --version
Spring CLI v1.4.3.RELEASE

现在Spring Boot CLI安装过程已成功完成。在讨论Spring Boot “HelloWorld”示例之前，首先要确定从命令提示符运行Groovy脚本是否正确。

Spring Boot “spring”命令

Spring Boot CLI提供了一个“spring”命令，用来从命令提示符运行Spring Boot Groovy脚本。Spring Boot 的“spring --help”命令有很多选项，可以将此命令用于不同的目的。其中有一个重要的选项是“run”选项。

“spring”命令语法：

spring run <SpringBoot-Groovy-Scriptname>

这里是Spring Boot应用程序的Groovy脚本文件名。将使用这个命令来执行Spring Boot HelloWorld示例。下面来看看一个 Spring Boot CLI的入门程序，HelloWorld Spring Boot示例。

Spring Boot 的 Hello World示例

可以使用Spring Boot开发两种基于Spring的应用程序。

Groovy应用程序

Java应用程序

Groovy应用程序：

现在我们来开发一个Spring Boot MVC Rest控制器示例。 这是在Pivotal团队的Twitter上发布的第一个例子，演示了Spring Boot框架牛逼的功能。请按照以下步骤开发Spring Boot Hello World示例：

在本地文件系统中创建一个“HelloWorld”文件夹，放置groovy脚本，这里放在 D:\software\yiibai\spring-1.4.3.RELEASE 目录下。

使用以下内容开发Groovy脚本文件。

@RestController
class HelloWorld {
  @RequestMapping("/")
  String hello() {
    "Hello JournalDev World."
  }
}

将此文件命名为HelloWorld.groovy，这里的“.groovy”扩展名是必须的。现在Spring Boot Hello World示例文件夹看起来如下图 -

现在Spring Boot Hello World示例已准备好使用Spring MVC Rest控制器。运行和测试这个例子来了解Spring Boot框架。

在本地文件系统中的“HelloWorld”文件夹中打开命令提示符。执行以下命令 -

spring run HelloWorld.groovy

观察“spring run”命令控制台的输出。

当执行“spring run HelloWorld.groovy”时，它会启动嵌入的Tomcat服务器的默认端口号：8080。现在Spring Boot Hello World示例应用程序已启动并正在运行。下面打开浏览器来测试一下。打开浏览器并访问以下链接。访问此URL：http://localhost:8080/

现在可以看到第一个Spring Boot MVC RESTful WebService示例运行的结果了。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot入门

Spring Boot安装 - Spring Boot教程™

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

$ java -version

如果你是Java开发的新手，或者如果你只想试验Spring Boot，你可能首先尝试Spring Boot CLI，否则，继续阅读“经典”安装说明。

虽然Spring Boot与Java 1.6兼容，如果可能，您应该考虑使用最新版本的Java。

Java开发人员的安装说明

可以使用与标准Java库的方式来使用Spring Boot。只需在类路径中包含适当的spring-boot-*.jar文件即可。 Spring Boot不需要任何特殊工具集成，因此可以使用任何IDE或文本编辑器; 并且Spring Boot应用程序没有什么特别之处，因此您可以像任何其他Java程序一样运行和调试。

虽然可以复制Spring Boot jar，但通常建议使用一个支持依赖管理的构建工具(例如Maven或Gradle)。

Maven安装

Spring Boot与Apache Maven 3.2或更高版本兼容。如果还没有安装Maven，可以参考 http://maven.apache.org 或 http://www.yiibai.com/maven/ 说明来安装。

在许多操作系统上，Maven可以通过软件包管理器安装。如果是OSX Homebrew用户尝试使用 brew install maven。Ubuntu用户可以运行 sudo apt-get install maven 来安装。

Spring引导依赖项groupId使用org.springframework.boot。 通常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.4.3.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继承，或者可能只是不喜欢默认设置。

Gradle安装

Spring Boot与Gradle 1.12或2.x兼容，但不支持2.8和更早版本。建议使用Gradle 2.14.1，但不支持Gradle 3。如果还没有安装Gradle，可以按照 http://www.yiibai.com/gradle/ 说明进行操作。

Spring启动依赖关系可以使用org.springframework.boot组来声明。通常，项目将声明一个或多个“Starters”的依赖关系。 Spring Boot提供了一个有用的Gradle插件，可用于简化依赖性声明和创建可执行jar。

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

plugins {
    id 'org.springframework.boot' version '1.4.3.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")
}

安装Spring Boot CLI

Spring Boot CLI是一个命令行工具，如果想要使用Spring快速原型化，可以使用它。它允许运行Groovy脚本，它有一个类似Java的语法，没有那么多的样板代码。

不一定需要CLI来使用Spring Boot，但它绝对是让Spring应用程序实现的最快捷方式。

具体安装过程也可参考：http://www.yiibai.com/spring-boot/getting-started-with-spring-boot.html

手动安装

可以从Spring软件存储库下载Spring CLI分发版：

spring-boot-cli-1.4.3.RELEASE-bin.zip

spring-boot-cli-1.4.3.RELEASE-bin.tar.gz

下载后，请按照解压缩的归档中的INSTALL.txt说明进行操作。

总之：下载的.zip文件的 bin/ 目录中有一个Spring脚本(适用于Windows的spring.bat)

参考： http://docs.spring.io/spring-boot/docs/current/reference/html/getting-started-installing-spring-boot.html#getting-started-installing-the-cli

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot安装

Spring Boot应用程序开发入门 - Spring Boot教程™

在本节中，我们来在Java中开发一个简单的“Hello World！” Web应用程序，突出一些Spring Boot的主要特性。在这里将使用Maven来构建这个项目，因为大多数IDE支持它。

在开始之前，打开一个终端，检查是否安装了Java和Maven的有效版本。

C:\Users\Administrator>java -version
java version "1.8.0_65"
Java(TM) SE Runtime Environment (build 1.8.0_65-b17)
Java HotSpot(TM) 64-Bit Server VM (build 25.65-b01, mixed mode)

C:\Users\Administrator>mvn -v
Apache Maven 3.3.9 (bb52d8502b132ec0a5a3f4c09453c07478323dc5; 2015-11-11T00:41:47+08:00)
Maven home: D:\worksp\yiibai.com\apache-maven-3.3.9
Java version: 1.8.0_65, vendor: Oracle Corporation
Java home: D:\Program Files\Java\jdk1.8.0_65\jre
Default locale: zh_CN, platform encoding: GBK
OS name: "windows 10", version: "10.0", arch: "amd64", family: "dos"

此示例需要在其自己的文件夹中创建。后续说明假定您已创建了一个合适的文件夹，并且它是“当前目录”。

提示，如果还没有安装 Maven ，请参考安装教程 - http://www.yiibai.com/maven/maven_environment_setup.html

创建POM文件

我们需要从创建一个Maven pom.xml文件开始。pom.xml是将用于构建项目的配置，在这个示例中，把它放在 D:\spring-boot\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.4.3.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的内置支持)。为了简单起见，这里将继续为此示例使用纯文本编辑器。

添加类路径依赖项

Spring Boot提供了一些“启动器”，使得容易添加 jar 到你的类路径。在我们的示例应用程序已经在POM的父部分中使用了spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的启动器，提供了有用的 Maven 默认值。 它还提供了一个依赖关系管理部分，以便您可以省略“blessed”依赖关系的 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.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

完整的 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.4.3.RELEASE</version>
    </parent>

    <!-- Additional lines to be added here... -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

</project>

如果再次运行mvn dependency:tree命令，将看到现在还有许多其他依赖项，包括Tomcat Web服务器和Spring Boot本身。

编写代码

要完成上面的应用程序示例，我们需要创建一个单一的Java文件。Maven将默认从src/main/java编译源代码，所以需要创建该文件夹结构，然后添加一个名为src/main/java/Example.java的文件，完整的文件路径是 D:/spring-boot/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!"; // Copyright: w w w . y i I b A i.c O m
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(Example.class, args);
    }

}

虽然这里没有太多的代码，但背后有很多事情正在发生。让我们看看代码的重要部分。

@RestController 和 @RequestMapping注解

Example类的第一个注解是@RestController。这称为构造型注释，它为阅读代码的人提供了提示，对于Spring，该类扮演了一个特定的角色。在这种情况下，这个类是一个web @Controller，因此Spring会在处理传入的Web请求时考虑它。

@RequestMapping注解提供了“路由”信息。它告诉Spring任何带有路径“/”的HTTP请求应该映射到home方法。@RestController注解告诉Spring将生成的字符串直接返回给调用者。

@RestController和@RequestMapping注解是Spring MVC注释(它们不是Spring Boot特有的)。有关更多详细信息，请参阅Spring参考文档中的MVC部分。

@EnableAutoConfiguration注解

第二个类级别注解是@EnableAutoConfiguration。这个注解告诉Spring Boot“猜测”将如何配置Spring，它是基于添加的jar依赖。 由于spring-boot-starter-web添加了Tomcat和Spring MVC，因此自动配置将假设正在开发一个Web应用程序并相应地设置Spring。

启动器和自动配置(Starters & Auto-Configuration)
自动配置旨在与“Starters”配合使用，但这两个概念不直接绑定。可以自由选择和选择起始者以外的jar依赖，Spring Boot仍将尽力自动配置应用程序。

“main”方法

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

运行示例

现在，我们的应用程序应该可以正常运行工作了。由于 POM 中使用了spring-boot-starter-parent，有一个有用的 run 目标，用它来启动应用程序。输入 mvn spring-boot:run 从根项目目录启动应用程序：

$ mvn spring-boot:run

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

如果打开Web浏览器访问 http://localhost:8080 ， 应该会看到以下输出：

要正常退出应用程序，请按ctrl-c。

创建可执行jar

现在，我们来完成一个例子，创建一个完全自包含的可执行jar文件，可以在生产中运行。可执行jar(有时称为“fat jar”)是包含编译的类以及需要运行的所有jar依赖性的代码存档。

可执行jar和Java
Java不提供任何标准方法来加载嵌套的jar文件(即包含在jar中的jar文件)。如果想要分发一个自包含的应用程序，这可能是有问题的。
为了解决这个问题，许多开发人员使用“uber” jar。 一个uber jar简单地将所有类，从所有jar到一个单一的归档。这种方法的问题是，很难看到实际上在应用程序中使用哪些库。如果在多个jar中使用相同的文件名(但是具有不同的内容)，它也可能是有问题的。
Spring Boot采用不同的方法，并允许直接嵌套JAR。
要创建可执行的jar，需要将spring-boot-maven-plugin添加到pom.xml文件中。 在dependencies部分下面插入以下行：

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

现在，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.4.3.RELEASE</version>
    </parent>

    <!-- Additional lines to be added here... -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

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

</project>

POM 中 spring-boot-starter-parent 包括<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.4.3.RELEASE:repackage (default) @ myproject ---
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------

在 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.4.3.RELEASE)
....... . . .
....... . . . (log output here)
....... . . .
........ Started Example in 2.536 seconds (JVM running for 2.864)

如果打开Web浏览器访问 http://localhost:8080 ， 应该会看到以下输出：

和之前一样，要正常退出应用程序，同时按住ctrl+c。

到此，第一个 Spring Boot应用程序的开发就结束了。接下来再学习其它方面的知识内容。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot应用程序开发入门

Spring Boot JSP应用实例 - Spring Boot教程™

这是一个Spring Boot web应用程序示例，使用嵌入式Tomcat + JSP模板，并将包作为可执行文件WAR文件发布。

使用到的技术和工具如下:

Spring Boot 1.4.2.RELEASE

Spring 4.3.4.RELEASE

Tomcat Embed 8.5.6

Maven 3

Java 8

项目目录

在这个示例中，是使用 Eclipse 来创建一个 Maven 项目，打开 Eclipse ，按照以下步骤：File -> New -> Other… 如下所示：

第二步，如下 -

第三步，填入相关信息 -

可参考 用Eclipse创建一个Maven Web项目： http://www.yiibai.com/maven/create-a-maven-web-project-with-eclipse.html

最终创建以下文件夹目录结构如下所示：

项目依赖

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>

    <artifactId>spring-boot-web-jsp</artifactId>
    <packaging>war</packaging>
    <name>Spring Boot Web JSP Example</name>
    <description>Spring Boot Web JSP Example</description>
    <url>http://www.yiibai.com</url>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
    </parent>

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

    <dependencies>

        <!-- This is a web application -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- Tomcat embedded container-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- JSTL for JSP -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
        </dependency>

        <!-- Need this to compile JSP -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- Need this to compile JSP,
            tomcat-embed-jasper version is not working, no idea why -->
        <dependency>
            <groupId>org.eclipse.jdt.core.compiler</groupId>
            <artifactId>ecj</artifactId>
            <version>4.6.1</version>
            <scope>provided</scope>
        </dependency>

        <!-- Optional, test for static content, bootstrap CSS-->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.3.7</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

执行后，显示项目依赖关系：

F:\worksp\springboot\springboot-jsp> mvn dependency:tree

[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Spring Boot Web JSP Example 1.0
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-dependency-plugin:2.10:tree (default-cli) @ spring-boot-web-jsp ---
[INFO] org.springframework.boot:spring-boot-web-jsp:war:1.0
[INFO] +- org.springframework.boot:spring-boot-starter-web:jar:1.4.2.RELEASE:compile
[INFO] |  +- org.springframework.boot:spring-boot-starter:jar:1.4.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot:jar:1.4.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot-autoconfigure:jar:1.4.2.RELEASE:compile
[INFO] |  |  +- org.springframework.boot:spring-boot-starter-logging:jar:1.4.2.RELEASE:compile
[INFO] |  |  |  +- ch.qos.logback:logback-classic:jar:1.1.7:compile
[INFO] |  |  |  |  +- ch.qos.logback:logback-core:jar:1.1.7:compile
[INFO] |  |  |  |  \- org.slf4j:slf4j-api:jar:1.7.21:compile
[INFO] |  |  |  +- org.slf4j:jcl-over-slf4j:jar:1.7.21:compile
[INFO] |  |  |  +- org.slf4j:jul-to-slf4j:jar:1.7.21:compile
[INFO] |  |  |  \- org.slf4j:log4j-over-slf4j:jar:1.7.21:compile
[INFO] |  |  +- org.springframework:spring-core:jar:4.3.4.RELEASE:compile
[INFO] |  |  \- org.yaml:snakeyaml:jar:1.17:runtime
[INFO] |  +- org.hibernate:hibernate-validator:jar:5.2.4.Final:compile
[INFO] |  |  +- javax.validation:validation-api:jar:1.1.0.Final:compile
[INFO] |  |  +- org.jboss.logging:jboss-logging:jar:3.3.0.Final:compile
[INFO] |  |  \- com.fasterxml:classmate:jar:1.3.3:compile
[INFO] |  +- com.fasterxml.jackson.core:jackson-databind:jar:2.8.4:compile
[INFO] |  |  +- com.fasterxml.jackson.core:jackson-annotations:jar:2.8.4:compile
[INFO] |  |  \- com.fasterxml.jackson.core:jackson-core:jar:2.8.4:compile
[INFO] |  +- org.springframework:spring-web:jar:4.3.4.RELEASE:compile
[INFO] |  |  +- org.springframework:spring-aop:jar:4.3.4.RELEASE:compile
[INFO] |  |  +- org.springframework:spring-beans:jar:4.3.4.RELEASE:compile
[INFO] |  |  \- org.springframework:spring-context:jar:4.3.4.RELEASE:compile
[INFO] |  \- org.springframework:spring-webmvc:jar:4.3.4.RELEASE:compile
[INFO] |     \- org.springframework:spring-expression:jar:4.3.4.RELEASE:compile
[INFO] +- org.springframework.boot:spring-boot-starter-tomcat:jar:1.4.2.RELEASE:provided
[INFO] |  +- org.apache.tomcat.embed:tomcat-embed-core:jar:8.5.6:provided
[INFO] |  +- org.apache.tomcat.embed:tomcat-embed-el:jar:8.5.6:provided
[INFO] |  \- org.apache.tomcat.embed:tomcat-embed-websocket:jar:8.5.6:provided
[INFO] +- javax.servlet:jstl:jar:1.2:compile
[INFO] +- org.apache.tomcat.embed:tomcat-embed-jasper:jar:8.5.6:provided
[INFO] +- org.eclipse.jdt.core.compiler:ecj:jar:4.6.1:provided
[INFO] \- org.webjars:bootstrap:jar:3.3.7:compile
[INFO]    \- org.webjars:jquery:jar:1.11.1:compile
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 1.327 s
[INFO] Finished at: 2017-01-21 T16:57:00+08:00
[INFO] Final Memory: 20M/309M
[INFO] ------------------------------------------------------------------------

3. Spring Boot

3.1 - 这个SpringBootServletInitializer执行传统的WAR部署运行SpringApplication

SpringBootWebApplication.java文件内容如下所示 -

package com.yiibai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringBootWebApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootWebApplication.class);
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

3.2 - 一个简单的Spring控制器类。WelcomeController.java类的代码如下所示 -

package com.yiibai;

import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WelcomeController {

    // inject via application.properties
    @Value("${welcome.message:test}")
    private String message = "Hello World";

    @RequestMapping("/")
    public String welcome(Map<String, Object> model) {
        model.put("message", this.message);
        return "welcome";
    }

}

4. JSP + 资源 + 静态文件

4.1 - 对于JSP文件，把它们全放入到 src/main/webapp/WEB-INF/jsp/ 目录中。
src/main/webapp/WEB-INF/jsp/welcome.jsp文件的内容如下所示 -

<!DOCTYPE html>
<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html lang="en">
<head>
<meta charset="UTF-8">
    <!-- Access the bootstrap Css like this,
        Spring boot will handle the resource mapping automcatically -->
    <link rel="stylesheet" type="text/css" href="webjars/bootstrap/3.3.7/css/bootstrap.min.css" />
    <!--
    <spring:url value="/css/main.css" var="springCss" />
    <link href="${springCss}" rel="stylesheet" />
     -->
    <c:url value="/css/main.css" var="jstlCss" />
    <link href="${jstlCss}" rel="stylesheet" />
</head>
<body>
    <nav class="navbar navbar-inverse">
        <div class="container">
            <div class="navbar-header">
                <a class="navbar-brand" href="#">Spring Boot</a>
            </div>
            <div id="navbar" class="collapse navbar-collapse">
                <ul class="nav navbar-nav">
                    <li class="active"><a href="#">Home</a></li>
                    <li><a href="#about">About</a></li>
                </ul>
            </div>
        </div>
    </nav>
    <div class="container">
        <div class="starter-template">
            <h1>Spring Boot Web JSP Example</h1>
            <h2>Message: ${message}</h2>
        </div>
    </div>
    <script type="text/javascript" src="webjars/bootstrap/3.3.7/js/bootstrap.min.js"></script>
</body>
</html>

4.2 - 对于像CSS或Javascript这样的静态文件，放在 /src/main/resources/static/ 目录中。/src/main/resources/static/css/main.css文件的内容如下所示 -

h1{
    color:#0000FF;
}
h2{
    color:#FF0000;
}

4.3 - 对于属性文件，放在 /src/main/resources/ 目录下， /src/main/resources/application.properties文件的内容如下所示 -

spring.mvc.view.prefix: /WEB-INF/jsp/
spring.mvc.view.suffix: .jsp

welcome.message: Hello Yiibai

注意
Spring Boot约定过配置，不需要像这样声明资源映射。资源映射只是自动处理。

运行实例

5.1 - 在终端下进入 F:\worksp\springboot\springboot-jsp 目录，执行以下命令，应该会看到以下结果 -

F:\worksp\springboot\springboot-jsp>mvn spring-boot:run
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Spring Boot Web JSP Example 1.0
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> spring-boot-maven-plugin:1.4.2.RELEASE:run (default-cli) > test-compile @ springboot-jsp >>>
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ springboot-jsp ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ springboot-jsp ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ springboot-jsp ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] skip non existing resourceDirectory F:\worksp\springboot\springboot-jsp\springboot-jsp\src\test\resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ springboot-jsp ---
[INFO] Nothing to compile - all classes are up to date
[INFO]
[INFO] <<< spring-boot-maven-plugin:1.4.2.RELEASE:run (default-cli) < test-compile @ springboot-jsp <<<
[INFO]
[INFO] --- spring-boot-maven-plugin:1.4.2.RELEASE:run (default-cli) @ springboot-jsp ---

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
::Spring Boot::       (v1.4.2.RELEASE)

2017-01-21 11:53:26.321  INFO 6584 --- [           main] com.yiibai.SpringBootWebApplication      : Starting SpringBootWebApplication on MY-PC with PID 6584 (F:\worksp\springboot\springboot-jsp\springboot-jsp\target\classes started by Administrator in F:\worksp\springboot\springboot-jsp\springboot-jsp)
2017-01-21 11:53:26.336  INFO 6584 --- [           main] com.yiibai.SpringBootWebApplication      : No active profile set, falling back to default profiles: default
2017-01-21 11:53:26.477  INFO 6584 --- [           main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@1614202d: startup date [Sat Jan 21 11:53:26 CST 2017]; root of context hierarchy
2017-01-21 11:53:28.921  INFO 6584 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2017-01-21 11:53:28.937  INFO 6584 --- [           main] o.apache.catalina.core.StandardService   : Starting service Tomcat
2017-01-21 11:53:28.952  INFO 6584 --- [           main] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.6
2017-01-21 11:53:29.391  INFO 6584 --- [ost-startStop-1] org.apache.jasper.servlet.TldScanner     : At least one JAR was scanned for TLDs yet contained no TLDs. Enable debug logging for this logger for a complete list of JARs that were scanned but no TLDs were found in them. Skipping unneeded JARs during scanning can improve startup time and JSP compilation time.
2017-01-21 11:53:29.406  INFO 6584 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2017-01-21 11:53:29.406  INFO 6584 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 2929 ms
2017-01-21 11:53:29.672  INFO 6584 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Mapping servlet: 'dispatcherServlet' to [/]
2017-01-21 11:53:29.672  INFO 6584 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
2017-01-21 11:53:29.672  INFO 6584 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2017-01-21 11:53:29.688  INFO 6584 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2017-01-21 11:53:29.688  INFO 6584 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
2017-01-21 11:53:30.148  INFO 6584 --- [           main] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@1614202d: startup date [Sat Jan 21 11:53:26 CST 2017]; root of context hierarchy
2017-01-21 11:53:30.258  INFO 6584 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/]}" onto public java.lang.String com.yiibai.WelcomeController.welcome(java.util.Map<java.lang.String, java.lang.Object>)
2017-01-21 11:53:30.258  INFO 6584 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2017-01-21 11:53:30.273  INFO 6584 --- [           main] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2017-01-21 11:53:30.320  INFO 6584 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-01-21 11:53:30.336  INFO 6584 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-01-21 11:53:30.383  INFO 6584 --- [           main] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-01-21 11:53:30.601  INFO 6584 --- [           main] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2017-01-21 11:53:30.787  INFO 6584 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-01-21 11:53:30.787  INFO 6584 --- [           main] com.yiibai.SpringBootWebApplication      : Started SpringBootWebApplication in 5.411 seconds (JVM running for 9.678)

之后，将项目发布到 Tomcat 中，在项目上点击右键，在弹出的选项中选择“Run As -> Ru On Server” ，使用浏览器访问：http://localhost:8080/springboot-jsp/ ，如果程序没有出错误，那应该会看到以下结果 -

JSP限制
不能创建可执行jar来运行这个嵌入式Tomcat + JSP Web示例，因为Tomcat中有一个硬编码文件模式。 阅读以下这篇文章：Spring Boot JSP限制。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot JSP应用实例

Spring Boot将WAR文件部署到Tomcat - Spring Boot教程™

在本文中，将演示如何将Spring Boot WAR文件部署到Tomcat servlet容器中。

对于Spring Boot WAR部署，需要执行三个步骤：

扩展SpringBootServletInitializer

根据提供标记嵌入式servlet容器。

更新包装为 War

测试工具：

Spring Boot 1.4.2.RELEASE

Tomcat 8.5.9

Maven 3

注意
在Spring Boot中，具有嵌入服务器解决方案的最终可执行JAR文件可能不适合所有生产环境，特别是部署团队(具有良好的服务器优化和监控技能知识，但缺乏开发经验的团队)，他们希望完全控制服务器，并且不能接触代码。

1. 推展 SpringBootServletInitializer

使现有的 @SpringBootApplication 类扩展 SpringBootServletInitializer
1.1 - 经典Spring Boot JAR部署(更新此文件以支持WAR部署)。

SpringBootWebApplication.java 文件的内容如下 -

import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootWebApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

1.2 Spring Boot WAR 部署

SpringBootWebApplication.java 文件的内容如下 -

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringBootWebApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootWebApplication.class);
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

/*@SpringBootApplication
public class SpringBootWebApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}*/

如果要为部署创建了一个额外的SpringBootWebApplication类，请确保告诉Spring Boot要从哪个主类开始启动程序：

在 pom.xml 文件中增加以下内容指定 -

<properties>
      <start-class>com.yiibai.NewSpringBootWebApplicationForWAR</start-class>
</properties>

2.提供标记嵌入式servlet容器

在 pom.xml 文件中增加以下内容指定 -

<dependencies>

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

    <!-- marked the embedded servlet container as provided -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-tomcat</artifactId>
        <scope>provided</scope>
    </dependency>

</dependencies>

3.更新包装为War
在 pom.xml 文件中增加以下内容指定 -

<packaging>war</packaging>

完成，mvn打包并将$project/target/xxx.war复制到Tomcat发布目录进行部署。

4. 完整的Spring Boot WAR + Tomcat部署

4.1 - 以Spring Boot Thymeleaf为例，更新它并手动部署到Tomcat。
4.2 - 更新现有的SpringBootWebApplication并让它扩展SpringBootServletInitializer类。

SpringBootWebApplication.java文件的完整代码如下所示 -

package com.yiibai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.support.SpringBootServletInitializer;

@SpringBootApplication
public class SpringBootWebApplication extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
        return application.sources(SpringBootWebApplication.class);
    }

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

4.3 - 更新打包包，并按提供的标记spring-boot-starter-tomcat。
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>

    <artifactId>spring-boot-web-thymeleaf</artifactId>
    <packaging>war</packaging>
    <name>Spring Boot Web Thymeleaf Example</name>
    <description>Spring Boot Web Thymeleaf Example</description>
    <url>http://www.yiibai.com</url>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
    </parent>

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

    <dependencies>

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

        <!-- marked the embedded servlet container as provided -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>

        <!-- hot swapping, disable cache for template, enable live reload -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Optional, for bootstrap -->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.3.7</version>
        </dependency>

    </dependencies>
    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

4.4 - 这是可选的，将contextPath更新为/yiibai以方便稍后作为演示。准备好WAR部署文件。

application.properties 文件的完整内容如下所示 -

welcome.message: Hello Yiibai

server.contextPath=/yiibai

4.5 - 获取Tomcat并部署WAR文件，执行以下命令 -

F:\worksp\springboot\spring-boot-war-tomcat>mvn clean package
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Spring Boot Web Thymeleaf Example 1.0
[INFO] ------------------------------------------------------------------------
Downloading: http://repo.maven.apache.org/maven2/org/springframework/boot/spring-boot-starter-thymeleaf/1.4.2.RELEASE/spring-boot-starter-thymeleaf-1.4.2.RELEASE.pom
Downloaded: http://repo.maven.apache.org/maven2/org/springframework/boot/spring-boot-starter-thymeleaf/1.4.2.RELEASE/spring-boot-starter-thymeleaf-1.4.2.RELEASE.pom (2 KB at 0.7 KB/sec)
Downloading: http://repo.maven.apache.org/maven2/org/thymeleaf/thymeleaf-spring4/2.1.5.RELEASE/thymeleaf-spring4-2.1.5.RELEASE.pom
....
.... ...

将生成的 spring-boot-web-thymeleaf-1.0.war 拷贝到 Tomcat 发布目录下 -

例如，写本文章时，Tomcat 发布目录使用的是 - F:\worksp\springmvc\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\webapps

4.6 - 现在启动 Tomcat，访问：http://localhost:8080/yiibai/ ，程序没有错误问题，应该会看到以下结果 -

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot将WAR文件部署到Tomcat

Spring Boot Hello World(Thymeleaf)示例 - Spring Boot教程™

这是一个Spring Boot Web应用示例，使用嵌入式Tomcat + Thymeleaf模板引擎，并将其作为可执行JAR文件。

使用的相关技术：

Spring Boot 1.4.2.RELEASE

Spring 4.3.4.RELEASE

Thymeleaf 2.1.5.RELEASE

Tomcat Embed 8.5.6

Maven 3

Java 8

1. 项目目录

手动创建以下文件夹目录结构：

2. 项目依赖

声明 spring-boot-starter-thymeleaf以获得开发Spring + Thymeleaf Web应用程序所需的任何程序类库。

参考如下 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>

    <artifactId>spring-boot-web-thymeleaf</artifactId>
    <packaging>jar</packaging>
    <name>Spring Boot Web Thymeleaf 示例</name>
    <description>Spring Boot Web Thymeleaf 示例描述</description>
    <url>http://www.yiibai.com</url>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.2.RELEASE</version>
    </parent>

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

    <dependencies>

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

        <!-- hot swapping, disable cache for template, enable live reload -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

        <!-- Optional, for bootstrap -->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>bootstrap</artifactId>
            <version>3.3.7</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

显示项目依赖关系：

提示： spring-boot-devtools
这个spring-boot-devtools有助于禁用缓存并启用热插拔，以便开发人员总是看到最后的更改。 有利于发展。 阅读这篇 - Spring Boot - 开发工具。尝试修改Thymeleaf模板或属性文件，刷新浏览器以查看更改立即生效。

3. Spring Boot

使用@SpringBootApplication进行注释。 运行此类来启动Spring Boot Web应用程序。

SpringBootWebApplication.java

package com.yiibai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootWebApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

一个简单的Spring控制器类： WelcomeController.java 代码如下 -

package com.yiibai;

import java.util.Map;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WelcomeController {

    // inject via application.properties
    @Value("${welcome.message:test}")
    private String message = "Hello World";

    @RequestMapping("/")
    public String welcome(Map<String, Object> model) {
        model.put("message", this.message);
        return "welcome";
    }

}

4. Thymeleaf +资源+静态文件

对于Thymeleaf模板文件，放入 src/main/resources/templates/ 目录下, src/main/resources/templates/welcome.html 文件代码如下 -

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
<title>Spring Boot Thymeleaf Hello World示例</title>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<link rel="stylesheet" type="text/css"
    href="webjars/bootstrap/3.3.7/css/bootstrap.min.css" />

<link rel="stylesheet" th:href="@{/css/main.css}"
    href="../../css/main.css" />

</head>
<body>

    <nav class="navbar navbar-inverse">
        <div class="container">
            <div class="navbar-header">
                <a class="navbar-brand" href="#">Spring Boot</a>
            </div>
            <div id="navbar" class="collapse navbar-collapse">
                <ul class="nav navbar-nav">
                    <li class="active"><a href="#">首页</a></li>
                    <li><a href="#about">关于</a></li>
                </ul>
            </div>
        </div>
    </nav>

    <div class="container">

        <div class="starter-template">
            <h1>Spring Boot Web Thymeleaf示例</h1>
            <h2>
                <span th:text="'Message: ' + ${message}"></span>
            </h2>
        </div>

    </div>
    <!-- /.container -->

    <script type="text/javascript"
        src="webjars/bootstrap/3.3.7/js/bootstrap.min.js"></script>

</body>
</html>
`

对于静态文件，如CSS或Javascript，将它们放入 /src/main/resources/static/ 目录， /src/main/resources/static/css/main.css文件代码如下 -

h1{
    font-size: 20pt;
}
h2{
    font-size: 16pt;
}

对于属性文件，放入 /src/main/resources/ 目录中， /src/main/resources/application.properties 文件中的代码内容如下 -

welcome.message: Hello, Spring Boot

注意: 阅读此Spring Boot服务静态内容以了解资源映射。

5. 运行演示

启动Spring Boot Web应用程序，使用Maven命令：mvn spring-boot:run，运行结果输出结果如下 -

F:\worksp\springboot\spring-boot-web-thymeleaf > mvn spring-boot:run
... ....

Downloaded: http://repo.maven.apache.org/maven2/commons-io/commons-io/1.3.2/commons-io-1.3.2.jar (86 KB at 1.4 KB/sec)
Downloaded: http://repo.maven.apache.org/maven2/org/apache/commons/commons-compress/1.9/commons-compress-1.9.jar (370 KB at 5.9 KB/sec)
Downloaded: http://repo.maven.apache.org/maven2/org/jdom/jdom/1.1/jdom-1.1.jar (150 KB at 2.3 KB/sec)
Downloaded: http://repo.maven.apache.org/maven2/org/sonatype/sisu/sisu-guice/2.1.7/sisu-guice-2.1.7-noaop.jar (461 KB at 6.8 KB/sec)
Downloaded: http://repo.maven.apache.org/maven2/com/google/guava/guava/18.0/guava-18.0.jar (2204 KB at 15.6 KB/sec)
[INFO] Attaching agents: []

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
::Spring Boot::       (v1.4.2.RELEASE)

2017-03-22 02:45:51.162  INFO 5284 --- [  restartedMain] com.yiibai.SpringBootWebApplication      : Starting SpringBootWebApplication on MY-PC with PID 5284 (F:\worksp\springboot\web-thymeleaf\target\classes started by Administrator in F:\worksp\springboot\web-thymeleaf)
2017-03-22 02:45:51.162  INFO 5284 --- [  restartedMain] com.yiibai.SpringBootWebApplication      : No active profile set, falling back to default profiles: default
2017-03-22 02:45:51.740  INFO 5284 --- [  restartedMain] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@e33d3c1: startup date [Wed Mar 22 02:45:51 CST 2017]; root of context hierarchy
2017-03-22 02:45:57.190  INFO 5284 --- [  restartedMain] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat initialized with port(s): 8080 (http)
2017-03-22 02:45:57.221  INFO 5284 --- [  restartedMain] o.apache.catalina.core.StandardService   : Starting service Tomcat
2017-03-22 02:45:57.221  INFO 5284 --- [  restartedMain] org.apache.catalina.core.StandardEngine  : Starting Servlet Engine: Apache Tomcat/8.5.6
2017-03-22 02:45:57.471  INFO 5284 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring embedded WebApplicationContext
2017-03-22 02:45:57.471  INFO 5284 --- [ost-startStop-1] o.s.web.context.ContextLoader            : Root WebApplicationContext: initialization completed in 5731 ms
2017-03-22 02:45:57.815  INFO 5284 --- [ost-startStop-1] o.s.b.w.servlet.ServletRegistrationBean  : Mapping servlet: 'dispatcherServlet' to [/]
2017-03-22 02:45:57.830  INFO 5284 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'characterEncodingFilter' to: [/*]
2017-03-22 02:45:57.846  INFO 5284 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
2017-03-22 02:45:57.846  INFO 5284 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'httpPutFormContentFilter' to: [/*]
2017-03-22 02:45:57.846  INFO 5284 --- [ost-startStop-1] o.s.b.w.servlet.FilterRegistrationBean   : Mapping filter: 'requestContextFilter' to: [/*]
2017-03-22 02:45:58.867  INFO 5284 --- [  restartedMain] s.w.s.m.m.a.RequestMappingHandlerAdapter : Looking for @ControllerAdvice: org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@e33d3c1: startup date [Wed Mar 22 02:45:51 CST 2017]; root of context hierarchy
2017-03-22 02:45:59.115  INFO 5284 --- [  restartedMain] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/]}" onto public java.lang.String com.yiibai.WelcomeController.welcome(java.util.Map<java.lang.String, java.lang.Object>)
2017-03-22 02:45:59.115  INFO 5284 --- [  restartedMain] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error]}" onto public org.springframework.http.ResponseEntity<java.util.Map<java.lang.String, java.lang.Object>> org.springframework.boot.autoconfigure.web.BasicErrorController.error(javax.servlet.http.HttpServletRequest)
2017-03-22 02:45:59.115  INFO 5284 --- [  restartedMain] s.w.s.m.m.a.RequestMappingHandlerMapping : Mapped "{[/error],produces=[text/html]}" onto public org.springframework.web.servlet.ModelAndView org.springframework.boot.autoconfigure.web.BasicErrorController.errorHtml(javax.servlet.http.HttpServletRequest,javax.servlet.http.HttpServletResponse)
2017-03-22 02:45:59.193  INFO 5284 --- [  restartedMain] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/webjars/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-03-22 02:45:59.193  INFO 5284 --- [  restartedMain] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-03-22 02:45:59.286  INFO 5284 --- [  restartedMain] o.s.w.s.handler.SimpleUrlHandlerMapping  : Mapped URL path [/**/favicon.ico] onto handler of type [class org.springframework.web.servlet.resource.ResourceHttpRequestHandler]
2017-03-22 02:46:10.440  INFO 5284 --- [  restartedMain] o.s.b.d.a.OptionalLiveReloadServer       : LiveReload server is running on port 35729
2017-03-22 02:46:10.721  INFO 5284 --- [  restartedMain] o.s.j.e.a.AnnotationMBeanExporter        : Registering beans for JMX exposure on startup
2017-03-22 02:46:14.581  INFO 5284 --- [  restartedMain] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2017-03-22 02:46:14.597  INFO 5284 --- [  restartedMain] com.yiibai.SpringBootWebApplication      : Started SpringBootWebApp

运行成功后，打浏览器访问： http://localhost:8080 ，没有问题应该会看到以下输出页面 -

6. 构建可执行JAR

打包项目以创建可执行的JAR文件。使用Maven命令：mvn clean package，

F:\worksp\springboot\spring-boot-web-thymeleaf> java -jar target/spring-boot-web-thymeleaf-1.0.jar

运行成功后，打浏览器再次访问： http://localhost:8080 ，没有问题应该会看到以下输出页面 -

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot Hello World(Thymeleaf)示例

Spring Boot非web应用程序实例 - Spring Boot教程™

在Spring Boot中，要创建一个非Web应用程序，实现CommandLineRunner并覆盖run()方法，例如：

import org.springframework.boot.CommandLineRunner;

@SpringBootApplication
public class SpringBootConsoleApplication implements CommandLineRunner {

    public static void main(String[] args) throws Exception {

        SpringApplication.run(SpringBootConsoleApplication.class, args);

    }

    //access command line arguments
    @Override
    public void run(String... args) throws Exception {
        //do something
    }
}

1. 项目结构

一个标准的Maven项目结构。如下所示 -

2. 项目依赖

只有依赖 spring-boot-starter 库，参考如下 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.0</modelVersion>

    <groupId>com.yiibai</groupId>
    <artifactId>spring-boot-non-web</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>spring-boot-non-web</name>
    <url>http://maven.apache.org</url>

    <properties>
        <java.version>1.8</java.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
    </dependencies>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.1.RELEASE</version>
    </parent>

    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

3. Spring

返回消息的服务，如下 HelloMessageService.java 代码所示 -

package com.yiibai.service;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class HelloMessageService {

    @Value("${name:unknown}")
    private String name;

    public String getMessage() {
        return getMessage(name);
    }

    public String getMessage(String name) {
        return "Hello " + name;
    }

}

属性文件配置文件： application.properties 如下所示 -

name=yiibai

下面是CommandLineRunner示例,如果运行这个Spring Boot，那么run方法将是入口点。
SpringBootConsoleApplication.java 代码内容如下所示 -

package com.yiibai;

import com.yiibai.service.HelloMessageService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.Banner;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import static java.lang.System.exit;

@SpringBootApplication
public class SpringBootConsoleApplication implements CommandLineRunner {

    @Autowired
    private HelloMessageService helloService;

    public static void main(String[] args) throws Exception {

        //disabled banner, don't want to see the spring logo
        SpringApplication app = new SpringApplication(SpringBootConsoleApplication.class);
        app.setBannerMode(Banner.Mode.OFF);
        app.run(args);

    }

    // Put your logic here.
    @Override
    public void run(String... args) throws Exception {

        if (args.length > 0) {
            System.out.println(helloService.getMessage(args[0].toString()));
        } else {
            System.out.println(helloService.getMessage());
        }

        exit(0);
    }
}

4. 实例运行演示

打包上面的项目并运行它，如下命令 -

## Go to project directory
## package it
$ mvn package

$ java -jar target/spring-boot-non-web-0.0.1-SNAPSHOT.jar
Hello yiibai

$ java -jar target/spring-boot-non-web-0.0.1-SNAPSHOT.jar "Max su"
Hello Max su

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot非web应用程序实例

Spring Boot @ConfigurationProperties实例 - Spring Boot教程™

Spring Boot @ConfigurationProperties是让开发人员比较容易地将整个文件映射成一个对象。

简单属性文件

通常，我们使用@Value注释来逐个注入.properties值，这对于小而简单的结构.properties文件很有用。

文件：global.properties

email=test@yiibai.com
thread-pool=12

@Value 示例
文件：GlobalProperties.java

@Component
@PropertySource("classpath:global.properties")
public class GlobalProperties {

    @Value("${thread-pool}")
    private int threadPool;

    @Value("${email}")
    private String email;

    //getters and setters

}

@ConfigurationProperties实例

文件：GlobalProperties.java

import org.springframework.boot.context.properties.ConfigurationProperties;

@Component
@PropertySource("classpath:global.properties")
@ConfigurationProperties
public class GlobalProperties {

    private int threadPool;
    private String email;

    //getters and setters

}

2.复杂属性文件

2.1. 查看复杂的结构.properties文件，如何通过@Value注释映射值。

文件：application.properties

#Logging
logging.level.org.springframework.web=ERROR
logging.level.com.yiibai=DEBUG

#Global
email=test@yiibai.com
thread-pool=10

#App
app.menus[0].title=Home
app.menus[0].name=Home
app.menus[0].path=/
app.menus[1].title=Login
app.menus[1].name=Login
app.menus[1].path=/login

app.compiler.timeout=5
app.compiler.output-folder=/temp/

app.error=/error/

或YAML中的下面配置， 文件： application.yml

logging:
  level:
    org.springframework.web: ERROR
    com.yiibai: DEBUG
email: test@yiibai.com
thread-pool: 10
app:
  menus:
    - title: Home
      name: Home
      path: /
    - title: Login
      name: Login
      path: /login
  compiler:
    timeout: 5
    output-folder: /temp/
  error: /error/

注意：@ConfigurationProperties支持.properties和.yml文件。

下面可使用@ConfigurationProperties来配置完成，创建一个@ConfigurationProperties bean，如下所示：

文件： AppProperties.java -

package com.yiibai;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
@ConfigurationProperties("app") // prefix app, find app.* values
public class AppProperties {

    private String error;
    private List<Menu> menus = new ArrayList<>();
    private Compiler compiler = new Compiler();

    public static class Menu {
        private String name;
        private String path;
        private String title;

        //getters and setters

        @Override
        public String toString() {
            return "Menu{" +
                    "name='" + name + '\'' +
                    ", path='" + path + '\'' +
                    ", title='" + title + '\'' +
                    '}';
        }
    }

    public static class Compiler {
        private String timeout;
        private String outputFolder;

        //getters and setters

        @Override
        public String toString() {
            return "Compiler{" +
                    "timeout='" + timeout + '\'' +
                    ", outputFolder='" + outputFolder + '\'' +
                    '}';
        }

    }

    //getters and setters
}

文件：GlobalProperties.java -

package com.yiibai;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties // no prefix, find root level values.
public class GlobalProperties {

    private int threadPool;
    private String email;

    //getters and setters
}
`

演示实例

测试以确保.properties值正确映射到对象。文件：WelcomeController.java -

package com.yiibai;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import java.util.Map;

@Controller
public class WelcomeController {

    private static final Logger logger = LoggerFactory.getLogger(WelcomeController.class);

    private AppProperties app;
    private GlobalProperties global;

    @Autowired
    public void setApp(AppProperties app) {
        this.app = app;
    }

    @Autowired
    public void setGlobal(GlobalProperties global) {
        this.global = global;
    }

    @RequestMapping("/")
    public String welcome(Map<String, Object> model) {

        String appProperties = app.toString();
        String globalProperties = global.toString();

        logger.debug("Welcome {}, {}", app, global);

        model.put("message", appProperties + globalProperties);
        return "welcome";
    }

}

文件：SpringBootWebApplication.java -

package com.yiibai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootWebApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

}

使用Maven命令mvn spring-boot:run启动Spring Boot，运行成功后访问默认/控制器，查看控制台输出：

Welcome
    AppProperties{error='/error/',
        menus=[
            Menu{name='Home', path='/', title='Home'},
            Menu{name='Login', path='/login', title='Login'}
        ],
        compiler=Compiler{timeout='5', outputFolder='/temp/'}},

    GlobalProperties{threadPool=10, email='test@yiibai.com'}

@ConfigurationProperties验证

让这个@ConfigurationProperties支持JSR-303 bean验证 - javax.validation

文件：GlobalProperties.java -

package com.yiibai;

import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;

@Component
@ConfigurationProperties
public class GlobalProperties {

    @Max(5)
    @Min(0)
    private int threadPool;

    @NotEmpty
    private String email;

    //getters and setters
}

尝试再次使用Maven命令mvn spring-boot:run启动Spring Boot，并查看控制台：

本项目名称为： spring-boot-properties， 请找到下载Spring Boot代码下载目录，并下载。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot @ConfigurationProperties实例

Spring Boot SLF4J日志实例 - Spring Boot教程™

默认情况下，SLF4j日志记录包含在Spring Boot Web应用程序中，只需要启用它就可以了。

注意：查看此Spring Boot Logback XML模板以了解默认的日志记录模式和配置。

SLF4j示例

我们将在接下来的文章中，创建一个项目：web-slf4j-logging，演示这几种常用的日志配置方法。

1. application.properties

要启用日志记录，请在资源文件夹的根目录中创建一个application.properties文件。logging.level- 定义日志记录级别，日志记录将被输出到控制台。

文件： application.properties

logging.level.org.springframework.web=ERROR
logging.level.com.yiibai=DEBUG

logging.file – 定义日志文件(可根据需要写上，如：c:/logs/mylog.log)，将日志记录输出到文件和控制台。
文件： application.properties

logging.level.org.springframework.web=ERROR
logging.level.com.yiibai=DEBUG

#output to a temp_folder/file
logging.file=${java.io.tmpdir}/application.log

#output to a file
#logging.file=c:/logs/mylog.log

logging.pattern - 定义自定义日志记录模式。
文件： application.properties

logging.level.org.springframework.web=ERROR
logging.level.com.yiibai=DEBUG

# Logging pattern for the console
logging.pattern.console= "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"

# Logging pattern for file
logging.pattern.file= "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

logging.file=c:/logs/mylog.log

2. application.yml

上面的配置，也可以使用YAML格式实现相同的效果。
文件：application.yml

logging:
  level:
    org.springframework.web: ERROR
    com.yiibai: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"
    file: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
  file: c:/logs/mylog.log

3. 经典Logback.xml

如果您不喜欢Spring Boot日志记录模板，也可以在资源文件夹的根目录或类路径的根目录中创建一个标准的logback.xml文件。它将会覆盖Spring Boot日志记录模板。
文件：logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration>

    <property name="DEV_HOME" value="c:/logs" />

    <appender name="FILE-AUDIT"
        class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${DEV_HOME}/debug.log</file>
        <encoder class="ch.qos.logback.classic.encoder.PatternLayoutEncoder">
            <Pattern>
                %d{yyyy-MM-dd HH:mm:ss} - %msg%n
            </Pattern>
        </encoder>

        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- rollover daily -->
            <fileNamePattern>${DEV_HOME}/archived/debug.%d{yyyy-MM-dd}.%i.log
                        </fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy
                class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>10MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>

    </appender>

    <logger name="com.yiibai" level="debug"
        additivity="false">
        <appender-ref ref="FILE-AUDIT" />
    </logger>

    <root level="error">
        <appender-ref ref="FILE-AUDIT" />
    </root>

</configuration>

4. 设置根级别

文件：application.properties

# root logging level, warning : too much output
logging.level.=DEBUG

文件：application.yml

logging:
  level:
    ROOT: DEBUG

使用 mvn spring-boot:run 命令运行上面示例，应该会看到有日志输出。代码下载请找到Spring Boot目录中的项目：web-slf4j-logging。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot SLF4J日志实例

Spring Boot Ajax实例 - Spring Boot教程™

本文将展示如何使用jQuery.ajax将HTML表单请求发送到Spring REST API并返回JSON响应。

使用的工具 ：

Spring Boot 1.5.1.RELEASE

Spring 4.3.6.RELEASE

Maven 3

jQuery

Bootstrap 3

1. 项目结构

创建一个标准的Maven项目：ajax-example，用于演示在Spring Boot中使用Ajax技术，搜索用户信息。其结构如下图所示 -

2. 项目依赖

文件：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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>

<groupId>com.yiibai</groupId>
<artifactId>ajax-example</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.5.1.RELEASE</version>
</parent>

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

<dependencies>

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>jquery</artifactId>
        <version>2.2.4</version>
    </dependency>

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>bootstrap</artifactId>
        <version>3.3.7</version>
    </dependency>

</dependencies>

<build>
    <plugins>
        <!-- Package as an executable jar/war -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>
</project>

3. Spring REST API

REST控制器，接受一个SearchCriteria并返回一个ResponseEntity。

一个正常的Spring Boot依赖和一些webjars资源。文件：SearchController.java 如下所示 -

package com.yiibai.controller;

import com.yiibai.model.AjaxResponseBody;
import com.yiibai.model.SearchCriteria;
import com.yiibai.model.User;
import com.yiibai.services.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.Errors;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import javax.validation.Valid;
import java.util.List;
import java.util.stream.Collectors;

@RestController
public class SearchController {

    UserService userService;

    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/api/search")
    public ResponseEntity<?> getSearchResultViaAjax(@Valid @RequestBody SearchCriteria search, Errors errors) {

        AjaxResponseBody result = new AjaxResponseBody();

        //If error, just return a 400 bad request, along with the error message
        if (errors.hasErrors()) {

            result.setMsg(errors.getAllErrors().stream().map(x -> x.getDefaultMessage()).collect(Collectors.joining(",")));
            return ResponseEntity.badRequest().body(result);

        }

        List<User> users = userService.findByUserNameOrEmail(search.getUsername());
        if (users.isEmpty()) {
            result.setMsg("no user found!");
        } else {
            result.setMsg("success");
        }
        result.setResult(users);

        return ResponseEntity.ok(result);
    }
}

一些其它的POJO类，它们分别如下所示 -
文件：AjaxResponseBody.java

package com.yiibai.model;

import java.util.List;

public class AjaxResponseBody {

    String msg;
    List<User> result;

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public List<User> getResult() {
        return result;
    }

    public void setResult(List<User> result) {
        this.result = result;
    }
}

文件：User.java

package com.yiibai.model;

public class User {

    String username;
    String password;
    String email;

    public User(String username, String password, String email) {
        this.username = username;
        this.password = password;
        this.email = email;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", email='" + email + '\'' +
                '}';
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

验证器类：SearchCriteria.java

package com.yiibai.model;

import org.hibernate.validator.constraints.NotBlank;

public class SearchCriteria {

    @NotBlank(message = "username can't empty!")
    String username;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }
}

用于初始化一些用户进行搜索的服务。文件：UserService.java 如下所示 -

package com.yiibai.services;

import com.yiibai.model.User;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class UserService {

    private List<User> users;

    // Love Java 8
    public List<User> findByUserNameOrEmail(String username) {

        List<User> result = users.stream().filter(x -> x.getUsername().equalsIgnoreCase(username)).collect(Collectors.toList());

        return result;

    }
    /*public List<User> findByUserNameOrEmail(String username, String email) {

        List<User> result = new ArrayList<User>();

        for (User user : users) {

            if ((!StringUtils.isEmpty(username)) && (!StringUtils.isEmpty(email))) {

                if (username.equals(user.getUsername()) && email.equals(user.getEmail())) {
                    result.add(user);
                    continue;
                } else {
                    continue;
                }

            }
            if (!StringUtils.isEmpty(username)) {
                if (username.equals(user.getUsername())) {
                    result.add(user);
                    continue;
                }
            }

            if (!StringUtils.isEmpty(email)) {
                if (email.equals(user.getEmail())) {
                    result.add(user);
                    continue;
                }
            }
        }
        return result;

    }*/

    // Init some users for testing
    @PostConstruct
    private void iniDataForTesting() {
        users = new ArrayList<User>();
        User user1 = new User("maxsu", "password111", "maxsu@yahoo.com");
        User user2 = new User("yiflow", "password222", "yflow@yahoo.com");
        User user3 = new User("minaxu", "password333", "minaxu@yahoo.com");
        User user4 = new User("minalee", "password333", "minalee@yahoo.com");
        User user5 = new User("yiiflow", "password333", "yiiflow@gmail.com");

        users.add(user1);
        users.add(user2);
        users.add(user3);
        users.add(user4);
        users.add(user5);
    }
}

Spring Boot启动器(程序入口)，参考以下代码实现。文件：SpringBootWebApplication.java 如下所示 -

package com.yiibai;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringBootWebApplication {

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }
}

4. HTML表单+ jQuery Ajax

一个简单的HTML表单，用 bootstrap 框架装饰。
文件：ajax.html

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Spring Boot Ajax实例</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>

    <link rel="stylesheet" type="text/css"
          href="webjars/bootstrap/3.3.7/css/bootstrap.min.css"/>
</head>
<body>

<nav class="navbar navbar-inverse">
    <div class="container">
        <div class="navbar-header">
            <a class="navbar-brand" href="http://www.yiibai.com">易百教程</a>
        </div>
    </div>
</nav>

<div class="container" style="min-height: 500px">
    <div class="starter-template">
        <h1>Spring Boot AJAX 示例</h1>
        <div id="feedback"></div>
        <form class="form-horizontal" id="search-form">
            <div class="form-group form-group-lg">
                <label class="col-sm-2 control-label">用户名：</label>
                <div class="col-sm-10">
                    <input type="text" class="form-control" id="username"/>
                </div>
            </div>

            <div class="form-group">
                <div class="col-sm-offset-2 col-sm-10">
                    <button type="submit" id="bth-search"
                            class="btn btn-primary btn-lg">搜索
                    </button>
                </div>
            </div>
        </form>
    </div>
</div>
<div class="container">
    <footer>
        <p>
            © <a href="http://www.yiibai.com">Yiibai.com</a> 2017
        </p>
    </footer>
</div>
<script type="text/javascript"
        src="webjars/jquery/2.2.4/jquery.min.js"></script>
<script type="text/javascript" src="js/main.js"></script>
</body>
</html>

获取HTML表单，并通过JSON.stringify将搜索条件转换为JSON格式，并通过jQuery.ajax发送POST请求。
文件：main.js 如下所示 -

$(document).ready(function () {
    $("#search-form").submit(function (event) {
        //stop submit the form, we will post it manually.
        event.preventDefault();
        fire_ajax_submit();
    });

});

function fire_ajax_submit() {
    var search = {}
    search["username"] = $("#username").val();
    //search["email"] = $("#email").val();
    $("#btn-search").prop("disabled", true);
    $.ajax({
        type: "POST",
        contentType: "application/json",
        url: "/api/search",
        data: JSON.stringify(search),
        dataType: 'json',
        cache: false,
        timeout: 600000,
        success: function (data) {
            var json = "<h4>Ajax Response</h4><pre>"
                + JSON.stringify(data, null, 4) + "</pre>";
            $('#feedback').html(json);
            console.log("SUCCESS : ", data);
            $("#btn-search").prop("disabled", false);
        },
        error: function (e) {
            var json = "<h4>Ajax Response</h4><pre>"
                + e.responseText + "</pre>";
            $('#feedback').html(json);
            console.log("ERROR : ", e);
            $("#btn-search").prop("disabled", false);
        }
    });
}

5. 运行示例

启动 Spring Boot 运行项目并测试结果。打开终端，进入到项目目录下(pom.xml文件所在目录)，执行以下命令 -

F:\worksp\springboot\ajax-example> mvn spring-boot:run
... ...
02:57:41,425 |-INFO in ch.qos.logback.core.joran.action.AppenderRefAction - Attaching appender named [STDOUT] to Logger[ROOT]
02:57:41,425 |-INFO in ch.qos.logback.classic.joran.action.ConfigurationAction - End of configuration.
02:57:41,425 |-INFO in ch.qos.logback.classic.joran.JoranConfigurator@7cf10a6f - Registering current configuration as safe fallback point

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
::Spring Boot::       (v1.5.1.RELEASE)

2017-03-28 02:57:42 INFO  com.yiibai.SpringBootWebApplication - Starting SpringBootWebApplication on MY-PC with PID 7656 (F:\worksp\springboot\ajax-example\target\classes started by Administrator in F:\worksp\springboot\ajax-example)
2017-03-28 02:57:42 DEBUG com.yiibai.SpringBootWebApplication - Running with Spring Boot v1.5.1.RELEASE, Spring v4.3.6.RELEASE
2017-03-28 02:57:42 INFO  com.yiibai.SpringBootWebApplication - No active profile set, falling back to default profiles: default
2017-03-28 02:57:46 INFO  com.yiibai.SpringBootWebApplication - Started SpringBootWebApplication in 5.007 seconds (JVM running for 6.084)

打开浏览器，访问以下地址：http://localhost:8080/ ， 应该会看到如下页面 -

如果没有输入用户名，直接点击“搜索”，那么应该会看到以下结果 -

如果输入一个存在的用户名:maxsu，直接点击“搜索”，那么应该会看到以下结果 -

6. 下载示例代码

要下载代码，请参考下载页面。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot Ajax实例

Spring Boot文件上传示例（Ajax和REST） - Spring Boot教程™

本文介绍如何使用Ajax请求在Spring Boot Web应用程序(REST结构)中上传文件。

本文中使用的工具：

Spring Boot 1.4.3.RELEASE

Spring 4.3.5.RELEASE

Thymeleaf

jQuery (webjars)

Maven

Embedded Tomcat 8.5.6

Google Chrome浏览器

1. 项目结构

一个标准的Maven项目结构。如下图所示 -

2. 项目依赖

声明一个额外的jQuery webjar依赖关系，适用于HTML格式的Ajax请求。

文件：pom.xml
```xml
4.0.0

<groupId>com.yiibai</groupId>
<artifactId>spring-boot-file-upload</artifactId>
<packaging>jar</packaging>
<version>1.0</version>

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.3.RELEASE</version>
</parent>

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

<dependencies>

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

    <!-- hot swapping, disable cache for template, enable live reload -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-devtools</artifactId>
        <optional>true</optional>
    </dependency>

    <dependency>
        <groupId>org.webjars</groupId>
        <artifactId>jquery</artifactId>
        <version>2.2.4</version>
    </dependency>

</dependencies>

<build>
    <plugins>
        <!-- Package as an executable jar/war -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

## 3.文件上传
为了支持Ajax请求和响应，最简单的解决方案返回一个ResponseEntity。
以下示例演示了上传文件的三种可能方式：
1. 单文件上传 - `MultipartFile`
2. 多文件上传 - `MultipartFile []`
3. 将文件上传到模型 - `@ModelAttribute`

*文件：RestUploadController.java*

```java
package com.yiibai.controller;

import com.yiibai.model.UploadModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

@RestController
public class RestUploadController {

    private final Logger logger = LoggerFactory.getLogger(RestUploadController.class);

    //Save the uploaded file to this folder
    private static String UPLOADED_FOLDER = "D://temp//";

    //Single file upload
    @PostMapping("/api/upload")
    // If not @RestController, uncomment this
    //@ResponseBody
    public ResponseEntity<?> uploadFile(
            @RequestParam("file") MultipartFile uploadfile) {

        logger.debug("Single file upload!");

        if (uploadfile.isEmpty()) {
            return new ResponseEntity("please select a file!", HttpStatus.OK);
        }

        try {

            saveUploadedFiles(Arrays.asList(uploadfile));

        } catch (IOException e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }

        return new ResponseEntity("Successfully uploaded - " +
                uploadfile.getOriginalFilename(), new HttpHeaders(), HttpStatus.OK);

    }

    // Multiple file upload
    @PostMapping("/api/upload/multi")
    public ResponseEntity<?> uploadFileMulti(
            @RequestParam("extraField") String extraField,
            @RequestParam("files") MultipartFile[] uploadfiles) {

        logger.debug("Multiple file upload!");

        String uploadedFileName = Arrays.stream(uploadfiles).map(x -> x.getOriginalFilename())
                .filter(x -> !StringUtils.isEmpty(x)).collect(Collectors.joining(" , "));

        if (StringUtils.isEmpty(uploadedFileName)) {
            return new ResponseEntity("please select a file!", HttpStatus.OK);
        }

        try {

            saveUploadedFiles(Arrays.asList(uploadfiles));

        } catch (IOException e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }

        return new ResponseEntity("Successfully uploaded - "
                + uploadedFileName, HttpStatus.OK);

    }

    // maps html form to a Model
    @PostMapping("/api/upload/multi/model")
    public ResponseEntity<?> multiUploadFileModel(@ModelAttribute UploadModel model) {

        logger.debug("Multiple file upload! With UploadModel");

        try {

            saveUploadedFiles(Arrays.asList(model.getFiles()));

        } catch (IOException e) {
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
        }

        return new ResponseEntity("Successfully uploaded!", HttpStatus.OK);

    }

    //save file
    private void saveUploadedFiles(List<MultipartFile> files) throws IOException {

        for (MultipartFile file : files) {

            if (file.isEmpty()) {
                continue; //next pls
            }

            byte[] bytes = file.getBytes();
            Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
            Files.write(path, bytes);

        }

    }
}

以上示例的简单模型 - @ModelAttribute，文件：UploadModel.java -

package com.yiibai.model;

import org.springframework.web.multipart.MultipartFile;

import java.util.Arrays;

public class UploadModel {

    private String extraField;

    private MultipartFile[] files;

    public String getExtraField() {
        return extraField;
    }

    public void setExtraField(String extraField) {
        this.extraField = extraField;
    }

    public MultipartFile[] getFiles() {
        return files;
    }

    public void setFiles(MultipartFile[] files) {
        this.files = files;
    }

    @Override
    public String toString() {
        return "UploadModel{" +
                "extraField='" + extraField + '\'' +
                ", files=" + Arrays.toString(files) +
                '}';
    }
}

视图文件

多个文件上传的HTML表单。文件：upload.html -

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>

<h2>Spring Boot多文件上传示例(使用AJAX)</h2>

<form method="POST" enctype="multipart/form-data" id="fileUploadForm">
    <input type="text" name="extraField"/><br/><br/>
    <input type="file" name="files"/><br/><br/>
    <input type="file" name="files"/><br/><br/>
    <input type="submit" value="提交" id="btnSubmit"/>
</form>

<h1>Ajax提交结果：</h1>
<pre>
    <span id="result"></span>
</pre>

<script type="text/javascript" src="webjars/jquery/2.2.4/jquery.min.js"></script>
<script type="text/javascript" src="js/main.js"></script>

</body>
</html>

5. jQuery - Ajax请求

jQuery通过表单#id获取表单，并通过Ajax请求发送多部分(multipart)表单数据。文件：resources/static/js/main.js -

$(document).ready(function () {

    $("#btnSubmit").click(function (event) {

        //stop submit the form, we will post it manually.
        event.preventDefault();

        fire_ajax_submit();

    });

});

function fire_ajax_submit() {

    // Get form
    var form = $('#fileUploadForm')[0];

    var data = new FormData(form);

    data.append("CustomField", "This is some extra data, testing");

    $("#btnSubmit").prop("disabled", true);

    $.ajax({
        type: "POST",
        enctype: 'multipart/form-data',
        url: "/api/upload/multi",
        data: data,
        //http://api.jquery.com/jQuery.ajax/
        //http://developer.mozilla.org/en-US/docs/Web/API/FormData/Using_FormData_Objects
        processData: false, //prevent jQuery from automatically transforming the data into a query string
        contentType: false,
        cache: false,
        timeout: 600000,
        success: function (data) {

            $("#result").text(data);
            console.log("SUCCESS : ", data);
            $("#btnSubmit").prop("disabled", false);

        },
        error: function (e) {

            $("#result").text(e.responseText);
            console.log("ERROR : ", e);
            $("#btnSubmit").prop("disabled", false);

        }
    });

}

6. 异常处理程序

要处理来自Ajax请求的异常，只需扩展ResponseEntityExceptionHandler并返回一个ResponseEntity。文件：RestGlobalExceptionHandler.java -

package com.yiibai.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import javax.servlet.http.HttpServletRequest;

//http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-error-handling
@ControllerAdvice
public class RestGlobalExceptionHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(MultipartException.class)
    @ResponseBody
    ResponseEntity<?> handleControllerException(HttpServletRequest request, Throwable ex) {

        HttpStatus status = getStatus(request);

        return new ResponseEntity(new CustomError("0x000123", "Attachment size exceeds the allowable limit! (10MB)"), status);

        //return new ResponseEntity("Attachment size exceeds the allowable limit! (10MB)", status);

        // example
        //return new ResponseEntity(ex.getMessage(), status);
        //return new ResponseEntity("success", responseHeaders, HttpStatus.OK);

    }

    private HttpStatus getStatus(HttpServletRequest request) {
        Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
        if (statusCode == null) {
            return HttpStatus.INTERNAL_SERVER_ERROR;
        }
        return HttpStatus.valueOf(statusCode);
    }

}

7. 运行演示

使用默认的嵌入式Tomcat的启动Spring Boot命令：mvn spring-boot:run.。
访问：http://localhost:8080/ ，选择几个文件并单击提交以触发ajax请求。

提示：打开目录：F:/temp 应该能看到上传的文件。

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot文件上传示例（Ajax和REST）

Spring Boot文件上传示例 - Spring Boot教程™

本文介绍如何在Spring Boot Web应用程序中上传文件。

使用的工具 ：

Spring Boot 1.4.3.RELEASE

Spring 4.3.5.RELEASE

Thymeleaf

Maven 3

Embedded Tomcat 8.5.6

1. 项目结构

标准项目结构如下图所示 -

2. 项目依赖

Spring boot依赖关系，无需额外的文件上传库。

<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/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yiibai</groupId>
    <artifactId>spring-boot-file-upload</artifactId>
    <packaging>jar</packaging>
    <version>1.0</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.4.3.RELEASE</version>
    </parent>

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

    <dependencies>

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

        <!-- hot swapping, disable cache for template, enable live reload -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <!-- Package as an executable jar/war -->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3.文件上传示例

Spring Boot文件上传，不需要什么特别的配置。在Controller中，将上传的文件映射到MultipartFile。
文件：UploadController.java -

package com.yiibai.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

@Controller
public class UploadController {

    //Save the uploaded file to this folder
    private static String UPLOADED_FOLDER = "D://temp//";

    @GetMapping("/")
    public String index() {
        return "upload";
    }

    @PostMapping("/upload") // //new annotation since 4.3
    public String singleFileUpload(@RequestParam("file") MultipartFile file,
                                   RedirectAttributes redirectAttributes) {

        if (file.isEmpty()) {
            redirectAttributes.addFlashAttribute("message", "Please select a file to upload");
            return "redirect:uploadStatus";
        }

        try {

            // Get the file and save it somewhere
            byte[] bytes = file.getBytes();
            Path path = Paths.get(UPLOADED_FOLDER + file.getOriginalFilename());
            Files.write(path, bytes);

            redirectAttributes.addFlashAttribute("message",
                    "You successfully uploaded '" + file.getOriginalFilename() + "'");

        } catch (IOException e) {
            e.printStackTrace();
        }

        return "redirect:/uploadStatus";
    }

    @GetMapping("/uploadStatus")
    public String uploadStatus() {
        return "uploadStatus";
    }

}

在thymeleaf，只是一些普通的HTML文件标签。文件：upload.html -

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<body>

<h1>Spring Boot文件上传示例</h1>

<form method="POST" action="/upload" enctype="multipart/form-data">
    <input type="file" name="file" /><br/><br/>
    <input type="submit" value="提交" />
</form>

</body>
</html>

另外一个页面，用为显示文件上传的状态。文件：uploadStatus.html -

<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.thymeleaf.org">
<body>

<h1>Spring Boot文件上传状态</h1>

<div th:if="${message}">
    <h2 th:text="${message}"/>
</div>

</body>
</html>

4. 超过最大上传大小

要处理最大上传大小超出异常，请声明一个@ControllerAdvice并捕获MultipartException。
文件：GlobalExceptionHandler.java

package com.yiibai.controller;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.multipart.MultipartException;
import org.springframework.web.servlet.mvc.support.RedirectAttributes;

@ControllerAdvice
public class GlobalExceptionHandler {

    //http://jira.spring.io/browse/SPR-14651
    //4.3.5 supports RedirectAttributes redirectAttributes
    @ExceptionHandler(MultipartException.class)
    public String handleError1(MultipartException e, RedirectAttributes redirectAttributes) {

        redirectAttributes.addFlashAttribute("message", e.getCause().getMessage());
        return "redirect:/uploadStatus";

    }

}

5. Tomcat连接重置

如果部署到Tomcat，请配置maxSwallowSize以避免此Tomcat连接重置问题。 对于嵌入式Tomcat，声明一个TomcatEmbeddedServletContainerFactory，如下所示, SpringBootWebApplication.java -

package com.yiibai;

import org.apache.coyote.http11.AbstractHttp11Protocol;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
import org.springframework.context.annotation.Bean;

//http://www.agilegroup.co.jp/technote/springboot-fileupload-error-handling.html
@SpringBootApplication
public class SpringBootWebApplication {

    private int maxUploadSizeInMb = 10 * 1024 * 1024; // 10 MB

    public static void main(String[] args) throws Exception {
        SpringApplication.run(SpringBootWebApplication.class, args);
    }

    //Tomcat large file upload connection reset

    @Bean
    public TomcatEmbeddedServletContainerFactory tomcatEmbedded() {

        TomcatEmbeddedServletContainerFactory tomcat = new TomcatEmbeddedServletContainerFactory();

        tomcat.addConnectorCustomizers((TomcatConnectorCustomizer) connector -> {
            if ((connector.getProtocolHandler() instanceof AbstractHttp11Protocol<?>)) {
                //-1 means unlimited
                ((AbstractHttp11Protocol<?>) connector.getProtocolHandler()).setMaxSwallowSize(-1);
            }
        });

        return tomcat;

    }

}

6. Multipart文件大小

默认情况下，Spring Boot max文件上传大小为1MB，可以通过以下应用程序属性来配置它的值，application.properties -

#http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#common-application-properties
#search multipart
spring.http.multipart.max-file-size=10MB
spring.http.multipart.max-request-size=10MB

7. 运行示例

使用默认的嵌入式Tomcat启动Spring Boot的命令如下： mvn spring-boot:run ，运行结果如下 -

23:40:03,238 |-INFO in ch.qos.logback.classic.joran.JoranConfigurator@5a39699c - Registering current configuration as safe fallback point

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
::Spring Boot::       (v1.4.3.RELEASE)

2017-03-30 23:40:04 INFO  com.yiibai.SpringBootWebApplication - Starting SpringBootWebApplication on MY-PC with PID 880 (F:\worksp\springboot\file-upload\target\classes started by Administrator in F:\worksp\springboot\file-upload)
2017-03-30 23:40:04 DEBUG com.yiibai.SpringBootWebApplication - Running with Spring Boot v1.4.3.RELEASE, Spring v4.3.5.RELEASE
2017-03-30 23:40:04 INFO  com.yiibai.SpringBootWebApplication - No active profile set, falling back to default profiles: default
2017-03-30 23:40:08 INFO  com.yiibai.SpringBootWebApplication - Started SpringBootWebApplication in 5.359 seconds (JVM running for 6.355)

打开浏览器，访问： http://localhost:8080/ 输出结果如下 -

选择一个文件并将其上传，选择大于10mb的文件，将会看到页面提示如下 -

本站代码下载：http://www.yiibai.com/siteinfo/download.html

本文属作者原创，转载请注明出处：易百教程 » Spring Boot文件上传示例