2015-02-07 16:43:51 +00:00
Spring Boot特性
===============
### SpringApplication
SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下， ：
```java
public static void main(String[] args){
SpringApplication.run(MySpringConfiguration.class, args);
}
```
* 自定义Banner
通过在classpath下添加一个banner.txt或设置banner.location来指定相应的文件可以改变启动过程中打印的banner。如果这个文件有特殊的编码， （ ）
在banner.txt中可以使用如下的变量：
| 变量 | 描述 |
| ----------- | :--------|
|${application.version}|MANIFEST.MF中声明的应用版本号，
|${application.formatted-version}|MANIFEST.MF中声明的被格式化后的应用版本号（ ） ， ，
|${spring-boot.version}|正在使用的Spring Boot版本号，
|${spring-boot.formatted-version}|正在使用的Spring Boot被格式化后的版本号（ ）
**注**： ， ，
* 自定义SpringApplication
如果默认的SpringApplication不符合你的口味， ， ：
```java
public static void main(String[] args){
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setShowBanner(false);
app.run(args);
}
```
**注**： ， ，
你也可以使用application.properties文件来配置SpringApplication。具体参考[Externalized 配置](#Externalized 配置)。查看配置选项的完整列表，可参考[SpringApplication Javadoc](http://docs.spring.io/spring-boot/docs/1.2.2.BUILD-SNAPSHOT/api/org/springframework/boot/SpringApplication.html).
* 流畅的构建API
如果你需要创建一个分层的ApplicationContext（ ） ， ， ，
```java
new SpringApplicationBuilder()
.showBanner(false)
.sources(Parent.class)
.child(Application.class)
.run(args);
```
**注**： ， ， ，
* Application事件和监听器
除了常见的Spring框架事件， ，
你可以使用多种方式注册事件监听器，
1. 在运行开始， ，
2. 在Environment将被用于已知的上下文， ，
3. 在refresh开始前， ，
4. 启动过程中如果出现异常，
**注**： ， （ ） ，
* Web环境
一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下，
用于确定一个web环境的算法相当简单（ ） ， ，
**注**： ，
* 命令行启动器
如果你想获取原始的命令行参数， ， ，
```java
import org.springframework.boot.*
import org.springframework.stereotype.*
@Component
public class MyBean implements CommandLineRunner {
public void run(String... args) {
// Do something...
}
}
```
如果一些CommandLineRunner beans被定义必须以特定的次序调用，
* Application退出
每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭， （ ， ）
此外， （ ） ，
### 外化配置
Spring Boot允许外化（ ） ， ， ， ， ，
Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖， ：
1. 命令行参数
2. 来自于java:comp/env的JNDI属性
3. Java系统属性（ ）
4. 操作系统环境变量
5. 只有在random.*里包含的属性会产生一个RandomValuePropertySource
6. 在打包的jar外的应用程序配置文件（ ， ）
7. 在打包的jar内的应用程序配置文件（ ， ）
8. 在@Configuration类上的@PropertySource注解
9. 默认属性（ ）
下面是一个具体的示例（ ） ：
```java
import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
@Value ("${name}")
private String name;
// ...
}
```
你可以将一个application.properties文件捆绑到jar内， ， ， （ ，
RandomValuePropertySource在注入随机值（ ， ） ， ， ：
```java
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[1024,65536]}
```
random.int*语法是OPEN value (,max) CLOSE， ， ， ， ， ， （ ）
* 访问命令行属性
默认情况下， （ ） ， ，
如果你不想将命令行属性添加到Environment里，
* Application属性文件
SpringApplication将从以下位置加载application.properties文件， ：
1. 当前目录下的一个/config子目录
2. 当前目录
3. 一个classpath下的/config包
4. classpath根路径（ ）
这个列表是按优先级排序的（列表中位置高的将覆盖位置低的）。
**注**： （
如果不喜欢将application.properties作为配置文件名， （ ）
```shell
$ java -jar myproject.jar --spring.config.name=myproject
//or
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
```
如果spring.config.location包含目录（ ） ， （ ， ） ， ， ， ，
**注**： ， （ ） ， （ ） （ ， ） ， （ ） ，
* 特定的Profile属性
除了application.properties文件， ，
* 属性占位符
当application.properties里的值被使用时， ， （ ， ）
```java
app.name=MyApp
app.description=${app.name} is a Spring Boot application
```
**注**： ‘ ’
* 使用YAML代替Properties
[YAML ](http://yaml.org/ )是JSON的一个超集， ，
**注**：如果你使用'starter POMs'，
* 加载YAML
Spring框架提供两个便利的类用于加载YAML文档， ，
示例：
```json
environments:
dev:
url: http://dev.bar.com
name: Developer Setup
prod:
url: http://foo.bar.com
name: My Cool App
```
上面的YAML文档会被转化到下面的属性中：
```java
environments.dev.url=http://dev.bar.com
environments.dev.name=Developer Setup
environments.prod.url=http://foo.bar.com
environments.prod.name=My Cool App
```
YAML列表被表示成使用[index]间接引用作为属性keys的形式， ：
```json
my:
servers:
- dev.bar.com
- foo.bar.com
```
将会转化到下面的属性中:
```java
my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com
```
使用Spring DataBinder工具绑定那样的属性（ ） ， ， ， ， ：
```java
@ConfigurationProperties (prefix="my")
public class Config {
private List< String > servers = new ArrayList< String > ();
public List< String > getServers() {
return this.servers;
}
}
```
* 在Spring环境中使用YAML暴露属性
YamlPropertySourceLoader类能够用于将YAML作为一个PropertySource导出到Sprig Environment。这允许你使用熟悉的@Value注解和占位符语法访问YAML属性。
* Multi-profile YAML文档
你可以在单个文件中定义多个特定配置（ ） ， ：
```json
server:
address: 192.168.1.100
---
spring:
profiles: development
server:
address: 127.0.0.1
---
spring:
profiles: production
server:
address: 192.168.1.120
```
在上面的例子中， ， （ ） ，
* YAML缺点
YAML文件不能通过@PropertySource注解加载。所以， ， ，
* 类型安全的配置属性
使用@Value("${property}")注解注入配置属性有时可能比较笨重， ，
示例：
```java
@Component
@ConfigurationProperties (prefix="connection")
public class ConnectionSettings {
private String username;
private InetAddress remoteAddress;
// ... getters and setters
}
```
当@EnableConfigurationProperties注解应用到你的@Configuration时，
```json
# application.yml
connection:
username: admin
remoteAddress: 192.168.1.1
# additional configuration as required
```
为了使用@ConfigurationProperties beans，
```java
@Service
public class MyService {
@Autowired
private ConnectionSettings connection;
//...
@PostConstruct
public void openConnection() {
Server server = new Server();
this.connection.configure(server);
}
}
```
你可以通过在@EnableConfigurationProperties注解中直接简单的列出属性类来快捷的注册@ConfigurationProperties bean的定义。
```java
@Configuration
@EnableConfigurationProperties (ConnectionSettings.class)
public class MyConfiguration {
}
```
**注**：使用@ConfigurationProperties能够产生可被IDEs使用的元数据文件。具体参考[Appendix B, Configuration meta-data](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#configuration-metadata)。
* 第3方配置
正如使用@ConfigurationProperties注解一个类， ，
为了从Environment属性配置一个bean， ：
```java
@ConfigurationProperties (prefix = "foo")
@Bean
public FooComponent fooComponent() {
...
}
```
和上面ConnectionSettings的示例方式相同，
* 松散的绑定（ ）
Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans， （ ， ） （ ， ）
示例：
```java
@Component
@ConfigurationProperties (prefix="person")
public class ConnectionSettings {
private String firstName;
}
```
下面的属性名都能用于上面的@ConfigurationProperties类：
| 属性 | 说明 |
| -------- | :----- |
|person.firstName|标准驼峰规则|
|person.first-name|虚线表示，推荐用于.properties和.yml文件中|
|PERSON_FIRST_NAME|大写形式，使用系统环境变量时推荐|
Spring会尝试强制外部的应用属性在绑定到@ConfigurationProperties beans时类型是正确的。如果需要自定义类型转换， （ ） （ ）
* @ConfigurationProperties 校验
Spring Boot将尝试校验外部的配置， （ ） ：
```java
@Component
@ConfigurationProperties (prefix="connection")
public class ConnectionSettings {
@NotNull
private InetAddress remoteAddress;
// ... getters and setters
}
```
你也可以通过创建一个叫做configurationPropertiesValidator的bean来添加自定义的Spring Validator。
**注**：
### Profiles
Spring Profiles提供了一种隔离应用程序配置的方式， ，
```java
@Configuration
@Profile ("production")
public class ProductionConfiguration {
// ...
}
```
以正常的Spring方式， ， ， ：
```java
spring.profiles.active=dev,hsqldb
```
或使用命令行开关：
```shell
--spring.profiles.active=dev,hsqldb
```
* 添加激活的配置(profiles)
spring.profiles.active属性和其他属性一样都遵循相同的排列规则， ， ，
有时， （ ， ） ：
示例：当一个应用使用下面的属性，并用`--spring.profiles.active=prod`开关运行， ：
```java
---
my.property: fromyamlfile
---
spring.profiles: prod
spring.profiles.include: proddb,prodmq
```
**注**： ，
* 以编程方式设置profiles
在应用运行前， ，
* Profile特定配置文件
application.properties（ ） ，
### 日志
Spring Boot内部日志系统使用的是[Commons Logging](http://commons.apache.org/logging)，但开放底层的日志实现。默认为会[Java Util Logging](http://docs.oracle.com/javase/7/docs/api/java/util/logging/package-summary.html), [Log4J ](http://logging.apache.org/log4j/ ), [Log4J2 ](http://logging.apache.org/log4j/2.x/ )和[Logback](http://logback.qos.ch/)提供配置。每种情况下都会预先配置使用控制台输出，也可以使用可选的文件输出。
默认情况下，如果你使用'Starter POMs'， ，
**注**： ， ， ， ，
* 日志格式
Spring Boot默认的日志输出格式如下：
```java
2014-03-05 10:57:51.112 INFO 45469 --- [ main] org.apache.catalina.core.StandardEngine : Starting Servlet Engine: Apache Tomcat/7.0.52
2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.a.c.c.C.[Tomcat].[localhost].[/] : Initializing Spring embedded WebApplicationContext
2014-03-05 10:57:51.253 INFO 45469 --- [ost-startStop-1] o.s.web.context.ContextLoader : Root WebApplicationContext: initialization completed in 1358 ms
2014-03-05 10:57:51.698 INFO 45469 --- [ost-startStop-1] o.s.b.c.e.ServletRegistrationBean : Mapping servlet: 'dispatcherServlet' to [/]
2014-03-05 10:57:51.702 INFO 45469 --- [ost-startStop-1] o.s.b.c.embedded.FilterRegistrationBean : Mapping filter: 'hiddenHttpMethodFilter' to: [/*]
```
输出的节点（ ） ：
1. 日期和时间 - 精确到毫秒，且易于排序。
2. 日志级别 - ERROR, WARN, INFO, DEBUG 或 TRACE。
3. Process ID。
4. 一个用于区分实际日志信息开头的---分隔符。
5. 线程名 - 包括在方括号中（控制台输出可能会被截断）。
6. 日志名 - 通常是源class的类名（ ）
7. 日志信息。
* 控制台输出
默认的日志配置会在写日志消息时将它们回显到控制台。默认， ，
```shell
$ java -jar myapp.jar --debug
```
如果你的终端支持ANSI，
* 文件输出
默认情况下， ， （ ）
下表显示如何组合使用`logging.*`：
|logging.file|logging.path| 示例 | 描述 |
| -------- | :----- | :----- | :-----|
| (none) | (none) | | 只记录到控制台 |
|Specific file|(none)|my.log|写到特定的日志文件里，名称可以是一个精确的位置或相对于当前目录|
|(none)|Specific folder|/var/log|写到特定文件夹下的spring.log里，
日志文件每达到10M就会被轮换（ ） ， ，
* 日志级别
所有支持的日志系统在Spring的Environment（ ） （ ）
示例：
```java
logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
```
* 自定义日志配置
通过将适当的库添加到classpath， （ ， ， ）
根据你的日志系统，下面的文件会被加载：
| 日志系统 | 定制 |
| -------- | :-----: |
|Logback|logback.xml|
|Log4j|log4j.properties或log4j.xml|
|Log4j2|log4j2.xml|
|JDK (Java Util Logging)|logging.properties|
为了帮助定制一些其他的属性， ：
| Spring Environment| System Property| 评价 |
| -------- | :-----: | :----: |
|logging.file|LOG_FILE|如果定义，在默认的日志配置中使用|
|logging.path|LOG_PATH|如果定义，在默认的日志配置中使用|
|PID|PID|当前的处理进程(process)ID（ ）
所有支持的日志系统在解析它们的配置文件时都能查询系统属性。具体可以参考spring-boot.jar中的默认配置。
**注**： ， ，
### 开发Web应用
Spring Boot非常适合开发web应用程序。你可以使用内嵌的Tomcat，
* Spring Web MVC框架
Spring Web MVC框架（
Spring MVC允许你创建特定的@Controller或@RestController beans来处理传入的HTTP请求。
使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。
示例：
```java
@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) {
// ...
}
}
```
* Spring MVC自动配置
Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上， ：
1. 引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
2. 对静态资源的支持，
3. 自动注册Converter， ，
4. 对HttpMessageConverters的支持。
5. 自动注册MessageCodeResolver。
6. 对静态index.html的支持。
7. 对自定义Favicon的支持。
如果想全面控制Spring MVC， ， ， ， ， ， （ ）
* HttpMessageConverters
Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处（ ） ， （ ） （ ， ）
如果需要添加或自定义转换器， ：
```java
import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
import org.springframework.context.annotation.*;
import org.springframework.http.converter.*;
@Configuration
public class MyConfiguration {
@Bean
public HttpMessageConverters customConverters() {
HttpMessageConverter< ?> additional = ...
HttpMessageConverter< ?> another = ...
return new HttpMessageConverters(additional, another);
}
}
```
任何在上下文中出现的HttpMessageConverter bean将会添加到converters列表， （ ）
* MessageCodesResolver
Spring MVC有一个策略， ： ） ，
* 静态内容
默认情况下， （ ， ） ， （ ）
在一个单独的web应用中， ， ， （ ） ， （ ） ，
此外，上述标准的静态资源位置有个例外情况是[Webjars内容](http://www.webjars.org/)。任何在/webjars/**路径下的资源都将从jar文件中提供，
**注**： ， ， ， ，
* 模板引擎
正如REST web服务， ，
Spring Boot为以下的模板引擎提供自动配置支持：
1. [FreeMarker ](http://freemarker.org/docs/ )
2. [Groovy ](http://beta.groovy-lang.org/docs/groovy-2.3.0/html/documentation/markup-template-engine.html )
3. [Thymeleaf ](http://www.thymeleaf.org/ )
4. [Velocity ](http://velocity.apache.org/ )
**注**： ， ，
当你使用这些引擎的任何一种， ，
**注**： ， ， ， ，
* 错误处理
Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误，
错误页面。对于机器客户端（ ， ） ， ， ， ， （ ） ， （ ） ， ， ， ，
如果在某些条件下需要比较多的错误页面， （ ）
示例：
```java
@Bean
public EmbeddedServletContainerCustomizer containerCustomizer(){
return new MyCustomizer();
}
// ...
private static class MyCustomizer implements EmbeddedServletContainerCustomizer {
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
container.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400"));
}
}
```
你也可以使用常规的Spring MVC特性来处理错误，
N.B. 如果你为一个路径注册一个ErrorPage， （ ） （ ， ） ， （ ）
```java
@Bean
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new MyFilter());
...
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
return registration;
}
```
**注**：
* Spring HATEOAS
如果你正在开发一个使用超媒体的RESTful API， ， ， ，
通过使用@EnableHypermediaSupport，
* JAX-RS和Jersey
如果喜欢JAX-RS为REST端点提供的编程模型， ， ， ， （ ）
想要开始使用Jersey 2.x只需要加入spring-boot-starter-jersey依赖， ， （ ）
```java
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
}
}
```
所有注册的端点都应该被@Components和HTTP资源annotations（ ）
```java
@Component
@Path ("/hello")
public class Endpoint {
@GET
public String message() {
return "Hello";
}
}
```
由于Endpoint是一个Spring组件（ ） ， ， ，
默认情况下， ， （ ， ） ，
这里有一个[Jersey示例](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-jersey)，你可以查看如何设置相关事项。
* 内嵌servlet容器支持
Spring Boot支持内嵌的Tomcat, Jetty和Undertow服务器。多数开发者只需要使用合适的'Starter POM'来获取一个完全配置好的实例即可。默认情况下，
**1.Servlets和Filters**
当使用内嵌的servlet容器时， ， ， ， ， （ ） ，
如果基于约定（ ） ， ，
**2.EmbeddedWebApplicationContext**
Spring Boot底层使用了一个新的ApplicationContext类型， ， ， ，
**注**： ，
**3.自定义内嵌servlet容器**
常见的Servlet容器设置可以通过Spring Environment属性进行配置。通常，
常见的服务器设置包括：
1. server.port - 进来的HTTP请求的监听端口号
2. server.address - 绑定的接口地址
3. server.sessionTimeout - session超时时间
具体参考[ServerProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/web/ServerProperties.java)。
**编程方式的自定义**
如果需要以编程的方式配置内嵌的servlet容器， ，
```java
import org.springframework.boot.context.embedded.*;
import org.springframework.stereotype.Component;
@Component
public class CustomizationBean implements EmbeddedServletContainerCustomizer {
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
container.setPort(9000);
}
}
```
**直接自定义ConfigurableEmbeddedServletContainer**
如果上面的自定义手法过于受限， ，
```java
@Bean
public EmbeddedServletContainerFactory servletContainer() {
TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
factory.setPort(9000);
factory.setSessionTimeout(10, TimeUnit.MINUTES);
factory.addErrorPages(new ErrorPage(HttpStatus.NOT_FOUND, "/notfound.html");
return factory;
}
```
很多可选的配置都提供了setter方法，
**4.JSP的限制**
在内嵌的servlet容器中运行一个Spring Boot应用时（ ） ，
1. tomcat只支持war的打包方式，
2. 内嵌的Jetty目前不支持JSPs。
3. Undertow不支持JSPs。
这里有个[JSP示例](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-web-jsp)，你可以查看如何设置相关事项。
### 安全
如果Spring Security在classpath下， （ ， ， ） ，
默认的AuthenticationManager有一个单一的user（ ） ：
```java
Using default security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35
```
**注**：如果你对日志配置进行微调，确保`org.springframework.boot.autoconfigure.security`类别能记录INFO信息，
你可以通过提供`security.user.password`改变默认的密码。这些和其他有用的属性通过[SecurityProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/security/SecurityProperties.java)（ ）
默认的安全配置（ ） （ ， ） ， （ ， ）
在一个web应用中你能得到的基本特性如下：
1. 一个使用内存存储的AuthenticationManager bean和唯一的user（ ）
2. 忽略（不保护）常见的静态资源路径（`/css/**, /js/**, /images/**`和 `**/favicon.ico` ）。
3. 对其他的路径实施HTTP Basic安全保护。
4. 安全相关的事件会发布到Spring的ApplicationEventPublisher（ ， ）
5. Spring Security提供的常见底层特性（
上述所有特性都能打开和关闭， （ ） （ ） ，
如果Actuator也在使用， ：
1. 即使应用路径不受保护，被管理的路径也会受到保护。
2. 安全相关的事件被转换为AuditEvents（ ） ，
3. 默认的用户有ADMIN和USER的角色。
使用外部属性能够修改Actuator（ ） （ ） ， ， ， ，
### 使用SQL数据库
Spring框架为使用SQL数据库提供了广泛的支持。从使用JdbcTemplate直接访问JDBC到完全的对象关系映射技术， ， ，
* 配置DataSource
Java的javax.sql.DataSource接口提供了一个标准的使用数据库连接的方法。传统做法是，
**1.对内嵌数据库的支持**
开发应用时使用内存数据库是很实用的。显而易见地，内存数据库不需要提供持久化存储。你不需要在应用启动时填充数据库，也不需要在应用结束时丢弃数据。
Spring Boot可以自动配置的内嵌数据库包括[H2](http://www.h2database.com/), [HSQL ](http://hsqldb.org/ )和[Derby](http://db.apache.org/derby/)。你不需要提供任何连接URLs，
示例： ：
```xml
< dependency >
< groupId > org.springframework.boot< / groupId >
< artifactId > spring-boot-starter-data-jpa< / artifactId >
< / dependency >
< dependency >
< groupId > org.hsqldb< / groupId >
< artifactId > hsqldb< / artifactId >
< scope > runtime< / scope >
< / dependency >
```
**注**： ， ，
**2.连接到一个生产环境数据库**
在生产环境中， ：
- 由于Tomcat数据源连接池的性能和并发， ，
- 如果HikariCP可用，
- 如果Commons DBCP可用， ，
- 最后， ，
如果你使用spring-boot-starter-jdbc或spring-boot-starter-data-jpa 'starter POMs'，
**注**： ，
DataSource配置通过外部配置文件的spring.datasource.*属性控制。示例中， ：
```java
spring.datasource.url=jdbc:mysql://localhost/test
spring.datasource.username=dbuser
spring.datasource.password=dbpass
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
```
其他可选的配置可以查看[DataSourceProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jdbc/DataSourceProperties.java)。同时注意你可以通过spring.datasource.*配置任何DataSource实现相关的特定属性：
**注**： ， ， ， ， ，
**3.连接到一个JNDI数据库**
如果正在将Spring Boot应用部署到一个应用服务器， ，
spring.datasource.jndi-name属性可以用来替代spring.datasource.url， ， ：
```java
spring.datasource.jndi-name=java:jboss/datasources/customers
```
* 使用JdbcTemplate
Spring的JdbcTemplate和NamedParameterJdbcTemplate类是被自动配置的，
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final JdbcTemplate jdbcTemplate;
@Autowired
public MyBean(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
// ...
}
```
* JPA和Spring Data
Java持久化API是一个允许你将对象映射为关系数据库的标准技术。spring-boot-starter-data-jpa POM提供了一种快速上手的方式。它提供下列关键的依赖：
- Hibernate - 一个非常流行的JPA实现。
2015-02-12 02:33:01 +00:00
- Spring Data JPA - 让实现基于JPA的repositories更容易。
2015-02-07 16:43:51 +00:00
- Spring ORMs - Spring框架的核心ORM支持。
**注**：
**1.实体类**
传统上， ， ， ， （ ） （ ）
任何被@Entity， ：
```java
package com.example.myapp.domain;
import java.io.Serializable;
import javax.persistence.*;
@Entity
public class City implements Serializable {
@Id
@GeneratedValue
private Long id;
@Column (nullable = false)
private String name;
@Column (nullable = false)
private String state;
// ... additional members, often include @OneToMany mappings
protected City() {
// no-args constructor required by JPA spec
// this one is protected since it shouldn't be used directly
}
public City(String name, String state) {
this.name = name;
this.country = country;
}
public String getName() {
return this.name;
}
public String getState() {
return this.state;
}
// ... etc
}
```
**注**：你可以使用@EntityScan注解自定义实体扫描路径。具体参考[Section 67.4, “Separate @Entity definitions from Spring configuration”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-separate-entity-definitions-from-spring-configuration)。
**2.Spring Data JPA仓库**
Spring Data JPA仓库（ ） ， ，
对于比较复杂的查询，
Spring Data仓库通常继承自[Repository](http://docs.spring.io/spring-data/commons/docs/current/api/org/springframework/data/repository/Repository.html)或[CrudRepository](http://docs.spring.io/spring-data/commons/docs/current/api/org/springframework/data/repository/CrudRepository.html)接口。如果你使用自动配置，包括在你的主配置类（被@EnableAutoConfiguration或@SpringBootApplication注解的类）
下面是一个传统的Spring Data仓库：
```java
package com.example.myapp.domain;
import org.springframework.data.domain.*;
import org.springframework.data.repository.*;
public interface CityRepository extends Repository< City , Long > {
Page< City > findAll(Pageable pageable);
City findByNameAndCountryAllIgnoringCase(String name, String country);
}
```
**注**：
**3.创建和删除JPA数据库**
默认情况下， （ ） ， ， ：
```java
spring.jpa.hibernate.ddl-auto=create-drop
```
**注**： ， （ ） （ ） ， ， ：
默认情况下， （ ） ， ， ，
### 使用NoSQL技术
2015-02-08 16:30:54 +00:00
Spring Data提供其他项目， ， Neo4J ](http://projects.spring.io/spring-data-neo4j/ ), [Elasticsearch ](https://github.com/spring-projects/spring-data-elasticsearch/ ), [Solr ](http://projects.spring.io/spring-data-solr/ ), [Redis ](http://projects.spring.io/spring-data-redis/ ), [Gemfire ](http://projects.spring.io/spring-data-gemfire/ ), [Couchbase ](http://projects.spring.io/spring-data-couchbase/ )和[Cassandra](http://projects.spring.io/spring-data-cassandra/)。Spring Boot为Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自动配置。你可以充分利用其他项目，
2015-02-07 16:43:51 +00:00
* Redis
2015-02-08 16:30:54 +00:00
[Redis ](http://redis.io/ )是一个缓存，
1. 连接Redis
你可以注入一个自动配置的RedisConnectionFactory， ，
```java
@Component
public class MyBean {
private StringRedisTemplate template;
@Autowired
public MyBean(StringRedisTemplate template) {
this.template = template;
}
// ...
}
```
如果你添加一个你自己的任何自动配置类型的@Bean， （ ， ） ，
2015-02-07 16:43:51 +00:00
* MongoDB
2015-02-08 16:30:54 +00:00
[MongoDB ](http://www.mongodb.com/ )是一个开源的NoSQL文档数据库， （ ） ，
**1. 连接MongoDB数据库**
你可以注入一个自动配置的`org.springframework.data.mongodb.MongoDbFactory`来访问Mongo数据库。默认情况下， ：
```java
import org.springframework.data.mongodb.MongoDbFactory;
2015-02-08 16:33:04 +00:00
import com.mongodb.DB;
2015-02-08 16:30:54 +00:00
@Component
public class MyBean {
private final MongoDbFactory mongo;
@Autowired
public MyBean(MongoDbFactory mongo) {
this.mongo = mongo;
}
// ...
public void example() {
DB db = mongo.getDb();
// ...
}
}
```
你可以通过设置`spring.data.mongodb.uri`来改变该url， ， ：
```java
spring.data.mongodb.host=mongoserver
spring.data.mongodb.port=27017
```
**注**：如果没有指定`spring.data.mongodb.port`， ，
2015-02-12 15:57:24 +00:00
如果想全面控制MongoDB连接的建立， ，
2015-02-08 16:30:54 +00:00
**2. MongoDBTemplate**
Spring Data Mongo提供了一个[MongoTemplate](http://docs.spring.io/spring-data/mongodb/docs/current/api/org/springframework/data/mongodb/core/MongoTemplate.html)类， ， ， ：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final MongoTemplate mongoTemplate;
@Autowired
public MyBean(MongoTemplate mongoTemplate) {
this.mongoTemplate = mongoTemplate;
}
// ...
}
```
具体参考MongoOperations Javadoc。
**3. Spring Data MongoDB仓库**
Spring Data的仓库包括对MongoDB的支持。正如上面讨论的JPA仓库，
实际上， ， ，
```java
package com.example.myapp.domain;
import org.springframework.data.domain.*;
import org.springframework.data.repository.*;
public interface CityRepository extends Repository< City , Long > {
Page< City > findAll(Pageable pageable);
City findByNameAndCountryAllIgnoringCase(String name, String country);
}
```
2015-02-07 16:43:51 +00:00
* Gemfire
2015-02-08 16:30:54 +00:00
[Spring Data Gemfire ](https://github.com/spring-projects/spring-data-gemfire )为使用[Pivotal Gemfire](http://www.pivotal.io/big-data/pivotal-gemfire#details)数据管理平台提供了方便的， ，
2015-02-07 16:43:51 +00:00
* Solr
2015-02-08 16:30:54 +00:00
[Apache Solr ](http://lucene.apache.org/solr/ )是一个搜索引擎。Spring Boot为solr客户端库及[Spring Data Solr](https://github.com/spring-projects/spring-data-solr)提供的基于solr客户端库的抽象提供了基本的配置。Spring Boot提供了一个用于聚集依赖的`spring-boot-starter-data-solr`'Starter POM'。
**1. 连接Solr**
你可以像其他Spring beans一样注入一个自动配置的SolrServer实例。默认情况下，
```java
@Component
public class MyBean {
private SolrServer solr;
@Autowired
public MyBean(SolrServer solr) {
this.solr = solr;
}
// ...
}
```
如果你添加一个自己的SolrServer类型的@Bean，
**2. Spring Data Solr仓库**
Spring Data的仓库包括了对Apache Solr的支持。正如上面讨论的JPA仓库，
实际上， ， ，
**注**：具体参考[Spring Data Solr文档](http://projects.spring.io/spring-data-solr/)。
2015-02-07 16:43:51 +00:00
* Elasticsearch
2015-02-08 16:30:54 +00:00
[Elastic Search ](http://www.elasticsearch.org/ )是一个开源的， ，
**1. 连接Elasticsearch**
你可以像其他Spring beans那样注入一个自动配置的ElasticsearchTemplate或Elasticsearch客户端实例。默认情况下， （ ） ， （ ， ）
```java
@Component
public class MyBean {
private ElasticsearchTemplate template;
@Autowired
public MyBean(ElasticsearchTemplate template) {
this.template = template;
}
// ...
}
```
如果你添加一个你自己的ElasticsearchTemplate类型的@Bean，
**2. Spring Data Elasticseach仓库**
Spring Data的仓库包括了对Elasticsearch的支持。正如上面讨论的JPA仓库，
实际上， ， @Document 类而不是JPA ，
**注**：具体参考[Spring Data Elasticsearch文档](http://docs.spring.io/spring-data/elasticsearch/docs/)。
2015-02-07 16:43:51 +00:00
### 消息
2015-02-27 04:23:36 +00:00
Spring Framework框架为集成消息系统提供了扩展（ ） ： ， ， ，
2015-02-07 16:43:51 +00:00
* JMS
2015-02-27 04:23:36 +00:00
2015-02-27 13:38:37 +00:00
javax.jms.ConnectionFactory接口提供了一个标准的用于创建一个javax.jms.Connection的方法， （ ） ， ， ， （ ） （ ）
2015-02-27 04:23:36 +00:00
1. HornetQ支持
2015-02-27 13:38:37 +00:00
如果在classpath下发现HornetQ， ， ， （ ） ： （ ， ） ， （ ） ， ，
2015-02-27 04:23:36 +00:00
**注**： ， ， ，
HornetQ配置被spring.hornetq.*中的外部配置属性所控制。例如， ：
```java
spring.hornetq.mode=native
spring.hornetq.host=192.168.1.210
spring.hornetq.port=9876
```
2015-02-27 13:38:37 +00:00
当内嵌代理时， ， ，
2015-02-27 04:23:36 +00:00
没有涉及JNDI查找， ， ，
2015-02-07 16:43:51 +00:00
2. ActiveQ支持
2015-02-27 04:23:36 +00:00
2015-02-27 13:38:37 +00:00
如果发现ActiveMQ在classpath下可用， ， ， （ ）
2015-02-27 04:23:36 +00:00
ActiveMQ配置是通过spring.activemq.*中的外部配置来控制的。例如， ：
```java
spring.activemq.broker-url=tcp://192.168.1.210:9876
spring.activemq.user=admin
spring.activemq.password=secret
```
具体参考[ActiveMQProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/activemq/ActiveMQProperties.java)。
默认情况下， ， ，
2015-02-07 16:43:51 +00:00
3. 使用JNDI ConnectionFactory
2015-02-27 04:23:36 +00:00
如果你在一个应用服务器中运行你的应用，
XAConnectionFactory。如果需要的话，
```java
spring.jms.jndi-name=java:/MyConnectionFactory
```
2015-02-07 16:43:51 +00:00
4. 发送消息
2015-02-27 04:23:36 +00:00
Spring的JmsTemplate会被自动配置， ：
```java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.stereotype.Component;
@Component
public class MyBean {
private final JmsTemplate jmsTemplate;
@Autowired
public MyBean(JmsTemplate jmsTemplate) {
this.jmsTemplate = jmsTemplate;
}
// ...
}
```
**注**：
2015-02-07 16:43:51 +00:00
5. 接收消息
2015-02-27 04:23:36 +00:00
当JMS基础设施能够使用时， ， ，
```java
@Component
public class MyBean {
@JmsListener (destination = "someQueue")
public void processMessage(String content) {
// ...
}
}
```
具体查看[@EnableJms javadoc](http://docs.spring.io/spring/docs/4.1.4.RELEASE/javadoc-api/org/springframework/jms/annotation/EnableJms.html)。
2015-02-07 16:43:51 +00:00
### 发送邮件
2015-02-27 04:23:36 +00:00
Spring框架使用JavaMailSender接口为发送邮件提供了一个简单的抽象，
具体查看[JavaMailSender参考文档](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#mail)。
如果spring.mail.host和相关的库（ ） ， ，
2015-02-07 16:43:51 +00:00
### 使用JTA处理分布式事务
2015-02-27 04:23:36 +00:00
Spring Boot使用一个[Atomkos](http://www.atomikos.com/)或[Bitronix](http://docs.codehaus.org/display/BTM/Home)的内嵌事务管理器来支持跨多个XA资源的分布式JTA事务。当部署到一个恰当的J2EE应用服务器时也会支持JTA事务。
当发现一个JTA环境时， ， ， ， ， ，
2015-02-07 16:43:51 +00:00
* 使用一个Atomikos事务管理器
2015-02-27 04:23:36 +00:00
Atomikos是一个非常流行的开源事务管理器， ， ，
默认情况下， （ ）
**注**： ， ， ，
2015-02-07 16:43:51 +00:00
* 使用一个Bitronix事务管理器
2015-02-27 04:23:36 +00:00
Bitronix是另一个流行的开源JTA事务管理器实现。你可以使用`spring-boot-starter-jta-bitronix`starter POM为项目添加合适的Birtronix依赖。和Atomikos类似， ， （ ）
默认情况下， ， ，
**注**： ， ， ，
2015-02-07 16:43:51 +00:00
* 使用一个J2EE管理的事务管理器
2015-02-27 04:23:36 +00:00
如果你将Spring Boot应用打包为一个war或ear文件， ， （ ） ， ， ，
2015-02-07 16:43:51 +00:00
* 混合XA和non-XA的JMS连接
2015-02-27 04:23:36 +00:00
当使用JTA时， ， ， ，
如果想使用一个non-XA的ConnectionFactory， ，
示例如下：
2015-02-27 13:38:37 +00:00
```java
2015-02-27 04:23:36 +00:00
// Inject the primary (XA aware) ConnectionFactory
@Autowired
private ConnectionFactory defaultConnectionFactory;
// Inject the XA aware ConnectionFactory (uses the alias and injects the same as above)
@Autowired
@Qualifier ("xaJmsConnectionFactory")
private ConnectionFactory xaConnectionFactory;
// Inject the non-XA aware ConnectionFactory
@Autowired
@Qualifier ("nonXaJmsConnectionFactory")
private ConnectionFactory nonXaConnectionFactory;
```
2015-02-07 16:43:51 +00:00
* 支持可替代的内嵌事务管理器
2015-02-27 04:23:36 +00:00
[XAConnectionFactoryWrapper ](http://github.com/spring-projects/spring-boot/tree/master/spring-boot/src/main/java/org/springframework/boot/jta/XAConnectionFactoryWrapper.java )和[XADataSourceWrapper](http://github.com/spring-projects/spring-boot/tree/master/spring-boot/src/main/java/org/springframework/boot/jta/XADataSourceWrapper.java)接口用于支持可替换的内嵌事务管理器。该接口用于包装XAConnectionFactory和XADataSource ， ，
2015-02-07 16:43:51 +00:00
### Spring集成
2015-02-27 04:23:36 +00:00
Spring集成提供基于消息和其他协议的， ， ， ，
2015-02-07 16:43:51 +00:00
### 基于JMX的监控和管理
2015-02-27 04:23:36 +00:00
Java管理扩展（ ） ， ‘ ’ ， （ ）
2015-02-07 16:43:51 +00:00
### 测试
2015-02-27 04:23:36 +00:00
Spring Boot提供很多有用的测试应用的工具。spring-boot-starter-test POM提供Spring Test， ，
2015-02-07 16:43:51 +00:00
* 测试作用域依赖
2015-02-27 04:23:36 +00:00
如果使用spring-boot-starter-test ‘ ’ （ ） ， ：
- Spring Test - 对Spring应用的集成测试支持
2015-02-27 13:38:37 +00:00
- JUnit - 事实上的（ ） ，
2015-02-27 04:23:36 +00:00
- Hamcrest - 一个匹配对象的库（ ） ，
- Mockito - 一个Java模拟框架。
这也有一些我们写测试用例时经常用到的库。如果它们不能满足你的要求，你可以随意添加其他的测试用的依赖库。
2015-02-07 16:43:51 +00:00
* 测试Spring应用
2015-02-27 04:23:36 +00:00
依赖注入最大的优点就是它能够让你的代码更容易进行单元测试。你只需简单的通过new操作符实例化对象，
你常常需要在进行单元测试后， （ ） ，
Spring框架包含一个dedicated测试模块， ， ‘ ’
如果你以前没有使用过spring-test模块，
2015-02-07 16:43:51 +00:00
* 测试Spring Boot应用
2015-02-27 04:23:36 +00:00
一个Spring Boot应用只是一个Spring ApplicationContext， ， ， ，
Spring Boot提供一个@SpringApplicationConfiguration注解用来替换标准的spring-test ， ，
示例如下：
```java
@RunWith (SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration (classes = SampleDataJpaApplication.class)
public class CityRepositoryIntegrationTests {
@Autowired
CityRepository repository;
// ...
}
```
**提示**：上下文加载器会通过查找@WebIntegrationTest或@WebAppConfiguration注解来猜测你想测试的是否是web应用（ ， ， ）
如果想让一个web应用启动， ， （ ， ） ， （ ） ， ， ，
示例：
```java
@RunWith (SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration (classes = SampleDataJpaApplication.class)
@WebIntegrationTest
public class CityRepositoryIntegrationTests {
@Autowired
CityRepository repository;
RestTemplate restTemplate = new TestRestTemplate();
// ... interact with the running server
}
```
**注**： ， ， ，
你可以为@WebIntegrationTest添加环境变量属性来改变应用服务器端口号， ， ０ ， ：
2015-02-27 11:51:54 +00:00
```java
@RunWith (SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration (classes = MyApplication.class)
@WebIntegrationTest ({"server.port=0", "management.port=0"})
public class SomeIntegrationTests {
// ...
}
```
可以查看[Section 64.4, “Discover the HTTP port at runtime”]()，它描述了如何在测试期间发现分配的实际端口。
1. 使用Spock测试Spring Boot应用
如果期望使用Spock测试一个Spring Boot应用，
2015-02-27 04:23:36 +00:00
2015-02-27 11:51:54 +00:00
注意你不能使用上述提到的@SpringApplicationConfiguration注解， ，
```java
@ContextConfiguration (loader = SpringApplicationContextLoader.class)
class ExampleSpec extends Specification {
// ...
}
```
**注**： ， ，
2015-02-27 04:23:36 +00:00
2015-02-07 16:43:51 +00:00
* 测试工具
2015-02-27 11:51:54 +00:00
打包进spring-boot的一些有用的测试工具类。
1. ConfigFileApplicationContextInitializer
ConfigFileApplicationContextInitializer是一个ApplicationContextInitializer， ，
2015-02-27 13:38:37 +00:00
2015-02-27 11:51:54 +00:00
```java
2015-02-27 13:38:37 +00:00
@ContextConfiguration (classes = Config.class,initializers = ConfigFileApplicationContextInitializer.class)
2015-02-27 11:51:54 +00:00
```
2. EnvironmentTestUtils
EnvironmentTestUtils允许你快速添加属性到一个ConfigurableEnvironment或ConfigurableApplicationContext。只需简单的使用key=value字符串调用它：
```java
EnvironmentTestUtils.addEnvironment(env, "org=Spring", "name=Boot");
```
3. OutputCapture
OutputCapture是一个JUnit Rule， ，
```java
import org.junit.Rule;
import org.junit.Test;
import org.springframework.boot.test.OutputCapture;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
public class MyTest {
@Rule
public OutputCapture capture = new OutputCapture();
@Test
public void testName() throws Exception {
System.out.println("Hello World!");
assertThat(capture.toString(), containsString("World"));
}
}
```
4. TestRestTemplate
TestRestTemplate是一个方便进行集成测试的Spring RestTemplate子类。你会获取到一个普通的模板或一个发送基本HTTP认证（ ） ， ： （ ） ， （ ） ， ， ，
```java
public class MyTest {
RestTemplate template = new TestRestTemplate();
@Test
public void testRequest() throws Exception {
HttpHeaders headers = template.getForEntity("http://myhost.com", String.class).getHeaders();
assertThat(headers.getLocation().toString(), containsString("myotherhost"));
}
}
```
2015-02-07 16:43:51 +00:00
### 开发自动配置和使用条件
2015-02-27 11:51:54 +00:00
如果你在一个开发者共享库的公司工作， ， ，
2015-02-07 16:43:51 +00:00
* 理解auto-configured beans
2015-02-27 11:51:54 +00:00
从底层来讲， ， ，
你可以浏览spring-boot-autoconfigure的源码， （ ）
2015-02-07 16:43:51 +00:00
* 定位auto-configuration候选者
2015-02-27 11:51:54 +00:00
Spring Boot会检查你发布的jar中是否存在META-INF/spring.factories文件。该文件应该列出以EnableAutoConfiguration为key的配置类：
```java
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.mycorp.libx.autoconfigure.LibXAutoConfiguration,\
com.mycorp.libx.autoconfigure.LibXWebAutoConfiguration
```
如果配置需要应用特定的顺序，你可以使用[@AutoConfigureAfter](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/AutoConfigureAfter.java)或[@AutoConfigureBefore](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/AutoConfigureBefore.java)注解。例如， ，
2015-02-07 16:43:51 +00:00
* Condition注解
2015-02-27 11:51:54 +00:00
你几乎总是需要在你的auto-configuration类里添加一个或更多的@Condition注解。@ConditionalOnMissingBean注解是一个常见的示例， ，
Spring Boot包含很多@Conditional注解，
1. Class条件
@ConditionalOnClass 和@ConditionalOnMissingClass注解允许根据特定类是否出现来跳过配置。由于注解元数据是使用[ASM](http://asm.ow2.org/)来解析的， ， ，
2. Bean条件
@ConditionalOnBean 和@ConditionalOnMissingBean注解允许根据特定beans是否出现来跳过配置。你可以使用value属性来指定beans（ ） ， （ ）
**注**：当@Configuration类被解析时@Conditional注解会被处理。Auto-configure @Configuration 总是最后被解析（ ） ， ， ，
3. Property条件
@ConditionalOnProperty 注解允许根据一个Spring Environment属性来决定是否包含配置。可以使用prefix和name属性指定要检查的配置属性。默认情况下，
4. Resource条件
@ConditionalOnResource 注解允许只有在特定资源出现时配置才会被包含。资源可以使用常见的Spring约定命名，
5. Web Application条件
@ConditionalOnWebApplication 和@ConditionalOnNotWebApplication注解允许根据应用是否为一个'web应用'来决定是否包含配置。一个web应用是任何使用Spring WebApplicationContext，
6. SpEL表达式条件
@ConditionalOnExpression 注解允许根据[SpEL表达式](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#expressions)结果来跳过配置。
2015-02-07 16:43:51 +00:00
### WebSockets
2015-02-27 11:51:54 +00:00
Spring Boot为内嵌的Tomcat(8和7)， ，
Spring框架提供[丰富的WebSocket支持](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#websocket)，
