深入学习微框架：Spring Boot[收藏 准备学习下]

深入学习微框架：Spring Boot

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