http://www.infoq.com/cn/articles/microframeworks1-spring-boot
spring boot 中文手册
https://qbgbook.gitbooks.io/spring-boot-reference-guide-zh/content/IV.%20Spring%20Boot%20features/25.3.%20File%20output.html
spring boot 中文手册学习笔记
-----------------------------------------------------------
1、你可以使用Spring Boot创建Java应用，并使用java -jar启动它或采用传统的war部署方式。我们也提供了一个运行"spring脚本"的命令行工具。
提供一系列大型项目常用的非功能性特征，比如：内嵌服务器，安全，指标，健康检测，外部化配置。
建议尽可能使用Java8
对于java开发者来说，使用Spring Boot就跟使用其他Java库一样，只需要在你的classpath下引入适当的spring-boot-*.jar文件
2、Spring Boot兼容Apache Maven 3.2或更高版本。
Spring Boot依赖使用的groupId为org.springframework.boot。通常，你的Maven POM文件会继承spring-boot-starter-parent工程，并声明一个或多个“Starter POMs”依赖。此外，Spring Boot提供了一个可选的Maven插件，用于创建可执行jars。
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.example</groupId>
<artifactId>myproject</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!-- Inherit defaults from Spring Boot -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.0.BUILD-SNAPSHOT</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>
<!-- Add Spring repositories -->
<!-- (you don't need this if you are using a .RELEASE version) -->
<repositories>
<repository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
<snapshots><enabled>true</enabled></snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</repository>
</repositories>
<pluginRepositories>
<pluginRepository>
<id>spring-snapshots</id>
<url>http://repo.spring.io/snapshot</url>
</pluginRepository>
<pluginRepository>
<id>spring-milestones</id>
<url>http://repo.spring.io/milestone</url>
</pluginRepository>
</pluginRepositories>
</project>
你可以使用import作用域这种替代方案，具体查看Section 13.2.2, “Using Spring Boot without the parent POM”。
https://start.spring.io/ 输入web starter来生成demo代码。
mvn dependency:tree
3、
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.stereotype.*;
import org.springframework.web.bind.annotation.*;
@RestController
@EnableAutoConfiguration
public class Example {
@RequestMapping("/")
String home() {
return "Hello World!";
}
public static void main(String[] args) throws Exception {
SpringApplication.run(Example.class, args);
}
}
@RequestMapping 注解提供路由信息，它告诉Spring任何来自"/"路径的HTTP请求都应该被映
射到 home 方法。 @RestController 注解告诉Spring以字符串的形式渲染结果，并直接返回给
调用者。
第二个类级别的注解是 @EnableAutoConfiguration ，这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于 spring-boot-starter-web 添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用，并对Spring进行相应地设置。
我们的main方法通过调用 run ，将业务委托给了Spring Boot的SpringApplication类。SpringApplication将引导我们的应用，启动Spring，相应地启动被自动配置的Tomcat web服务器。我们需要将 Example.class 作为参数传递给 run 方法，以此告诉SpringApplication谁是主要的Spring组件，并传递args数组以暴露所有的命令行参数。
在项目根目录下输入 mvn spring-boot:run 启动应用
4、创建可执行jar
为了创建可执行的jar，我们需要将 spring-boot-maven-plugin 添加到 pom.xml 中，在
dependencies节点后面插入以下内容：
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
从命令行运行mvn package
如果查看target目录，你应该可以看到myproject-0.0.1-SNAPSHOT.jar，该文件大概有10Mb。想查看内部结构，可以运行jar tvf：
jar tvf target/myproject-0.0.1-SNAPSHOT.jar
在该目录下，你应该还能看到一个很小的名为myproject-0.0.1-SNAPSHOT.jar.original的文件，这是在Spring Boot重新打包前，Maven创建的原始jar文件。
java -jar target/myproject-0.0.1-SNAPSHOT.jar
5、放置应用的main类
当类没有声明 package 时，它被认为处于 default package 下。
通常建议将应用的main类放到其他类所在包的顶层(root package)，并将 @EnableAutoConfiguration 注解到你的main类上，这样就隐式地定义了一个基础的包搜索路径（search package），以搜索某些特定的注解实体（比如@Service，@Component等） 。
采用root package方式，你就可以使用 @ComponentScan 注解而不需要指定 basePackage 属性，也可以使用 @SpringBootApplication 注解，只要将main类放到root package中。
com
+- example
+- myproject
+- Application.java
|
+- domain
| +- Customer.java
| +- CustomerRepository.java
|
+- service
| +- CustomerService.java
|
+- web
+- CustomerController.java
6、配置类
Spring Boot提倡基于Java的配置。尽管你可以使用XML源调用 SpringApplication.run() ，不过还是建议你使用 @Configuration 类作为主要配置源。通常定义了 main 方法的类也是使
用 @Configuration 注解的一个很好的替补。
@Import 注解可以用来导入其他配置类。另外，你也可以使用 @ComponentScan 注解自动收集所有Spring组件，包括 @Configuration 类。
如果必须使用XML配置，建议你仍旧从一个 @Configuration 类开始，然后使用@ImportResource 注解加载XML配置文件。
自动配置
Spring Boot自动配置（auto-configuration）尝试根据添加的jar依赖自动配置你的Spring应
用。例如，如果classpath下存在 HSQLDB ，并且你没有手动配置任何数据库连接的beans，那
么Spring Boot将自动配置一个内存型（in-memory）数据库。
实现自动配置有两种可选方式，分别是将 @EnableAutoConfiguration 或 @SpringBootApplication 注解到 @Configuration 类上。
注：你应该只添加一个 @EnableAutoConfiguration 注解，通常建议将它添加到主配置类
（primary @Configuration ）上。
如果需要查看当前应用启动了哪些自动配置项，你可以在运行应用时打开 --debug 开关，这
将为核心日志开启debug日志级别，并将自动配置相关的日志输出到控制台。
禁用特定的自动配置项
使用 @EnableAutoConfiguration 注解的exclude属性禁用它们：
import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}
如果该类不在classpath中，你可以使用该注解的excludeName属性，并指定全限定名来达到
相同效果。最后，你可以通过 spring.autoconfigure.exclude 属性exclude多个自动配置项（一个自动配置项集合）。
注 通过注解级别或exclude属性都可以定义排除项。
7、Spring Beans和依赖注入
你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见，我
们经常使用 @ComponentScan 注解搜索beans，并结合 @Autowired 构造器注入。
如果遵循以上的建议组织代码结构（将应用的main类放到包的最上层，即root package），
那么你就可以添加 @ComponentScan 注解而不需要任何参数，所有应用组件（ @Component ,
@Service , @Repository , @Controller 等）都会自动注册成Spring Beans。
使用@SpringBootApplication注解
@SpringBootApplication 注解等价于以默认属性使
用 @Configuration ， @EnableAutoConfiguration 和 @ComponentScan
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
8、作为一个打包后的应用运行
java -jar target/myproject-0.0.1-SNAPSHOT.jar
Spring Boot支持以远程调试模式运行一个打包的应用，下面的命令可以为应用关联一个调试
器：
java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n \
-jar target/myproject-0.0.1-SNAPSHOT.jar
使用Maven插件运行
$ mvn spring-boot:run
9、Spring Boot特性
参考
http://www.cnblogs.com/softidea/p/5644750.html
SpringApplication
SpringApplication 类是启动 Spring Boot 应用的入口类，你可以创建一个包含 main() 方法的类，来运行 SpringApplication.run 这个静态方法：
public static void main(String[] args) {
SpringApplication.run(MySpringConfiguration.class, args);
}
自定义SpringApplication
如果默认的SpringApplication不符合你的口味，你可以创建一个本地的实例并自定义它。例如，关闭banner你可以这样写：
public static void main(String[] args) {
SpringApplication app = new SpringApplication(MySpringConfiguration.class);
app.setShowBanner(false);
app.run(args);
}
如果你需要创建一个分层的ApplicationContext（多个具有父子关系的上下文），或你只是喜欢使用流畅的构建API，你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法，包括可以创建层次结构的parent和child方法。
new SpringApplicationBuilder()
.showBanner(false)
.sources(Parent.class)
.child(Application.class)
.run(args);
Application事件和监听器
SpringApplication 启动过程会触发一些事件，你可以针对这些事件通过 SpringApplication.addListeners(…) 添加一些监听器:
ApplicationStartedEvent
ApplicationEnvironmentPreparedEvent
ApplicationPreparedEvent
ApplicationFailedEvent
SpringApplication 会注册一个 shutdown hook 以便在应用退出的时候能够保证 ApplicationContext 优雅地关闭，这样能够保证所有 Spring lifecycle 的回调都会被执行，包括 DisposableBean 接口的实现类以及 @PreDestroy 注解。
另外，你也可以实现 org.springframework.boot.ExitCodeGenerator 接口来定义你自己的退出时候的逻辑。
Web环境
一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下，使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。
用于确定一个web环境的算法相当简单（基于是否存在某些类）。如果需要覆盖默认行为，你可以使用setWebEnvironment(boolean webEnvironment)。通过调用setApplicationContextClass(…)，你可以完全控制ApplicationContext的类型。
获取应用参数
如果你想获取应用程序传递给SpringApplication.run(…)的参数，你可以注入一个org.springframework.boot.ApplicationArgumentsbean，ApplicationArguments这个接口提供了方法获取可选的和非可选的String[]类型的参数。
import org.springframework.boot.*
import org.springframework.beans.factory.annotation.*
import org.springframework.stereotype.*
@Component
public class MyBean {
@Autowired
public MyBean(ApplicationArguments args) {
boolean debug = args.containsOption("debug");
List<String> files = args.getNonOptionArgs();
// if run with "--debug logfile.txt" debug=true, files=["logfile.txt"]
}
}
外化配置
Spring Boot允许你针对不同的环境配置不同的配置参数，你可以使用 properties文件、YAML 文件、环境变量或者命令行参数来修改应用的配置。你可以在代码中使用@Value注解来获取配置参数的值。
Spring Boot使用一个特别的PropertySource来按顺序加载配置，加载顺序如下：
命令行参数
来自SPRING_APPLICATION_JSON的属性
java:comp/env 中的 JNDI 属性
Java系统环境变量
操作系统环境变量
RandomValuePropertySource，随机值，使用 random.* 来定义
jar 包外的 Profile 配置文件，如 application-{profile}.properties 和 YAML 文件
jar 包内的 Profile 配置文件，如 application-{profile}.properties 和 YAML 文件
jar 包外的 Application 配置，如 application.properties 和 application.yml 文件
jar 包内的 Application 配置，如 application.properties 和 application.yml 文件
在标有 @Configuration 注解的类标有@PropertySource注解的
默认值，使用 SpringApplication.setDefaultProperties 设置的
示例代码：
import org.springframework.stereotype.*
import org.springframework.beans.factory.annotation.*
@Component
public class MyBean {
@Value("${name}")
private String name;
// ...
}
你可以在 application.properties 中定义一个 name 变量，或者在运行该 jar 时候，指定一个命令行参数（以 -- 标识），例如：java -jar app.jar --name="Spring"
也可以使用SPRING_APPLICATION_JSON属性：
$ SPRING_APPLICATION_JSON='{"foo":{"bar":"spam"}}'
$ java -jar myapp.jar
在这个例子中，你可以在Spring的Environment中通过foo.bar来引用变量。你可以在系统变量中定义pring.application.json：
$ java -Dspring.application.json='{"foo":"bar"}' -jar myapp.jar
或者使用命令行参数：
$ java -jar myapp.jar --spring.application.json='{"foo":"bar"}'
或者使用JNDI变量：
java:comp/env/spring.application.json
应用属性文件
SpringApplication 会在以下路径查找 application.properties 并加载该文件：
/config 目录下
当前目录
classpath 中 /config 包下
classpath 根路径下
另外，你也可以通过 spring.config.location 来指定 application.properties 文件的存放路径，或者通过 spring.config.name 指定该文件的名称，例如：
$ java -jar myproject.jar --spring.config.location=classpath:/default.properties,classpath:/override.properties
或者：
$ java -jar myproject.jar --spring.config.name=myproject
指定Profile配置文件
即application-{profile}.properties配置文件。
占位符
在application.properties文件中可以引用Environment中已经存在的变量。
app.name=MyApp
app.description=${app.name} is a Spring Boot application
Profiles
你可以使用 @Profile 注解来标注应用使用的环境
@Configuration
@Profile("production")
public class ProductionConfiguration {
// ...
}
可以使用 spring.profiles.active 变量来定义应用激活的 profile：
spring.profiles.active=dev,hsqldb
还可以通过 SpringApplication 来设置，调用 SpringApplication.setAdditionalProfiles(…) 代码即可。
10、Spring Web MVC框架
Spring MVC允许你创建特定的@Controller或@RestController beans来处理传入的
HTTP请求。 使用@RequestMapping注解可以将控制器中的方法映射到相应的HTTP请求。
@RestController
@RequestMapping(value="/users")
public class MyRestController {
@RequestMapping(value="/{user}", method=RequestMethod.GET)
public User getUser(@PathVariable Long user) {
// ...
}
@RequestMapping(value="/{user}/customers", method=RequestMethod.GET)
List<Customer> getUserCustomers(@PathVariable Long user) {
// ...
}
@RequestMapping(value="/{user}", method=RequestMethod.DELETE)
public User deleteUser(@PathVariable Long user) {
// ...
}
}
Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动
配置添加了以下特性：
1. 引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。
2. 对静态资源的支持，包括对WebJars的支持。
3. 自动注册Converter，GenericConverter，Formatter beans。
4. 对HttpMessageConverters的支持。
5. 自动注册MessageCodeResolver。
6. 对静态index.html的支持。
7. 对自定义Favicon的支持。
如果想全面控制Spring MVC，你可以添加自己的@Configuration，并使用@EnableWebMvc
对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器，
formatters，视图控制器等)，你可以添加自己的WebMvcConfigurerAdapter类型的
@Bean（不使用@EnableWebMvc注解）。
静态内容
默认情况下，Spring Boot从classpath下一个叫/static（/public，/resources或/METAINF/
resources）的文件夹或从ServletContext根目录提供静态内容。这使用了Spring MVC的
ResourceHttpRequestHandler，所以你可以通过添加自己的WebMvcConfigurerAdapter并覆
写addResourceHandlers方法来改变这个行为（加载静态文件）。
当你使用这些引擎的任何一种，并采用默认的配置，你的模板将会从src/main/resources/templates目录下自动加载。
或者，你可以配置模块的前缀为classpath*:/templates/，这样会查找classpath下的所有模板目录。
EmbeddedWebApplicationContext
Spring Boot底层使用了一个新的ApplicationContext类型，用于对内嵌servlet容器的支持。
EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext，它通过搜索一
个单一的EmbeddedServletContainerFactory bean来启动自己。通常，
TomcatEmbeddedServletContainerFactory，JettyEmbeddedServletContainerFactory或
UndertowEmbeddedServletContainerFactory将被自动配置。
注：你通常不需要知道这些实现类。大多数应用将被自动配置，并根据你的行为创建合适的
ApplicationContext和EmbeddedServletContainerFactory。
How-to指南
--------------------------------------------------------------
spring-boot 实例
https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples