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/)。
-
-### 消息
-
-Spring Framework框架为集成消息系统提供了扩展（extensive）支持：从使用JmsTemplate简化JMS API，到实现一个完整异步消息接收的底层设施。Spring AMQP提供一个相似的用于'高级消息队列协议'的特征集，并且Spring Boot也为RabbitTemplate和RabbitMQ提供了自动配置选项。Spring Websocket提供原生的STOMP消息支持，并且Spring Boot通过starters和一些自动配置也提供了对它的支持。
-
-* JMS
-
-javax.jms.ConnectionFactory接口提供了一个标准的用于创建一个javax.jms.Connection的方法，javax.jms.Connection用于和JMS代理（broker）交互。尽管为了使用JMS，Spring需要一个ConnectionFactory，但通常你不需要直接使用它，而是依赖于上层消息抽象（具体参考Spring框架的[相关章节](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#jms)）。Spring Boot也会自动配置发送和接收消息需要的设施（infrastructure）。
-
- 1. HornetQ支持
-
-如果在classpath下发现HornetQ，Spring Boot会自动配置ConnectionFactory。如果需要代理，将会开启一个内嵌的，已经自动配置好的代理（除非显式设置mode属性）。支持的modes有：embedded（显式声明使用一个内嵌的代理，如果该代理在classpath下不可用将导致一个错误），native（使用netty传输协议连接代理）。当后者被配置，Spring Boot配置一个连接到一个代理的ConnectionFactory，该代理运行在使用默认配置的本地机器上。
-
-**注**：如果使用spring-boot-starter-hornetq，连接到一个已存在的HornetQ实例所需的依赖都会被提供，同时还有用于集成JMS的Spring基础设施。将org.hornetq:hornetq-jms-server添加到你的应用中，你就可以使用embedded模式。
-
-HornetQ配置被spring.hornetq.*中的外部配置属性所控制。例如，你可能在application.properties声明以下片段：
-```java
-spring.hornetq.mode=native
-spring.hornetq.host=192.168.1.210
-spring.hornetq.port=9876
-```
-当内嵌代理时，你可以选择是否启用持久化，并且列表中的目标都应该是可用的。这些可以通过一个以逗号分割的列表来指定一些默认的配置项，或定义org.hornetq.jms.server.config.JMSQueueConfiguration或org.hornetq.jms.server.config.TopicConfiguration类型的bean(s)来配置更高级的队列和主题。具体参考[HornetQProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jms/hornetq/HornetQProperties.java)。
-
-没有涉及JNDI查找，目标是通过名字解析的，名字即可以使用HornetQ配置中的name属性，也可以是配置中提供的names。
-
- 2. ActiveQ支持
-
-如果发现ActiveMQ在classpath下可用，Spring Boot会配置一个ConnectionFactory。如果需要代理，将会开启一个内嵌的，已经自动配置好的代理（只要配置中没有指定代理URL）。
-
-ActiveMQ配置是通过spring.activemq.*中的外部配置来控制的。例如，你可能在application.properties中声明下面的片段：
-```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)。
-
-默认情况下，如果目标还不存在，ActiveMQ将创建一个，所以目标是通过它们提供的名称解析出来的。
-
- 3. 使用JNDI ConnectionFactory
-
-如果你在一个应用服务器中运行你的应用，Spring Boot将尝试使用JNDI定位一个JMS ConnectionFactory。默认情况会检查java:/JmsXA和java:/
-XAConnectionFactory。如果需要的话，你可以使用spring.jms.jndi-name属性来指定一个替代位置。
-```java
-spring.jms.jndi-name=java:/MyConnectionFactory
-```
- 4. 发送消息
-
-Spring的JmsTemplate会被自动配置，你可以将它直接注入到你自己的beans中：
-```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;
-}
-// ...
-}
-```
-
-**注**：[JmsMessagingTemplate](http://docs.spring.io/spring/docs/4.1.4.RELEASE/javadoc-api/org/springframework/jms/core/JmsMessagingTemplate.html)(Spring4.1新增的)也可以使用相同的方式注入。
-
- 5. 接收消息
-
-当JMS基础设施能够使用时，任何bean都能够被@JmsListener注解，以创建一个监听者端点。如果没有定义JmsListenerContainerFactory，一个默认的将会被自动配置。下面的组件在someQueue目标上创建一个监听者端点。
-```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)。
-
-### 发送邮件
-
-Spring框架使用JavaMailSender接口为发送邮件提供了一个简单的抽象，并且Spring Boot也为它提供了自动配置和一个starter模块。
-具体查看[JavaMailSender参考文档](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#mail)。
-
-如果spring.mail.host和相关的库（通过spring-boot-starter-mail定义）都存在，一个默认的JavaMailSender将被创建。该sender可以通过spring.mail命名空间下的配置项进一步自定义，具体参考[MailProperties](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/mail/MailProperties.java)。
-
-### 使用JTA处理分布式事务
-
-Spring Boot使用一个[Atomkos](http://www.atomikos.com/)或[Bitronix](http://docs.codehaus.org/display/BTM/Home)的内嵌事务管理器来支持跨多个XA资源的分布式JTA事务。当部署到一个恰当的J2EE应用服务器时也会支持JTA事务。
-
-当发现一个JTA环境时，Spring Boot将使用Spring的JtaTransactionManager来管理事务。自动配置的JMS，DataSource和JPA beans将被升级以支持XA事务。你可以使用标准的Spring idioms，比如@Transactional，来参与到一个分布式事务中。如果你处于JTA环境里，但仍旧想使用本地事务，你可以将spring.jta.enabled属性设置为false来禁用JTA自动配置功能。
-
-* 使用一个Atomikos事务管理器
-
-Atomikos是一个非常流行的开源事务管理器，它可以嵌入到你的Spring Boot应用中。你可以使用`spring-boot-starter-jta-atomikos`Starter POM去获取正确的Atomikos库。Spring Boot会自动配置Atomikos，并将合适的depends-on应用到你的Spring Beans上，确保它们以正确的顺序启动和关闭。
-
-默认情况下，Atomikos事务日志将被记录在应用home目录（你的应用jar文件放置的目录）下的transaction-logs文件夹中。你可以在application.properties文件中通过设置spring.jta.log-dir属性来自定义该目录。以spring.jta.开头的属性能用来自定义Atomikos的UserTransactionServiceIml实现。具体参考[AtomikosProperties javadoc](http://docs.spring.io/spring-boot/docs/1.2.2.BUILD-SNAPSHOT/api/org/springframework/boot/jta/atomikos/AtomikosProperties.html)。
-
-**注**：为了确保多个事务管理器能够安全地和相应的资源管理器配合，每个Atomikos实例必须设置一个唯一的ID。默认情况下，该ID是Atomikos实例运行的机器上的IP地址。为了确保生产环境中该ID的唯一性，你需要为应用的每个实例设置不同的spring.jta.transaction-manager-id属性值。
-
-* 使用一个Bitronix事务管理器
-
-Bitronix是另一个流行的开源JTA事务管理器实现。你可以使用`spring-boot-starter-jta-bitronix`starter POM为项目添加合适的Birtronix依赖。和Atomikos类似，Spring Boot将自动配置Bitronix，并对beans进行后处理（post-process）以确保它们以正确的顺序启动和关闭。
-
-默认情况下，Bitronix事务日志将被记录到应用home目录下的transaction-logs文件夹中。通过设置spring.jta.log-dir属性，你可以自定义该目录。以spring.jta.开头的属性将被绑定到bitronix.tm.Configuration bean，你可以通过这完成进一步的自定义。具体参考[Bitronix文档](http://btm.codehaus.org/api/2.0.1/bitronix/tm/Configuration.html)。
-
-**注**：为了确保多个事务管理器能够安全地和相应的资源管理器配合，每个Bitronix实例必须设置一个唯一的ID。默认情况下，该ID是Bitronix实例运行的机器上的IP地址。为了确保生产环境中该ID的唯一性，你需要为应用的每个实例设置不同的spring.jta.transaction-manager-id属性值。
-
-* 使用一个J2EE管理的事务管理器
-
-如果你将Spring Boot应用打包为一个war或ear文件，并将它部署到一个J2EE的应用服务器中，那你就能使用应用服务器内建的事务管理器。Spring Boot将尝试通过查找常见的JNDI路径（java:comp/UserTransaction, java:comp/TransactionManager等）来自动配置一个事务管理器。如果使用应用服务器提供的事务服务，你通常需要确保所有的资源都被应用服务器管理，并通过JNDI暴露出去。Spring Boot通过查找JNDI路径java:/JmsXA或java:/XAConnectionFactory获取一个ConnectionFactory来自动配置JMS，并且你可以使用spring.datasource.jndi-name属性配置你的DataSource。
-
-* 混合XA和non-XA的JMS连接
-
-当使用JTA时，主要的JMS ConnectionFactory bean将是XA aware，并参与到分布式事务中。有些情况下，你可能需要使用non-XA的ConnectionFactory去处理一些JMS消息。例如，你的JMS处理逻辑可能比XA超时时间长。
-
-如果想使用一个non-XA的ConnectionFactory，你可以注入nonXaJmsConnectionFactory bean而不是@Primary jmsConnectionFactory bean。为了保持一致，jmsConnectionFactory bean将以别名xaJmsConnectionFactor来被使用。
-
-示例如下：
-```java
-// 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;
-```
-* 支持可替代的内嵌事务管理器
-
-[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 beans，并将它们暴露为普通的ConnectionFactory和DataSource beans，这样在分布式事务中可以透明使用。
-
-### Spring集成
-
-Spring集成提供基于消息和其他协议的，比如HTTP，TCP等的抽象。如果Spring集成在classpath下可用，它将会通过@EnableIntegration注解被初始化。如果classpath下'spring-integration-jmx'可用，则消息处理统计分析将被通过JMX发布出去。具体参考[IntegrationAutoConfiguration类](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/integration/IntegrationAutoConfiguration.java)。
-
-### 基于JMX的监控和管理
-
-Java管理扩展（JMX）提供了一个标准的用于监控和管理应用的机制。默认情况下，Spring Boot将创建一个id为‘mbeanServer’的MBeanServer，并导出任何被Spring JMX注解（@ManagedResource,@ManagedAttribute,@ManagedOperation）的beans。具体参考[JmxAutoConfiguration类](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-autoconfigure/src/main/java/org/springframework/boot/autoconfigure/jmx/JmxAutoConfiguration.java)。
-
-### 测试
-
-Spring Boot提供很多有用的测试应用的工具。spring-boot-starter-test POM提供Spring Test，JUnit，Hamcrest和Mockito的依赖。在spring-boot核心模块org.springframework.boot.test包下也有很多有用的测试工具。
-
-* 测试作用域依赖
-
-如果使用spring-boot-starter-test ‘Starter POM’（在test作用域内），你将发现下列被提供的库：
-- Spring Test - 对Spring应用的集成测试支持
-- JUnit - 事实上的（de-facto）标准，用于Java应用的单元测试。
-- Hamcrest - 一个匹配对象的库（也称为约束或前置条件），它允许assertThat等JUnit类型的断言。
-- Mockito - 一个Java模拟框架。
-
-这也有一些我们写测试用例时经常用到的库。如果它们不能满足你的要求，你可以随意添加其他的测试用的依赖库。
-
-* 测试Spring应用
-
-依赖注入最大的优点就是它能够让你的代码更容易进行单元测试。你只需简单的通过new操作符实例化对象，而不需要涉及Spring。你也可以使用模拟对象替换真正的依赖。
-
-你常常需要在进行单元测试后，开始集成测试（在这个过程中只需要涉及到Spring的ApplicationContext）。在执行集成测试时，不需要部署应用或连接到其他基础设施是非常有用的。
-
-Spring框架包含一个dedicated测试模块，用于这样的集成测试。你可以直接声明对org.springframework:spring-test的依赖，或使用spring-boot-starter-test ‘Starter POM’以透明的方式拉取它。
-
-如果你以前没有使用过spring-test模块，可以查看Spring框架参考文档中的[相关章节](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#testing)。
-
-* 测试Spring Boot应用
-
-一个Spring Boot应用只是一个Spring ApplicationContext，所以在测试它时除了正常情况下处理一个vanilla Spring context外不需要做其他特别事情。唯一需要注意的是，如果你使用SpringApplication创建上下文，外部配置，日志和Spring Boot的其他特性只会在默认的上下文中起作用。
-
-Spring Boot提供一个@SpringApplicationConfiguration注解用来替换标准的spring-test @ContextConfiguration注解。如果使用@SpringApplicationConfiguration来设置你的测试中使用的ApplicationContext，它最终将通过SpringApplication创建，并且你将获取到Spring Boot的其他特性。
-
-示例如下：
-```java
-@RunWith(SpringJUnit4ClassRunner.class)
-@SpringApplicationConfiguration(classes = SampleDataJpaApplication.class)
-public class CityRepositoryIntegrationTests {
-@Autowired
-CityRepository repository;
-// ...
-}
-```
-**提示**：上下文加载器会通过查找@WebIntegrationTest或@WebAppConfiguration注解来猜测你想测试的是否是web应用（例如，是否使用MockMVC，MockMVC和@WebAppConfiguration是spring-test的一部分）。
-
-如果想让一个web应用启动，并监听它的正常的端口，你可以使用HTTP来测试它（比如，使用RestTemplate），并使用@WebIntegrationTest注解你的测试类（或它的一个父类）。这很有用，因为它意味着你可以对你的应用进行全栈测试，但在一次HTTP交互后，你需要在你的测试类中注入相应的组件并使用它们断言应用的内部状态。
-
-示例：
-```java
-@RunWith(SpringJUnit4ClassRunner.class)
-@SpringApplicationConfiguration(classes = SampleDataJpaApplication.class)
-@WebIntegrationTest
-public class CityRepositoryIntegrationTests {
-@Autowired
-CityRepository repository;
-RestTemplate restTemplate = new TestRestTemplate();
-// ... interact with the running server
-}
-```
-**注**：Spring测试框架在每次测试时会缓存应用上下文。因此，只要你的测试共享相同的配置，不管你实际运行多少测试，开启和停止服务器只会发生一次。
-
-你可以为@WebIntegrationTest添加环境变量属性来改变应用服务器端口号，比如@WebIntegrationTest("server.port:9000")。此外，你可以将server.port和management.port属性设置为０来让你的集成测试使用随机的端口号，例如：
-```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应用，你应该将Spock的spock-spring模块依赖添加到应用的构建中。spock-spring将Spring的测试框架集成到了Spock里。
-
-注意你不能使用上述提到的@SpringApplicationConfiguration注解，因为[Spock找不到@ContextConfiguration元注解](https://code.google.com/p/spock/issues/detail?id=349)。为了绕过该限制，你应该直接使用@ContextConfiguration注解，并使用Spring Boot特定的上下文加载器来配置它。
-```java
-@ContextConfiguration(loader = SpringApplicationContextLoader.class)
-class ExampleSpec extends Specification {
-// ...
-}
-```
-**注**：上面描述的注解在Spock中可以使用，比如，你可以使用@WebIntegrationTest注解你的Specification以满足测试需要。
-
-* 测试工具
-
-打包进spring-boot的一些有用的测试工具类。
-
-1. ConfigFileApplicationContextInitializer
-
-ConfigFileApplicationContextInitializer是一个ApplicationContextInitializer，可以用来测试加载Spring Boot的application.properties文件。当不需要使用@SpringApplicationConfiguration提供的全部特性时，你可以使用它。
-
-```java
-@ContextConfiguration(classes = Config.class,initializers = ConfigFileApplicationContextInitializer.class)
-```
-2. EnvironmentTestUtils
-
-EnvironmentTestUtils允许你快速添加属性到一个ConfigurableEnvironment或ConfigurableApplicationContext。只需简单的使用key=value字符串调用它：
-```java
-EnvironmentTestUtils.addEnvironment(env, "org=Spring", "name=Boot");
-```
-3. OutputCapture
-
-OutputCapture是一个JUnit Rule，用于捕获System.out和System.err输出。只需简单的将捕获声明为一个@Rule，并使用toString()断言：
-```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认证（使用用户名和密码）的模板。在任何情况下，这些模板都表现出对测试友好：不允许重定向（这样你可以对响应地址进行断言），忽略cookies（这样模板就是无状态的），对于服务端错误不会抛出异常。推荐使用Apache HTTP Client(4.3.2或更好的版本)，但不强制这样做。如果在classpath下存在Apache HTTP Client，TestRestTemplate将以正确配置的client进行响应。
-```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"));
-}
-}
-```
-
-### 开发自动配置和使用条件
-
-如果你在一个开发者共享库的公司工作，或你在从事一个开源或商业型的库，你可能想要开发自己的auto-configuration。Auto-configuration类能够在外部的jars中绑定，并仍能被Spring Boot发现。
-
-* 理解auto-configured beans
-
-从底层来讲，auto-configured是使用标准的@Configuration实现的类，另外的@Conditional注解用来约束在什么情况下使用auto-configuration。通常auto-configuration类使用@ConditionalOnClass和@ConditionalOnMissingBean注解。这是为了确保只有在相关的类被发现，和你没有声明自己的@Configuration时才应用auto-configuration。
-
-你可以浏览spring-boot-autoconfigure的源码，查看我们提供的@Configuration类（查看META-INF/spring.factories文件）。
-
-* 定位auto-configuration候选者
-
-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)注解。例如，你想提供web-specific配置，你的类就需要应用在WebMvcAutoConfiguration后面。
-
-* Condition注解
-
-你几乎总是需要在你的auto-configuration类里添加一个或更多的@Condition注解。@ConditionalOnMissingBean注解是一个常见的示例，它经常用于允许开发者覆盖auto-configuration，如果他们不喜欢你提供的默认行为。
-
-Spring Boot包含很多@Conditional注解，你可以在自己的代码中通过注解@Configuration类或单独的@Bean方法来重用它们。
-
-1. Class条件
-
-@ConditionalOnClass和@ConditionalOnMissingClass注解允许根据特定类是否出现来跳过配置。由于注解元数据是使用[ASM](http://asm.ow2.org/)来解析的，你实际上可以使用value属性来引用真正的类，即使该类可能实际上并没有出现在运行应用的classpath下。如果你倾向于使用一个String值来指定类名，你也可以使用name属性。
-
-2. Bean条件
-
-@ConditionalOnBean和@ConditionalOnMissingBean注解允许根据特定beans是否出现来跳过配置。你可以使用value属性来指定beans（by type），也可以使用name来指定beans（by name）。search属性允许你限制搜索beans时需要考虑的ApplicationContext的层次。
-
-**注**：当@Configuration类被解析时@Conditional注解会被处理。Auto-configure @Configuration总是最后被解析（在所有用户定义beans后面），然而，如果你将那些注解用到常规的@Configuration类，需要注意不能引用那些还没有创建好的bean定义。
-
-3. Property条件
-
-@ConditionalOnProperty注解允许根据一个Spring Environment属性来决定是否包含配置。可以使用prefix和name属性指定要检查的配置属性。默认情况下，任何存在的只要不是false的属性都会匹配。你也可以使用havingValue和matchIfMissing属性创建更高级的检测。
-
-4. Resource条件
-
-@ConditionalOnResource注解允许只有在特定资源出现时配置才会被包含。资源可以使用常见的Spring约定命名，例如file:/home/user/test.dat。
-
-5. Web Application条件
-
-@ConditionalOnWebApplication和@ConditionalOnNotWebApplication注解允许根据应用是否为一个'web应用'来决定是否包含配置。一个web应用是任何使用Spring WebApplicationContext，定义一个session作用域或有一个StandardServletEnvironment的应用。
-
-6. SpEL表达式条件
-
-@ConditionalOnExpression注解允许根据[SpEL表达式](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#expressions)结果来跳过配置。
-
-### WebSockets
-
-Spring Boot为内嵌的Tomcat(8和7)，Jetty 9和Undertow提供WebSockets自动配置。如果你正在将一个war包部署到一个单独的容器，Spring Boot会假设该容器会对它的WebSocket支持相关的配置负责。
-
-Spring框架提供[丰富的WebSocket支持](http://docs.spring.io/spring/docs/4.1.4.RELEASE/spring-framework-reference/htmlsingle/#websocket)，通过spring-boot-starter-websocket模块可以轻易获取到。
-
diff --git a/all in one/spring_boot_start.md b/all in one/spring_boot_start.md
deleted file mode 100644
index 88276420..00000000
--- a/all in one/spring_boot_start.md
+++ /dev/null
@@ -1,113 +0,0 @@
-Spring Boot初级教程
-=======================
-
-### 一. Spring Boot安装
-环境要求：Java 8，Maven 3.2或Gradle 1.12
-
-#### 1.Maven方式
-
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-xsi:schemaLocation="http://maven.apache.org/POM/4.0.0%20-%20%20%20%20http://maven.apache.org/xsd/maven-4.0.0.xsd">
-
- <modelVersion>4.0.0</modelVersion>
- <groupId>com.example</groupId>
- <artifactId>myproject</artifactId>
- <version>0.0.1-SNAPSHOT</version>
-
- <!-- Inherit defaults from Spring Boot -->
- <parent>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-parent</artifactId>
- <version>1.2.1.RELEASE</version>
- </parent>
-
- <!-- Add typical dependencies for a web application -->
- <dependencies>
- <dependency>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-starter-web</artifactId>
- </dependency>
- </dependencies>
-
- <!-- Package as an executable jar -->
- <build>
- <plugins>
- <plugin>
- <groupId>org.springframework.boot</groupId>
- <artifactId>spring-boot-maven-plugin</artifactId>
- </plugin>
- </plugins>
- </build>
-</project>
-
-注：Spring Boot依赖的groupId是org.springframework.boot，一般Maven pom需要继承spring-boot-starter-parent，然后声明相应[Starter POMs](http://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#using-boot-starter-poms).如果不想继承spring-boot-starter-parent，可以使用import作用域。
-
-#### 2.Gradle方式
-
-build.gradle脚本：
-
-buildscript {
- repositories {
- jcenter()
- maven { url "http://repo.spring.io/snapshot" }
- maven { url "http://repo.spring.io/milestone" }
- }
- dependencies {
- classpath("org.springframework.boot:spring-boot-gradle-plugin:1.2.2.BUILD-SNAPSHOT")
- }
-}
-
-apply plugin: 'java'
-apply plugin: 'spring-boot'
-
-jar {
- baseName = 'myproject'
- version = '0.0.1-SNAPSHOT'
-}
-
-repositories {
- jcenter()
- maven { url "http://repo.spring.io/snapshot" }
- maven { url "http://repo.spring.io/milestone" }
-}
-
-dependencies {
- compile("org.springframework.boot:spring-boot-starter-web")
- testCompile("org.springframework.boot:spring-boot-starter-test")
-}
-
-
-#### 3.安装Spring Boot命令行工具
-
-
-$ gvm install springboot
-$ spring --version
-$ gvm ls springboot
-$ . ~/.gvm/springboot/current/shell-completion/bash/spring
-$ spring
- grab help jar run test version
-
-
-#### 4.Quick Start
-
-创建app.groovy，代码如下：
-
-@RestController
-class ThisWillActuallyRun {
- @RequestMapping("/")
- String home() {
- "Hello World!"
- }
-}
-
-运行：
-
-$ spring run app.groovy
-
-
-
-
-
diff --git a/all in one/using_spring_boot.md b/all in one/using_spring_boot.md
deleted file mode 100644
index e4dd83f6..00000000
--- a/all in one/using_spring_boot.md
+++ /dev/null
@@ -1,388 +0,0 @@
-### 使用Spring Boot
-本章节将会详细介绍如何使用Spring Boot。它覆盖了构建系统，自动配置和运行/部署选项等主题。我们也覆盖了一些Spring Boot最佳实践。尽管Spring Boot没有什么特别的（只是一个你能消费的库），但仍有一些建议，如果你遵循的话将会让你的开发进程更容易。
-
-如果你刚接触Spring Boot，那最好先读下上一章节的[Getting Started](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started)指南。
-
-### 构建系统
-
-强烈建议你选择一个支持依赖管理，能消费发布到Maven中央仓库的artifacts的构建系统。我们推荐你选择Maven或Gradle。选择其他构建系统来使用Spring Boot也是可能的（比如Ant），但它们不会被很好的支持。
-
-* Maven
-
-Maven用户可以继承`spring-boot-starter-parent`项目来获取合适的默认设置。该父项目提供以下特性：
-- 默认编译级别为Java 1.6
-- 源码编码为UTF-8
-- 一个依赖管理节点，允许你省略普通依赖的``标签，继承自`spring-boot-dependencies` POM。
-- 合适的[资源过滤](https://maven.apache.org/plugins/maven-resources-plugin/examples/filter.html)
-- 合适的插件配置（[exec插件](http://mojo.codehaus.org/exec-maven-plugin/)，[surefire](http://maven.apache.org/surefire/maven-surefire-plugin/)，[Git commit ID](https://github.com/ktoso/maven-git-commit-id-plugin)，[shade](http://maven.apache.org/plugins/maven-shade-plugin/)）
-- 针对`application.properties`和`application.yml`的资源过滤
-
-最后一点：由于默认配置文件接收Spring风格的占位符（`${...}`），Maven filtering改用`@..@`占位符（你可以使用Maven属性`resource.delimiter`来覆盖它）。
-
-* 继承starter parent
-
-想配置你的项目继承`spring-boot-starter-parent`只需要简单地设置`parent`为：
-```xml
-
-
- org.springframework.boot
- spring-boot-starter-parent
- 1.3.0.BUILD-SNAPSHOT
-
-```
-**注**：你应该只需要在该依赖上指定Spring Boot版本。如果导入其他的starters，你可以放心的省略版本号。
-
-* 使用没有父POM的Spring Boot
-
-不是每个人都喜欢继承`spring-boot-starter-parent` POM。你可能需要使用公司标准parent，或你可能倾向于显式声明所有Maven配置。
-
-如果你不使用`spring-boot-starter-parent`，通过使用一个`scope=import`的依赖，你仍能获取到依赖管理的好处：
-```xml
-
-
-
-
- org.springframework.boot
- spring-boot-dependencies
- 1.3.0.BUILD-SNAPSHOT
- pom
- import
-
-
-
-```
-* 改变Java版本
-
-`spring-boot-starter-parent`选择相当保守的Java兼容策略。如果你遵循我们的建议，使用最新的Java版本，你可以添加一个`java.version`属性：
-```xml
-
- 1.8
-
-```
-* 使用Spring Boot Maven插件
-
-Spring Boot包含一个[Maven插件](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#build-tool-plugins-maven-plugin)，它可以将项目打包成一个可执行jar。如果想使用它，你可以将该插件添加到``节点处：
-```xml
-
-
-
- org.springframework.boot
- spring-boot-maven-plugin
-
-
-
-```
-**注**：如果使用Spring Boot starter parent pom，你只需要添加该插件而无需配置它，除非你想改变定义在partent中的设置。
-
-* Gradle
-
-Gradle用户可以直接在它们的`dependencies`节点处导入”starter POMs“。跟Maven不同的是，这里没有用于导入共享配置的"超父"（super parent）。
-```gradle
-apply plugin: 'java'
-
-repositories { jcenter() }
-dependencies {
- compile("org.springframework.boot:spring-boot-starter-web:1.3.0.BUILD-SNAPSHOT")
-}
-```
-[spring-boot-gradle-plugin](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#build-tool-plugins-gradle-plugin)插件也是可以使用的，它提供创建可执行jar和从source运行项目的任务。它也添加了一个`ResolutionStrategy`用于让你省略常用依赖的版本号：
-```gradle
-buildscript {
- repositories { jcenter() }
- dependencies {
- classpath("org.springframework.boot:spring-boot-gradle-plugin:1.3.0.BUILD-SNAPSHOT")
- }
-}
-
-apply plugin: 'java'
-apply plugin: 'spring-boot'
-
-repositories { jcenter() }
-dependencies {
- compile("org.springframework.boot:spring-boot-starter-web")
- testCompile("org.springframework.boot:spring-boot-starter-test")
-}
-```
-* Ant
-
-使用Apache Ant构建一个Spring Boot项目是完全可能的，然而，Spring Boot没有为它提供特殊的支持或插件。Ant脚本可以使用Ivy依赖管理系统来导入starter POMs。
-
-查看[Section 73.8, “Build an executable archive with Ant”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-build-an-executable-archive-with-ant)获取更多指导。
-
-* Starter POMs
-
-Starter POMs是可以包含到应用中的一个方便的依赖关系描述符集合。你可以获取所有Spring及相关技术的一站式服务，而不需要翻阅示例代码，拷贝粘贴大量的依赖描述符。例如，如果你想使用Spring和JPA进行数据库访问，只需要在你的项目中包含`spring-boot-starter-data-jpa`依赖，然后你就可以开始了。
-
-该starters包含很多你搭建项目，快速运行所需的依赖，并提供一致的，管理的传递依赖集。
-
-**名字有什么含义**：所有的starters遵循一个相似的命名模式：`spring-boot-starter-*`，在这里`*`是一种特殊类型的应用程序。该命名结构旨在帮你找到需要的starter。很多IDEs集成的Maven允许你通过名称搜索依赖。例如，使用相应的Eclipse或STS插件，你可以简单地在POM编辑器中点击`ctrl-space`，然后输入"spring-boot-starter"可以获取一个完整列表。
-
-下面的应用程序starters是Spring Boot在`org.springframework.boot`组下提供的：
-
-**表 13.1. Spring Boot application starters**
-
-|名称|描述|
-|------|:-----|
-|spring-boot-starter|核心Spring Boot starter，包括自动配置支持，日志和YAML|
-|spring-boot-starter-actuator|生产准备的特性，用于帮你监控和管理应用|
-|spring-boot-starter-amqp|对"高级消息队列协议"的支持，通过`spring-rabbit`实现|
-|spring-boot-starter-aop|对面向切面编程的支持，包括`spring-aop`和AspectJ|
-|spring-boot-starter-batch|对Spring Batch的支持，包括HSQLDB数据库|
-|spring-boot-starter-cloud-connectors|对Spring Cloud Connectors的支持，简化在云平台下（例如，Cloud Foundry 和Heroku）服务的连接|
-|spring-boot-starter-data-elasticsearch|对Elasticsearch搜索和分析引擎的支持，包括`spring-data-elasticsearch`|
-|spring-boot-starter-data-gemfire|对GemFire分布式数据存储的支持，包括`spring-data-gemfire`|
-|spring-boot-starter-data-jpa|对"Java持久化API"的支持，包括`spring-data-jpa`，`spring-orm`和Hibernate|
-|spring-boot-starter-data-mongodb|对MongoDB NOSQL数据库的支持，包括`spring-data-mongodb`|
-|spring-boot-starter-data-rest|对通过REST暴露Spring Data仓库的支持，通过`spring-data-rest-webmvc`实现|
-|spring-boot-starter-data-solr|对Apache Solr搜索平台的支持，包括`spring-data-solr`|
-|spring-boot-starter-freemarker|对FreeMarker模板引擎的支持|
-|spring-boot-starter-groovy-templates|对Groovy模板引擎的支持|
-|spring-boot-starter-hateoas|对基于HATEOAS的RESTful服务的支持，通过`spring-hateoas`实现|
-|spring-boot-starter-hornetq|对"Java消息服务API"的支持，通过HornetQ实现|
-|spring-boot-starter-integration|对普通`spring-integration`模块的支持|
-|spring-boot-starter-jdbc|对JDBC数据库的支持|
-|spring-boot-starter-jersey|对Jersey RESTful Web服务框架的支持|
-|spring-boot-starter-jta-atomikos|对JTA分布式事务的支持，通过Atomikos实现|
-|spring-boot-starter-jta-bitronix|对JTA分布式事务的支持，通过Bitronix实现|
-|spring-boot-starter-mail|对`javax.mail`的支持|
-|spring-boot-starter-mobile|对`spring-mobile`的支持|
-|spring-boot-starter-mustache|对Mustache模板引擎的支持|
-|spring-boot-starter-redis|对REDIS键值数据存储的支持，包括`spring-redis`|
-|spring-boot-starter-security|对`spring-security`的支持|
-|spring-boot-starter-social-facebook|对`spring-social-facebook`的支持|
-|spring-boot-starter-social-linkedin|对`spring-social-linkedin`的支持|
-|spring-boot-starter-social-twitter|对`spring-social-twitter`的支持|
-|spring-boot-starter-test|对常用测试依赖的支持，包括JUnit, Hamcrest和Mockito，还有`spring-test`模块|
-|spring-boot-starter-thymeleaf|对Thymeleaf模板引擎的支持，包括和Spring的集成|
-|spring-boot-starter-velocity|对Velocity模板引擎的支持|
-|spring-boot-starter-web|对全栈web开发的支持，包括Tomcat和`spring-webmvc`|
-|spring-boot-starter-websocket|对WebSocket开发的支持|
-|spring-boot-starter-ws|对Spring Web服务的支持|
-
-除了应用程序的starters，下面的starters可以用于添加[生产准备](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#production-ready)的特性。
-
-**表 13.2. Spring Boot生产准备的starters**
-
-|名称|描述|
-|----|:----|
-|spring-boot-starter-actuator|添加生产准备特性，比如指标和监控|
-|spring-boot-starter-remote-shell|添加远程`ssh` shell支持|
-
-最后，Spring Boot包含一些可用于排除或交换具体技术方面的starters。
-
-**表 13.3. Spring Boot technical starters**
-
-|名称|描述|
-|------|:------|
-|spring-boot-starter-jetty|导入Jetty HTTP引擎（作为Tomcat的替代）|
-|spring-boot-starter-log4j|对Log4J日志系统的支持|
-|spring-boot-starter-logging|导入Spring Boot的默认日志系统（Logback）|
-|spring-boot-starter-tomcat|导入Spring Boot的默认HTTP引擎（Tomcat）|
-|spring-boot-starter-undertow|导入Undertow HTTP引擎（作为Tomcat的替代）|
-
-**注**：查看GitHub上位于`spring-boot-starters`模块内的[README文件](http://github.com/spring-projects/spring-boot/tree/master/spring-boot-starters/README.adoc)，可以获取到一个社区贡献的其他starter POMs列表。
-
-### 组织你的代码
-
-Spring Boot不需要使用任何特殊的代码结构，然而，这里有一些有用的最佳实践。
-
-* 使用"default"包
-
-当类没有包含`package`声明时，它被认为处于`default package`下。通常不推荐使用`default package`，并应该避免使用它。因为对于使用`@ComponentScan`，`@EntityScan`或`@SpringBootApplication`注解的Spring Boot应用来说，来自每个jar的类都会被读取，这会造成一定的问题。
-
-**注**：我们建议你遵循Java推荐的包命名规范，使用一个反转的域名（例如`com.example.project`）。
-
-* 定位main应用类
-
-我们通常建议你将main应用类放在位于其他类上面的根包（root package）中。通常使用`@EnableAutoConfiguration`注解你的main类，并且暗地里为某些项定义了一个基础“search package”。例如，如果你正在编写一个JPA应用，被`@EnableAutoConfiguration`注解的类所在包将被用来搜索`@Entity`项。
-
-使用根包允许你使用`@ComponentScan`注解而不需要定义一个`basePackage`属性。如果main类位于根包中，你也可以使用`@SpringBootApplication`注解。
-
-下面是一个典型的结构：
-```shell
-com
- +- example
- +- myproject
- +- Application.java
- |
- +- domain
- | +- Customer.java
- | +- CustomerRepository.java
- |
- +- service
- | +- CustomerService.java
- |
- +- web
- +- CustomerController.java
-```
-`Application.java`文件将声明`main`方法，还有基本的`@Configuration`。
-```java
-package com.example.myproject;
-
-import org.springframework.boot.SpringApplication;
-import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
-import org.springframework.context.annotation.ComponentScan;
-import org.springframework.context.annotation.Configuration;
-
-@Configuration
-@EnableAutoConfiguration
-@ComponentScan
-public class Application {
-
- public static void main(String[] args) {
- SpringApplication.run(Application.class, args);
- }
-
-}
-```
-### 配置类
-
-Spring Boot提倡基于Java的配置。尽管你可以使用一个XML源来调用`SpringApplication.run()`，我们通常建议你使用`@Configuration`类作为主要源。一般定义`main`方法的类也是主要`@Configuration`的一个很好候选。
-
-**注**：很多使用XML配置的Spring配置示例已经被发布到网络上。你应该总是尽可能的使用基于Java的配置。搜索查看`enable*`注解就是一个好的开端。
-
-* 导入其他配置类
-
-你不需要将所有的`@Configuration`放进一个单独的类。`@Import`注解可以用来导入其他配置类。另外，你也可以使用`@ComponentScan`注解自动收集所有的Spring组件，包括`@Configuration`类。
-
-* 导入XML配置
-
-如果你绝对需要使用基于XML的配置，我们建议你仍旧从一个`@Configuration`类开始。你可以使用附加的`@ImportResource`注解加载XML配置文件。
-
-### 自动配置
-
-Spring Boot自动配置（auto-configuration）尝试根据你添加的jar依赖自动配置你的Spring应用。例如，如果你的classpath下存在`HSQLDB`，并且你没有手动配置任何数据库连接beans，那么我们将自动配置一个内存型（in-memory）数据库。
-
-你可以通过将`@EnableAutoConfiguration`或`@SpringBootApplication`注解添加到一个`@Configuration`类上来选择自动配置。
-
-**注**：你只需要添加一个`@EnableAutoConfiguration`注解。我们建议你将它添加到主`@Configuration`类上。
-
-* 逐步替换自动配置
-
-自动配置是非侵占性的，任何时候你都可以定义自己的配置类来替换自动配置的特定部分。例如，如果你添加自己的`DataSource` bean，默认的内嵌数据库支持将不被考虑。
-
-如果需要找出当前应用了哪些自动配置及应用的原因，你可以使用`--debug`开关启动应用。这将会记录一个自动配置的报告并输出到控制台。
-
-* 禁用特定的自动配置
-
-如果发现应用了你不想要的特定自动配置类，你可以使用`@EnableAutoConfiguration`注解的排除属性来禁用它们。
-```java
-import org.springframework.boot.autoconfigure.*;
-import org.springframework.boot.autoconfigure.jdbc.*;
-import org.springframework.context.annotation.*;
-
-@Configuration
-@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
-public class MyConfiguration {
-}
-```
-
-### Spring Beans和依赖注入
-
-你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见，我们经常使用`@ComponentScan`注解搜索beans，并结合`@Autowired`构造器注入。
-
-如果使用上面建议的结构组织代码（将应用类放到根包下），你可以添加`@ComponentScan`注解而不需要任何参数。你的所有应用程序组件（`@Component`, `@Service`, `@Repository`, `@Controller`等）将被自动注册为Spring Beans。
-
-下面是一个`@Service` Bean的示例，它使用构建器注入获取一个需要的`RiskAssessor` bean。
-```java
-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;
- }
-
- // ...
-}
-```
-**注**：注意如何使用构建器注入来允许`riskAssessor`字段被标记为`final`，这意味着`riskAssessor`后续是不能改变的。
-
-### 使用@SpringBootApplication注解
-
-很多Spring Boot开发者总是使用`@Configuration`，`@EnableAutoConfiguration`和`@ComponentScan`注解他们的main类。由于这些注解被如此频繁地一块使用（特别是你遵循以上[最佳实践](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#using-boot-structuring-your-code)时），Spring Boot提供一个方便的`@SpringBootApplication`选择。
-
-该`@SpringBootApplication`注解等价于以默认属性使用`@Configuration`，`@EnableAutoConfiguration`和`@ComponentScan`。
-```java
-package com.example.myproject;
-
-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);
- }
-
-}
-```
-### 运行应用程序
-
-将应用打包成jar并使用一个内嵌HTTP服务器的一个最大好处是，你可以像其他方式那样运行你的应用程序。调试Spring Boot应用也很简单；你不需要任何特殊IDE或扩展。
-
-**注**：本章节只覆盖基于jar的打包，如果选择将应用打包成war文件，你最好参考一下服务器和IDE文档。
-
-* 从IDE中运行
-
-你可以从IDE中运行Spring Boot应用，就像一个简单的Java应用，但是，你首先需要导入项目。导入步骤跟你的IDE和构建系统有关。大多数IDEs能够直接导入Maven项目，例如Eclipse用户可以选择`File`菜单的`Import…` --> `Existing Maven Projects`。
-
-如果不能直接将项目导入IDE，你可以需要使用构建系统生成IDE元数据。Maven有针对[Eclipse](http://maven.apache.org/plugins/maven-eclipse-plugin/)和[IDEA](http://maven.apache.org/plugins/maven-idea-plugin/)的插件；Gradle为[各种IDEs](http://www.gradle.org/docs/current/userguide/ide_support.html)提供插件。
-
-**注**：如果意外地运行一个web应用两次，你将看到一个"端口已在使用中"错误。为了确保任何存在的实例是关闭的，STS用户可以使用`Relaunch`按钮而不是`Run`按钮。
-
-* 作为一个打包后的应用运行
-
-如果使用Spring Boot Maven或Gradle插件创建一个可执行jar，你可以使用`java -jar`运行你的应用。例如：
-```shell
-$ java -jar target/myproject-0.0.1-SNAPSHOT.jar
-```
-运行一个打包的程序并开启远程调试支持是可能的，这允许你将调试器附加到打包的应用程序上：
-```shell
-$ java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
- -jar target/myproject-0.0.1-SNAPSHOT.jar
-```
-* 使用Maven插件运行
-
-Spring Boot Maven插件包含一个`run`目标，它可以用来快速编译和运行应用程序。应用程序以一种暴露的方式运行，由于即时"热"加载，你可以编辑资源。
-```shell
-$ mvn spring-boot:run
-```
-你可能想使用有用的操作系统环境变量：
-```shell
-$ export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
-```
-("egd"设置是通过为Tomcat提供一个更快的会话keys熵源来加速Tomcat的。)
-
-* 使用Gradle插件运行
-
-Spring Boot Gradle插件也包含一个`run`目标，它可以用来以暴露的方式运行你的应用程序。不管你什么时候导入`spring-boot-plugin`，`bootRun`任务总是被添加进去。
-```shell
-$ gradle bootRun
-```
-你可能想使用那些有用的操作系统环境变量：
-```shell
-$ export JAVA_OPTS=-Xmx1024m -XX:MaxPermSize=128M -Djava.security.egd=file:/dev/./urandom
-```
-* 热交换
-
-由于Spring Boot应用程序只是普通的Java应用，那JVM热交换（hot-swapping）应该能出色的工作。JVM热交换在它能替换的字节码上有些限制，更全面的解决方案可以使用[Spring Loaded](https://github.com/spring-projects/spring-loaded)项目或[JRebel](http://zeroturnaround.com/software/jrebel/)。
-
-关于热交换可以参考[“How-to”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#howto-hotswapping)章节。
-
-### 打包用于生产的应用程序
-
-可执行jars可用于生产部署。由于它们是自包含的，非常适合基于云的部署。关于其他“生产准备”的特性，比如健康监控，审计和指标REST，或JMX端点，可以考虑添加`spring-boot-actuator`。具体参考[Part V, “Spring Boot Actuator: Production-ready features”](http://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#production-ready)。
-
-
-
-
-