spring_reference/spring_boot_features.md

1124 lines
62 KiB
Markdown
Raw Blame History

This file contains invisible Unicode characters!

This file contains invisible Unicode characters that may be processed differently from what appears below. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to reveal hidden characters.

This file contains ambiguous Unicode characters that may be confused with others in your current locale. If your use case is intentional and legitimate, you can safely ignore this warning. Use the Escape button to highlight these characters.

Spring Boot特性
===============
### SpringApplication
SpringApplication类提供了一种从main()方法启动Spring应用的便捷方式。在很多情况下你只需委托给SpringApplication.run这个静态方法
```java
public static void main(String[] args){
SpringApplication.run(MySpringConfiguration.class, args);
}
```
* 自定义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()方法。
* 自定义SpringApplication
如果默认的SpringApplication不符合你的口味你可以创建一个本地的实例并自定义它。例如关闭banner你可以这样写
```java
public static void main(String[] args){
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setShowBanner(false);
app.run(args);
}
```
**注**传递给SpringApplication的构造器参数是spring beans的配置源。在大多数情况下这些将是@Configuration类的引用但它们也可能是XML配置或要扫描包的引用。
你也可以使用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多个具有父子关系的上下文或你只是喜欢使用流畅的构建API你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法包括可以创建层次结构的parent和child方法。
```java
new SpringApplicationBuilder()
.showBanner(false)
.sources(Parent.class)
.child(Application.class)
.run(args);
```
**注**创建ApplicationContext层次时有些限制比如Web组件(components)必须包含在子上下文(child context)中且相同的Environment即用于父上下文也用于子上下文中。具体参考[SpringApplicationBuilder javadoc](http://docs.spring.io/spring-boot/docs/1.2.2.BUILD-SNAPSHOT/api/org/springframework/boot/builder/SpringApplicationBuilder.html)
* Application事件和监听器
除了常见的Spring框架事件比如[ContextRefreshedEvent](http://docs.spring.io/spring/docs/4.1.4.RELEASE/javadoc-api/org/springframework/context/event/ContextRefreshedEvent.html)一个SpringApplication也发送一些额外的应用事件。一些事件实际上是在ApplicationContext被创建前触发的。
你可以使用多种方式注册事件监听器最普通的是使用SpringApplication.addListeners(…)方法。在你的应用运行时,应用事件会以下面的次序发送:
1. 在运行开始但除了监听器注册和初始化以外的任何处理之前会发送一个ApplicationStartedEvent。
2. 在Environment将被用于已知的上下文但在上下文被创建前会发送一个ApplicationEnvironmentPreparedEvent。
3. 在refresh开始前但在bean定义已被加载后会发送一个ApplicationPreparedEvent。
4. 启动过程中如果出现异常会发送一个ApplicationFailedEvent。
**注**你通常不需要使用应用程序事件但知道它们的存在会很方便在某些场合可能会使用到。在Spring内部Spring Boot使用事件处理各种各样的任务。
* Web环境
一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。
用于确定一个web环境的算法相当简单基于是否存在某些类。如果需要覆盖默认行为你可以使用setWebEnvironment(boolean webEnvironment)。通过调用setApplicationContextClass(…)你可以完全控制ApplicationContext的类型。
**注**当JUnit测试里使用SpringApplication时调用setWebEnvironment(false)是可取的。
* 命令行启动器
如果你想获取原始的命令行参数或一旦SpringApplication启动你需要运行一些特定的代码你可以实现CommandLineRunner接口。在所有实现该接口的Spring beans上将调用run(String… args)方法。
```java
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注解。
* Application退出
每个SpringApplication在退出时为了确保ApplicationContext被优雅的关闭将会注册一个JVM的shutdown钩子。所有标准的Spring生命周期回调比如DisposableBean接口或@PreDestroy注解都能使用。
此外如果beans想在应用结束时返回一个特定的退出码exit code可以实现org.springframework.boot.ExitCodeGenerator接口。
### 外化配置
Spring Boot允许外化externalize你的配置这样你能够在不同的环境下使用相同的代码。你可以使用properties文件YAML文件环境变量和命令行参数来外化配置。使用@Value注解可以直接将属性值注入到你的beans中并通过Spring的Environment抽象或绑定到结构化对象来访问。
Spring Boot使用一个非常特别的PropertySource次序来允许对值进行合理的覆盖需要以下面的次序考虑属性
1. 命令行参数
2. 来自于java:comp/env的JNDI属性
3. Java系统属性System.getProperties()
4. 操作系统环境变量
5. 只有在random.*里包含的属性会产生一个RandomValuePropertySource
6. 在打包的jar外的应用程序配置文件application.properties包含YAML和profile变量
7. 在打包的jar内的应用程序配置文件application.properties包含YAML和profile变量
8. 在@Configuration类上的@PropertySource注解
9. 默认属性使用SpringApplication.setDefaultProperties指定
下面是一个具体的示例假设你开发一个使用name属性的@Component
```java
import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
@Value("${name}")
private String name;
// ...
}
```
你可以将一个application.properties文件捆绑到jar内用来提供一个合理的默认name属性值。当运行在生产环境时可以在jar外提供一个application.properties文件来覆盖name属性。对于一次性的测试你可以使用特定的命令行开关启动比如java -jar app.jar --name="Spring")。
RandomValuePropertySource在注入随机值比如密钥或测试用例时很有用。它能产生整数longs或字符串比如
```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此处OPENCLOSE可以是任何字符并且valuemax是整数。如果提供max那么value是最小的值max是最大的值不包含在内
* 访问命令行属性
默认情况下SpringApplication将任何可选的命令行参数以'--'开头,比如,--server.port=9000转化为property并将其添加到Spring Environment中。如上所述命令行属性总是优先于其他属性源。
如果你不想将命令行属性添加到Environment里你可以使用SpringApplication.setAddCommandLineProperties(false)来禁止它们。
* Application属性文件
SpringApplication将从以下位置加载application.properties文件并把它们添加到Spring Environment中
1. 当前目录下的一个/config子目录
2. 当前目录
3. 一个classpath下的/config包
4. classpath根路径root
这个列表是按优先级排序的(列表中位置高的将覆盖位置低的)。
**注**你可以使用YAML'.yml')文件替代'.properties'。
如果不喜欢将application.properties作为配置文件名你可以通过指定spring.config.name环境属性来切换其他的名称。你也可以使用spring.config.location环境属性来引用一个明确的路径目录位置或文件路径列表以逗号分割
```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包含目录相对于文件那它们应该以/结尾在加载前spring.config.name产生的名称将被追加到后面。不管spring.config.location是什么值默认的搜索路径classpath:,classpath:/config,file:,file:config/总会被使用。以这种方式你可以在application.properties中为应用设置默认值然后在运行的时候使用不同的文件覆盖它同时保留默认配置。
**注**如果你使用环境变量而不是系统配置大多数操作系统不允许以句号分割period-separated的key名称但你可以使用下划线underscores代替比如使用SPRING_CONFIG_NAME代替spring.config.name。如果你的应用运行在一个容器中那么JNDI属性java:comp/env或servlet上下文初始化参数可以用来取代环境变量或系统属性当然也可以使用环境变量或系统属性。
* 特定的Profile属性
除了application.properties文件特定配置属性也能通过命令惯例application-{profile}.properties来定义。特定Profile属性从跟标准application.properties相同的路径加载并且特定profile文件会覆盖默认的配置。
* 属性占位符
当application.properties里的值被使用时它们会被存在的Environment过滤所以你能够引用先前定义的值比如系统属性
```java
app.name=MyApp
app.description=${app.name} is a Spring Boot application
```
**注**你也能使用相应的技巧为存在的Spring Boot属性创建'短'变量,具体参考[Section 63.3, “Use short command line arguments”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-use-short-command-line-arguments)。
* 使用YAML代替Properties
[YAML](http://yaml.org/)是JSON的一个超集也是一种方便的定义层次配置数据的格式。无论你何时将[SnakeYAML ](http://code.google.com/p/snakeyaml/)库放到classpath下SpringApplication类都会自动支持YAML作为properties的替换。
**注**:如果你使用'starter POMs'spring-boot-starter会自动提供SnakeYAML。
* 加载YAML
Spring框架提供两个便利的类用于加载YAML文档YamlPropertiesFactoryBean会将YAML作为Properties来加载YamlMapFactoryBean会将YAML作为Map来加载。
示例:
```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的形式例如下面的YAML
```json
my:
servers:
- dev.bar.com
- foo.bar.com
```
将会转化到下面的属性中:
```java
my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com
```
使用Spring DataBinder工具绑定那样的属性这是@ConfigurationProperties做的事你需要确定目标bean中有个java.util.List或Set类型的属性并且需要提供一个setter或使用可变的值初始化它比如下面的代码将绑定上面的属性
```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文档
你可以在单个文件中定义多个特定配置profile-specific的YAML文档并通过一个spring.profiles key标示应用的文档。例如
```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
```
在上面的例子中如果development配置被激活那server.address属性将是127.0.0.1。如果development和production配置profiles没有启用则该属性的值将是192.168.1.100。
* YAML缺点
YAML文件不能通过@PropertySource注解加载。所以在这种情况下如果需要使用@PropertySource注解的方式加载值那就要使用properties文件。
* 类型安全的配置属性
使用@Value("${property}")注解注入配置属性有时可能比较笨重特别是需要使用多个properties或你的数据本身有层次结构。为了控制和校验你的应用配置Spring Boot提供一个允许强类型beans的替代方法来使用properties。
示例:
```java
@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
private String username;
private InetAddress remoteAddress;
// ... getters and setters
}
```
当@EnableConfigurationProperties注解应用到你的@Configuration时任何被@ConfigurationProperties注解的beans将自动被Environment属性配置。这种风格的配置特别适合与SpringApplication的外部YAML配置进行配合使用。
```json
# application.yml
connection:
username: admin
remoteAddress: 192.168.1.1
# additional configuration as required
```
为了使用@ConfigurationProperties beans你可以使用与其他任何bean相同的方式注入它们。
```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注解一个类你也可以在@Bean方法上使用它。当你需要绑定属性到不受你控制的第三方组件时这种方式非常有用。
为了从Environment属性配置一个bean将@ConfigurationProperties添加到它的bean注册过程
```java
@ConfigurationProperties(prefix = "foo")
@Bean
public FooComponent fooComponent() {
...
}
```
和上面ConnectionSettings的示例方式相同任何以foo为前缀的属性定义都会被映射到FooComponent上。
* 松散的绑定Relaxed binding
Spring Boot使用一些宽松的规则用于绑定Environment属性到@ConfigurationProperties beans所以Environment属性名和bean属性名不需要精确匹配。常见的示例中有用的包括虚线分割比如context--path绑定到contextPath和将环境属性转为大写字母比如PORT绑定port
示例:
```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时类型是正确的。如果需要自定义类型转换你可以提供一个ConversionService beanbean id为conversionService或自定义属性编辑器通过一个CustomEditorConfigurer bean
* @ConfigurationProperties校验
Spring Boot将尝试校验外部的配置默认使用JSR-303如果在classpath路径中。你可以轻松的为你的@ConfigurationProperties类添加JSR-303 javax.validation约束注解
```java
@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
@NotNull
private InetAddress remoteAddress;
// ... getters and setters
}
```
你也可以通过创建一个叫做configurationPropertiesValidator的bean来添加自定义的Spring Validator。
**注**spring-boot-actuator模块包含一个暴露所有@ConfigurationProperties beans的端点。简单地将你的web浏览器指向/configprops或使用等效的JMX端点。具体参考[Production ready features](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#production-ready-endpoints)。
### Profiles
Spring Profiles提供了一种隔离应用程序配置的方式并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记从而限制加载它的时机。
```java
@Configuration
@Profile("production")
public class ProductionConfiguration {
// ...
}
```
以正常的Spring方式你可以使用一个spring.profiles.active的Environment属性来指定哪个配置生效。你可以使用平常的任何方式来指定该属性例如可以将它包含到你的application.properties中
```java
spring.profiles.active=dev,hsqldb
```
或使用命令行开关:
```shell
--spring.profiles.active=dev,hsqldb
```
* 添加激活的配置(profiles)
spring.profiles.active属性和其他属性一样都遵循相同的排列规则最高的PropertySource获胜。也就是说你可以在application.properties中指定生效的配置然后使用命令行开关替换它们。
有时将特定的配置属性添加到生效的配置中而不是替换它们是有用的。spring.profiles.include属性可以用来无条件的添加生效的配置。SpringApplication的入口点也提供了一个用于设置额外配置的Java API比如在那些通过spring.profiles.active属性生效的配置之上参考setAdditionalProfiles()方法。
示例:当一个应用使用下面的属性,并用`--spring.profiles.active=prod`开关运行那proddb和prodmq配置也会生效
```java
---
my.property: fromyamlfile
---
spring.profiles: prod
spring.profiles.include: proddb,prodmq
```
**注**spring.profiles属性可以定义到一个YAML文档中用于决定什么时候该文档被包含进配置中。具体参考[Section 63.6, “Change configuration depending on the environment”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-change-configuration-depending-on-the-environment)
* 以编程方式设置profiles
在应用运行前你可以通过调用SpringApplication.setAdditionalProfiles(…)方法以编程的方式设置生效的配置。使用Spring的ConfigurableEnvironment接口激动配置也是可行的。
* Profile特定配置文件
application.properties或application.yml和通过@ConfigurationProperties引用的文件这两种配置特定变种都被当作文件来加载的具体参考[Section 23.3, “Profile specific properties”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-external-config-profile-specific-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'那么就会使用Logback记录日志。为了确保那些使用Java Util Logging, Commons Logging, Log4J或SLF4J的依赖库能够正常工作正确的Logback路由也被包含进来。
**注**如果上面的列表看起来令人困惑不要担心Java有很多可用的日志框架。通常你不需要改变日志依赖Spring Boot默认的就能很好的工作。
* 日志格式
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: [/*]
```
输出的节点items如下
1. 日期和时间 - 精确到毫秒,且易于排序。
2. 日志级别 - ERROR, WARN, INFO, DEBUG 或 TRACE。
3. Process ID。
4. 一个用于区分实际日志信息开头的---分隔符。
5. 线程名 - 包括在方括号中(控制台输出可能会被截断)。
6. 日志名 - 通常是源class的类名缩写
7. 日志信息。
* 控制台输出
默认的日志配置会在写日志消息时将它们回显到控制台。默认ERROR, WARN和INFO级别的消息会被记录。可以在启动应用时通过`--debug`标识开启控制台的DEBUG级别日志记录。
```shell
$ java -jar myapp.jar --debug
```
如果你的终端支持ANSI为了增加可读性将会使用彩色的日志输出。你可以设置`spring.output.ansi.enabled`为一个[支持的值](http://docs.spring.io/spring-boot/docs/1.2.2.BUILD-SNAPSHOT/api/org/springframework/boot/ansi/AnsiOutput.Enabled.html)来覆盖自动检测。
* 文件输出
默认情况下Spring Boot只会将日志记录到控制台而不会写进日志文件。如果除了输出到控制台你还想写入到日志文件那你需要设置`logging.file`或`logging.path`属性例如在你的application.properties中
下表显示如何组合使用`logging.*`
|logging.file|logging.path| 示例 | 描述 |
| -------- | :----- | :----- | :-----|
| (none) | (none) | | 只记录到控制台 |
|Specific file|(none)|my.log|写到特定的日志文件里,名称可以是一个精确的位置或相对于当前目录|
|(none)|Specific folder|/var/log|写到特定文件夹下的spring.log里名称可以是一个精确的位置或相对于当前目录|
日志文件每达到10M就会被轮换分割和控制台一样默认记录ERROR, WARN和INFO级别的信息。
* 日志级别
所有支持的日志系统在Spring的Environment例如在application.properties里都有通过'logging.level.*=LEVEL''LEVEL'是TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF中的一个设置的日志级别。
示例application.properties
```java
logging.level.org.springframework.web: DEBUG
logging.level.org.hibernate: ERROR
```
* 自定义日志配置
通过将适当的库添加到classpath可以激活各种日志系统。然后在classpath的根目录(root)或通过Spring Environment的`logging.config`属性指定的位置提供一个合适的配置文件来达到进一步的定制注意由于日志是在ApplicationContext被创建之前初始化的所以不可能在Spring的@Configuration文件中通过@PropertySources控制日志。系统属性和平常的Spring Boot外部配置文件能正常工作
根据你的日志系统,下面的文件会被加载:
| 日志系统 | 定制 |
| -------- | :-----: |
|Logback|logback.xml|
|Log4j|log4j.properties或log4j.xml|
|Log4j2|log4j2.xml|
|JDK (Java Util Logging)|logging.properties|
为了帮助定制一些其他的属性从Spring的Envrionment转换到系统属性
| Spring Environment| System Property| 评价 |
| -------- | :-----: | :----: |
|logging.file|LOG_FILE|如果定义,在默认的日志配置中使用|
|logging.path|LOG_PATH|如果定义,在默认的日志配置中使用|
|PID|PID|当前的处理进程(process)ID如果能够被发现且还没有作为操作系统环境变量被定义|
所有支持的日志系统在解析它们的配置文件时都能查询系统属性。具体可以参考spring-boot.jar中的默认配置。
**注**在运行可执行的jar时Java Util Logging有类加载问题我们建议你尽可能避免使用它。
### 开发Web应用
Spring Boot非常适合开发web应用程序。你可以使用内嵌的TomcatJetty或Undertow轻轻松松地创建一个HTTP服务器。大多数的web应用都使用spring-boot-starter-web模块进行快速搭建和运行。
* Spring Web MVC框架
Spring Web MVC框架通常简称为"Spring MVC")是一个富"模型,视图,控制器"的web框架。
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. 对静态资源的支持包括对WebJars的支持。
3. 自动注册ConverterGenericConverterFormatter beans。
4. 对HttpMessageConverters的支持。
5. 自动注册MessageCodeResolver。
6. 对静态index.html的支持。
7. 对自定义Favicon的支持。
如果想全面控制Spring MVC你可以添加自己的@Configuration并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性并只是添加其他的[MVC配置](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle#mvc)(拦截器formatters视图控制器等)你可以添加自己的WebMvcConfigurerAdapter类型的@Bean不使用@EnableWebMvc注解
* HttpMessageConverters
Spring MVC使用HttpMessageConverter接口转换HTTP请求和响应。合理的缺省值被包含的恰到好处out of the box例如对象可以自动转换为JSON使用Jackson库或XML如果Jackson XML扩展可用则使用它否则使用JAXB。字符串默认使用UTF-8编码。
如果需要添加或自定义转换器你可以使用Spring Boot的HttpMessageConverters类
```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列表你可以通过这种方式覆盖默认的转换器converters
* MessageCodesResolver
Spring MVC有一个策略用于从绑定的errors产生用来渲染错误信息的错误码MessageCodesResolver。如果设置`spring.mvc.message-codes-resolver.format`属性为`PREFIX_ERROR_CODE`或`POSTFIX_ERROR_CODE`(具体查看`DefaultMessageCodesResolver.Format`枚举值Spring Boot会为你创建一个MessageCodesResolver。
* 静态内容
默认情况下Spring Boot从classpath下一个叫/static/public/resources或/META-INF/resources的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的ResourceHttpRequestHandler所以你可以通过添加自己的WebMvcConfigurerAdapter并覆写addResourceHandlers方法来改变这个行为加载静态文件
在一个单独的web应用中容器默认的servlet是开启的如果Spring决定不处理某些请求默认的servlet作为一个回退降级将从ServletContext根目录加载内容。大多数时候这不会发生除非你修改默认的MVC配置因为Spring总能够通过DispatcherServlet处理请求。
此外,上述标准的静态资源位置有个例外情况是[Webjars内容](http://www.webjars.org/)。任何在/webjars/**路径下的资源都将从jar文件中提供只要它们以Webjars的格式打包。
**注**如果你的应用将被打包成jar那就不要使用src/main/webapp文件夹。尽管该文件夹是一个共同的标准但它仅在打包成war的情况下起作用并且如果产生一个jar多数构建工具都会静悄悄的忽略它。
* 模板引擎
正如REST web服务你也可以使用Spring MVC提供动态HTML内容。Spring MVC支持各种各样的模板技术包括Velocity, FreeMarker和JSPs。很多其他的模板引擎也提供它们自己的Spring MVC集成。
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/)
**注**如果可能的话应该忽略JSPs因为在内嵌的servlet容器使用它们时存在一些[已知的限制](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#boot-features-jsp-limitations)。
当你使用这些引擎的任何一种并采用默认的配置你的模板将会从src/main/resources/templates目录下自动加载。
**注**IntelliJ IDEA根据你运行应用的方式会对classpath进行不同的整理。在IDE里通过main方法运行你的应用跟从Maven或Gradle或打包好的jar中运行相比会导致不同的顺序。这可能导致Spring Boot不能从classpath下成功地找到模板。如果遇到这个问题你可以在IDE里重新对classpath进行排序将模块的类和资源放到第一位。或者你可以配置模块的前缀为classpath*:/templates/这样会查找classpath下的所有模板目录。
* 错误处理
Spring Boot默认提供一个/error映射用来以合适的方式处理所有的错误并且它在servlet容器中注册了一个全局的
错误页面。对于机器客户端相对于浏览器而言浏览器偏重于人的行为它会产生一个具有详细错误HTTP状态异常信息的JSON响应。对于浏览器客户端它会产生一个白色标签样式whitelabel的错误视图该视图将以HTML格式显示同样的数据可以添加一个解析为erro的View来自定义它。为了完全替换默认的行为你可以实现ErrorController并注册一个该类型的bean定义或简单地添加一个ErrorAttributes类型的bean以使用现存的机制只是替换显示的内容。
如果在某些条件下需要比较多的错误页面内嵌的servlet容器提供了一个统一的Java DSL领域特定语言来自定义错误处理。
示例:
```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特性来处理错误比如[@ExceptionHandler方法](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#mvc-exceptionhandlers)和[@ControllerAdvice](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#mvc-ann-controller-advice)。ErrorController将会捡起任何没有处理的异常。
N.B. 如果你为一个路径注册一个ErrorPage最终被一个过滤器Filter处理对于一些非Spring web框架像Jersey和Wicket这很常见然后过滤器需要显式注册为一个ERROR分发器dispatcher
```java
@Bean
public FilterRegistrationBean myFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new MyFilter());
...
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
return registration;
}
```
**注**默认的FilterRegistrationBean没有包含ERROR分发器类型。
* Spring HATEOAS
如果你正在开发一个使用超媒体的RESTful APISpring Boot将为Spring HATEOAS提供自动配置这在多数应用中都工作良好。自动配置替换了对使用@EnableHypermediaSupport的需求并注册一定数量的beans来简化构建基于超媒体的应用这些beans包括一个LinkDiscoverer和配置好的用于将响应正确编排为想要的表示的ObjectMapper。ObjectMapper可以根据spring.jackson.*属性或一个存在的Jackson2ObjectMapperBuilder bean进行自定义。
通过使用@EnableHypermediaSupport你可以控制Spring HATEOAS的配置。注意这会禁用上述的对ObjectMapper的自定义。
* 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
```java
@Component
public class JerseyConfig extends ResourceConfig {
public JerseyConfig() {
register(Endpoint.class);
}
}
```
所有注册的端点都应该被@Components和HTTP资源annotations比如@GET注解。
```java
@Component
@Path("/hello")
public class Endpoint {
@GET
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示例](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/spring-boot-sample-jersey),你可以查看如何设置相关事项。
* 内嵌servlet容器支持
Spring Boot支持内嵌的Tomcat, Jetty和Undertow服务器。多数开发者只需要使用合适的'Starter POM'来获取一个完全配置好的实例即可。默认情况下内嵌的服务器会在8080端口监听HTTP请求。
**1.Servlets和Filters**
当使用内嵌的servlet容器时你可以直接将servlet和filter注册为Spring的beans。在配置期间如果你想引用来自application.properties的值这是非常方便的。默认情况下如果上下文只包含单一的Servlet那它将被映射到根路径/。在多Servlet beans的情况下bean的名称将被用作路径的前缀。过滤器会被映射到/*。
如果基于约定convention-based的映射不够灵活你可以使用ServletRegistrationBean和FilterRegistrationBean类实现完全的控制。如果你的bean实现了ServletContextInitializer接口也可以直接注册它们。
**2.EmbeddedWebApplicationContext**
Spring Boot底层使用了一个新的ApplicationContext类型用于对内嵌servlet容器的支持。EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext它通过搜索一个单一的EmbeddedServletContainerFactory bean来启动自己。通常TomcatEmbeddedServletContainerFactoryJettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory将被自动配置。
**注**你通常不需要知道这些实现类。大多数应用将被自动配置并根据你的行为创建合适的ApplicationContext和EmbeddedServletContainerFactory。
**3.自定义内嵌servlet容器**
常见的Servlet容器设置可以通过Spring Environment属性进行配置。通常你会把这些属性定义到application.properties文件中。
常见的服务器设置包括:
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容器你可以注册一个实现EmbeddedServletContainerCustomizer接口的Spring bean。EmbeddedServletContainerCustomizer提供对ConfigurableEmbeddedServletContainer的访问ConfigurableEmbeddedServletContainer包含很多自定义的setter方法。
```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**
如果上面的自定义手法过于受限你可以自己注册TomcatEmbeddedServletContainerFactoryJettyEmbeddedServletContainerFactory或UndertowEmbeddedServletContainerFactory。
```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应用时并打包成一个可执行的存档archive容器对JSP的支持有一些限制。
1. tomcat只支持war的打包方式不支持可执行的jar。
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下那么web应用默认对所有的HTTP路径也称为终点端点表示API的具体网址使用'basic'认证。为了给web应用添加方法级别的保护你可以添加@EnableGlobalMethodSecurity并使用想要的设置。其他信息参考[Spring Security Reference](http://docs.spring.io/spring-security/site/docs/3.2.5.RELEASE/reference/htmlsingle#jc-method)。
默认的AuthenticationManager有一个单一的user'user'的用户名和随机密码会在应用启动时以INFO日志级别打印出来。如下
```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)以security为前缀的属性被外部化了。
默认的安全配置security configuration是在SecurityAutoConfiguration和导入的类中实现的SpringBootWebSecurityConfiguration用于web安全AuthenticationManagerConfiguration用于与非web应用也相关的认证配置。你可以添加一个@EnableWebSecurity bean来彻底关掉Spring Boot的默认配置。为了对它进行自定义你需要使用外部的属性配置和WebSecurityConfigurerAdapter类型的beans比如添加基于表单的登陆。在[Spring Boot示例](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples/)里有一些安全相关的应用可以带你体验常见的用例。
在一个web应用中你能得到的基本特性如下
1. 一个使用内存存储的AuthenticationManager bean和唯一的user查看SecurityProperties.User获取user的属性
2. 忽略(不保护)常见的静态资源路径(`/css/**, /js/**, /images/**`和 `**/favicon.ico`)。
3. 对其他的路径实施HTTP Basic安全保护。
4. 安全相关的事件会发布到Spring的ApplicationEventPublisher成功和失败的认证拒绝访问
5. Spring Security提供的常见底层特性HSTS, XSS, CSRF, 缓存)默认都被开启。
上述所有特性都能打开和关闭或使用外部的配置进行修改security.*。为了覆盖访问规则access rules而不改变其他自动配置的特性你可以添加一个使用@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)注解的WebSecurityConfigurerAdapter类型的@Bean。
如果Actuator也在使用你会发现
1. 即使应用路径不受保护,被管理的路径也会受到保护。
2. 安全相关的事件被转换为AuditEvents审计事件并发布给AuditService。
3. 默认的用户有ADMIN和USER的角色。
使用外部属性能够修改Actuator执行器的安全特性management.security.*。为了覆盖应用程序的访问规则你可以添加一个WebSecurityConfigurerAdapter类型的@Bean。同时如果不想覆盖执行器的访问规则你可以使用@Order(SecurityProperties.ACCESS_OVERRIDE_ORDER)注解该bean否则使用@Order(ManagementServerProperties.ACCESS_OVERRIDE_ORDER)注解该bean。
### 使用SQL数据库
Spring框架为使用SQL数据库提供了广泛的支持。从使用JdbcTemplate直接访问JDBC到完全的对象关系映射技术比如Hibernate。Spring Data提供一个额外的功能直接从接口创建Repository实现并使用约定从你的方法名生成查询。
* 配置DataSource
Java的javax.sql.DataSource接口提供了一个标准的使用数据库连接的方法。传统做法是一个DataSource使用一个URL连同相应的证书去初始化一个数据库连接。
**1.对内嵌数据库的支持**
开发应用时使用内存数据库是很实用的。显而易见地,内存数据库不需要提供持久化存储。你不需要在应用启动时填充数据库,也不需要在应用结束时丢弃数据。
Spring Boot可以自动配置的内嵌数据库包括[H2](http://www.h2database.com/), [HSQL](http://hsqldb.org/)和[Derby](http://db.apache.org/derby/)。你不需要提供任何连接URLs只需要简单的添加你想使用的内嵌数据库依赖。
示例典型的POM依赖如下
```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>
```
**注**对于自动配置的内嵌数据库你需要依赖spring-jdbc。在示例中它通过`spring-boot-starter-data-jpa`被传递地拉过来了。
**2.连接到一个生产环境数据库**
在生产环境中数据库连接可以使用DataSource池进行自动配置。下面是选取一个特定实现的算法
- 由于Tomcat数据源连接池的性能和并发在tomcat可用时我们总是优先使用它。
- 如果HikariCP可用我们将使用它。
- 如果Commons DBCP可用我们将使用它但在生产环境不推荐使用它。
- 最后如果Commons DBCP2可用我们将使用它。
如果你使用spring-boot-starter-jdbc或spring-boot-starter-data-jpa 'starter POMs'你将会自动获取对tomcat-jdbc的依赖。
**注**其他的连接池可以手动配置。如果你定义自己的DataSource bean自动配置不会发生。
DataSource配置通过外部配置文件的spring.datasource.*属性控制。示例中你可能会在application.properties中声明下面的片段
```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实现相关的特定属性具体参考你使用的连接池实现的文档。
**注**既然Spring Boot能够从大多数数据库的url上推断出driver-class-name那么你就不需要再指定它了。对于一个将要创建的DataSource连接池我们需要能够验证Driver是否可用所以我们会在做任何事情之前检查它。比如如果你设置spring.datasource.driverClassName=com.mysql.jdbc.Driver然后这个类就会被加载。
**3.连接到一个JNDI数据库**
如果正在将Spring Boot应用部署到一个应用服务器你可能想要用应用服务器内建的特性来配置和管理你的DataSource并使用JNDI访问它。
spring.datasource.jndi-name属性可以用来替代spring.datasource.urlspring.datasource.username和spring.datasource.password去从一个特定的JNDI路径访问DataSource。比如下面application.properties中的片段展示了如何获取JBoss定义的DataSource
```java
spring.datasource.jndi-name=java:jboss/datasources/customers
```
* 使用JdbcTemplate
Spring的JdbcTemplate和NamedParameterJdbcTemplate类是被自动配置的你可以在自己的beans中通过@Autowire直接注入它们。
```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实现。
- Spring Data JPA - 让实现基于JPA的repositories更容易。
- Spring ORMs - Spring框架的核心ORM支持。
**注**我们不想在这涉及太多关于JPA或Spring Data的细节。你可以参考来自[spring.io](http://spring.io/)的指南[使用JPA获取数据](http://spring.io/guides/gs/accessing-data-jpa/),并阅读[Spring Data JPA](http://projects.spring.io/spring-data-jpa/)和[Hibernate](http://hibernate.org/orm/documentation/)的参考文档。
**1.实体类**
传统上JPA实体类被定义到一个persistence.xml文件中。在Spring Boot中这个文件不是必需的并被'实体扫描'替代。默认情况下在你主main配置类被@EnableAutoConfiguration或@SpringBootApplication注解的类下的所有包都将被查找。
任何被@Entity@Embeddable或@MappedSuperclass注解的类都将被考虑。一个普通的实体类看起来像下面这样
```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仓库repositories是用来定义访问数据的接口。根据你的方法名JPA查询会被自动创建。比如一个CityRepository接口可能声明一个findAllByState(String state)方法,用来查找给定状态的所有城市。
对于比较复杂的查询你可以使用Spring Data的[Query](http://docs.spring.io/spring-data/jpa/docs/current/api/org/springframework/data/jpa/repository/Query.html)来注解你的方法。
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);
}
```
**注**我们仅仅触及了Spring Data JPA的表面。具体查看它的[参考指南](http://projects.spring.io/spring-data-jpa/)。
**3.创建和删除JPA数据库**
默认情况下只有在你使用内嵌数据库H2, HSQL或DerbyJPA数据库才会被自动创建。你可以使用spring.jpa.*属性显示的设置JPA。比如为了创建和删除表你可以将下面的配置添加到application.properties中
```java
spring.jpa.hibernate.ddl-auto=create-drop
```
**注**Hibernate自己内部对创建删除表支持如果你恰好记得这回事更好的属性是hibernate.hbm2ddl.auto。使用spring.jpa.properties.*前缀在被添加到实体管理器之前会被剥离掉你可以设置Hibernate本身的属性比如hibernate.hbm2ddl.auto。示例`spring.jpa.properties.hibernate.globally_quoted_identifiers=true`将传递hibernate.globally_quoted_identifiers到Hibernate实体管理器。
默认情况下DDL执行或验证被延迟到ApplicationContext启动。这也有一个spring.jpa.generate-ddl标识如果Hibernate自动配置被激活那该标识就不会被使用因为ddl-auto设置粒度更细。
### 使用NoSQL技术
Spring Data提供其他项目用来帮你使用各种各样的NoSQL技术包括[MongoDB](http://projects.spring.io/spring-data-mongodb/), [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提供自动配置。你可以充分利用其他项目但你需要自己配置它们。具体查看[projects.spring.io/spring-data.](http://projects.spring.io/spring-data/)中合适的参考文档。
* Redis
[Redis](http://redis.io/)是一个缓存消息中间件及具有丰富特性的键值存储系统。Spring Boot为[Jedis](https://github.com/xetorthio/jedis/)客户端库和由[Spring Data Redis](https://github.com/spring-projects/spring-data-redis)提供的基于Jedis客户端的抽象提供自动配置。`spring-boot-starter-redis`'Starter POM'为收集依赖提供一种便利的方式。
1. 连接Redis
你可以注入一个自动配置的RedisConnectionFactoryStringRedisTemplate或普通的跟其他Spring Bean相同的RedisTemplate实例。默认情况下这个实例将尝试使用localhost:6379连接Redis服务器。
```java
@Component
public class MyBean {
private StringRedisTemplate template;
@Autowired
public MyBean(StringRedisTemplate template) {
this.template = template;
}
// ...
}
```
如果你添加一个你自己的任何自动配置类型的@Bean它将替换默认的除了RedisTemplate的情况它是根据bean的名称'redisTemplate'而不是它的类型进行排除的。如果在classpath路径下存在commons-pool2默认你会获得一个连接池工厂。
* MongoDB
[MongoDB](http://www.mongodb.com/)是一个开源的NoSQL文档数据库它使用一个JSON格式的模式schema替换了传统的基于表的关系数据。Spring Boot为使用MongoDB提供了很多便利包括`spring-boot-starter-data-mongodb`'Starter POM'。
**1. 连接MongoDB数据库**
你可以注入一个自动配置的`org.springframework.data.mongodb.MongoDbFactory`来访问Mongo数据库。默认情况下该实例将尝试使用URL`mongodb://localhost/test`连接一个MongoDB服务器。
```java
import org.springframework.data.mongodb.MongoDbFactory;
import com.mongodb.DB;
@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或指定一个host/port。比如你可能会在你的application.properties中设置如下的属性
```java
spring.data.mongodb.host=mongoserver
spring.data.mongodb.port=27017
```
**注**:如果没有指定`spring.data.mongodb.port`那将使用默认的端口27017。你可以简单的从上面的示例中删除这一行。如果不使用Spring Data Mongo你可以注入com.mongodb.Mongo beans而不是使用MongoDbFactory。
如果想全面控制MongoDB连接的建立你也可以声明自己的MongoDbFactory或Mongo@Beans
**2. MongoDBTemplate**
Spring Data Mongo提供了一个[MongoTemplate](http://docs.spring.io/spring-data/mongodb/docs/current/api/org/springframework/data/mongodb/core/MongoTemplate.html)类它的设计和Spring的JdbcTemplate很相似。正如JdbcTemplate一样Spring Boot会为你自动配置一个bean你只需简单的注入它即可
```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仓库基本的原则是查询会自动基于你的方法名创建。
实际上不管是Spring Data JPA还是Spring Data MongoDB都共享相同的基础设施。所以你可以使用上面的JPA示例并假设那个City现在是一个Mongo数据类而不是JPA @Entity它将以同样的方式工作。
```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);
}
```
* Gemfire
[Spring Data Gemfire](https://github.com/spring-projects/spring-data-gemfire)为使用[Pivotal Gemfire](http://www.pivotal.io/big-data/pivotal-gemfire#details)数据管理平台提供了方便的Spring友好的工具。Spring Boot提供了一个用于聚集依赖的`spring-boot-starter-data-gemfire`'Starter POM'。目前不支持Gemfire的自动配置但你可以使用一个[单一的注解](https://github.com/spring-projects/spring-data-gemfire/blob/master/src/main/java/org/springframework/data/gemfire/repository/config/EnableGemfireRepositories.java)使Spring Data仓库支持它。
* Solr
[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实例。默认情况下该实例将尝试使用`localhost:8983/solr`连接一个服务器。
```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 JPA还是Spring Data Solr都共享相同的基础设施。所以你可以使用上面的JPA示例并假设那个City现在是一个@SolrDocument类而不是JPA @Entity它将以同样的方式工作。
**注**:具体参考[Spring Data Solr文档](http://projects.spring.io/spring-data-solr/)。
* Elasticsearch
[Elastic Search](http://www.elasticsearch.org/)是一个开源的分布式实时搜索和分析引擎。Spring Boot为Elasticsearch及[Spring Data Elasticsearch](https://github.com/spring-projects/spring-data-elasticsearch)提供的基于它的抽象提供了基本的配置。Spring Boot提供了一个用于聚集依赖的`spring-boot-starter-data-elasticsearch`'Starter POM'。
**1. 连接Elasticsearch**
你可以像其他Spring beans那样注入一个自动配置的ElasticsearchTemplate或Elasticsearch客户端实例。默认情况下该实例将尝试连接到一个本地内存服务器在Elasticsearch项目中的一个NodeClient但你可以通过设置`spring.data.elasticsearch.clusterNodes`为一个以逗号分割的host:port列表来将其切换到一个远程服务器比如TransportClient
```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仓库基本的原则是查询会自动基于你的方法名创建。
实际上不管是Spring Data JPA还是Spring Data Elasticsearch都共享相同的基础设施。所以你可以使用上面的JPA示例并假设那个City现在是一个Elasticsearch @Document类而不是JPA @Entity它将以同样的方式工作。
**注**:具体参考[Spring Data Elasticsearch文档](http://docs.spring.io/spring-data/elasticsearch/docs/)。
### 消息
* JMS
1. HornetQ支持
2. ActiveQ支持
3. 使用JNDI ConnectionFactory
4. 发送消息
5. 接收消息
### 发送邮件
### 使用JTA处理分布式事务
* 使用一个Atomikos事务管理器
* 使用一个Bitronix事务管理器
* 使用一个J2EE管理的事务管理器
* 混合XA和non-XA的JMS连接
* 支持可替代的内嵌事务管理器
### Spring集成
### 基于JMX的监控和管理
### 测试
* 测试作用域依赖
* 测试Spring应用
* 测试Spring Boot应用
1. 使用Spock测试Spring Boot应用
* 测试工具
1. ConfigFileApplicationContextInitializer
2. EnvironmentTestUtils
3. OutputCapture
4. TestRestTemplate
### 开发自动配置和使用条件
* 理解auto-configured beans
* 定位auto-configuration候选者
* Condition注解
1. Class条件
2. Bean条件
3. Property条件
4. Resource条件
5. Web Application条件
6. SpEL表达式条件
### WebSockets