Part III. 使用Spring Boot
本节将深入讲述使用spring boot的更多细节。包括项目构建系统，自动配置，和如何运行应用等主题。同样包含一些spring boot的练习。
虽然spring boot没有什么特殊的地方，但是这里还是做了一些介绍，跟着学习，可以使你的开发过程更容易一些。
如果你是spring boot的新手，进入本节之前你应该先阅读启动指南。
13. 项目构建系统
强烈建议选择一个支持依赖管理并且可以发布到maven中心仓库的工具。我们推荐maven和gradle。当然也可以使用其他的项目构建系统（如ant）
，但是可能不会支持的很好。
13.1 依赖管理
每个spring boot版本都提供了它所支持的依赖的列表。实际上，在创建配置时不需要为这些依赖提供版本信息，spring boot会自动匹配。
如果升级spring boot，这些依赖也会随着升级。
[注意]
如果需要，同样可以自己指定依赖的版本。
列表中包含所有可用的spring模块和第三方库，提供maven和grade可使用的标准依赖。
[警告]
每个spring boot的版本和spring框架的版本是一致的，不推荐自定义spring boot的版本。
13.2 Maven
maven用户可以通过继承spring-boot-starter-parent实现预设。spring-boot-starter-parent提供了以下特性：
Java 1.8作为默认编译器级别。
UTF-8编码。
继承自spring-boot-dependencies pom的依赖管理模块，这个模块使你无需自己指定依赖的版本。
合理的资源过滤。
合理的插件配置。
注意，由于application.properties和application.yml文件接受spring风格的${…}占位符，maven过滤改为了使用@..@占位符。
13.2.1 继承Starter Parent
如下设置继承spring-boot-starter-parent：
<!-- Inherit defaults from Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.3.RELEASE</version>
</parent>
[注意]
你只需要在这里设定spring boot的版本，导入其他starter可以忽略版本设置。
你也可以通过以下方式覆盖上面的版本设置：
<properties>
<spring-data-releasetrain.version>Fowler-SR2</spring-data-releasetrain.version>
</properties>
[小窍门]
检查spring-boot-dependencies pom，获得所支持的属性列表。
13.2.2 使用没有Parent POM的spring boot
并不是所有人都喜欢继承spring-boot-starter-parent POM，你可以声明自己的依赖。
如果你不想使用the spring-boot-starter-parent，你依然可以通过设置<scope>import</scope>使用依赖管理功能
（插件功能就不能使用了），如下：
<dependencyManagement>
<dependencies>
<dependency>
<!-- Import dependency management from Spring Boot -->
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.0.3.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
以上的设置并不是不允许你设置自己的依赖版本了。要设置自己的依赖版本，就需要在spring-boot-dependencies入口之前添加你的
依赖管理入口。以下是spring data升级的例子：
<dependencyManagement>
<dependencies>
<!-- Override Spring Data release train provided by Spring Boot -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-releasetrain</artifactId>
<version>Fowler-SR2</version>
<type>pom</type>
<scope>import</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.0.3.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
[注意]
上面例子中自定义了BOM, 所有依赖类型都可以用同样的方式覆盖.
13.2.3 使用Spring Boot Maven插件
spring boot包括一个maven插件，它可以将项目打包为一个可执行jar。如下设置：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
[注意]
如果你使用Spring Boot starter parent pom，除非要改变parent中的设置，否则，你只需添加<plugin>而不需要其他配置，
13.3 Gradle
13.4 Ant
13.5 Starters
Starters是一组非常方便的依赖。
Starters命名格式为spring-boot-starter-*，方便寻找。
以下starters由org.springframework.boot提供：
....
14. 结构化代码
spring boot对代码布局没有要求。然而这里有一些帮助范例。
14.1 使用默认包
如果一个类没有包含在任何一个包中，它就会被认为属于默认包。要尽量避免使用默认包，它会在应用使用@ComponentScan, @EntityScan,
或 @SpringBootApplication注解时导致一些特殊的错误，因为它们会读取每一个jar中的每一个类。
[Tip]
推荐遵循java的命名规则，使用反向域名命名（例如，com.example.project）。
14.2 定位主应用类
建议将主应用类放在root包中所有其他类之前。@SpringBootApplication经常在主类上，它会为项目定义一个基本的搜索包。例如，
如果写一个JPA类，@SpringBootApplication类的包用于搜索@Entity项目。使用root包也允许组件扫描只用于你自己的项目。
[小窍门]
如果你不想使用@SpringBootApplication，可以用@EnableAutoConfiguration和@ComponentScan代替。
以下展示了一个典型的代码结构布局：
com
+- example
+- myapplication
+- Application.java
|
+- customer
| +- Customer.java
| +- CustomerController.java
| +- CustomerService.java
| +- CustomerRepository.java
|
+- order
+- Order.java
+- OrderController.java
+- OrderService.java
+- OrderRepository.java
Application.java文件会和@SpringBootApplication一起声明主函数，如下：
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
15. 配置类
spring boot支持java基本配置。即使可以使用xml配置，但是还是推荐使用@Configuration类。通常定义主方法的类是作为主@Configuration
类的好的候选者。
[小窍门]
网上有许多使用xml配置spring的例子。如果有可能，使用等价的基于java的配置。可以将查找Enable*注解作为一个好的起点。
15.1 导入额外配置类
你不需要将所有的@Configuration放在一个类中。@Import注解可以导入额外的配置类。另外，你可以使用@ComponentScan注解自动查找
所有的spring组件，包括@Configuration类。
15.2 导入XML配置
如果必须使用XML配置，依然推荐从@Configuration开始。然后你可以使用@ImportResource注解加载XML配置文件。
16. 自动配置
spring boot试图通过你添加的依赖自动配置spring应用。例如，如果HSQLDB在你的类路径中，如果你没有手动配置任何数据库连接bean，spring boot会自动配置一个内存中的数据库。
你需要在你的一个@Configuration类中添加@EnableAutoConfiguration或@SpringBootApplication注解选择加入到自动配置。
[小窍门]
你只需要添加一个@SpringBootApplication或@EnableAutoConfiguration注解，推荐在主@Configuration类添加。
16.1 逐步取代自动配置
自动配置是非侵入性的。在任何时候，你都可以定义你自己的配置来替代自动配置的特定部分。例如，你增加了一个自己的数据源bean,
默认的嵌入式数据库支持就会回退。
如果你需要找出当前应用的自动配置，为什么，使用--debug开启你的应用。这样做可以使核心记录器生成debug日志，
并且将报告以log方式输出到控制台。
16.2 禁止特定的自动配置类
如果你发现你不想要的特定自动配置类出现在应用中，你可以使用@EnableAutoConfiguration的排除（exclude）属性禁止它，如下例：
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}
如果类没有在类路径中，你可以使用excludeName属性加入全类名代替。最后，你也可以通过使用spring.autoconfigure.exclude
属性，控制自动配置类列表来排除不想要出现的类。
[小窍门]
你既可以用注解亦可以用属性配置定义排除特定的类。
17. Spring Beans和依赖注入
你可以自由的使用任何标准的spring框架来定义你的beans和它们的注入依赖项。简单起见，使用@ComponentScan（寻找bean）和
@Autowired（寻找构造注入）很方便。
如果你按以上所述结构化你的代码（将application类放到root包），你可以添加@ComponentScan注解而不需要给注解添加任何属性。
所有的应用组件（@Component, @Service, @Repository, @Controller）都会自动注册为spring bean。
下面的例子展示了使用构造注入生成RiskAssessor bean的@Service Bean：
package com.example.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskAssessor;
@Autowired
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
如果一个bean只含有一个构造方法，你可以忽略@Autowired，如下：
@Service
public class DatabaseAccountService implements AccountService {
private final RiskAssessor riskAssessor;
public DatabaseAccountService(RiskAssessor riskAssessor) {
this.riskAssessor = riskAssessor;
}
// ...
}
[小窍门]
注意构造注入如何将riskAssessor标记为常量的，表明riskAssessor随后不能再被修改。
18. 使用@SpringBootApplication注解
许多spring boot开发者希望他们应用的Application类中能够同时具有使用自动配置，组件扫描和可以定义额外配置的功能。
一个@SpringBootApplication注解就可以满足以上三个特性。如下：
@EnableAutoConfiguration: 开启spring boot的自动配置功能
@ComponentScan: 开启application所在包@Component扫描
@Configuration: 允许在上下文中注册额外的beans或导入额外的配置类
@SpringBootApplication注解相当于使用@Configuration, @EnableAutoConfiguration, 和 @ComponentScan作为默认属性，如下所示：
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
[注意]
@SpringBootApplication同样提供了别名自定义@EnableAutoConfiguration和@ComponentScan的属性
[注意]
这些特性都不是强制性的。你可以选择任何可用的特性来替代原有的单个注解。例如，你如果不想在应用中使用组件扫描：
package com.example.myapplication;
import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration
@EnableAutoConfiguration
@Import({ MyConfig.class, MyAnotherConfig.class })
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
在本例中，除了@Component注解的类不会被扫描，并且导入了用户自定义的beans（@Import）以外，Application和其他的
spring boot应用没有什么不同。
19. 运行应用
将你的应用打包为jar并使用嵌入式HTTP服务器的一个最大的优势是你可以像其他任何方式一样运行你的应用。debug spring boot也很方便。
你不需要任何特殊的IDE插件或扩展。
[注意]
本节只包括基于jar的打包方式，若果你选择打war包，你应该参考你的服务器和IDE文档。
19.1 从IDE运行
你可以将你的spring boot应用作为一个单个的java应用在IDE上运行。然而，你首先需要导入你的项目。导入步骤根据你的IDE和构建系统的
不同而不同。大多数的IDE可以直接导入maven项目。例如，eclipse用户可以从文件菜单中选择Import… → Existing Maven Projects。
如果你不能直接将项目导入到IDE，你可能需要使用构建插件创建IDE metadata（元数据）。maven有支持Eclipse和IDEA的插件。Gradle
为各种IDE提供插件。
[小窍门]
如果你意外的运行了两侧web应用程序，你会看到“Port already in use”错误。STS使用Relaunch（重启）按钮而不是运按钮保证所有的
实例都已经关闭。
19.2 运行打包的应用
如果你使用spring boot maven或Gradle插件创建一个可运行jar，你可以使用java -jar运行应用，如下：
$ java -jar target/myapplication-0.0.1-SNAPSHOT.jar
同样支持远程启动debug打包应用。如下：
$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myapplication-0.0.1-SNAPSHOT.jar
19.3 使用Maven插件
spring boot Maven插件包括了一个可以用于快速编译和启动应用的入口。效果和在IDE中运行一样。以下展示了一个运行spring boot应用的
典型的Maven命令：
$ mvn spring-boot:run
你也可是使用MAVEN_OPTS运行系统环境变量，如下：
$ export MAVEN_OPTS=-Xmx1024m
19.4 使用Gradle插件
spring boot Gradle插件可以使用bootRun以同样的方式启动应用，如下：
$ gradle bootRun
你也可以使用JAVA_OPTS运行系统环境变量，如下：
$ export JAVA_OPTS=-Xmx1024m
19.5 热插拔
由于spring boot应用只是简单的java应用，所以可以使用JVM热插拔。但是JVM受可替代的字节码的限制，可以使用JRebel。
Since Spring Boot applications are just plain Java applications, JVM hot-swapping should work out of the box. JVM hot swapping is somewhat limited with the bytecode that it can replace. For a more complete solution, JRebel can be used.
spring-boot-devtools模块也支持快速重启应用。第20章，开发者工具部分热插拔“How-to”查看详细信息。
20. 开发者工具
spring boot包括一组可以使应用开发体验更加愉快的工具。spring-boot-devtools模块可以被加入到任何项目中提供开发时特性。添加模块依赖
，如下为maven和Gradle的配置内容：
Maven.
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
</dependencies>
Gradle.
dependencies {
compile("org.springframework.boot:spring-boot-devtools")
}
[注意]
在运行完全打包的应用程序时开发者工具会自动失效。如果你的应用通过java -jar或特殊的类加载器启动，它会被认为是一个生产应用。
在maven中标记为可选或是在Gradle中使用compileOnly，是一个最实际的阻止devtools应用到使用您的项目的其他模块的方式。
[小窍门]
重新打包不会默认包含devtools。如果你想要使用远程的devtools特性，你需要通过禁止excludeDevtools属性加入devtools。Maven和
Gradle插件都支持这个属性。
20.1 默认属性
spring boot支持的一些库使用缓存提高性能。例如，末班引擎缓存编译后的模板来避免重复的解析模板文件。同样，spring MVC可以增加
HTTP缓存头响应静态资源。
虽然缓存很在生产中很有用，但是在开发时会起反作用，使得刚开发的代码不能立即生效。基于这个原因，spring-boot-devtools默认禁止
缓存。
缓存通常在你的application.properties配置文件中配置。例如，Thymeleaf提供spring.thymeleaf.cache配置。相对于手动配置，
spring-boot-devtools模块提供了更好的自动的合理的开发时配置。
[小窍门]
通过DevToolsPropertyDefaultsPostProcessor查看devtools的所有配置。
20.2 自动重启
无论何时类路径中的文件发生改变都可使用spring-boot-devtools自动重启。这个特性在使用IDE开发时会非常有用，它为代码改变提供了
一个快速的反馈回路。默认情况下，指向文件夹的类路径上的任何条目都会被监控以进行更改。注意，某些资源，如静态资源和视图模板，
不需要重启应用。
触发重启
由于DevTools监控类路径资源，唯一触发重启的方式就是修改类路径。修改类路径的方式取决于你使用的IDE。在Eclipse中，保存一个被修改
的文件会导致类路径的改变触发重启。在IntelliJ IDEA中，创建项目（Build -> Build Project）可以达到同样的效果。
[注意]
只要启用forKing，你就可以通过使用支持的构建插件（Maven和Gradle）启动应用，因为DevTools正常运行需要单独的类加载器。
默认的，Gradle和Maven在类路径中检测到DevTools时会提供单独的类加载器。
[小窍门]
使用LiveReload可以使自动重启效果更好。在LiveReload部分查看详细信息。如果你使用JRebel，为了支持动态类加载，自动重启会被
禁用。devtools的其他特性（例如LiveReload和属性覆盖）仍然可以使用。
[注意]
在重启时，DevTools依赖应用上下文的shutdown hook关闭应用。如果shutdown hook被禁用
（SpringApplication.setRegisterShutdownHook(false)），DevTools重启功能就不能正常工作了。
[注意]
当决定类路径中条目改变是否触发重启时，DevTools自动忽略以spring-boot, spring-boot-devtools, spring-boot-autoconfigure, spring-boot-actuator, and spring-boot-starter命名的项目。
[注意]
DevTools需要自定义ApplicationContext所使用的ResourceLoader。如果你的应用已经提供了一个，那么它会被覆盖。不支持直接
覆盖ApplicationContext中的getResource方法。
重启vs重载
重启技术是spring boot提供的通过使用两个类加载器实现的。不变的类被加载在基本加载器中，你开发的变化的类加载到重启加载器中。
应用重启时，重启类加载器会被删掉并创建一个新的重启类加载器。这种方式意味着，应用重启的速度比冷启动更快，这是因为基本类加载
器一直可以使用。
如果你发现对于你的应用来说重启已经不够快你可以考虑重载技术，如来自于ZeroTurnaround的JRebel。这些工作通过重写类来完成，使
它们更易于重新加载。
20.2.1 条件评估中日志改变
默认的，每次重启应用，显示条件评估delta的报告会以日志的形式记录下来。报告显示了你应用的自动配置的改变，如添加删除beans
和设置配置属性。
禁止记录报告日志，做如下设置：
spring.devtools.restart.log-condition-evaluation-delta=false
20.2.2 排除资源
有些资源在发生改变时不需要触发重启。例如，Thymeleaf模板可以就地编辑。默认的，在/META-INF/maven, /META-INF/resources, /resources, /static, /public, or /templates中修改资源不会触发重启，但是会触发在线重载。你可以使用
spring.devtools.restart.exclude自定义无需触发重启的资源。例如，只排除/static和/public，你可以如下设置：
spring.devtools.restart.exclude=static/**,public/**
[小窍门]
如果你想要保持默认的同时添加额外的排除资源，你可以使用he spring.devtools.restart.additional-exclude设置。
20.2.3 查看额外路径
当你想要不在类路径中的文件改变时触发重启或重载。可以使用spring.devtools.restart.additional-paths配置额外的路径。
可以提前使用spring.devtools.restart.exclude设置额外路径触发重启还是在线重载。
20.2.4 禁止重启
如果你不想使用重启特性，可以使用spring.devtools.restart.enabled禁止。大多数情况，可以在application.properties中设置。
如果需要完全禁止重启支持，在调用SpringApplication.run(…)之前设置spring.devtools.restart.enabled为false，如下：
public static void main(String[] args) {
System.setProperty("spring.devtools.restart.enabled", "false");
SpringApplication.run(MyApp.class, args);
}
20.2.5 使用触发文件
如果你使用频繁编译改变文件的IDE，你可能需要特定时间触发重启。你可以使用触发文件，触发文件是一个特殊的文件，必须修改触
发文件才能实际开启触发重启的检查。改变文件只触发检查并且只有Devtools检测到做了什么时才触发重启。触发文件可以手动修改也
可以通过IDE插件来修改。
如果使用触发文件，通过spring.devtools.restart.trigger-file设置触发文件的路径。
[小窍门]
将spring.devtools.restart.trigger-file设为全局属性，整个项目都以同样的方式运作。
20.2.6 自定义重启类加载器
如上所描述的，重启功能的实现需要使用两个类加载器。对于大多数应用，整个方式比较适合。然而，它有时候可能会导致类加载问题。
默认的，IDE开启的任何项目都使用重启类加载器加载，并且任何常规的jar文件都使用基本类加载器加载。如果你开发一个多模块的项目，
并且并不是所有模块都导入IDE中，可以通过创建META-INF/spring-devtools.properties文件进行自定义。
spring-devtools.properties文件包含以restart.exclude和restart.include为前缀的配置。包含项是需要加入到重启类加载器中的，
排除项是需要加入到基本类加载器中的。属性值是正则格式的类路径，如下：
restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar
[注意]
属性的键是惟一的。只要以restart.include. 或 restart.exclude启动，都是经过深思熟虑的。
[小窍门]
所有来自类路径的META-INF/spring-devtools.properties都会被加载。你可以将文件打包到项目中，或项目所使用的库中。
20.2.7 了解限制
重启动能对于被标准对象输入流反序列化的对象支持的不是很好。如果你需要反序列化数据，你可以使用spring的 ConfigurableObjectInputStream结合Thread.currentThread().getContextClassLoader()。
不幸的是，一些第三方库在反序列化时没有考虑使用上下文类加载器。如果发现这个问题，你需要和原作者协商。
20.3 在线重载
spring-boot-devtools模块包括一个嵌入式在线重载服务器可以在资源改变时触发浏览器刷新。可以从livereload.com获取支持
Chrome, Firefox和Safari的在线重载扩展。
如果你在程序运行时不想启动在线重载，你可以设置spring.devtools.livereload.enabled property为false。
[注意]
你可以一次只运行一个在线重载服务器。启动应用之前，确定其他在线重载服务器没有运行。如果你使用IDE开启多个应用，
只有第一个支持在线重载。
20.4 全局设置
你可以在你的$HOME文件夹中通过添加一个名为.spring-boot-devtools.properties（注意文件名以“.”开头）的配置文件来对devtools
进行全局配置。任何添加到这个文件的属性都会作用在你机器中所有支持devtools的spring boot应用中。例如，配置总是使用触发
文件重启，你需要添加一下配置：
~/.spring-boot-devtools.properties.
spring.devtools.reload.trigger-file=.reloadtrigger
20.5 远程应用
spring boot开发者工具对本地开发没有限制。你在运行远程应用时也可以使用它的一些特性。远程支持是可以选择的。如果启用它，
需要确保重新打包的结构中包含devtools，如下所示：
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<excludeDevtools>false</excludeDevtools>
</configuration>
</plugin>
</plugins>
</build>
然后需要设置spring.devtools.remote.secret属性，如下所示：
spring.devtools.remote.secret=mysecret
[警告]
远程启用spring-boot-devtools存在安全问题。永远不要在生产中启动。
远程devtools支持包括两部分：接受连接的服务器端和在IDE中运行的客户端。当spring.devtools.remote.secret属性设置好以后服务器端
会自动启动devtools。客户端组件必须手动启动。
20.5.1 运行远程客户端应用
远程客户端应用在IDE中运行。你需要以所连接的远程客户端相同的类路径运行
org.springframework.boot.devtools.RemoteSpringApplication。应用所需的唯一参数是要连接的远程的URL。
例如，如果使用Eclipse或STS并且以项目名为my-app部署到Cloud Foundry，如下操作：
从Run菜单中选择Run Configurations…
创建一个新的Java应用“launch configuration”。
浏览my-app项目.
org.springframework.boot.devtools.RemoteSpringApplication作为主类。
在项目参数中添加https://myapp.cfapps.io（你的远程URL）
一个运行的远程客户端内容如下所示：
. ____ _ __ _ _
/\\ / ___'_ __ _ _(_)_ __ __ _ ___ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | | _ \___ _ __ ___| |_ ___ \ \ \ \
\\/ ___)| |_)| | | | | || (_| []::::::[] / -_) ' \/ _ \ _/ -_) ) ) ) )
' |____| .__|_| |_|_| |_\__, | |_|_\___|_|_|_\___/\__\___|/ / / /
=========|_|==============|___/===================================/_/_/_/
:: Spring Boot Remote :: 2.0.3.RELEASE
2015-06-10 18:25:06.632 INFO 14938 --- [ main] o.s.b.devtools.RemoteSpringApplication : Starting RemoteSpringApplication on pwmbp with PID 14938 (/Users/pwebb/projects/spring-boot/code/spring-boot-devtools/target/classes started by pwebb in /Users/pwebb/projects/spring-boot/code/spring-boot-samples/spring-boot-sample-devtools)
2015-06-10 18:25:06.671 INFO 14938 --- [ main] s.c.a.AnnotationConfigApplicationContext : Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@2a17b7b6: startup date [Wed Jun 10 18:25:06 PDT 2015]; root of context hierarchy
2015-06-10 18:25:07.043 WARN 14938 --- [ main] o.s.b.d.r.c.RemoteClientConfiguration : The connection to http://localhost:8080 is insecure. You should use a URL starting with 'https://'.
2015-06-10 18:25:07.074 INFO 14938 --- [ main] o.s.b.d.a.OptionalLiveReloadServer : LiveReload server is running on port 35729
2015-06-10 18:25:07.130 INFO 14938 --- [ main] o.s.b.devtools.RemoteSpringApplication : Started RemoteSpringApplication in 0.74 seconds (JVM running for 1.105)
[注意]
Because the remote client is using the same classpath as the real application it can directly read application properties. This is how the spring.devtools.remote.secret property is read and passed to the server for authentication.
[小窍门]
使用https://做为连接协议很安全，不会被拦截。
[小窍门]
如果你是用代理访问远程应用，配置spring.devtools.remote.proxy.host 和 spring.devtools.remote.proxy.port属性。
20.5.2 远程更新
远程客户端和本地重启一样监控应用类路径和改变。任何资源的改变都会被推从到远程应用并处罚重启。这对这对在云服务上频繁修改
属性很有帮助。通常远程修改比全部重新创建和部署更快。
[注意]
只有远程客户端运行时才对文件进行监控。如果开启远程客户端之前修改文件，修改记录不会被推送到远程服务器。
21. 打包生产应用
可执行jar包可以部署到生产中。由于时独立的，也可以基于云来部署。
对于额外的“production ready”特性，例如health, auditing, and metric REST or JMX end-points,可以考虑添加spring-boot-actuator。
阅读Part V，“Spring Boot Actuator: Production-ready features”，查看详细信息。
22. 导读
你现在应该明白了如何使用spring boot并且跟随指导做了一些实践。你现在可以深入的学习spring boot的一些具体特性，你也可以跳过前面
去阅读spring boot的“production ready”部分。