深入学习微框架:SpringBoot

http://www.infoq.com/cn/articles/microframeworks1-spring-boot

springboot中文手册

https://qbgbook.gitbooks.io/spring-boot-reference-guide-zh/content/IV.%20Spring%20Boot%20features/25.3.%20File%20output.html

springboot中文手册学习笔记

-----------------------------------------------------------

1、你可以使用SpringBoot创建Java应用,并使用java-jar启动它或采用传统的war部署方式。我们也提供了一个运行"spring脚本"的命令行工具。

提供一系列大型项目常用的非功能性特征,比如:内嵌服务器,安全,指标,健康检测,外部化配置。

建议尽可能使用Java8

对于java开发者来说,使用SpringBoot就跟使用其他Java库一样,只需要在你的classpath下引入适当的spring-boot-*.jar文件

2、SpringBoot兼容ApacheMaven3.2或更高版本。

SpringBoot依赖使用的groupId为org.springframework.boot。通常,你的MavenPOM文件会继承spring-boot-starter-parent工程,并声明一个或多个“StarterPOMs”依赖。此外,SpringBoot提供了一个可选的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作用域这种替代方案,具体查看Section13.2.2,“UsingSpringBootwithouttheparentPOM”。

https://start.spring.io/输入webstarter来生成demo代码。

mvndependency: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,这个注解告诉SpringBoot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和SpringMVC,所以auto-configuration将假定你正在开发一个web应用,并对Spring进行相应地设置。

我们的main方法通过调用run,将业务委托给了SpringBoot的SpringApplication类。SpringApplication将引导我们的应用,启动Spring,相应地启动被自动配置的Tomcatweb服务器。我们需要将Example.class作为参数传递给run方法,以此告诉SpringApplication谁是主要的Spring组件,并传递args数组以暴露所有的命令行参数。

在项目根目录下输入mvnspring-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>

从命令行运行mvnpackage

如果查看target目录,你应该可以看到myproject-0.0.1-SNAPSHOT.jar,该文件大概有10Mb。想查看内部结构,可以运行jartvf:

jartvftarget/myproject-0.0.1-SNAPSHOT.jar

在该目录下,你应该还能看到一个很小的名为myproject-0.0.1-SNAPSHOT.jar.original的文件,这是在SpringBoot重新打包前,Maven创建的原始jar文件。

java-jartarget/myproject-0.0.1-SNAPSHOT.jar

5、放置应用的main类

当类没有声明package时,它被认为处于defaultpackage下。

通常建议将应用的main类放到其他类所在包的顶层(rootpackage),并将@EnableAutoConfiguration注解到你的main类上,这样就隐式地定义了一个基础的包搜索路径(searchpackage),以搜索某些特定的注解实体(比如@Service,@Component等)。

采用rootpackage方式,你就可以使用@ComponentScan注解而不需要指定basePackage属性,也可以使用@SpringBootApplication注解,只要将main类放到rootpackage中。

com
 +- example
     +- myproject
         +- Application.java
         |
         +- domain
         |   +- Customer.java
         |   +- CustomerRepository.java
         |
         +- service
         |   +- CustomerService.java
         |
         +- web
             +- CustomerController.java

6、配置类

SpringBoot提倡基于Java的配置。尽管你可以使用XML源调用SpringApplication.run(),不过还是建议你使用@Configuration类作为主要配置源。通常定义了main方法的类也是使

用@Configuration注解的一个很好的替补。

@Import注解可以用来导入其他配置类。另外,你也可以使用@ComponentScan注解自动收集所有Spring组件,包括@Configuration类。

如果必须使用XML配置,建议你仍旧从一个@Configuration类开始,然后使用@ImportResource注解加载XML配置文件。

自动配置

SpringBoot自动配置(auto-configuration)尝试根据添加的jar依赖自动配置你的Spring应

用。例如,如果classpath下存在HSQLDB,并且你没有手动配置任何数据库连接的beans,那

