如何运行Spring Boot应用商店已停止运行
点击联系发帖人
时间：2017-06-02 11:56
Spring Boot应用的后台运行配置
被围观&735&次
酱油一篇，整理一下关于Spring Boot后台运行的一些配置方式。在介绍后台运行配置之前，我们先回顾一下Spring Boot应用的几种运行方式：
运行Spring Boot的应用主类
使用Maven的Spring Boot插件mvn
spring-boot:run来运行
打成jar包后，使用java
我们在开发的时候，通常会使用前两种，而在部署的时候往往会使用第三种。但是，我们在使用java
-jar来运行的时候，并非后台运行。下面我们分别针对Windows和Linux/Unix两种环境，整理一下如何配置后台运行的方法。
Windows下比较简单，我们可以直接使用这款软件：AlwaysUp。如下图所示，简单、暴力、好用。
配置方式很简单，我们只需要把Spring Boot应用通过mvn
install打成jar包，然后编写一个java
-jar yourapp.jar的bat文件。再打开AlwaysUp，点击工具栏的第一个按钮，如下图所示，选择上面编写的bat文件，并填写服务名称。
完成了创建之后，在列表中可以看到我们配置的服务，通过右键选择Start
xxx就能在后台将该应用启动起来了。
Linux/Unix
下面我们来说说服务器上该如何来配置。实际上，实现的方法有很多种，这里就列两种还比较好用的方式：
nohup和Shell
该方法主要通过使用nohup命令来实现，该命令的详细介绍如下：
所以，我们只需要使用nohup
java -jar yourapp.jar &命令，就能让yourapp.jar在后台运行了。但是，为了方便管理，我们还可以通过Shell来编写一些用于启动应用的脚本，比如下面几个：
关闭应用的脚本：stop.sh#!/bin/bash
PID=$(ps -ef | grep yourapp.jar | grep -v grep | awk '{ print $2 }')
if [ -z &$PID& ]
echo Application is already stopped
echo kill $PID
启动应用的脚本：start.sh#!/bin/bash
nohup java -jar yourapp.jar --server.port=8888 &
整合了关闭和启动的脚本：run.sh，由于会先执行关闭应用，然后再启动应用，这样不会引起端口冲突等问题，适合在持续集成系统中进行反复调用。#!/bin/bash
echo stop application
source stop.sh
echo start application
source start.sh
在Spring Boot的Maven插件中，还提供了构建完整可执行程序的功能，什么意思呢？就是说，我们可以不用java
-jar，而是直接运行jar来执行程序。这样我们就可以方便的将其创建成系统服务在后台运行了。主要步骤如下：
在pom.xml中添加Spring
Boot的插件，并注意设置executable配置&build&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&configuration&
&executable&true&/executable&
&/configuration&
&/plugins&
在完成上述配置后，使用mvn
install进行打包，构建一个可执行的jar包
创建软连接到/etc/init.d/目录下sudo ln -s /var/yourapp/yourapp.jar /etc/init.d/yourapp
在完成软连接创建之后，我们就可以通过如下命令对yourapp.jar应用来控制启动、停止、重启操作了/etc/init.d/yourapp start|stop|restart
&本文由&&创作，采用&&进行许可。 可自由转载、引用，但需署名作者且注明文章出处。如转载至微信公众号，请在文末添加作者公众号二维码。
------------------------------------------------------------------------------------------------------------------------------&
如您觉得文章不错，对您有所帮助，可以通过“支付宝”或“微信支付”请我喝咖啡。
本文已收录于以下专栏：
相关文章推荐
在cmd命令行或者IDEA的Terminal终端界面，使用mvn spring-boot:run命令利用spring boot框架内置的tomcat运行spring boot开发的web应用。
SpringBoot:应用日常jar后台启动:nohup java -jar ./owl.jar &
直接前台执行:java -jar ./owl.jar
如果 Maven 运行过程出现内存溢出，则可...
网络绝对是任何系统的核心，对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术，有很多令人称道的功能，如 Docker 的镜像管理。然而，Docker的网络一直以来都比较薄弱，所以我们有必要深入了解Docker的网络知识，以满足更高的网络需求。
一个完整的极简后台框架，方便做小项目的时候可以快速开发。
这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。
先放几张图项目介绍SpringBoot，...
基于springBoot的Web后端 (二)
酱油一篇，整理一下关于Spring Boot后台运行的一些配置方式。在介绍后台运行配置之前，我们先回顾一下Spring Boot应用的几种运行方式：
运行Spring Boot的应用主类
使用Mav...
前面两篇博客中我们简单介绍了Spring Boot项目的创建、并且也带小伙伴们来DIY了一个Spring Boot自动配置功能，那么这些东西说到底最终还是要回归到Web上才能体现出它的更大的价值，so...
本文通过创建.sh文件启动jar，并在后台运行。
假如需要运行的jar为
business-callpush-1.1.jar，系统linux centos6.9
1、新建一个文件夹callpush
startTest.sh内容如下：!/bin/shJava -jar Test.jar &
#注意：必须有&让其后台执行，否则没有pid生成
echo $! & /var/r...
Spring-boot jar 包方式启动：
首先，为了防止和常用的 Tomcat 8080 端口冲突，将 Spring-boot 项目的端口号设置为 9090。
具体方法：在 applicati...
他的最新文章
讲师：董西成
讲师：唐宇迪
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)【图文】SpringBoot入门基础以及应用_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
SpringBoot入门基础以及应用
&&springBoot基础入门PPT
大小：444.90KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢Spring Boot 学习笔记1——初体验之3分钟启动你的Web应用 - 简书
Spring Boot 学习笔记1——初体验之3分钟启动你的Web应用
早在去年就简单的使用了一下Spring Boot，当时就被其便捷的功能所震惊。但是那是也没有深入的研究，随着其在业界被应用的越来越广泛，因此决定好好地深入学习一下，将自己的学习心得在此记录，本文主要围绕以下几点进行说明：
Spring Boot 简介
使用Spring Boot快速搭建一个Web应用
如有不对的地方，请指正。**
1. Spring Boot简介
Spring Boot是一个基于Spring的衍生框架，其主要的目的是帮助我们快速构建独立、生产级别的Spring的应用,其崇尚的理念是“约定优于配置”。
其主要有如下的特点:
创建一个单独的Spring应用
内置Web容器(默认使用Tomcat,如果你想换成Jetty只需简单修改配置即可)，以Java Application的方式就可以完成Web应用的启动。
提供了大量maven模版配置(通常被称为Starter
POMs)，通过使用其提供的maven配置，它将我们日常开发所使用到的依赖都集成了，因此可以大大减少我们对于maven的pom文件的配置的工作量。
自动化地对Spring进行配置，它可以根据你当前classpath路径下的jar包来推断出你当前的运行环境，自动的帮助我们创建出一些应该用必须使用的对象，并且根据对应的环境以其对应的方式进行启动。
提供了生产环境下的一些特性：如指标统计、健康检查。
无需冗余的代码与XML配置。
提供了现成的maven插件，可以更加方便地使用maven进行打包。
2. Spring Boot初体验
在简单了解完Spring Boot之后，下面让我们快速地使用Spring Boot搭建一个Web应用，来快速地感受一下Spring Boot其强大的功能。
2.1 快速搭建一个Web应用
引入的maven依赖:
这里使用官方最新的版本，官方推荐建议继承默认的springboot配置
继承后，项目的编译级别会自动变为jdk1.6版本。
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.3.RELEASE&/version&
添加一个web应用所需要的依赖,它会自动引入tomcat内置容器、log4j、jackson等通用的依赖
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
我们可以通过mvn dependency:tree来查看项目的依赖结构树
项目的依赖结构树
编写一个简单的Controller
package com.panlingxiao.springboot.web.
import org.springframework.beans.factory.annotation.V
import org.springframework.web.bind.annotation.RequestM
import org.springframework.web.bind.annotation.RestC
* RestController是Spring 4.0推出的新特性,
* 使用其标注表示当前类为一个@Controller,并且
* 使用@RequestMapping所标注的方法的返回值默认会被认为使用
* 了@ResponseBody进行标注，因此不再使用视图解析的方式进行处理，
* 而是将内容通过HTTP响应体返回给客户端。
@RestController
public class HelloController {
* spring boot会自动读取application.properties,
* 并且将其作为系统参数进行注入,用户也可以在启动应用的时候
* 通过-Dname=xxx来手动注入，手动注入会覆盖配置文件中的参数
* 如果没有指定值，那么name的默认值就是World。
@Value("${name:World}")
* 由于使用了@RestControlelr,因此无需在使用@ResponseBody来标注返回的结果
@RequestMapping("/hello")
public String sayHello(){
return String.format("hello:%s", name);
编写Spring Boot的启动类
package com.panlingxiao.springboot.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
@SpringBootApplication
public class WebApp{
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
至此，我们的Web应用已经搭建完毕，只需启动WebApp即可。启动应用之后，会输出如下的信息。
启动日志.png
在浏览器中请求所返回的结果如下：
响应结果.png
这个Hello World的例子虽然简单，但是我们应该能够看到Spring Boot的强大之处。我们无需再在web.xml中编写DispatcherServlet，无需再写对应的Spring配置文件，无需再去找对应的maven依赖等，这一切的一切只需几个简单的注解就搞定一切了。
2.2 在命令行下启动应用
我们除了可以通过在IDE中启动Spring Boot应用的启动，Spring Boot官方还提供了另外一个种方式，可以让我们在命令行下完成应用的启动。
通过输入mvn spring-boot run
命令行启动结果.png
2.3 创建一个可运行的jar
以上命令行的方式虽然可以完成了Web应用的启动，但是其启动依赖于maven。我们在部署应用到服务器的时候，通常不会在服务器上去单独的安装maven，而只是希望它能够以单独的一个JAR包的形式启动。在此之前，如果我们希望一个服务单独地打成一个JAR包来运行的经历，那么我需要通过在POM文件中引入大量的插件，比如资源文件拷贝、将项目依赖的JAR单独地创建一个目录、生成运行的主程序等等，这一系列操作都需要基于Maven的插件来完成。而现在，Spring Boot为我们提供了一个打包执行的JAR的插件，我们只需引入，然后使用mvn clean package就可以搞定一切了。
在原来的POM文件中加入如下内容:
Spring Boot提供的打包插件,会自动生成运行的类,
同时将项目依赖的JAR一起和JAR包绑定在一切输出。
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
打包输出结果.png
MENIFEST结果.png
现在我们就可以通过java -jar xxx.jar来完成一个Web的启动。
以Java Application方式启动结果.png
2.4 简单理解Spring Boot的Hello World
上面的程序虽然简单，但是我们并没有分析为什么使用这么几行代码就可以一个Web应用的启动，如果不理解原因，个人感觉一切都是白搭，因为你只是知道如何做，而不是知道为什么这么做。下面就来简单的分析一下我们所编写的WebApp这个类为什么它就可以被完成一个Web应用的启动。
@SpringBootApplication
public class WebApp{
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
首先我们看到该类使用了@SpringBootApplication这个注解来进行标识。该注解其实又是由其他3个注解来标识,它们分别是@Configuration、@EnableAutoConfiguration、@ComponentScan。
SpringBootApplication源码.png
(1). @Configuration：其作用是标识当前类是一个Bean定义信息的来源，它可以被Spring的ApplicationContext进行加载处理；其作用等同于我们之前使用的xml文件，只是我们以前将Bean的定义配置在xml中，而现在是将Bean的定义全部基于代码写在了使用@Configuration所标识的这个类中。
下面我们通过一个例子更加清楚地说明@Configuration的作用。
public class User {
public String getName() {
public void setName(String name) {
this.name =
通过@Configuration标识的类，可以完成对Bean信息的定义：
* 使用@Configuration标识
* 在当前类中通过@Bean标注的方式
* 之后都由Spring的AppplicationContext来进行调用
* 从而生成Bean对象。
@Configuration
public class AppConfig {
public User getUser(){
User user = new User();
public class App {
public static void main(String[] args) {
* 将@Configuraion所标识的类通过Spring的上下问进行加载,从而实现Bean的创建。
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class);
ctx.refresh();
User user = ctx.getBean("user", User.class);
String value = user.sayHello();
通过上面的例子，我们应该可以看到@Configuration与xml几乎是一个等价的关系，其作用如出一辙，在我们上面的例子中，其实WebApp这个类可以不使用@Configuration来标准，也不会影响程序的正常启动。
(2). @EnableAutoConfiguration：该注解是让Spring根据当前classpath中所存在的类，自动推断出当前运行的环境(判断是否一个Web应用还是一个普通的Java应用)，然后根据具体的环境去创建对应的bean，将其添加的Spring的ApplicationContext中。比如:我们在classpath中添加了tomcat-embedded.jar，因此它会去自动帮助我们自动地创建一个EmbeddedServletContainerFactory。如果没有这个对象，那么我们的Tomcat是无法启动的。我们将WebApp改成如下结果:
//不再设置EnableAutoConfiguration会导致应用启动失败
@Configuration
@ComponentScan
public class WebApp {
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
缺少EnableAutoConfiguration启动结果.png
从上面的分析结果我们可以，@EnableAutoConfiguration对应配置Spring Boot应用非常重要，如果缺少这个注解，就非常可能由于缺少需要的Bean而导致应用的启动失败。
(3). @ComponentScan：该注解就是让Spring容器自动根据指定的包以及子包中进行组件的查找然后创建，如果没有指定具体到哪个包中进行查找，那么就以当前使用该注解的类所在的包作为查找的根，进行查找。即在WebApp这个类所在的包及其子包中进行查找。注意:这里我将HelloController定义在了WebApp所在的包的子包中，如果它们所在的包不具有上面所描述的查找关系，那么Controller是不会被创建的，即使应用可以启动，但是最终响应的结果将是404。
我们在main方法中使用了SpringApplication这个类完成了应用的启动，该类是一个Spring应用启动的引导工具类，它底层维护着Spring容器。由于篇幅有限，SpingApplication具体引导的过程不再这里细说，我会在后面的笔记中记录分析SpringApplication的具体如何完成Spring容器的创建、如何完成Web应用的启动。
SpringBoot除了提供强大的功能外，官方还提供了非常人性化的支持，我们可以访问 ，在该网站上根据我们应用的特点，自动其对应的生成spring boot的模版文件。
至此，Spring Boot的入门笔记就先写到这里，下一节会去分析SpringApplication这个神奇的东西，看看它到底是如何工作的。
每天都在努力成为一个合格且优秀的程序员！1504人阅读
springBoot（3）
原文：http://blog.csdn.net/jsyxcjw/article/details/
1.1 spring介绍
Spring Boot使开发独立的，产品级别的基于Spring的应用变得非常简单，你只需&just run&。 我们为Spring平台及第三方库提供开箱即用的设置，这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。
你可以使用Spring Boot创建Java应用，并使用java -jar启动它或采用传统的war部署方式。
1.2 系统要求
默认情况下，Spring Boot 1.3.0.BUILD-SNAPSHOT 需要Java7和Spring框架4.1.3或以上。你可以在Java6下使用Spring Boot，不过需要添加额外配置。具体参考Section 73.9, “How to use Java 6” 。构建环境明确支持的有Maven（3.2+）和Gradle（1.12+）。
Servlet容器 下列内嵌容器支持开箱即用（out of the box）：
Servlet版本
Java 7+
Java 6+
Java 7+
Java 6+
Undertow 1.1
3.1 Java 7+
你也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。
1.3 第一个spring boot应用
在开始前，你需要打开一个终端，检查是否安装可用的Java版本和Maven：
Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebadfdf4; T13:58:10-07:00)
Maven home: /Users/user/tools/apache-maven-3.1.1
Java version: 1.7.0_51, vendor: Oracle Corporation
创建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&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
&!-- Additional lines to be added here... --&
&!-- (you don't need this if you are using a .RELEASE version) --&
&repositories&
&repository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&snapshots&&enabled&true&/enabled&&/snapshots&
&/repository&
&repository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/repository&
&/repositories&
&pluginRepositories&
&pluginRepository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&/pluginRepository&
&pluginRepository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/pluginRepository&
&/pluginRepositories&
&/project&
添加classpath依赖：
Spring Boot提供很多&Starter POMs&，这能够让你轻松的将jars添加到你的classpath下。我们的示例程序已经在POM的partent节点使用了spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的starter，它提供了有用的Maven默认设置。同时，它也提供了一个dependency-management节点，这样对于”blessed“依赖你可以省略version标记。
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
如果再次运行mvn dependency:tree，你将看到现在有了一些其他依赖，包括Tomcat web服务器和Spring Boot自身。
编写代码：
为了完成应用程序，我们需要创建一个单独的Java文件。Maven默认会编译src/main/java下的源码，所以你需要创建那样的文件结构，然后添加一个名为src/main/java/Example.java的文件：
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
@RequestMapping(&/&)
String home() {
return &Hello World!&;
public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
@RestController和@RequestMapping说明：
@RestController。这被称为一个构造型（stereotype）注解。它为阅读代码的人们提供建议。对于Spring，该类扮演了一个特殊角色。在本示例中，我们的类是一个web @Controller，所以当处理进来的web请求时，Spring会询问它。
@RequestMapping注解提供路由信息。它告诉Spring任何来自&/&路径的HTTP请求都应该被映射到home方法。@RestController注解告诉Spring以字符串的形式渲染结果，并直接返回给调用者。
@EnableAutoConfiguration。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
main方法。这只是一个标准的方法，它遵循Java对于一个应用程序入口点的约定。我们的main方法通过调用run，将业务委托给了Spring Boot的SpringApplication类。SpringApplication将引导我们的应用，启动Spring，相应地启动被自动配置的Tomcat web服务器。我们需要将Example.class作为参数传递给run方法来告诉SpringApplication谁是主要的Spring组件。
mvn spring-boot:run
如果使用一个浏览器打开&localhost:8080，以下输出：
Hello World!
创建可执行jar
为了创建可执行的jar，需要将spring-boot-maven-plugin添加到我们的pom.xml中。在dependencies节点下插入以下内容：
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
注：spring-boot-starter-parent POM包含用于绑定repackage目标的配置。如果你不使用parent POM，你将需要自己声明该配置。具体参考插件文档。
保存你的pom.xml，然后从命令行运行mvn package：
mvn package
如果查看target目录，你应该看到myproject-0.0.1-SNAPSHOT.jar。该文件应该有10Mb左右的大小。如果想偷看内部结构，你可以运行jar tvf：
jar tvf target/myproject-0.0.1-SNAPSHOT.jar
在target目录下，你应该也能看到一个很小的名为myproject-0.0.1-SNAPSHOT.jar.original的文件。这是在Spring Boot重新打包前Maven创建的原始jar文件。
为了运行该应用程序，你可以使用java -jar命令：
java -jar target/myproject-0.0.1-SNAPSHOT.jar
2. 使用Spring Boot
Maven用户可以继承spring-boot-starter-parent项目来获取合适的默认设置。该父项目提供以下特性：
默认编译级别为Java 1.6
源码编码为UTF-8
一个依赖管理节点，允许你省略普通依赖的&version&标签，继承自spring-boot-dependencies POM。
合适的资源过滤
合适的插件配置（exec插件，surefire，Git commit ID，shade）
针对application.properties和application.xml的资源过滤
最后一点：由于默认配置文件接收Spring风格的占位符（${...}），Maven filtering改用@..@占位符（你可以使用Maven属性resource.delimiter来覆盖它）。
想配置你的项目继承spring-boot-starter-parent只需要简单地设置parent为：
&!-- Inherit defaults from Spring Boot --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
注：你应该只需要在该依赖上指定Spring Boot版本。如果导入其他的starters，你可以放心的省略版本号。
使用没有父POM的Spring Boot
不是每个人都喜欢继承spring-boot-starter-parent POM。你可能需要使用公司标准parent，或你可能倾向于显式声明所有Maven配置。
如果你不使用spring-boot-starter-parent，通过使用一个scope=import的依赖，你仍能获取到依赖管理的好处：
&dependencyManagement&
&dependencies&
&dependency&
&!-- Import dependency management from Spring Boot --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-dependencies&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
&type&pom&/type&
&scope&import&/scope&
&/dependency&
&/dependencies&
&/dependencyManagement&
改变Java版本
spring-boot-starter-parent选择相当保守的Java兼容策略。如果你遵循我们的建议，使用最新的Java版本，你可以添加一个java.version属性：
&properties&
&java.version&1.8&/java.version&
&/properties&
** 使用Spring Boot Maven插件**
Spring Boot包含一个Maven插件，它可以将项目打包成一个可执行jar。如果想使用它，你可以将该插件添加到节点处：
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
注：如果使用Spring Boot starter parent pom，你只需要添加该插件而无需配置它，除非你想改变定义在partent中的设置。
2.2 组织代码
Spring Boot不需要使用任何特殊的代码结构，然而，这里有一些有用的最佳实践。
使用&default&包
当类没有包含package声明时，它被认为处于default package下。通常不推荐使用default package，并应该避免使用它。因为对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot应用来说，来自每个jar的类都会被读取，这会造成一定的问题。
定位main应用类
我们通常建议你将main应用类放在位于其他类上面的根包（root package）中。通常使用@EnableAutoConfiguration注解你的main类，并且暗地里为某些项定义了一个基础“search package”。例如，如果你正在编写一个JPA应用，被@EnableAutoConfiguration注解的类所在包将被用来搜索@Entity项。
使用根包允许你使用@ComponentScan注解而不需要定义一个basePackage属性。如果main类位于根包中，你也可以使用@SpringBootApplication注解。
下面是一个典型的结构：
+- example
+- myproject
+- Application.java
+- domain
+- Customer.java
+- CustomerRepository.java
+- service
+- CustomerService.java
+- web
+- CustomerController.java
Application.java文件将声明main方法，还有基本的@Configuration。
package com.example.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.EnableAutoC
import org.springframework.ponentS
import org.springframework.context.annotation.C
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
2.3 配置类
Spring Boot提倡基于Java的配置。尽管你可以使用一个XML源来调用SpringApplication.run()，我们通常建议你使用@Configuration类作为主要源。一般定义main方法的类也是主要@Configuration的一个很好候选。
1、导入其他配置类
你不需要将所有的@Configuration放进一个单独的类。@Import注解可以用来导入其他配置类。另外，你也可以使用@ComponentScan注解自动收集所有的Spring组件，包括@Configuration类。
2、导入XML配置
如果你绝对需要使用基于XML的配置，我们建议你仍旧从一个@Configuration类开始。你可以使用附加的@ImportResource注解加载XML配置文件。
2.4 自动配置
Spring Boot自动配置（auto-configuration）尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库。
你可以通过将@EnableAutoConfiguration或@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。
注：你只需要添加一个@EnableAutoConfiguration注解。我们建议你将它添加到主@Configuration类上。
禁用特定的自动配置
如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
2.5 Spring Beans和依赖注入
你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见，我们经常使用@ComponentScan注解搜索beans，并结合@Autowired构造器注入。
如果使用上面建议的结构组织代码（将应用类放到根包下），你可以添加@ComponentScan注解而不需要任何参数。你的所有应用程序组件（@Component, @Service, @Repository, @Controller等）将被自动注册为Spring Beans。
下面是一个@Service Bean的示例，它使用构建器注入获取一个需要的RiskAssessor bean。
package com.example.
import org.springframework.beans.factory.annotation.A
import org.springframework.stereotype.S
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskA
@Autowired
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskA
注：注意如何使用构建器注入来允许riskAssessor字段被标记为final，这意味着riskAssessor后续是不能改变的。
2.6 使用@SpringBootApplication注解
很多Spring Boot开发者总是使用@Configuration，@EnableAutoConfiguration和@ComponentScan注解他们的main类。由于这些注解被如此频繁地一块使用（特别是你遵循以上最佳实践时），Spring Boot提供一个方便的@SpringBootApplication选择。
该@SpringBootApplication注解等价于以默认属性使用@Configuration，@EnableAutoConfiguration和@ComponentScan。
package com.example.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
2.7 作为一个打包后的应用运行
如果使用Spring Boot Maven或Gradle插件创建一个可执行jar，你可以使用java -jar运行你的应用。例如：
java -jar target/myproject-0.0.1-SNAPSHOT.jar
运行一个打包的程序并开启远程调试支持是可能的，这允许你将调试器附加到打包的应用程序上：
java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myproject-0.0.1-SNAPSHOT.jar
2.8 使用Maven插件运行
Spring Boot Maven插件包含一个run目标，它可以用来快速编译和运行应用程序。应用程序以一种暴露的方式运行，由于即时&热&加载，你可以编辑资源。
mvn spring-boot:run
你可能想使用有用的操作系统环境变量：
export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
3 Spring Boot特性
3.1 SpringApplication
SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下，你只需委托给SpringApplication.run这个静态方法：
public static void main(String[] args){
SpringApplication.run(MySpringConfiguration.class, args);
当应用启动时，你应该会看到类似下面的东西（这是何方神兽？？）：
/\\ / ___'_ __ _ _(_)_ __
__ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
___)| |_)| | | | | || (_| |
|____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::
v1.2.2.BUILD-SNAPSHOT
00:08:16.117
INFO 56603 --- [
main] o.s.b.s.app.SampleApplication
: Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
00:08:16.166
INFO 56603 --- [
main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
13:09:54.912
INFO 41370 --- [
main] .t.TomcatEmbeddedServletContainerFactory : Server initialized with port: 8080
13:09:56.501
INFO 41370 --- [
main] o.s.b.s.app.SampleApplication
默认情况下会显示INFO级别的日志信息，包括一些相关的启动详情，比如启动应用的用户等。
3.1.1 自定义Banner
通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner。如果这个文件有特殊的编码，你可以使用banner.encoding设置它（默认为UTF-8）。
在banner.txt中可以使用如下的变量：
${application.version}
MANIFEST.MF中声明的应用版本号，例如1.0
${application.formatted-version}
MANIFEST.MF中声明的被格式化后的应用版本号（被括号包裹且以v作为前缀），用于显示，例如(v1.0)
${spring-boot.version}
正在使用的Spring Boot版本号，例如1.2.2.BUILD-SNAPSHOT
${spring-boot.formatted-version}
正在使用的Spring Boot被格式化后的版本号（被括号包裹且以v作为前缀）, 用于显示，例如(v1.2.2.BUILD-SNAPSHOT)
注：如果想以编程的方式产生一个banner，可以使用SpringBootApplication.setBanner(…)方法。使用org.springframework.boot.Banner接口，实现你自己的printBanner()方法。
3.1.2 自定义SpringApplication
如果默认的SpringApplication不符合你的口味，你可以创建一个本地的实例并自定义它。例如，关闭banner你可以这样写：
public static void main(String[] args){
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setShowBanner(false);
app.run(args);
注：传递给SpringApplication的构造器参数是spring beans的配置源。在大多数情况下，这些将是@Configuration类的引用，但它们也可能是XML配置或要扫描包的引用。
3.1.3 流畅的构建API
如果你需要创建一个分层的ApplicationContext（多个具有父子关系的上下文），或你只是喜欢使用流畅的构建API，你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法，包括可以创建层次结构的parent和child方法。
new SpringApplicationBuilder()
.showBanner(false)
.sources(Parent.class)
.child(Application.class)
.run(args);
注：创建ApplicationContext层次时有些限制，比如，Web组件(components)必须包含在子上下文(child context)中，且相同的Environment即用于父上下文也用于子上下文中。
3.1.4 Application事件和监听器
除了常见的Spring框架事件，比如ContextRefreshedEvent，一个SpringApplication也发送一些额外的应用事件。一些事件实际上是在ApplicationContext被创建前触发的。
你可以使用多种方式注册事件监听器，最普通的是使用SpringApplication.addListeners(…)方法。在你的应用运行时，应用事件会以下面的次序发送：
在运行开始，但除了监听器注册和初始化以外的任何处理之前，会发送一个ApplicationStartedEvent。
在Environment将被用于已知的上下文，但在上下文被创建前，会发送一个ApplicationEnvironmentPreparedEvent。
在refresh开始前，但在bean定义已被加载后，会发送一个ApplicationPreparedEvent。
启动过程中如果出现异常，会发送一个ApplicationFailedEvent。
注：你通常不需要使用应用程序事件，但知道它们的存在会很方便（在某些场合可能会使用到）。在Spring内部，Spring Boot使用事件处理各种各样的任务。
3.1.5 Web环境
一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。
用于确定一个web环境的算法相当简单（基于是否存在某些类）。如果需要覆盖默认行为，你可以使用setWebEnvironment(boolean webEnvironment)。通过调用setApplicationContextClass(…)，你可以完全控制ApplicationContext的类型。
注：当JUnit测试里使用SpringApplication时，调用setWebEnvironment(false)是可取的。
3.1.6 命令行启动器
如果你想获取原始的命令行参数，或一旦SpringApplication启动，你需要运行一些特定的代码，你可以实现CommandLineRunner接口。在所有实现该接口的Spring beans上将调用run(String… args)方法。
import org.springframework.boot.*
import org.springframework.stereotype.*
@Component
public class MyBean implements CommandLineRunner {
public void run(String... args) {
// Do something...
如果一些CommandLineRunner beans被定义必须以特定的次序调用，你可以额外实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order注解。
3.1.7 Application退出
每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭，将会注册一个JVM的shutdown钩子。所有标准的Spring生命周期回调（比如，DisposableBean接口或@PreDestroy注解）都能使用。
此外，如果beans想在应用结束时返回一个特定的退出码（exit code），可以实现org.springframework.boot.ExitCodeGenerator接口。
4 外化配置
Spring Boot允许外化（externalize）你的配置，这样你能够在不同的环境下使用相同的代码。你可以使用properties文件，YAML文件，环境变量和命令行参数来外化配置。使用@Value注解，可以直接将属性值注入到你的beans中，并通过Spring的Environment抽象或绑定到结构化对象来访问。
Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖，需要以下面的次序考虑属性：
命令行参数
来自于java:comp/env的JNDI属性
Java系统属性（System.getProperties()）
操作系统环境变量
只有在random.*里包含的属性会产生一个RandomValuePropertySource
在打包的jar外的应用程序配置文件（application.properties，包含YAML和profile变量）
在打包的jar内的应用程序配置文件（application.properties，包含YAML和profile变量）
在@Configuration类上的@PropertySource注解
默认属性（使用SpringApplication.setDefaultProperties指定）
下面是一个具体的示例（假设你开发一个使用name属性的@Component）：
import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
@Value(&${name}&)
你可以将一个application.properties文件捆绑到jar内，用来提供一个合理的默认name属性值。当运行在生产环境时，可以在jar外提供一个application.properties文件来覆盖name属性。对于一次性的测试，你可以使用特定的命令行开关启动（比如，java -jar app.jar --name=&Spring&）。
4.1 配置随机值
RandomValuePropertySource在注入随机值（比如，密钥或测试用例）时很有用。它能产生整数，longs或字符串，比如：
my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.number.less.than.ten=${random.int(10)}
my.number.in.range=${random.int[]}
random.int*语法是OPEN value (,max) CLOSE，此处OPEN，CLOSE可以是任何字符，并且value，max是整数。如果提供max，那么value是最小的值，max是最大的值（不包含在内）。
4.2访问命令行属性
默认情况下，SpringApplication将任何可选的命令行参数（以'--'开头，比如，--server.port=9000）转化为property，并将其添加到Spring Environment中。如上所述，命令行属性总是优先于其他属性源。
如果你不想将命令行属性添加到Environment里，你可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。
4.3 Application属性文件
SpringApplication将从以下位置加载application.properties文件，并把它们添加到Spring Environment中：
当前目录下的一个/config子目录
一个classpath下的/config包
classpath根路径（root）
这个列表是按优先级排序的（列表中位置高的将覆盖位置低的）。
注：你可以使用YAML（'.yml'）文件替代'.properties'。
如果不喜欢将application.properties作为配置文件名，你可以通过指定spring.config.name环境属性来切换其他的名称。你也可以使用spring.config.location环境属性来引用一个明确的路径（目录位置或文件路径列表以逗号分割）。
$ java -jar myproject.jar --spring.config.name=myproject
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
如果spring.config.location包含目录（相对于文件），那它们应该以/结尾（在加载前，spring.config.name产生的名称将被追加到后面）。不管spring.config.location是什么值，默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。以这种方式，你可以在application.properties中为应用设置默认值，然后在运行的时候使用不同的文件覆盖它，同时保留默认配置。
注：如果你使用环境变量而不是系统配置，大多数操作系统不允许以句号分割（period-separated）的key名称，但你可以使用下划线（underscores）代替（比如，使用SPRINGCONFIGNAME代替spring.config.name）。如果你的应用运行在一个容器中，那么JNDI属性（java:comp/env）或servlet上下文初始化参数可以用来取代环境变量或系统属性，当然也可以使用环境变量或系统属性。
4.4 特定的Profile属性
除了application.properties文件，特定配置属性也能通过命令惯例application-{profile}.properties来定义。特定Profile属性从跟标准application.properties相同的路径加载，并且特定profile文件会覆盖默认的配置。
4.5 属性占位符
当application.properties里的值被使用时，它们会被存在的Environment过滤，所以你能够引用先前定义的值（比如，系统属性）。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
4.6 使用YAML代替Properties
YAML是JSON的一个超集，也是一种方便的定义层次配置数据的格式。无论你何时将SnakeYAML 库放到classpath下，SpringApplication类都会自动支持YAML作为properties的替换。
注：如果你使用'starter POMs'，spring-boot-starter会自动提供SnakeYAML。
4.6.1. 加载YAML
Spring框架提供两个便利的类用于加载YAML文档，YamlPropertiesFactoryBean会将YAML作为Properties来加载，YamlMapFactoryBean会将YAML作为Map来加载。
environments:
name: Developer Setup
name: My Cool App
上面的YAML文档会被转化到下面的属性中：
environments.dev.url=
environments.dev.name=Developer Setup
environments.prod.url=
environments.prod.name=My Cool App
YAML列表被表示成使用[index]间接引用作为属性keys的形式，例如下面的YAML：
将会转化到下面的属性中:
my.servers[0]=
my.servers[1]=
使用Spring DataBinder工具绑定那样的属性（这是@ConfigurationProperties做的事），你需要确定目标bean中有个java.util.List或Set类型的属性，并且需要提供一个setter或使用可变的值初始化它，比如，下面的代码将绑定上面的属性：
@ConfigurationProperties(prefix=&my&)
public class Config {
private List&String& servers = new ArrayList&String&();
public List&String& getServers() {
return this.
4.6.2. 在Spring环境中使用YAML暴露属性
YamlPropertySourceLoader类能够用于将YAML作为一个PropertySource导出到Sprig Environment。这允许你使用熟悉的@Value注解和占位符语法访问YAML属性。
4.6.3. Multi-profile YAML文档
你可以在单个文件中定义多个特定配置（profile-specific）的YAML文档，并通过一个spring.profiles key标示应用的文档。例如：
address: 192.168.1.100
profiles: development
address: 127.0.0.1
profiles: production
address: 192.168.1.120
在上面的例子中，如果development配置被激活，那server.address属性将是127.0.0.1。如果development和production配置（profiles）没有启用，则该属性的值将是192.168.1.100。
YAML文件不能通过@PropertySource注解加载。所以，在这种情况下，如果需要使用@PropertySource注解的方式加载值，那就要使用properties文件。
4.7. 类型安全的配置属性
使用@Value(&${property}&)注解注入配置属性有时可能比较笨重，特别是需要使用多个properties或你的数据本身有层次结构。为了控制和校验你的应用配置，Spring Boot提供一个允许强类型beans的替代方法来使用properties。
@Component
@ConfigurationProperties(prefix=&connection&)
public class ConnectionSettings {
private InetAddress remoteA
// ... getters and setters
当@EnableConfigurationProperties注解应用到你的@Configuration时，任何被@ConfigurationProperties注解的beans将自动被Environment属性配置。这种风格的配置特别适合与SpringApplication的外部YAML配置进行配合使用。
# application.yml
connection:
username: admin
remoteAddress: 192.168.1.1
# additional configuration as required
为了使用@ConfigurationProperties beans，你可以使用与其他任何bean相同的方式注入它们。
public class MyService {
@Autowired
private ConnectionS
@PostConstruct
public void openConnection() {
Server server = new Server();
this.connection.configure(server);
你可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义。
@Configuration
@EnableConfigurationProperties(ConnectionSettings.class)
public class MyConfiguration {
注：使用@ConfigurationProperties能够产生可被IDEs使用的元数据文件。具体参考Appendix B, Configuration meta-data。
4.7.1. 第三方配置
正如使用@ConfigurationProperties注解一个类，你也可以在@Bean方法上使用它。当你需要绑定属性到不受你控制的第三方组件时，这种方式非常有用。
为了从Environment属性配置一个bean，将@ConfigurationProperties添加到它的bean注册过程：
@ConfigurationProperties(prefix = &foo&)
public FooComponent fooComponent() {
和上面ConnectionSettings的示例方式相同，任何以foo为前缀的属性定义都会被映射到FooComponent上。
4.7.2. 松散的绑定（Relaxed binding）
Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans，所以Environment属性名和bean属性名不需要精确匹配。常见的示例中有用的包括虚线分割（比如，context--path绑定到contextPath）和将环境属性转为大写字母（比如，PORT绑定port）。
@Component
@ConfigurationProperties(prefix=&person&)
public class ConnectionSettings {
private String firstN
下面的属性名都能用于上面的@ConfigurationProperties类：
person.firstName
标准驼峰规则
person.first-name
虚线表示，推荐用于.properties和.yml文件中
PERSON_FIRST_NAME
大写形式，使用系统环境变量时推荐
Spring会尝试强制外部的应用属性在绑定到@ConfigurationProperties beans时类型是正确的。如果需要自定义类型转换，你可以提供一个ConversionService bean（bean id为conversionService）或自定义属性编辑器（通过一个CustomEditorConfigurer bean）。
4.7.3. @ConfigurationProperties校验
Spring Boot将尝试校验外部的配置，默认使用JSR-303（如果在classpath路径中）。你可以轻松的为你的@ConfigurationProperties类添加JSR-303 javax.validation约束注解：
@Component
@ConfigurationProperties(prefix=&connection&)
public class ConnectionSettings {
private InetAddress remoteA
// ... getters and setters
你也可以通过创建一个叫做configurationPropertiesValidator的bean来添加自定义的Spring Validator。
注：spring-boot-actuator模块包含一个暴露所有@ConfigurationProperties beans的端点。
5 Profiles
Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。
@Configuration
@Profile(&production&)
public class ProductionConfiguration {
以正常的Spring方式，你可以使用一个spring.profiles.active的Environment属性来指定哪个配置生效。你可以使用平常的任何方式来指定该属性，例如，可以将它包含到你的application.properties中：
spring.profiles.active=dev,hsqldb
或使用命令行开关：
--spring.profiles.active=dev,hsqldb
5.1. 添加激活的配置(profiles)
spring.profiles.active属性和其他属性一样都遵循相同的排列规则，最高的PropertySource获胜。也就是说，你可以在application.properties中指定生效的配置，然后使用命令行开关替换它们。
有时，将特定的配置属性添加到生效的配置中而不是替换它们是有用的。spring.profiles.include属性可以用来无条件的添加生效的配置。SpringApplication的入口点也提供了一个用于设置额外配置的Java API（比如，在那些通过spring.profiles.active属性生效的配置之上）：参考setAdditionalProfiles()方法。
示例：当一个应用使用下面的属性，并用--spring.profiles.active=prod开关运行，那proddb和prodmq配置也会生效：
my.property: fromyamlfile
spring.profiles: prod
spring.profiles.include: proddb,prodmq
注：spring.profiles属性可以定义到一个YAML文档中，用于决定什么时候该文档被包含进配置中。
5.2.以编程方式设置profiles
在应用运行前，你可以通过调用SpringApplication.setAdditionalProfiles(…)方法，以编程的方式设置生效的配置。使用Spring的ConfigurableEnvironment接口激动配置也是可行的。
5.3. Profile特定配置文件
application.properties（或application.yml）和通过@ConfigurationProperties引用的文件这两种配置特定变种都被当作文件来加载的，具体参考Section 23.3, “Profile specific properties”。
Spring Boot内部日志系统使用的是Commons Logging，但开放底层的日志实现。默认为会Java Util Logging, Log4J, Log4J2和Logback提供配置。每种情况下都会预先配置使用控制台输出，也可以使用可选的文件输出。
默认情况下，如果你使用'Starter POMs'，那么就会使用Logback记录日志。为了确保那些使用Java Util Logging, Commons Logging, Log4J或SLF4J的依赖库能够正常工作，正确的Logback路由也被包含进来。
注：如果上面的列表看起来令人困惑，不要担心，Java有很多可用的日志框架。通常，你不需要改变日志依赖，Spring Boot默认的就能很好的工作。
6.1. 日志格式
Spring Boot默认的日志输出格式如下：
10:57:51.112
INFO 45469 --- [
main] org.apache.catalina.core.StandardEngine
: Starting Servlet Engine: Apache Tomcat/7.0.52
10:57:51.253
INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]
: Initializing Spring embedded WebApplicationContext
10:57:51.253
INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader
: Root WebApplicationContext: initialization completed in 1358 ms
10:57:51.698
INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean
: Mapping servlet: 'dispatcherServlet' to [/]
10:57:51.702
INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
输出的节点（items）如下：
日期和时间 - 精确到毫秒，且易于排序。
日志级别 - ERROR, WARN, INFO, DEBUG 或 TRACE。
Process ID。
一个用于区分实际日志信息开头的---分隔符。
线程名 - 包括在方括号中（控制台输出可能会被截断）。
日志名 - 通常是源class的类名（缩写）。
日志信息。
5.2. 控制台输出
默认的日志配置会在写日志消息时将它们回显到控制台。默认，ERROR, WARN和INFO级别的消息会被记录。可以在启动应用时，通过--debug标识开启控制台的DEBUG级别日志记录。
java -jar myapp.jar --debug
如果你的终端支持ANSI，为了增加可读性将会使用彩色的日志输出。你可以设置spring.output.ansi.enabled为一个支持的值来覆盖自动检测。
5.3. 文件输出
默认情况下，Spring Boot只会将日志记录到控制台而不会写进日志文件。如果除了输出到控制台你还想写入到日志文件，那你需要设置logging.file或logging.path属性（例如在你的application.properties中）。
下表显示如何组合使用logging.*：
logging.file
logging.path
只记录到控制台
Specific file
写到特定的日志文件里，名称可以是一个精确的位置或相对于当前目录
Specific folder
写到特定文件夹下的spring.log里，名称可以是一个精确的位置或相对于当前目录
日志文件每达到10M就会被轮换（分割），和控制台一样，默认记录ERROR, WARN和INFO级别的信息。
5.4. 日志级别
所有支持的日志系统在Spring的Environment（例如在application.properties里）都有通过'logging.level.*=LEVEL'（'LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一个）设置的日志级别。
示例：application.properties
logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
5.5. 自定义日志配置
通过将适当的库添加到classpath，可以激活各种日志系统。然后在classpath的根目录(root)或通过Spring Environment的logging.config属性指定的位置提供一个合适的配置文件来达到进一步的定制（注意由于日志是在ApplicationContext被创建之前初始化的，所以不可能在Spring的@Configuration文件中，通过@PropertySources控制日志。系统属性和平常的Spring Boot外部配置文件能正常工作）。
根据你的日志系统，下面的文件会被加载：
Logback logback.xml
log4j.properties或log4j.xml
log4j2.xml
JDK (Java Util Logging) logging.properties
为了帮助定制一些其他的属性，从Spring的Envrionment转换到系统属性：
Spring Environment
System Property 评价
logging.file
如果定义，在默认的日志配置中使用
logging.path
如果定义，在默认的日志配置中使用
PID PID 当前的处理进程(process)ID（如果能够被发现且还没有作为操作系统环境变量被定义）
所有支持的日志系统在解析它们的配置文件时都能查询系统属性。具体可以参考spring-boot.jar中的默认配置。
注：在运行可执行的jar时，Java Util Logging有类加载问题，我们建议你尽可能避免使用它。
6 开发Web应用
Spring Boot非常适合开发web应用程序。你可以使用内嵌的Tomcat，Jetty或Undertow轻轻松松地创建一个HTTP服务器。大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。
6.1. Spring Web MVC框架
Spring Web MVC框架（通常简称为&Spring MVC&）是一个富&模型，视图，控制器&的web框架。 Spring MVC允许你创建特定的@Controller或@RestController beans来处理传入的HTTP请求。 使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。
@RestController
@RequestMapping(value=&/users&)
public class MyRestController {
@RequestMapping(value=&/{user}&, method=RequestMethod.GET)
public User getUser(@PathVariable Long user) {
@RequestMapping(value=&/{user}/customers&, method=RequestMethod.GET)
List&Customer& getUserCustomers(@PathVariable Long user) {
@RequestMapping(value=&/{user}&, method=RequestMethod.DELETE)
public User deleteUser(@PathVariable Long user) {
6.1.1. Spring MVC自动配置
Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：
引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
对静态资源的支持，包括对WebJars的支持。
自动注册Converter，GenericConverter，Formatter beans。
对HttpMessageConverters的支持。
自动注册MessageCodeResolver。
对静态index.html的支持。
对自定义Favicon的支持。
如果想全面控制Spring MVC，你可以添加自己的@Configuration，并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器，formatters，视图控制器等)，你可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解）。
6.1.2. HttpMessageConverters
Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处（out of the box），例如对象可以自动转换为JSON（使用Jackson库）或XML（如果Jackson XML扩展可用则使用它，否则使用JAXB）。字符串默认使用UTF-8编码。
如果需要添加或自定义转换器，你可以使用Spring Boot的HttpMessageConverters类：
import org.springframework.boot.autoconfigure.web.HttpMessageC
import org.springframework.context.annotation.*;
import org.springframework.http.converter.*;
@Configuration
public class MyConfiguration {
public HttpMessageConverters customConverters() {
HttpMessageConverter&?& additional = ...
HttpMessageConverter&?& another = ...
return new HttpMessageConverters(additional, another);
任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表，你可以通过这种方式覆盖默认的转换器（converters）。
6.1.3. MessageCodesResolver
Spring MVC有一个策略，用于从绑定的errors产生用来渲染错误信息的错误码：MessageCodesResolver。如果设置spring.mvc.message-codes-resolver.format属性为PREFIXERRORCODE或POSTFIXERRORCODE（具体查看DefaultMessageCodesResolver.Format枚举值），Spring
Boot会为你创建一个MessageCodesResolver。
6.1.4. 静态内容
默认情况下，Spring Boot从classpath下一个叫/static（/public，/resources或/META-INF/resources）的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的ResourceHttpRequestHandler，所以你可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为（加载静态文件）。
在一个单独的web应用中，容器默认的servlet是开启的，如果Spring决定不处理某些请求，默认的servlet作为一个回退（降级）将从ServletContext根目录加载内容。大多数时候，这不会发生（除非你修改默认的MVC配置），因为Spring总能够通过DispatcherServlet处理请求。
此外，上述标准的静态资源位置有个例外情况是Webjars内容。任何在/webjars/**路径下的资源都将从jar文件中提供，只要它们以Webjars的格式打包。
注：如果你的应用将被打包成jar，那就不要使用src/main/webapp文件夹。尽管该文件夹是一个共同的标准，但它仅在打包成war的情况下起作用，并且如果产生一个jar，多数构建工具都会静悄悄的忽略它。
6.1.5. 模板引擎
正如REST web服务，你也可以使用Spring MVC提供动态HTML内容。Spring MVC支持各种各样的模板技术，包括Velocity, FreeMarker和JSPs。很多其他的模板引擎也提供它们自己的Spring MVC集成。
Spring Boot为以下的模板引擎提供自动配置支持：
FreeMarker
注：如果可能的话，应该忽略JSPs，因为在内嵌的servlet容器使用它们时存在一些已知的限制。
当你使用这些引擎的任何一种，并采用默认的配置，你的模板将会从src/main/resources/templates目录下自动加载。
注：IntelliJ IDEA根据你运行应用的方式会对classpath进行不同的整理。在IDE里通过main方法运行你的应用跟从Maven或Gradle或打包好的jar中运行相比会导致不同的顺序。这可能导致Spring Boot不能从classpath下成功地找到模板。如果遇到这个问题，你可以在IDE里重新对classpath进行排序，将模块的类和资源放到第一位。或者，你可以配置模块的前缀为classpath*:/templates/，这样会查找classpath下的所有模板目录。
6.1.6. 错误处理
Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误，并且它在servlet容器中注册了一个全局的 错误页面。对于机器客户端（相对于浏览器而言，浏览器偏重于人的行为），它会产生一个具有详细错误，HTTP状态，异常信息的JSON响应。对于浏览器客户端，它会产生一个白色标签样式（whitelabel）的错误视图，该视图将以HTML格式显示同样的数据（可以添加一个解析为erro的View来自定义它）。为了完全替换默认的行为，你可以实现ErrorController，并注册一个该类型的bean定义，或简单地添加一个ErrorAttributes类型的bean以使用现存的机制，只是替换显示的内容。
如果在某些条件下需要比较多的错误页面，内嵌的servlet容器提供了一个统一的Java DSL（领域特定语言）来自定义错误处理。 示例：
public EmbeddedServletContainerCustomizer containerCustomizer(){
return new MyCustomizer();
private static class MyCustomizer implements EmbeddedServletContainerCustomizer {
public void customize(ConfigurableEmbeddedServletContainer container) {
container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, &/400&));
你也可以使用常规的Spring MVC特性来处理错误，比如@ExceptionHandler方法和@ControllerAdvice。ErrorController将会捡起任何没有处理的异常。
N.B. 如果你为一个路径注册一个ErrorPage，最终被一个过滤器（Filter）处理（对于一些非Spring web框架，像Jersey和Wicket这很常见），然后过滤器需要显式注册为一个ERROR分发器（dispatcher）。
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new MyFilter());
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
注：默认的FilterRegistrationBean没有包含ERROR分发器类型。
6.1.7. Spring HATEOAS
如果你正在开发一个使用超媒体的RESTful API，Spring Boot将为Spring HATEOAS提供自动配置，这在多数应用中都工作良好。自动配置替换了对使用@EnableHypermediaSupport的需求，并注册一定数量的beans来简化构建基于超媒体的应用，这些beans包括一个LinkDiscoverer和配置好的用于将响应正确编排为想要的表示的ObjectMapper。ObjectMapper可以根据spring.jackson.*属性或一个存在的Jackson2ObjectMapperBuilder
bean进行自定义。
通过使用@EnableHypermediaSupport，你可以控制Spring HATEOAS的配置。注意这会禁用上述的对ObjectMapper的自定义。
6.2. JAX-RS和Jersey
如果喜欢JAX-RS为REST端点提供的编程模型，你可以使用可用的实现替代Spring MVC。如果在你的应用上下文中将Jersey 1.x和Apache Celtix的Servlet或Filter注册为一个@Bean，那它们工作的相当好。Jersey 2.x有一些原生的Spring支持，所以我们会在Spring Boot为它提供自动配置支持，连同一个启动器（starter）。
想要开始使用Jersey 2.x只需要加入spring-boot-starter-jersey依赖，然后你需要一个ResourceConfig类型的@Bean，用于注册所有的端点（endpoints）。
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
所有注册的端点都应该被@Components和HTTP资源annotations（比如@GET）注解。
@Component
@Path(&/hello&)
public class Endpoint {
public String message() {
return &Hello&;
由于Endpoint是一个Spring组件（@Component），所以它的生命周期受Spring管理，并且你可以使用@Autowired添加依赖及使用@Value注入外部配置。Jersey servlet将被注册，并默认映射到/*。你可以将@ApplicationPath添加到ResourceConfig来改变该映射。
默认情况下，Jersey将在一个ServletRegistrationBean类型的@Bean中被设置成名称为jerseyServletRegistration的Servlet。通过创建自己的相同名称的bean，你可以禁止或覆盖这个bean。你也可以通过设置spring.jersey.type=filter来使用一个Filter代替Servlet（在这种情况下，被覆盖或替换的@Bean是jerseyFilterRegistration）。该servlet有@Order属性，你可以通过spring.jersey.filter.order进行设置。不管是Servlet还是Filter注册都可以使用spring.jersey.init.*定义一个属性集合作为初始化参数传递过去。
这里有一个Jersey示例，你可以查看如何设置相关事项。
6.3. 内嵌servlet容器支持
Spring Boot支持内嵌的Tomcat, Jetty和Undertow服务器。多数开发者只需要使用合适的'Starter POM'来获取一个完全配置好的实例即可。默认情况下，内嵌的服务器会在8080端口监听HTTP请求。
6.3.1. Servlets和Filters
当使用内嵌的servlet容器时，你可以直接将servlet和filter注册为Spring的beans。在配置期间，如果你想引用来自application.properties的值，这是非常方便的。默认情况下，如果上下文只包含单一的Servlet，那它将被映射到根路径（/）。在多Servlet beans的情况下，bean的名称将被用作路径的前缀。过滤器会被映射到/*。
如果基于约定（convention-based）的映射不够灵活，你可以使用ServletRegistrationBean和FilterRegistrationBean类实现完全的控制。如果你的bean实现了ServletContextInitializer接口，也可以直接注册它们。
6.3.2. EmbeddedWebApplicationContext
Spring Boot底层使用了一个新的ApplicationContext类型，用于对内嵌servlet容器的支持。EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext，它通过搜索一个单一的EmbeddedServletContainerFactory bean来启动自己。通常，TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory将被自动配置。
注：你通常不需要知道这些实现类。大多数应用将被自动配置，并根据你的行为创建合适的ApplicationContext和EmbeddedServletContainerFactory。
6.3.3. 自定义内嵌servlet容器
常见的Servlet容器设置可以通过Spring Environment属性进行配置。通常，你会把这些属性定义到application.properties文件中。 常见的服务器设置包括：
server.port - 进来的HTTP请求的监听端口号
server.address - 绑定的接口地址
server.sessionTimeout - session超时时间
具体参考ServerProperties。
编程方式的自定义 如果需要以编程的方式配置内嵌的servlet容器，你可以注册一个实现EmbeddedServletContainerCustomizer接口的Spring bean。EmbeddedServletContainerCustomizer提供对ConfigurableEmbeddedServletContainer的访问，ConfigurableEmbeddedServletContainer包含很多自定义的setter方法。
import org.springframework.boot.context.embedded.*;
import org.
@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(9000);
直接自定义ConfigurableEmbeddedServletContainer 如果上面的自定义手法过于受限，你可以自己注册TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。
public EmbeddedServletContainerFactory servletContainer() {
TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
factory.setPort(9000);
factory.setSessionTimeout(10, TimeUnit.MINUTES);
factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, &/notfound.html&);
很多可选的配置都提供了setter方法，也提供了一些受保护的钩子方法以满足你的某些特殊需求。具体参考相关文档。
6.3.4. JSP的限制
在内嵌的servlet容器中运行一个Spring Boot应用时（并打包成一个可执行的存档archive），容器对JSP的支持有一些限制。
tomcat只支持war的打包方式，不支持可执行的jar。
内嵌的Jetty目前不支持JSPs。
Undertow不支持JSPs。
这里有个JSP示例，你可以查看如何设置相关事项。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：312910次
积分：4385
积分：4385
排名：第7096名
原创：90篇
转载：247篇
评论：22条
(1)(1)(2)(1)(1)(2)(3)(3)(3)(3)(6)(1)(8)(3)(3)(7)(1)(4)(8)(1)(9)(5)(8)(1)(1)(2)(1)(11)(2)(2)(6)(4)(8)(13)(6)(6)(6)(9)(4)(1)(5)(3)(6)(3)(5)(12)(5)(2)(4)(5)(6)(11)(8)(3)(17)(16)(22)(13)(6)(19)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'}
被围观&735&次
酱油一篇，整理一下关于Spring Boot后台运行的一些配置方式。在介绍后台运行配置之前，我们先回顾一下Spring Boot应用的几种运行方式：
运行Spring Boot的应用主类
使用Maven的Spring Boot插件mvn
spring-boot:run来运行
打成jar包后，使用java
我们在开发的时候，通常会使用前两种，而在部署的时候往往会使用第三种。但是，我们在使用java
-jar来运行的时候，并非后台运行。下面我们分别针对Windows和Linux/Unix两种环境，整理一下如何配置后台运行的方法。
Windows下比较简单，我们可以直接使用这款软件：AlwaysUp。如下图所示，简单、暴力、好用。
配置方式很简单，我们只需要把Spring Boot应用通过mvn
install打成jar包，然后编写一个java
-jar yourapp.jar的bat文件。再打开AlwaysUp，点击工具栏的第一个按钮，如下图所示，选择上面编写的bat文件，并填写服务名称。
完成了创建之后，在列表中可以看到我们配置的服务，通过右键选择Start
xxx就能在后台将该应用启动起来了。
Linux/Unix
下面我们来说说服务器上该如何来配置。实际上，实现的方法有很多种，这里就列两种还比较好用的方式：
nohup和Shell
该方法主要通过使用nohup命令来实现，该命令的详细介绍如下：
所以，我们只需要使用nohup
java -jar yourapp.jar &命令，就能让yourapp.jar在后台运行了。但是，为了方便管理，我们还可以通过Shell来编写一些用于启动应用的脚本，比如下面几个：
关闭应用的脚本：stop.sh#!/bin/bash
PID=$(ps -ef | grep yourapp.jar | grep -v grep | awk '{ print $2 }')
if [ -z &$PID& ]
echo Application is already stopped
echo kill $PID
启动应用的脚本：start.sh#!/bin/bash
nohup java -jar yourapp.jar --server.port=8888 &
整合了关闭和启动的脚本：run.sh，由于会先执行关闭应用，然后再启动应用，这样不会引起端口冲突等问题，适合在持续集成系统中进行反复调用。#!/bin/bash
echo stop application
source stop.sh
echo start application
source start.sh
在Spring Boot的Maven插件中，还提供了构建完整可执行程序的功能，什么意思呢？就是说，我们可以不用java
-jar，而是直接运行jar来执行程序。这样我们就可以方便的将其创建成系统服务在后台运行了。主要步骤如下：
在pom.xml中添加Spring
Boot的插件，并注意设置executable配置&build&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&configuration&
&executable&true&/executable&
&/configuration&
&/plugins&
在完成上述配置后，使用mvn
install进行打包，构建一个可执行的jar包
创建软连接到/etc/init.d/目录下sudo ln -s /var/yourapp/yourapp.jar /etc/init.d/yourapp
在完成软连接创建之后，我们就可以通过如下命令对yourapp.jar应用来控制启动、停止、重启操作了/etc/init.d/yourapp start|stop|restart
&本文由&&创作，采用&&进行许可。 可自由转载、引用，但需署名作者且注明文章出处。如转载至微信公众号，请在文末添加作者公众号二维码。
------------------------------------------------------------------------------------------------------------------------------&
如您觉得文章不错，对您有所帮助，可以通过“支付宝”或“微信支付”请我喝咖啡。
本文已收录于以下专栏：
相关文章推荐
在cmd命令行或者IDEA的Terminal终端界面，使用mvn spring-boot:run命令利用spring boot框架内置的tomcat运行spring boot开发的web应用。
SpringBoot:应用日常jar后台启动:nohup java -jar ./owl.jar &
直接前台执行:java -jar ./owl.jar
如果 Maven 运行过程出现内存溢出，则可...
网络绝对是任何系统的核心，对于容器而言也是如此。Docker 作为目前最火的轻量级容器技术，有很多令人称道的功能，如 Docker 的镜像管理。然而，Docker的网络一直以来都比较薄弱，所以我们有必要深入了解Docker的网络知识，以满足更高的网络需求。
一个完整的极简后台框架，方便做小项目的时候可以快速开发。
这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。
先放几张图项目介绍SpringBoot，...
基于springBoot的Web后端 (二)
酱油一篇，整理一下关于Spring Boot后台运行的一些配置方式。在介绍后台运行配置之前，我们先回顾一下Spring Boot应用的几种运行方式：
运行Spring Boot的应用主类
使用Mav...
前面两篇博客中我们简单介绍了Spring Boot项目的创建、并且也带小伙伴们来DIY了一个Spring Boot自动配置功能，那么这些东西说到底最终还是要回归到Web上才能体现出它的更大的价值，so...
本文通过创建.sh文件启动jar，并在后台运行。
假如需要运行的jar为
business-callpush-1.1.jar，系统linux centos6.9
1、新建一个文件夹callpush
startTest.sh内容如下：!/bin/shJava -jar Test.jar &
#注意：必须有&让其后台执行，否则没有pid生成
echo $! & /var/r...
Spring-boot jar 包方式启动：
首先，为了防止和常用的 Tomcat 8080 端口冲突，将 Spring-boot 项目的端口号设置为 9090。
具体方法：在 applicati...
他的最新文章
讲师：董西成
讲师：唐宇迪
您举报文章：
举报原因：
原文地址：
原因补充：
(最多只允许输入30个字)【图文】SpringBoot入门基础以及应用_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
SpringBoot入门基础以及应用
&&springBoot基础入门PPT
大小：444.90KB
登录百度文库，专享文档复制特权，财富值每天免费拿！
你可能喜欢Spring Boot 学习笔记1——初体验之3分钟启动你的Web应用 - 简书
Spring Boot 学习笔记1——初体验之3分钟启动你的Web应用
早在去年就简单的使用了一下Spring Boot，当时就被其便捷的功能所震惊。但是那是也没有深入的研究，随着其在业界被应用的越来越广泛，因此决定好好地深入学习一下，将自己的学习心得在此记录，本文主要围绕以下几点进行说明：
Spring Boot 简介
使用Spring Boot快速搭建一个Web应用
如有不对的地方，请指正。**
1. Spring Boot简介
Spring Boot是一个基于Spring的衍生框架，其主要的目的是帮助我们快速构建独立、生产级别的Spring的应用,其崇尚的理念是“约定优于配置”。
其主要有如下的特点:
创建一个单独的Spring应用
内置Web容器(默认使用Tomcat,如果你想换成Jetty只需简单修改配置即可)，以Java Application的方式就可以完成Web应用的启动。
提供了大量maven模版配置(通常被称为Starter
POMs)，通过使用其提供的maven配置，它将我们日常开发所使用到的依赖都集成了，因此可以大大减少我们对于maven的pom文件的配置的工作量。
自动化地对Spring进行配置，它可以根据你当前classpath路径下的jar包来推断出你当前的运行环境，自动的帮助我们创建出一些应该用必须使用的对象，并且根据对应的环境以其对应的方式进行启动。
提供了生产环境下的一些特性：如指标统计、健康检查。
无需冗余的代码与XML配置。
提供了现成的maven插件，可以更加方便地使用maven进行打包。
2. Spring Boot初体验
在简单了解完Spring Boot之后，下面让我们快速地使用Spring Boot搭建一个Web应用，来快速地感受一下Spring Boot其强大的功能。
2.1 快速搭建一个Web应用
引入的maven依赖:
这里使用官方最新的版本，官方推荐建议继承默认的springboot配置
继承后，项目的编译级别会自动变为jdk1.6版本。
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.3.RELEASE&/version&
添加一个web应用所需要的依赖,它会自动引入tomcat内置容器、log4j、jackson等通用的依赖
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
我们可以通过mvn dependency:tree来查看项目的依赖结构树
项目的依赖结构树
编写一个简单的Controller
package com.panlingxiao.springboot.web.
import org.springframework.beans.factory.annotation.V
import org.springframework.web.bind.annotation.RequestM
import org.springframework.web.bind.annotation.RestC
* RestController是Spring 4.0推出的新特性,
* 使用其标注表示当前类为一个@Controller,并且
* 使用@RequestMapping所标注的方法的返回值默认会被认为使用
* 了@ResponseBody进行标注，因此不再使用视图解析的方式进行处理，
* 而是将内容通过HTTP响应体返回给客户端。
@RestController
public class HelloController {
* spring boot会自动读取application.properties,
* 并且将其作为系统参数进行注入,用户也可以在启动应用的时候
* 通过-Dname=xxx来手动注入，手动注入会覆盖配置文件中的参数
* 如果没有指定值，那么name的默认值就是World。
@Value("${name:World}")
* 由于使用了@RestControlelr,因此无需在使用@ResponseBody来标注返回的结果
@RequestMapping("/hello")
public String sayHello(){
return String.format("hello:%s", name);
编写Spring Boot的启动类
package com.panlingxiao.springboot.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
@SpringBootApplication
public class WebApp{
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
至此，我们的Web应用已经搭建完毕，只需启动WebApp即可。启动应用之后，会输出如下的信息。
启动日志.png
在浏览器中请求所返回的结果如下：
响应结果.png
这个Hello World的例子虽然简单，但是我们应该能够看到Spring Boot的强大之处。我们无需再在web.xml中编写DispatcherServlet，无需再写对应的Spring配置文件，无需再去找对应的maven依赖等，这一切的一切只需几个简单的注解就搞定一切了。
2.2 在命令行下启动应用
我们除了可以通过在IDE中启动Spring Boot应用的启动，Spring Boot官方还提供了另外一个种方式，可以让我们在命令行下完成应用的启动。
通过输入mvn spring-boot run
命令行启动结果.png
2.3 创建一个可运行的jar
以上命令行的方式虽然可以完成了Web应用的启动，但是其启动依赖于maven。我们在部署应用到服务器的时候，通常不会在服务器上去单独的安装maven，而只是希望它能够以单独的一个JAR包的形式启动。在此之前，如果我们希望一个服务单独地打成一个JAR包来运行的经历，那么我需要通过在POM文件中引入大量的插件，比如资源文件拷贝、将项目依赖的JAR单独地创建一个目录、生成运行的主程序等等，这一系列操作都需要基于Maven的插件来完成。而现在，Spring Boot为我们提供了一个打包执行的JAR的插件，我们只需引入，然后使用mvn clean package就可以搞定一切了。
在原来的POM文件中加入如下内容:
Spring Boot提供的打包插件,会自动生成运行的类,
同时将项目依赖的JAR一起和JAR包绑定在一切输出。
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
打包输出结果.png
MENIFEST结果.png
现在我们就可以通过java -jar xxx.jar来完成一个Web的启动。
以Java Application方式启动结果.png
2.4 简单理解Spring Boot的Hello World
上面的程序虽然简单，但是我们并没有分析为什么使用这么几行代码就可以一个Web应用的启动，如果不理解原因，个人感觉一切都是白搭，因为你只是知道如何做，而不是知道为什么这么做。下面就来简单的分析一下我们所编写的WebApp这个类为什么它就可以被完成一个Web应用的启动。
@SpringBootApplication
public class WebApp{
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
首先我们看到该类使用了@SpringBootApplication这个注解来进行标识。该注解其实又是由其他3个注解来标识,它们分别是@Configuration、@EnableAutoConfiguration、@ComponentScan。
SpringBootApplication源码.png
(1). @Configuration：其作用是标识当前类是一个Bean定义信息的来源，它可以被Spring的ApplicationContext进行加载处理；其作用等同于我们之前使用的xml文件，只是我们以前将Bean的定义配置在xml中，而现在是将Bean的定义全部基于代码写在了使用@Configuration所标识的这个类中。
下面我们通过一个例子更加清楚地说明@Configuration的作用。
public class User {
public String getName() {
public void setName(String name) {
this.name =
通过@Configuration标识的类，可以完成对Bean信息的定义：
* 使用@Configuration标识
* 在当前类中通过@Bean标注的方式
* 之后都由Spring的AppplicationContext来进行调用
* 从而生成Bean对象。
@Configuration
public class AppConfig {
public User getUser(){
User user = new User();
public class App {
public static void main(String[] args) {
* 将@Configuraion所标识的类通过Spring的上下问进行加载,从而实现Bean的创建。
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class);
ctx.refresh();
User user = ctx.getBean("user", User.class);
String value = user.sayHello();
通过上面的例子，我们应该可以看到@Configuration与xml几乎是一个等价的关系，其作用如出一辙，在我们上面的例子中，其实WebApp这个类可以不使用@Configuration来标准，也不会影响程序的正常启动。
(2). @EnableAutoConfiguration：该注解是让Spring根据当前classpath中所存在的类，自动推断出当前运行的环境(判断是否一个Web应用还是一个普通的Java应用)，然后根据具体的环境去创建对应的bean，将其添加的Spring的ApplicationContext中。比如:我们在classpath中添加了tomcat-embedded.jar，因此它会去自动帮助我们自动地创建一个EmbeddedServletContainerFactory。如果没有这个对象，那么我们的Tomcat是无法启动的。我们将WebApp改成如下结果:
//不再设置EnableAutoConfiguration会导致应用启动失败
@Configuration
@ComponentScan
public class WebApp {
public static void main(String[] args) {
SpringApplication.run(WebApp.class, args);
缺少EnableAutoConfiguration启动结果.png
从上面的分析结果我们可以，@EnableAutoConfiguration对应配置Spring Boot应用非常重要，如果缺少这个注解，就非常可能由于缺少需要的Bean而导致应用的启动失败。
(3). @ComponentScan：该注解就是让Spring容器自动根据指定的包以及子包中进行组件的查找然后创建，如果没有指定具体到哪个包中进行查找，那么就以当前使用该注解的类所在的包作为查找的根，进行查找。即在WebApp这个类所在的包及其子包中进行查找。注意:这里我将HelloController定义在了WebApp所在的包的子包中，如果它们所在的包不具有上面所描述的查找关系，那么Controller是不会被创建的，即使应用可以启动，但是最终响应的结果将是404。
我们在main方法中使用了SpringApplication这个类完成了应用的启动，该类是一个Spring应用启动的引导工具类，它底层维护着Spring容器。由于篇幅有限，SpingApplication具体引导的过程不再这里细说，我会在后面的笔记中记录分析SpringApplication的具体如何完成Spring容器的创建、如何完成Web应用的启动。
SpringBoot除了提供强大的功能外，官方还提供了非常人性化的支持，我们可以访问 ，在该网站上根据我们应用的特点，自动其对应的生成spring boot的模版文件。
至此，Spring Boot的入门笔记就先写到这里，下一节会去分析SpringApplication这个神奇的东西，看看它到底是如何工作的。
每天都在努力成为一个合格且优秀的程序员！1504人阅读
springBoot（3）
原文：http://blog.csdn.net/jsyxcjw/article/details/
1.1 spring介绍
Spring Boot使开发独立的，产品级别的基于Spring的应用变得非常简单，你只需&just run&。 我们为Spring平台及第三方库提供开箱即用的设置，这样你就可以有条不紊地开始。多数Spring Boot应用需要很少的Spring配置。
你可以使用Spring Boot创建Java应用，并使用java -jar启动它或采用传统的war部署方式。
1.2 系统要求
默认情况下，Spring Boot 1.3.0.BUILD-SNAPSHOT 需要Java7和Spring框架4.1.3或以上。你可以在Java6下使用Spring Boot，不过需要添加额外配置。具体参考Section 73.9, “How to use Java 6” 。构建环境明确支持的有Maven（3.2+）和Gradle（1.12+）。
Servlet容器 下列内嵌容器支持开箱即用（out of the box）：
Servlet版本
Java 7+
Java 6+
Java 7+
Java 6+
Undertow 1.1
3.1 Java 7+
你也可以将Spring Boot应用部署到任何兼容Servlet 3.0+的容器。
1.3 第一个spring boot应用
在开始前，你需要打开一个终端，检查是否安装可用的Java版本和Maven：
Apache Maven 3.2.3 (33f8c3e1027c3ddde99d3cdebadfdf4; T13:58:10-07:00)
Maven home: /Users/user/tools/apache-maven-3.1.1
Java version: 1.7.0_51, vendor: Oracle Corporation
创建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&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
&!-- Additional lines to be added here... --&
&!-- (you don't need this if you are using a .RELEASE version) --&
&repositories&
&repository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&snapshots&&enabled&true&/enabled&&/snapshots&
&/repository&
&repository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/repository&
&/repositories&
&pluginRepositories&
&pluginRepository&
&id&spring-snapshots&/id&
&url&http://repo.spring.io/snapshot&/url&
&/pluginRepository&
&pluginRepository&
&id&spring-milestones&/id&
&url&http://repo.spring.io/milestone&/url&
&/pluginRepository&
&/pluginRepositories&
&/project&
添加classpath依赖：
Spring Boot提供很多&Starter POMs&，这能够让你轻松的将jars添加到你的classpath下。我们的示例程序已经在POM的partent节点使用了spring-boot-starter-parent。spring-boot-starter-parent是一个特殊的starter，它提供了有用的Maven默认设置。同时，它也提供了一个dependency-management节点，这样对于”blessed“依赖你可以省略version标记。
&dependencies&
&dependency&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-web&/artifactId&
&/dependency&
&/dependencies&
如果再次运行mvn dependency:tree，你将看到现在有了一些其他依赖，包括Tomcat web服务器和Spring Boot自身。
编写代码：
为了完成应用程序，我们需要创建一个单独的Java文件。Maven默认会编译src/main/java下的源码，所以你需要创建那样的文件结构，然后添加一个名为src/main/java/Example.java的文件：
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
@RequestMapping(&/&)
String home() {
return &Hello World!&;
public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
@RestController和@RequestMapping说明：
@RestController。这被称为一个构造型（stereotype）注解。它为阅读代码的人们提供建议。对于Spring，该类扮演了一个特殊角色。在本示例中，我们的类是一个web @Controller，所以当处理进来的web请求时，Spring会询问它。
@RequestMapping注解提供路由信息。它告诉Spring任何来自&/&路径的HTTP请求都应该被映射到home方法。@RestController注解告诉Spring以字符串的形式渲染结果，并直接返回给调用者。
@EnableAutoConfiguration。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
main方法。这只是一个标准的方法，它遵循Java对于一个应用程序入口点的约定。我们的main方法通过调用run，将业务委托给了Spring Boot的SpringApplication类。SpringApplication将引导我们的应用，启动Spring，相应地启动被自动配置的Tomcat web服务器。我们需要将Example.class作为参数传递给run方法来告诉SpringApplication谁是主要的Spring组件。
mvn spring-boot:run
如果使用一个浏览器打开&localhost:8080，以下输出：
Hello World!
创建可执行jar
为了创建可执行的jar，需要将spring-boot-maven-plugin添加到我们的pom.xml中。在dependencies节点下插入以下内容：
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
注：spring-boot-starter-parent POM包含用于绑定repackage目标的配置。如果你不使用parent POM，你将需要自己声明该配置。具体参考插件文档。
保存你的pom.xml，然后从命令行运行mvn package：
mvn package
如果查看target目录，你应该看到myproject-0.0.1-SNAPSHOT.jar。该文件应该有10Mb左右的大小。如果想偷看内部结构，你可以运行jar tvf：
jar tvf target/myproject-0.0.1-SNAPSHOT.jar
在target目录下，你应该也能看到一个很小的名为myproject-0.0.1-SNAPSHOT.jar.original的文件。这是在Spring Boot重新打包前Maven创建的原始jar文件。
为了运行该应用程序，你可以使用java -jar命令：
java -jar target/myproject-0.0.1-SNAPSHOT.jar
2. 使用Spring Boot
Maven用户可以继承spring-boot-starter-parent项目来获取合适的默认设置。该父项目提供以下特性：
默认编译级别为Java 1.6
源码编码为UTF-8
一个依赖管理节点，允许你省略普通依赖的&version&标签，继承自spring-boot-dependencies POM。
合适的资源过滤
合适的插件配置（exec插件，surefire，Git commit ID，shade）
针对application.properties和application.xml的资源过滤
最后一点：由于默认配置文件接收Spring风格的占位符（${...}），Maven filtering改用@..@占位符（你可以使用Maven属性resource.delimiter来覆盖它）。
想配置你的项目继承spring-boot-starter-parent只需要简单地设置parent为：
&!-- Inherit defaults from Spring Boot --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-starter-parent&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
注：你应该只需要在该依赖上指定Spring Boot版本。如果导入其他的starters，你可以放心的省略版本号。
使用没有父POM的Spring Boot
不是每个人都喜欢继承spring-boot-starter-parent POM。你可能需要使用公司标准parent，或你可能倾向于显式声明所有Maven配置。
如果你不使用spring-boot-starter-parent，通过使用一个scope=import的依赖，你仍能获取到依赖管理的好处：
&dependencyManagement&
&dependencies&
&dependency&
&!-- Import dependency management from Spring Boot --&
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-dependencies&/artifactId&
&version&1.3.0.BUILD-SNAPSHOT&/version&
&type&pom&/type&
&scope&import&/scope&
&/dependency&
&/dependencies&
&/dependencyManagement&
改变Java版本
spring-boot-starter-parent选择相当保守的Java兼容策略。如果你遵循我们的建议，使用最新的Java版本，你可以添加一个java.version属性：
&properties&
&java.version&1.8&/java.version&
&/properties&
** 使用Spring Boot Maven插件**
Spring Boot包含一个Maven插件，它可以将项目打包成一个可执行jar。如果想使用它，你可以将该插件添加到节点处：
&groupId&org.springframework.boot&/groupId&
&artifactId&spring-boot-maven-plugin&/artifactId&
&/plugins&
注：如果使用Spring Boot starter parent pom，你只需要添加该插件而无需配置它，除非你想改变定义在partent中的设置。
2.2 组织代码
Spring Boot不需要使用任何特殊的代码结构，然而，这里有一些有用的最佳实践。
使用&default&包
当类没有包含package声明时，它被认为处于default package下。通常不推荐使用default package，并应该避免使用它。因为对于使用@ComponentScan，@EntityScan或@SpringBootApplication注解的Spring Boot应用来说，来自每个jar的类都会被读取，这会造成一定的问题。
定位main应用类
我们通常建议你将main应用类放在位于其他类上面的根包（root package）中。通常使用@EnableAutoConfiguration注解你的main类，并且暗地里为某些项定义了一个基础“search package”。例如，如果你正在编写一个JPA应用，被@EnableAutoConfiguration注解的类所在包将被用来搜索@Entity项。
使用根包允许你使用@ComponentScan注解而不需要定义一个basePackage属性。如果main类位于根包中，你也可以使用@SpringBootApplication注解。
下面是一个典型的结构：
+- example
+- myproject
+- Application.java
+- domain
+- Customer.java
+- CustomerRepository.java
+- service
+- CustomerService.java
+- web
+- CustomerController.java
Application.java文件将声明main方法，还有基本的@Configuration。
package com.example.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.EnableAutoC
import org.springframework.ponentS
import org.springframework.context.annotation.C
@Configuration
@EnableAutoConfiguration
@ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
2.3 配置类
Spring Boot提倡基于Java的配置。尽管你可以使用一个XML源来调用SpringApplication.run()，我们通常建议你使用@Configuration类作为主要源。一般定义main方法的类也是主要@Configuration的一个很好候选。
1、导入其他配置类
你不需要将所有的@Configuration放进一个单独的类。@Import注解可以用来导入其他配置类。另外，你也可以使用@ComponentScan注解自动收集所有的Spring组件，包括@Configuration类。
2、导入XML配置
如果你绝对需要使用基于XML的配置，我们建议你仍旧从一个@Configuration类开始。你可以使用附加的@ImportResource注解加载XML配置文件。
2.4 自动配置
Spring Boot自动配置（auto-configuration）尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在HSQLDB，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库。
你可以通过将@EnableAutoConfiguration或@SpringBootApplication注解添加到一个@Configuration类上来选择自动配置。
注：你只需要添加一个@EnableAutoConfiguration注解。我们建议你将它添加到主@Configuration类上。
禁用特定的自动配置
如果发现应用了你不想要的特定自动配置类，你可以使用@EnableAutoConfiguration注解的排除属性来禁用它们。
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
2.5 Spring Beans和依赖注入
你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见，我们经常使用@ComponentScan注解搜索beans，并结合@Autowired构造器注入。
如果使用上面建议的结构组织代码（将应用类放到根包下），你可以添加@ComponentScan注解而不需要任何参数。你的所有应用程序组件（@Component, @Service, @Repository, @Controller等）将被自动注册为Spring Beans。
下面是一个@Service Bean的示例，它使用构建器注入获取一个需要的RiskAssessor bean。
package com.example.
import org.springframework.beans.factory.annotation.A
import org.springframework.stereotype.S
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskA
@Autowired
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskA
注：注意如何使用构建器注入来允许riskAssessor字段被标记为final，这意味着riskAssessor后续是不能改变的。
2.6 使用@SpringBootApplication注解
很多Spring Boot开发者总是使用@Configuration，@EnableAutoConfiguration和@ComponentScan注解他们的main类。由于这些注解被如此频繁地一块使用（特别是你遵循以上最佳实践时），Spring Boot提供一个方便的@SpringBootApplication选择。
该@SpringBootApplication注解等价于以默认属性使用@Configuration，@EnableAutoConfiguration和@ComponentScan。
package com.example.
import org.springframework.boot.SpringA
import org.springframework.boot.autoconfigure.SpringBootA
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
2.7 作为一个打包后的应用运行
如果使用Spring Boot Maven或Gradle插件创建一个可执行jar，你可以使用java -jar运行你的应用。例如：
java -jar target/myproject-0.0.1-SNAPSHOT.jar
运行一个打包的程序并开启远程调试支持是可能的，这允许你将调试器附加到打包的应用程序上：
java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myproject-0.0.1-SNAPSHOT.jar
2.8 使用Maven插件运行
Spring Boot Maven插件包含一个run目标，它可以用来快速编译和运行应用程序。应用程序以一种暴露的方式运行，由于即时&热&加载，你可以编辑资源。
mvn spring-boot:run
你可能想使用有用的操作系统环境变量：
export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
3 Spring Boot特性
3.1 SpringApplication
SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下，你只需委托给SpringApplication.run这个静态方法：
public static void main(String[] args){
SpringApplication.run(MySpringConfiguration.class, args);
当应用启动时，你应该会看到类似下面的东西（这是何方神兽？？）：
/\\ / ___'_ __ _ _(_)_ __
__ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
___)| |_)| | | | | || (_| |
|____| .__|_| |_|_| |_\__, | / / / /
=========|_|==============|___/=/_/_/_/
:: Spring Boot ::
v1.2.2.BUILD-SNAPSHOT
00:08:16.117
INFO 56603 --- [
main] o.s.b.s.app.SampleApplication
: Starting SampleApplication v0.1.0 on mycomputer with PID 56603 (/apps/myapp.jar started by pwebb)
00:08:16.166
INFO 56603 --- [
main] ationConfigEmbeddedWebApplicationContext : Refreshing org.springframework.boot.context.embedded.AnnotationConfigEmbeddedWebApplicationContext@6e5a8246: startup date [Wed Jul 31 00:08:16 PDT 2013]; root of context hierarchy
13:09:54.912
INFO 41370 --- [
main] .t.TomcatEmbeddedServletContainerFactory : Server initialized with port: 8080
13:09:56.501
INFO 41370 --- [
main] o.s.b.s.app.SampleApplication
默认情况下会显示INFO级别的日志信息，包括一些相关的启动详情，比如启动应用的用户等。
3.1.1 自定义Banner
通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner。如果这个文件有特殊的编码，你可以使用banner.encoding设置它（默认为UTF-8）。
在banner.txt中可以使用如下的变量：
${application.version}
MANIFEST.MF中声明的应用版本号，例如1.0
${application.formatted-version}
MANIFEST.MF中声明的被格式化后的应用版本号（被括号包裹且以v作为前缀），用于显示，例如(v1.0)
${spring-boot.version}
正在使用的Spring Boot版本号，例如1.2.2.BUILD-SNAPSHOT
${spring-boot.formatted-version}
正在使用的Spring Boot被格式化后的版本号（被括号包裹且以v作为前缀）, 用于显示，例如(v1.2.2.BUILD-SNAPSHOT)
注：如果想以编程的方式产生一个banner，可以使用SpringBootApplication.setBanner(…)方法。使用org.springframework.boot.Banner接口，实现你自己的printBanner()方法。
3.1.2 自定义SpringApplication
如果默认的SpringApplication不符合你的口味，你可以创建一个本地的实例并自定义它。例如，关闭banner你可以这样写：
public static void main(String[] args){
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setShowBanner(false);
app.run(args);
注：传递给SpringApplication的构造器参数是spring beans的配置源。在大多数情况下，这些将是@Configuration类的引用，但它们也可能是XML配置或要扫描包的引用。
3.1.3 流畅的构建API
如果你需要创建一个分层的ApplicationContext（多个具有父子关系的上下文），或你只是喜欢使用流畅的构建API，你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法，包括可以创建层次结构的parent和child方法。
new SpringApplicationBuilder()
.showBanner(false)
.sources(Parent.class)
.child(Application.class)
.run(args);
注：创建ApplicationContext层次时有些限制，比如，Web组件(components)必须包含在子上下文(child context)中，且相同的Environment即用于父上下文也用于子上下文中。
3.1.4 Application事件和监听器
除了常见的Spring框架事件，比如ContextRefreshedEvent，一个SpringApplication也发送一些额外的应用事件。一些事件实际上是在ApplicationContext被创建前触发的。
你可以使用多种方式注册事件监听器，最普通的是使用SpringApplication.addListeners(…)方法。在你的应用运行时，应用事件会以下面的次序发送：
在运行开始，但除了监听器注册和初始化以外的任何处理之前，会发送一个ApplicationStartedEvent。
在Environment将被用于已知的上下文，但在上下文被创建前，会发送一个ApplicationEnvironmentPreparedEvent。
在refresh开始前，但在bean定义已被加载后，会发送一个ApplicationPreparedEvent。
启动过程中如果出现异常，会发送一个ApplicationFailedEvent。
注：你通常不需要使用应用程序事件，但知道它们的存在会很方便（在某些场合可能会使用到）。在Spring内部，Spring Boot使用事件处理各种各样的任务。
3.1.5 Web环境
一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。
用于确定一个web环境的算法相当简单（基于是否存在某些类）。如果需要覆盖默认行为，你可以使用setWebEnvironment(boolean webEnvironment)。通过调用setApplicationContextClass(…)，你可以完全控制ApplicationContext的类型。
注：当JUnit测试里使用SpringApplication时，调用setWebEnvironment(false)是可取的。
3.1.6 命令行启动器
如果你想获取原始的命令行参数，或一旦SpringApplication启动，你需要运行一些特定的代码，你可以实现CommandLineRunner接口。在所有实现该接口的Spring beans上将调用run(String… args)方法。
import org.springframework.boot.*
import org.springframework.stereotype.*
@Component
public class MyBean implements CommandLineRunner {
public void run(String... args) {
// Do something...
如果一些CommandLineRunner beans被定义必须以特定的次序调用，你可以额外实现org.springframework.core.Ordered接口或使用org.springframework.core.annotation.Order注解。
3.1.7 Application退出
每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭，将会注册一个JVM的shutdown钩子。所有标准的Spring生命周期回调（比如，DisposableBean接口或@PreDestroy注解）都能使用。
此外，如果beans想在应用结束时返回一个特定的退出码（exit code），可以实现org.springframework.boot.ExitCodeGenerator接口。
4 外化配置
Spring Boot允许外化（externalize）你的配置，这样你能够在不同的环境下使用相同的代码。你可以使用properties文件，YAML文件，环境变量和命令行参数来外化配置。使用@Value注解，可以直接将属性值注入到你的beans中，并通过Spring的Environment抽象或绑定到结构化对象来访问。
Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖，需要以下面的次序考虑属性：
命令行参数
来自于java:comp/env的JNDI属性
Java系统属性（System.getProperties()）
操作系统环境变量
只有在random.*里包含的属性会产生一个RandomValuePropertySource
在打包的jar外的应用程序配置文件（application.properties，包含YAML和profile变量）
在打包的jar内的应用程序配置文件（application.properties，包含YAML和profile变量）
在@Configuration类上的@PropertySource注解
默认属性（使用SpringApplication.setDefaultProperties指定）
下面是一个具体的示例（假设你开发一个使用name属性的@Component）：
import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
@Value(&${name}&)
你可以将一个application.properties文件捆绑到jar内，用来提供一个合理的默认name属性值。当运行在生产环境时，可以在jar外提供一个application.properties文件来覆盖name属性。对于一次性的测试，你可以使用特定的命令行开关启动（比如，java -jar app.jar --name=&Spring&）。
4.1 配置随机值
RandomValuePropertySource在注入随机值（比如，密钥或测试用例）时很有用。它能产生整数，longs或字符串，比如：
my.secret=${random.value}
my.number=${random.int}
my.bignumber=${random.long}
my.number.less.than.ten=${random.int(10)}
my.number.in.range=${random.int[]}
random.int*语法是OPEN value (,max) CLOSE，此处OPEN，CLOSE可以是任何字符，并且value，max是整数。如果提供max，那么value是最小的值，max是最大的值（不包含在内）。
4.2访问命令行属性
默认情况下，SpringApplication将任何可选的命令行参数（以'--'开头，比如，--server.port=9000）转化为property，并将其添加到Spring Environment中。如上所述，命令行属性总是优先于其他属性源。
如果你不想将命令行属性添加到Environment里，你可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。
4.3 Application属性文件
SpringApplication将从以下位置加载application.properties文件，并把它们添加到Spring Environment中：
当前目录下的一个/config子目录
一个classpath下的/config包
classpath根路径（root）
这个列表是按优先级排序的（列表中位置高的将覆盖位置低的）。
注：你可以使用YAML（'.yml'）文件替代'.properties'。
如果不喜欢将application.properties作为配置文件名，你可以通过指定spring.config.name环境属性来切换其他的名称。你也可以使用spring.config.location环境属性来引用一个明确的路径（目录位置或文件路径列表以逗号分割）。
$ java -jar myproject.jar --spring.config.name=myproject
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
如果spring.config.location包含目录（相对于文件），那它们应该以/结尾（在加载前，spring.config.name产生的名称将被追加到后面）。不管spring.config.location是什么值，默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。以这种方式，你可以在application.properties中为应用设置默认值，然后在运行的时候使用不同的文件覆盖它，同时保留默认配置。
注：如果你使用环境变量而不是系统配置，大多数操作系统不允许以句号分割（period-separated）的key名称，但你可以使用下划线（underscores）代替（比如，使用SPRINGCONFIGNAME代替spring.config.name）。如果你的应用运行在一个容器中，那么JNDI属性（java:comp/env）或servlet上下文初始化参数可以用来取代环境变量或系统属性，当然也可以使用环境变量或系统属性。
4.4 特定的Profile属性
除了application.properties文件，特定配置属性也能通过命令惯例application-{profile}.properties来定义。特定Profile属性从跟标准application.properties相同的路径加载，并且特定profile文件会覆盖默认的配置。
4.5 属性占位符
当application.properties里的值被使用时，它们会被存在的Environment过滤，所以你能够引用先前定义的值（比如，系统属性）。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
4.6 使用YAML代替Properties
YAML是JSON的一个超集，也是一种方便的定义层次配置数据的格式。无论你何时将SnakeYAML 库放到classpath下，SpringApplication类都会自动支持YAML作为properties的替换。
注：如果你使用'starter POMs'，spring-boot-starter会自动提供SnakeYAML。
4.6.1. 加载YAML
Spring框架提供两个便利的类用于加载YAML文档，YamlPropertiesFactoryBean会将YAML作为Properties来加载，YamlMapFactoryBean会将YAML作为Map来加载。
environments:
name: Developer Setup
name: My Cool App
上面的YAML文档会被转化到下面的属性中：
environments.dev.url=
environments.dev.name=Developer Setup
environments.prod.url=
environments.prod.name=My Cool App
YAML列表被表示成使用[index]间接引用作为属性keys的形式，例如下面的YAML：
将会转化到下面的属性中:
my.servers[0]=
my.servers[1]=
使用Spring DataBinder工具绑定那样的属性（这是@ConfigurationProperties做的事），你需要确定目标bean中有个java.util.List或Set类型的属性，并且需要提供一个setter或使用可变的值初始化它，比如，下面的代码将绑定上面的属性：
@ConfigurationProperties(prefix=&my&)
public class Config {
private List&String& servers = new ArrayList&String&();
public List&String& getServers() {
return this.
4.6.2. 在Spring环境中使用YAML暴露属性
YamlPropertySourceLoader类能够用于将YAML作为一个PropertySource导出到Sprig Environment。这允许你使用熟悉的@Value注解和占位符语法访问YAML属性。
4.6.3. Multi-profile YAML文档
你可以在单个文件中定义多个特定配置（profile-specific）的YAML文档，并通过一个spring.profiles key标示应用的文档。例如：
address: 192.168.1.100
profiles: development
address: 127.0.0.1
profiles: production
address: 192.168.1.120
在上面的例子中，如果development配置被激活，那server.address属性将是127.0.0.1。如果development和production配置（profiles）没有启用，则该属性的值将是192.168.1.100。
YAML文件不能通过@PropertySource注解加载。所以，在这种情况下，如果需要使用@PropertySource注解的方式加载值，那就要使用properties文件。
4.7. 类型安全的配置属性
使用@Value(&${property}&)注解注入配置属性有时可能比较笨重，特别是需要使用多个properties或你的数据本身有层次结构。为了控制和校验你的应用配置，Spring Boot提供一个允许强类型beans的替代方法来使用properties。
@Component
@ConfigurationProperties(prefix=&connection&)
public class ConnectionSettings {
private InetAddress remoteA
// ... getters and setters
当@EnableConfigurationProperties注解应用到你的@Configuration时，任何被@ConfigurationProperties注解的beans将自动被Environment属性配置。这种风格的配置特别适合与SpringApplication的外部YAML配置进行配合使用。
# application.yml
connection:
username: admin
remoteAddress: 192.168.1.1
# additional configuration as required
为了使用@ConfigurationProperties beans，你可以使用与其他任何bean相同的方式注入它们。
public class MyService {
@Autowired
private ConnectionS
@PostConstruct
public void openConnection() {
Server server = new Server();
this.connection.configure(server);
你可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义。
@Configuration
@EnableConfigurationProperties(ConnectionSettings.class)
public class MyConfiguration {
注：使用@ConfigurationProperties能够产生可被IDEs使用的元数据文件。具体参考Appendix B, Configuration meta-data。
4.7.1. 第三方配置
正如使用@ConfigurationProperties注解一个类，你也可以在@Bean方法上使用它。当你需要绑定属性到不受你控制的第三方组件时，这种方式非常有用。
为了从Environment属性配置一个bean，将@ConfigurationProperties添加到它的bean注册过程：
@ConfigurationProperties(prefix = &foo&)
public FooComponent fooComponent() {
和上面ConnectionSettings的示例方式相同，任何以foo为前缀的属性定义都会被映射到FooComponent上。
4.7.2. 松散的绑定（Relaxed binding）
Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans，所以Environment属性名和bean属性名不需要精确匹配。常见的示例中有用的包括虚线分割（比如，context--path绑定到contextPath）和将环境属性转为大写字母（比如，PORT绑定port）。
@Component
@ConfigurationProperties(prefix=&person&)
public class ConnectionSettings {
private String firstN
下面的属性名都能用于上面的@ConfigurationProperties类：
person.firstName
标准驼峰规则
person.first-name
虚线表示，推荐用于.properties和.yml文件中
PERSON_FIRST_NAME
大写形式，使用系统环境变量时推荐
Spring会尝试强制外部的应用属性在绑定到@ConfigurationProperties beans时类型是正确的。如果需要自定义类型转换，你可以提供一个ConversionService bean（bean id为conversionService）或自定义属性编辑器（通过一个CustomEditorConfigurer bean）。
4.7.3. @ConfigurationProperties校验
Spring Boot将尝试校验外部的配置，默认使用JSR-303（如果在classpath路径中）。你可以轻松的为你的@ConfigurationProperties类添加JSR-303 javax.validation约束注解：
@Component
@ConfigurationProperties(prefix=&connection&)
public class ConnectionSettings {
private InetAddress remoteA
// ... getters and setters
你也可以通过创建一个叫做configurationPropertiesValidator的bean来添加自定义的Spring Validator。
注：spring-boot-actuator模块包含一个暴露所有@ConfigurationProperties beans的端点。
5 Profiles
Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。
@Configuration
@Profile(&production&)
public class ProductionConfiguration {
以正常的Spring方式，你可以使用一个spring.profiles.active的Environment属性来指定哪个配置生效。你可以使用平常的任何方式来指定该属性，例如，可以将它包含到你的application.properties中：
spring.profiles.active=dev,hsqldb
或使用命令行开关：
--spring.profiles.active=dev,hsqldb
5.1. 添加激活的配置(profiles)
spring.profiles.active属性和其他属性一样都遵循相同的排列规则，最高的PropertySource获胜。也就是说，你可以在application.properties中指定生效的配置，然后使用命令行开关替换它们。
有时，将特定的配置属性添加到生效的配置中而不是替换它们是有用的。spring.profiles.include属性可以用来无条件的添加生效的配置。SpringApplication的入口点也提供了一个用于设置额外配置的Java API（比如，在那些通过spring.profiles.active属性生效的配置之上）：参考setAdditionalProfiles()方法。
示例：当一个应用使用下面的属性，并用--spring.profiles.active=prod开关运行，那proddb和prodmq配置也会生效：
my.property: fromyamlfile
spring.profiles: prod
spring.profiles.include: proddb,prodmq
注：spring.profiles属性可以定义到一个YAML文档中，用于决定什么时候该文档被包含进配置中。
5.2.以编程方式设置profiles
在应用运行前，你可以通过调用SpringApplication.setAdditionalProfiles(…)方法，以编程的方式设置生效的配置。使用Spring的ConfigurableEnvironment接口激动配置也是可行的。
5.3. Profile特定配置文件
application.properties（或application.yml）和通过@ConfigurationProperties引用的文件这两种配置特定变种都被当作文件来加载的，具体参考Section 23.3, “Profile specific properties”。
Spring Boot内部日志系统使用的是Commons Logging，但开放底层的日志实现。默认为会Java Util Logging, Log4J, Log4J2和Logback提供配置。每种情况下都会预先配置使用控制台输出，也可以使用可选的文件输出。
默认情况下，如果你使用'Starter POMs'，那么就会使用Logback记录日志。为了确保那些使用Java Util Logging, Commons Logging, Log4J或SLF4J的依赖库能够正常工作，正确的Logback路由也被包含进来。
注：如果上面的列表看起来令人困惑，不要担心，Java有很多可用的日志框架。通常，你不需要改变日志依赖，Spring Boot默认的就能很好的工作。
6.1. 日志格式
Spring Boot默认的日志输出格式如下：
10:57:51.112
INFO 45469 --- [
main] org.apache.catalina.core.StandardEngine
: Starting Servlet Engine: Apache Tomcat/7.0.52
10:57:51.253
INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/]
: Initializing Spring embedded WebApplicationContext
10:57:51.253
INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader
: Root WebApplicationContext: initialization completed in 1358 ms
10:57:51.698
INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean
: Mapping servlet: 'dispatcherServlet' to [/]
10:57:51.702
INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean
: Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
输出的节点（items）如下：
日期和时间 - 精确到毫秒，且易于排序。
日志级别 - ERROR, WARN, INFO, DEBUG 或 TRACE。
Process ID。
一个用于区分实际日志信息开头的---分隔符。
线程名 - 包括在方括号中（控制台输出可能会被截断）。
日志名 - 通常是源class的类名（缩写）。
日志信息。
5.2. 控制台输出
默认的日志配置会在写日志消息时将它们回显到控制台。默认，ERROR, WARN和INFO级别的消息会被记录。可以在启动应用时，通过--debug标识开启控制台的DEBUG级别日志记录。
java -jar myapp.jar --debug
如果你的终端支持ANSI，为了增加可读性将会使用彩色的日志输出。你可以设置spring.output.ansi.enabled为一个支持的值来覆盖自动检测。
5.3. 文件输出
默认情况下，Spring Boot只会将日志记录到控制台而不会写进日志文件。如果除了输出到控制台你还想写入到日志文件，那你需要设置logging.file或logging.path属性（例如在你的application.properties中）。
下表显示如何组合使用logging.*：
logging.file
logging.path
只记录到控制台
Specific file
写到特定的日志文件里，名称可以是一个精确的位置或相对于当前目录
Specific folder
写到特定文件夹下的spring.log里，名称可以是一个精确的位置或相对于当前目录
日志文件每达到10M就会被轮换（分割），和控制台一样，默认记录ERROR, WARN和INFO级别的信息。
5.4. 日志级别
所有支持的日志系统在Spring的Environment（例如在application.properties里）都有通过'logging.level.*=LEVEL'（'LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一个）设置的日志级别。
示例：application.properties
logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
5.5. 自定义日志配置
通过将适当的库添加到classpath，可以激活各种日志系统。然后在classpath的根目录(root)或通过Spring Environment的logging.config属性指定的位置提供一个合适的配置文件来达到进一步的定制（注意由于日志是在ApplicationContext被创建之前初始化的，所以不可能在Spring的@Configuration文件中，通过@PropertySources控制日志。系统属性和平常的Spring Boot外部配置文件能正常工作）。
根据你的日志系统，下面的文件会被加载：
Logback logback.xml
log4j.properties或log4j.xml
log4j2.xml
JDK (Java Util Logging) logging.properties
为了帮助定制一些其他的属性，从Spring的Envrionment转换到系统属性：
Spring Environment
System Property 评价
logging.file
如果定义，在默认的日志配置中使用
logging.path
如果定义，在默认的日志配置中使用
PID PID 当前的处理进程(process)ID（如果能够被发现且还没有作为操作系统环境变量被定义）
所有支持的日志系统在解析它们的配置文件时都能查询系统属性。具体可以参考spring-boot.jar中的默认配置。
注：在运行可执行的jar时，Java Util Logging有类加载问题，我们建议你尽可能避免使用它。
6 开发Web应用
Spring Boot非常适合开发web应用程序。你可以使用内嵌的Tomcat，Jetty或Undertow轻轻松松地创建一个HTTP服务器。大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。
6.1. Spring Web MVC框架
Spring Web MVC框架（通常简称为&Spring MVC&）是一个富&模型，视图，控制器&的web框架。 Spring MVC允许你创建特定的@Controller或@RestController beans来处理传入的HTTP请求。 使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。
@RestController
@RequestMapping(value=&/users&)
public class MyRestController {
@RequestMapping(value=&/{user}&, method=RequestMethod.GET)
public User getUser(@PathVariable Long user) {
@RequestMapping(value=&/{user}/customers&, method=RequestMethod.GET)
List&Customer& getUserCustomers(@PathVariable Long user) {
@RequestMapping(value=&/{user}&, method=RequestMethod.DELETE)
public User deleteUser(@PathVariable Long user) {
6.1.1. Spring MVC自动配置
Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：
引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
对静态资源的支持，包括对WebJars的支持。
自动注册Converter，GenericConverter，Formatter beans。
对HttpMessageConverters的支持。
自动注册MessageCodeResolver。
对静态index.html的支持。
对自定义Favicon的支持。
如果想全面控制Spring MVC，你可以添加自己的@Configuration，并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器，formatters，视图控制器等)，你可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解）。
6.1.2. HttpMessageConverters
Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处（out of the box），例如对象可以自动转换为JSON（使用Jackson库）或XML（如果Jackson XML扩展可用则使用它，否则使用JAXB）。字符串默认使用UTF-8编码。
如果需要添加或自定义转换器，你可以使用Spring Boot的HttpMessageConverters类：
import org.springframework.boot.autoconfigure.web.HttpMessageC
import org.springframework.context.annotation.*;
import org.springframework.http.converter.*;
@Configuration
public class MyConfiguration {
public HttpMessageConverters customConverters() {
HttpMessageConverter&?& additional = ...
HttpMessageConverter&?& another = ...
return new HttpMessageConverters(additional, another);
任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表，你可以通过这种方式覆盖默认的转换器（converters）。
6.1.3. MessageCodesResolver
Spring MVC有一个策略，用于从绑定的errors产生用来渲染错误信息的错误码：MessageCodesResolver。如果设置spring.mvc.message-codes-resolver.format属性为PREFIXERRORCODE或POSTFIXERRORCODE（具体查看DefaultMessageCodesResolver.Format枚举值），Spring
Boot会为你创建一个MessageCodesResolver。
6.1.4. 静态内容
默认情况下，Spring Boot从classpath下一个叫/static（/public，/resources或/META-INF/resources）的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的ResourceHttpRequestHandler，所以你可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为（加载静态文件）。
在一个单独的web应用中，容器默认的servlet是开启的，如果Spring决定不处理某些请求，默认的servlet作为一个回退（降级）将从ServletContext根目录加载内容。大多数时候，这不会发生（除非你修改默认的MVC配置），因为Spring总能够通过DispatcherServlet处理请求。
此外，上述标准的静态资源位置有个例外情况是Webjars内容。任何在/webjars/**路径下的资源都将从jar文件中提供，只要它们以Webjars的格式打包。
注：如果你的应用将被打包成jar，那就不要使用src/main/webapp文件夹。尽管该文件夹是一个共同的标准，但它仅在打包成war的情况下起作用，并且如果产生一个jar，多数构建工具都会静悄悄的忽略它。
6.1.5. 模板引擎
正如REST web服务，你也可以使用Spring MVC提供动态HTML内容。Spring MVC支持各种各样的模板技术，包括Velocity, FreeMarker和JSPs。很多其他的模板引擎也提供它们自己的Spring MVC集成。
Spring Boot为以下的模板引擎提供自动配置支持：
FreeMarker
注：如果可能的话，应该忽略JSPs，因为在内嵌的servlet容器使用它们时存在一些已知的限制。
当你使用这些引擎的任何一种，并采用默认的配置，你的模板将会从src/main/resources/templates目录下自动加载。
注：IntelliJ IDEA根据你运行应用的方式会对classpath进行不同的整理。在IDE里通过main方法运行你的应用跟从Maven或Gradle或打包好的jar中运行相比会导致不同的顺序。这可能导致Spring Boot不能从classpath下成功地找到模板。如果遇到这个问题，你可以在IDE里重新对classpath进行排序，将模块的类和资源放到第一位。或者，你可以配置模块的前缀为classpath*:/templates/，这样会查找classpath下的所有模板目录。
6.1.6. 错误处理
Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误，并且它在servlet容器中注册了一个全局的 错误页面。对于机器客户端（相对于浏览器而言，浏览器偏重于人的行为），它会产生一个具有详细错误，HTTP状态，异常信息的JSON响应。对于浏览器客户端，它会产生一个白色标签样式（whitelabel）的错误视图，该视图将以HTML格式显示同样的数据（可以添加一个解析为erro的View来自定义它）。为了完全替换默认的行为，你可以实现ErrorController，并注册一个该类型的bean定义，或简单地添加一个ErrorAttributes类型的bean以使用现存的机制，只是替换显示的内容。
如果在某些条件下需要比较多的错误页面，内嵌的servlet容器提供了一个统一的Java DSL（领域特定语言）来自定义错误处理。 示例：
public EmbeddedServletContainerCustomizer containerCustomizer(){
return new MyCustomizer();
private static class MyCustomizer implements EmbeddedServletContainerCustomizer {
public void customize(ConfigurableEmbeddedServletContainer container) {
container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, &/400&));
你也可以使用常规的Spring MVC特性来处理错误，比如@ExceptionHandler方法和@ControllerAdvice。ErrorController将会捡起任何没有处理的异常。
N.B. 如果你为一个路径注册一个ErrorPage，最终被一个过滤器（Filter）处理（对于一些非Spring web框架，像Jersey和Wicket这很常见），然后过滤器需要显式注册为一个ERROR分发器（dispatcher）。
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new MyFilter());
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
注：默认的FilterRegistrationBean没有包含ERROR分发器类型。
6.1.7. Spring HATEOAS
如果你正在开发一个使用超媒体的RESTful API，Spring Boot将为Spring HATEOAS提供自动配置，这在多数应用中都工作良好。自动配置替换了对使用@EnableHypermediaSupport的需求，并注册一定数量的beans来简化构建基于超媒体的应用，这些beans包括一个LinkDiscoverer和配置好的用于将响应正确编排为想要的表示的ObjectMapper。ObjectMapper可以根据spring.jackson.*属性或一个存在的Jackson2ObjectMapperBuilder
bean进行自定义。
通过使用@EnableHypermediaSupport，你可以控制Spring HATEOAS的配置。注意这会禁用上述的对ObjectMapper的自定义。
6.2. JAX-RS和Jersey
如果喜欢JAX-RS为REST端点提供的编程模型，你可以使用可用的实现替代Spring MVC。如果在你的应用上下文中将Jersey 1.x和Apache Celtix的Servlet或Filter注册为一个@Bean，那它们工作的相当好。Jersey 2.x有一些原生的Spring支持，所以我们会在Spring Boot为它提供自动配置支持，连同一个启动器（starter）。
想要开始使用Jersey 2.x只需要加入spring-boot-starter-jersey依赖，然后你需要一个ResourceConfig类型的@Bean，用于注册所有的端点（endpoints）。
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
所有注册的端点都应该被@Components和HTTP资源annotations（比如@GET）注解。
@Component
@Path(&/hello&)
public class Endpoint {
public String message() {
return &Hello&;
由于Endpoint是一个Spring组件（@Component），所以它的生命周期受Spring管理，并且你可以使用@Autowired添加依赖及使用@Value注入外部配置。Jersey servlet将被注册，并默认映射到/*。你可以将@ApplicationPath添加到ResourceConfig来改变该映射。
默认情况下，Jersey将在一个ServletRegistrationBean类型的@Bean中被设置成名称为jerseyServletRegistration的Servlet。通过创建自己的相同名称的bean，你可以禁止或覆盖这个bean。你也可以通过设置spring.jersey.type=filter来使用一个Filter代替Servlet（在这种情况下，被覆盖或替换的@Bean是jerseyFilterRegistration）。该servlet有@Order属性，你可以通过spring.jersey.filter.order进行设置。不管是Servlet还是Filter注册都可以使用spring.jersey.init.*定义一个属性集合作为初始化参数传递过去。
这里有一个Jersey示例，你可以查看如何设置相关事项。
6.3. 内嵌servlet容器支持
Spring Boot支持内嵌的Tomcat, Jetty和Undertow服务器。多数开发者只需要使用合适的'Starter POM'来获取一个完全配置好的实例即可。默认情况下，内嵌的服务器会在8080端口监听HTTP请求。
6.3.1. Servlets和Filters
当使用内嵌的servlet容器时，你可以直接将servlet和filter注册为Spring的beans。在配置期间，如果你想引用来自application.properties的值，这是非常方便的。默认情况下，如果上下文只包含单一的Servlet，那它将被映射到根路径（/）。在多Servlet beans的情况下，bean的名称将被用作路径的前缀。过滤器会被映射到/*。
如果基于约定（convention-based）的映射不够灵活，你可以使用ServletRegistrationBean和FilterRegistrationBean类实现完全的控制。如果你的bean实现了ServletContextInitializer接口，也可以直接注册它们。
6.3.2. EmbeddedWebApplicationContext
Spring Boot底层使用了一个新的ApplicationContext类型，用于对内嵌servlet容器的支持。EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext，它通过搜索一个单一的EmbeddedServletContainerFactory bean来启动自己。通常，TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory将被自动配置。
注：你通常不需要知道这些实现类。大多数应用将被自动配置，并根据你的行为创建合适的ApplicationContext和EmbeddedServletContainerFactory。
6.3.3. 自定义内嵌servlet容器
常见的Servlet容器设置可以通过Spring Environment属性进行配置。通常，你会把这些属性定义到application.properties文件中。 常见的服务器设置包括：
server.port - 进来的HTTP请求的监听端口号
server.address - 绑定的接口地址
server.sessionTimeout - session超时时间
具体参考ServerProperties。
编程方式的自定义 如果需要以编程的方式配置内嵌的servlet容器，你可以注册一个实现EmbeddedServletContainerCustomizer接口的Spring bean。EmbeddedServletContainerCustomizer提供对ConfigurableEmbeddedServletContainer的访问，ConfigurableEmbeddedServletContainer包含很多自定义的setter方法。
import org.springframework.boot.context.embedded.*;
import org.
@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(9000);
直接自定义ConfigurableEmbeddedServletContainer 如果上面的自定义手法过于受限，你可以自己注册TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。
public EmbeddedServletContainerFactory servletContainer() {
TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
factory.setPort(9000);
factory.setSessionTimeout(10, TimeUnit.MINUTES);
factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, &/notfound.html&);
很多可选的配置都提供了setter方法，也提供了一些受保护的钩子方法以满足你的某些特殊需求。具体参考相关文档。
6.3.4. JSP的限制
在内嵌的servlet容器中运行一个Spring Boot应用时（并打包成一个可执行的存档archive），容器对JSP的支持有一些限制。
tomcat只支持war的打包方式，不支持可执行的jar。
内嵌的Jetty目前不支持JSPs。
Undertow不支持JSPs。
这里有个JSP示例，你可以查看如何设置相关事项。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：312910次
积分：4385
积分：4385
排名：第7096名
原创：90篇
转载：247篇
评论：22条
(1)(1)(2)(1)(1)(2)(3)(3)(3)(3)(6)(1)(8)(3)(3)(7)(1)(4)(8)(1)(9)(5)(8)(1)(1)(2)(1)(11)(2)(2)(6)(4)(8)(13)(6)(6)(6)(9)(4)(1)(5)(3)(6)(3)(5)(12)(5)(2)(4)(5)(6)(11)(8)(3)(17)(16)(22)(13)(6)(19)
(window.slotbydup = window.slotbydup || []).push({
id: '4740881',
container: s,
size: '200,200',
display: 'inlay-fix'}
我要回帖
更多关于 h1z1应用运行中 的文章
更多推荐
- ·平安寿险的中国平安车险理赔流程程是怎样的？有人能详细介绍一下吗？
- ·最近你了解过中国平安保险咋样的服务质量吗？感觉如何？
- ·传音控股未来发展前景移动互联业务在海外的发展状况如何？
- ·阅读加盟10大品牌排行机构哪个品牌好，阅读加盟10大品牌排行项目前景如何，项目投入大吗？
- ·有没有提供人才发展的公司人才引进落户？
- ·办个金钟烤肉城城需要提供什么,卖什么,提供给谁，要有那些资源或条件，优势是什么，靠什么获得利润
- ·浦发银行信用卡激活没激活需要注销吗
- ·密云农村房屋租售售好做嘛？
- ·开车撞人只有交强险险自己全责
- ·对房屋权利的记载信息属于房屋权属登记申请表信息的一部分吗
- ·淘宝上允许发布金融学入门书籍书籍吗？
- ·截至2014年哪个国家参加国家共享经济鑫圆共享的人口为1400万人
- ·美国的美国电子商务务法叫什么？
- ·为什么戴尔灵越55775577软件界面都缩小了
- ·如何在 HTML 登录页面显示不出来上显示出有交互的统计图
- ·老公微信的聊天资料微信怎么看聊天记录啊？
- ·欧地线包括哪些国家几欧是什么意思
- ·洛奇英雄传鼠标不消失l.n.s.鼠标连点工具怎么用
- ·用友软件期初差价仓库选项单元格下拉选项是空的
- ·如何运行Spring Boot应用商店已停止运行
- ·怎么修改marker的百度地图label样式的边框样式
- ·张柏芝种子哪位大神有能把这个百度文库的文档发我吗？谢谢了
- ·能同步收到别人的同步老公微信聊天记录计录吗？？
- ·技嘉主板调节cpu电压GTX1050ti 4G显卡 cpu I5 3570 主板 技嘉主板调节cpu电压B75M 内存4G＋2G
- ·请问：中彩网怎么样？有没有人知道？？？
- ·通过QQ附近的人什么行业好找男朋友友好吗？QQ附近的男生是不是不靠谱啊？
- ·Excel 2007主界面如何显示wps符号栏在哪 (如同Excel 2003中的wps符号栏在哪)
- ·qq还没加qq误删好友怎么恢复该怎么删
- ·老公的QQ聊天资料qq聊天记录能不能导出看到？
- ·如何把安卓登录界面界面变成IOS7
- ·为什么删除不了qq使用过的qq历史头像怎么删除
- ·联想值得推荐的电脑YOGA 720 13值得买吗
- ·36+10的和与36+几的和10和什么同样多多
- ·qq发送图片很多纯黑色背景照片相片。。。怎么回事，而且很多数字文件，我进去系统相册就看不见那些了。如何清除？