么SpringBoot将自动配置一个内存型(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、SpringBeans和依赖注入

你可以自由地使用任何标准的Spring框架技术去定义beans和它们注入的依赖。简单起见,我

们经常使用@ComponentScan注解搜索beans,并结合@Autowired构造器注入。

如果遵循以上的建议组织代码结构(将应用的main类放到包的最上层,即rootpackage),

那么你就可以添加@ComponentScan注解而不需要任何参数,所有应用组件(@Component,

@Service,@Repository,@Controller等)都会自动注册成SpringBeans。

使用@SpringBootApplication注解

@SpringBootApplication注解等价于以默认属性使

用@Configuration,@EnableAutoConfiguration和@ComponentScan

@SpringBootApplication//sameas@Configuration@EnableAutoConfiguration@ComponentScan

8、作为一个打包后的应用运行

java-jartarget/myproject-0.0.1-SNAPSHOT.jar

SpringBoot支持以远程调试模式运行一个打包的应用,下面的命令可以为应用关联一个调试

器:

java-Xdebug-Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n\

-jartarget/myproject-0.0.1-SNAPSHOT.jar

使用Maven插件运行

$mvnspring-boot:run

9、SpringBoot特性

参考

http://www.cnblogs.com/softidea/p/5644750.html

SpringApplication

SpringApplication类是启动SpringBoot应用的入口类,你可以创建一个包含main()方法的类,来运行SpringApplication.run这个静态方法:

publicstaticvoidmain(String[]args){

SpringApplication.run(MySpringConfiguration.class,args);

}

自定义SpringApplication

如果默认的SpringApplication不符合你的口味,你可以创建一个本地的实例并自定义它。例如,关闭banner你可以这样写:

publicstaticvoidmain(String[]args){

SpringApplicationapp=newSpringApplication(MySpringConfiguration.class);

app.setShowBanner(false);

app.run(args);

}

如果你需要创建一个分层的ApplicationContext(多个具有父子关系的上下文),或你只是喜欢使用流畅的构建API,你可以使用SpringApplicationBuilder。SpringApplicationBuilder允许你以链式方式调用多个方法,包括可以创建层次结构的parent和child方法。

newSpringApplicationBuilder()

.showBanner(false)

.sources(Parent.class)

.child(Application.class)

.run(args);

Application事件和监听器

SpringApplication启动过程会触发一些事件,你可以针对这些事件通过SpringApplication.addListeners(…​)添加一些监听器:

ApplicationStartedEvent

ApplicationEnvironmentPreparedEvent

ApplicationPreparedEvent

ApplicationFailedEvent

SpringApplication会注册一个shutdownhook以便在应用退出的时候能够保证ApplicationContext优雅地关闭,这样能够保证所有Springlifecycle的回调都会被执行,包括DisposableBean接口的实现类以及@PreDestroy注解。

另外,你也可以实现org.springframework.boot.ExitCodeGenerator接口来定义你自己的退出时候的逻辑。

Web环境

一个SpringApplication将尝试为你创建正确类型的ApplicationContext。在默认情况下,使用AnnotationConfigApplicationContext或AnnotationConfigEmbeddedWebApplicationContext取决于你正在开发的是否是web应用。

用于确定一个web环境的算法相当简单(基于是否存在某些类)。如果需要覆盖默认行为,你可以使用setWebEnvironment(booleanwebEnvironment)。通过调用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"]
    }
}

外化配置

SpringBoot允许你针对不同的环境配置不同的配置参数,你可以使用properties文件、YAML文件、环境变量或者命令行参数来修改应用的配置。你可以在代码中使用@Value注解来获取配置参数的值。

SpringBoot使用一个特别的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-jarmyproject.jar--spring.config.location=classpath:/default.properties,classpath:/override.properties

或者:

$java-jarmyproject.jar--spring.config.name=myproject

指定Profile配置文件

即application-{profile}.properties配置文件。

占位符

在application.properties文件中可以引用Environment中已经存在的变量。

app.name=MyApp

app.description=${app.name}isaSpringBootapplication

Profiles

你可以使用@Profile注解来标注应用使用的环境

@Configuration

@Profile("production")

publicclassProductionConfiguration{

//...

}

可以使用spring.profiles.active变量来定义应用激活的profile:

spring.profiles.active=dev,hsqldb

还可以通过SpringApplication来设置,调用SpringApplication.setAdditionalProfiles(…​)代码即可。

10、SpringWebMVC框架

SpringMVC允许你创建特定的@Controller或@RestControllerbeans来处理传入的

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) {
        // ...
    }

}

SpringBoot为SpringMVC提供适用于多数应用的自动配置功能。在Spring默认基础上,自动

配置添加了以下特性:

1.引入ContentNegotiatingViewResolver和BeanNameViewResolverbeans。

2.对静态资源的支持,包括对WebJars的支持。

3.自动注册Converter,GenericConverter,Formatterbeans。

4.对HttpMessageConverters的支持。

5.自动注册MessageCodeResolver。

6.对静态index.html的支持。

7.对自定义Favicon的支持。

如果想全面控制SpringMVC,你可以添加自己的@Configuration,并使用@EnableWebMvc

对其注解。如果想保留SpringBootMVC的特性,并只是添加其他的MVC配置(拦截器,

formatters,视图控制器等),你可以添加自己的WebMvcConfigurerAdapter类型的

@Bean(不使用@EnableWebMvc注解)。

静态内容

默认情况下,SpringBoot从classpath下一个叫/static(/public,/resources或/METAINF/

resources)的文件夹或从ServletContext根目录提供静态内容。这使用了SpringMVC的

ResourceHttpRequestHandler,所以你可以通过添加自己的WebMvcConfigurerAdapter并覆

写addResourceHandlers方法来改变这个行为(加载静态文件)。

当你使用这些引擎的任何一种,并采用默认的配置,你的模板将会从src/main/resources/templates目录下自动加载。

或者,你可以配置模块的前缀为classpath*:/templates/,这样会查找classpath下的所有模板目录。

EmbeddedWebApplicationContext

SpringBoot底层使用了一个新的ApplicationContext类型,用于对内嵌servlet容器的支持。

EmbeddedWebApplicationContext是一个特殊类型的WebApplicationContext,它通过搜索一

个单一的EmbeddedServletContainerFactorybean来启动自己。通常,

TomcatEmbeddedServletContainerFactory,JettyEmbeddedServletContainerFactory或

UndertowEmbeddedServletContainerFactory将被自动配置。

注:你通常不需要知道这些实现类。大多数应用将被自动配置,并根据你的行为创建合适的

ApplicationContext和EmbeddedServletContainerFactory。

How-to指南

--------------------------------------------------------------

spring-boot实例

https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples