springBoot 配置 和 使用

简介

• 创建可以独立运行的 Spring 应用。
• 直接嵌入 Tomcat 或 Jetty 服务器，不需要部署 WAR 文件。
• 提供推荐的基础 POM 文件来简化 Apache Maven 配置。
• 尽可能的根据项目依赖来自动配置 Spring 框架。
• 提供可以直接在生产环境中使用的功能，如性能指标、应用信息和应用健康检查。
• 没有代码生成，也没有 XML 配置文件。

快速构建

可以通过http://start.spring.io/网站直接构建springboot基础框架.

maven构建

pom依赖

pom文件常见依赖 
在springboot开发中,groupId都是org.springframework.boot

依赖artifactId	说明
spring-boot-starter	核心 POM，包含自动配置支持、日志库和对 YAML 配置文件的支持。
spring-boot-starter-amqp	通过 spring-rabbit 支持 AMQP。
spring-boot-starter-aop	包含 spring-aop 和 AspectJ 来支持面向切面编程（AOP）。
spring-boot-starter-batch	支持 Spring Batch，包含 HSQLDB。
spring-boot-starter-data-jpa	包含 spring-data-jpa、spring-orm 和 Hibernate 来支持 JPA。
spring-boot-starter-data-mongodb	包含 spring-data-mongodb 来支持 MongoDB。
spring-boot-starter-data-rest	通过 spring-data-rest-webmvc 支持以 REST 方式暴露 Spring Data 仓库。
spring-boot-starter-jdbc	支持使用 JDBC 访问数据库。
spring-boot-starter-security	包含 spring-security。
spring-boot-starter-test	包含常用的测试所需的依赖，如 JUnit、Hamcrest、Mockito 和 spring-test 等。
spring-boot-starter-velocity	支持使用 Velocity 作为模板引擎。
spring-boot-starter-web	支持 Web 应用开发，包含 Tomcat 和 spring-mvc。
spring-boot-starter-websocket	支持使用 Tomcat 开发 WebSocket 应用。
spring-boot-starter-ws	支持 Spring Web Services。
spring-boot-starter-actuator	添加适用于生产环境的功能，如性能指标和监测等功能。
spring-boot-starter-remote-shell	添加远程 SSH 支持。
spring-boot-starter-jetty	使用 Jetty 而不是默认的 Tomcat 作为应用服务器。
spring-boot-starter-log4j	添加 Log4j 的支持。
spring-boot-starter-logging	使用 Spring Boot 默认的日志框架 Logback。
spring-boot-starter-tomcat	使用 Spring Boot 默认的 Tomcat 作为应用服务器。

kotlin开发

kotlin开发pom.xml示例文件

<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.0modelVersion>

    <groupId>com.tingfenggroupId>
    <artifactId>springboottestartifactId>
    <version>1.0-SNAPSHOTversion>

    <parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>1.5.8.RELEASEversion>
        <relativePath/>
        
    parent>
    <properties>
        <kotlin.compiler.incremental>truekotlin.compiler.incremental>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <java.version>1.8java.version>
        <kotlin.version>1.1.51kotlin.version>
        <mysql.version>5.1.38mysql.version>
        <druid.version>1.1.3druid.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>com.alibabagroupId>
            <artifactId>druid-spring-boot-starterartifactId>
            <version>${druid.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-jpaartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.jetbrains.kotlingroupId>
            <artifactId>kotlin-stdlib-jre8artifactId>
            <version>${kotlin.version}version>
        dependency>
        <dependency>
            <groupId>org.jetbrains.kotlingroupId>
            <artifactId>kotlin-reflectartifactId>
            <version>${kotlin.version}version>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>${mysql.version}version>
        dependency>
    dependencies>
    <build>
        <sourceDirectory>${project.basedir}/src/main/javasourceDirectory>
        <testSourceDirectory>${project.basedir}/src/test/javatestSourceDirectory>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
            plugin>
            <plugin>
                <artifactId>kotlin-maven-pluginartifactId>
                <groupId>org.jetbrains.kotlingroupId>
                <version>${kotlin.version}version>
                <configuration>
                    <compilerPlugins>
                        <plugin>springplugin>
                    compilerPlugins>
                    <jvmTarget>1.8jvmTarget>
                configuration>
                <executions>
                    <execution>
                        <id>compileid>
                        <phase>compilephase>
                        <goals>
                            <goal>compilegoal>
                        goals>
                    execution>
                    <execution>
                        <id>test-compileid>
                        <phase>test-compilephase>
                        <goals>
                            <goal>test-compilegoal>
                        goals>
                    execution>
                executions>
                <dependencies>
                    <dependency>
                        <groupId>org.jetbrains.kotlingroupId>
                        <artifactId>kotlin-maven-allopenartifactId>
                        <version>${kotlin.version}version>
                    dependency>
                dependencies>
            plugin>
        plugins>
    build>
project>

• 
  

热部署

devtools

<dependency>
      <groupId>org.springframework.bootgroupId>
      <artifactId>spring-boot-devtoolsartifactId>
      <scope>providedscope>
      
      <optional>trueoptional>
dependency>

• 
  

通过项目主程序入口启动即可，改动以后重新编译就好。

springloaded 
Pom.xml中直接在spring-boot插件中添加依赖即可：

<plugin>
          <groupId>org.springframework.bootgroupId>
          <artifactId>spring-boot-maven-pluginartifactId>
          <dependencies>
            
            <dependency>
              <groupId>org.springframeworkgroupId>
              <artifactId>springloadedartifactId>
              <version>1.2.6.RELEASEversion>
            dependency>
          dependencies>
          <configuration>
            <mainClass>cn.springboot.MainspringbootmainClass>
          configuration>
plugin>

• 
  

运行：

$ mvn clean spring-boot:run 
改动后，编译即可实现热部署

这两种方式其实都是spring官网为了spring项目所推出的jar包，加之springBoot框架内嵌服务器的优势， 
使得改动后的项目部署变得非常简单；当我使用以后这两种方法以后， 
发现真正实现热部署的只是后者，前者只是实现了热启动而已，从控制台日志就可以看出来。

说明 
项目使用maven管理: 
第一种方式配置文件改动后不能触发热启动 
第二种方式配置文件改动后不能触发热部署，会提示一下错误 
2017-05-24 11:54:53.276 ERROR 12063 — [Loader@18b4aac2] org.springsource.loaded.ReloadableType

springboot配置优先级顺序

优先级从高到低顺序如下,命令行优先级最高. 
1. 命令行参数。 
通过 System.getProperties() 获取的 Java 系统参数。 
2. 操作系统环境变量。 
从 java:comp/env 得到的 JNDI 属性。 
3. 通过 RandomValuePropertySource 生成的“random.*”属性。 
4. 应用 Jar 文件之外的属性文件。 
5. 应用 Jar 文件内部的属性文件。 
6. 在应用配置 Java 类（包含“@Configuration”注解的 Java 类）中通过“@PropertySource”注解声明的属性文件。 
7. 通过“SpringApplication.setDefaultProperties”声明的默认属性。

Spring Boot 的这个配置优先级看似复杂，其实是很合理的。 
比如命令行参数的优先级被设置为最高。 
这样的好处是可以在测试或生产环境中快速地修改配置参数值，而不需要重新打包和部署应用。

SpringApplication 类默认会把以“–”开头的命令行参数转化成应用中可以使用的配置参数， 
如 “–name=Alex” 会设置配置参数 “name” 的值为 “Alex”。 
如果不需要这个功能，可以通过 “SpringApplication.setAddCommandLineProperties(false)” 禁用解析命令行参数。

RandomValuePropertySource 可以用来生成测试所需要的各种不同类型的随机值，从而免去了在代码中生成的麻烦。RandomValuePropertySource 可以生成数字和字符串。数字的类型包含 int 和 long，可以限定数字的大小范围。 
以“random.”作为前缀的配置属性名称由 RandomValuePropertySource 来生成，如代码

//使用 RandomValuePropertySource 生成的配置属性
user.id=${random.value}
user.count=${random.int}
user.max=${random.long}
user.number=${random.int(100)}
user.range=${random.int[100, 1000]}

• 
  

springboot配置文件

Profile-多环境配置

当应用程序需要部署到不同运行环境时，一些配置细节通常会有所不同，最简单的比如日志， 
生产日志会将日志级别设置为WARN或更高级别，并将日志写入日志文件， 
而开发的时候需要日志级别为DEBUG，日志输出到控制台即可。 
Spring Boot的Profile就给我们提供了解决方案，命令带上参数就搞定。

在Spring Boot中多环境配置文件名需要满足application-{profile}.properties的格式，其中{profile}对应你的环境标识，比如： 
- application-dev.properties：开发环境 
- application-prod.properties：生产环境

想要使用对应的环境，只需要在application.properties中使用spring.profiles.active属性来设置， 
值对应上面提到的{profile}，这里就是指dev、prod这2个。

当然你也可以用命令行启动的时候带上参数：

java - jar xxx.jar --spring.profiles.active=dev

• 1

除了可以用profile的配置文件来分区配置我们的环境变量，在代码里， 
我们还可以直接用@Profile注解来进行配置，例如数据库配置，这里我们先定义一个接口: 
分别定义俩个实现类来实现它

//测试数据库
@Component
@Profile("testdb")
public class TestDBConnector implements DBConnector{
    @Override
    public void configure(){
        System.out.println("testdb");
    }
}

//生产数据库
@Component
@Profile("devdb")
public class DevDBConnector implements DBConnector{
    @Override
    public void configure(){
        System.out.println("devdb");
    }
}

• 
  

通过在配置文件激活具体使用哪个实现类 
spring.profiles.active=testdb 
然后通过注入DBConnector(注入接口,spring自动选择实现类),就可以用了. 
除了spring.profiles.active来激活一个或者多个profile之外，还可以用spring.profiles.include来叠加profile

spring.profiles.active:testdb
spring.profiles.include:proddb,prodmq

• 1
• 2

properties配置文件

属性文件是最常见的管理配置属性的方式。 
Spring Boot 提供的 SpringApplication 类会搜索并加载 application.properties 文件来获取配置属性值。 
SpringApplication 类会在下面位置搜索该文件。 
1. 当前目录的“/config”子目录。 
2. 当前目录。 
3. classpath 中的“/config”包。 
4. classpath 
上面的顺序也表示了该位置上包含的属性文件的优先级。 
优先级按照从高到低的顺序排列。 
可以通过“spring.config.name”配置属性来指定不同的属性文件名称。 
也可以通过“spring.config.location”来添加额外的属性文件的搜索路径。 
如果应用中包含多个 profile，可以为每个 profile 定义各自的属性文件，按照“application-{profile}”来命名。 
对于配置属性，可以在代码中通过“@Value”来使用，如代码所示。

//通过“@Value”来使用配置属性
@RestController
@EnableAutoConfiguration
public class Application {
    @Value("${name}")
    private String name;

    @RequestMapping("/")
    String home() {
        return String.format("Hello %s!", name);
    }
}
//变量 name 的值来自配置属性中的“name”属性。

• 
  

YAML配置

相对于属性文件来说，YAML 是一个更好的配置文件格式。YAML 在 Ruby on Rails 中得到了很好的应用。 
SpringApplication 类也提供了对 YAML 配置文件的支持，只需要添加对 SnakeYAML 的依赖即可。 
application.yml 文件的示例。

spring:
profiles: development
db:
url: jdbc:hsqldb:file:testdb
username: sa
password:
spring:
profiles: test
db:
url: jdbc:mysql://localhost/test
username: test
password: test

• 
  
• 12

通过“@ConfigurationProperties(prefix=”db”)”注解，配置属性中以“db”为前缀的属性值会被自动绑 
定到 Java 类中同名的域上，如 url 域的值会对应属性“db.url”的值。 
只需要在应用的配置类中添加“@EnableConfigurationProperties”注解就可以启用该自动绑定功能。

//使用 YAML 文件的 Java 类
@Component
@ConfigurationProperties(prefix="db")
public class DBSettings {
    private String url;
    private String username;
    private String password;
}

• 
  

如果你使用的是1.5以前的版本，那么可以通过locations指定properties文件的位置. 
但是1.5版本后就没有这个属性了，添加@Configuration和@PropertySource(“classpath:test.properties”)后才可以读取。

@configrationProperties(prefix="db",locations="classpath:xxxx.properties")

• 1

yaml配置文件示例

spring:
# 环境 dev|test|pro
profiles:
  active: dev
datasource:
  type: com.alibaba.druid.pool.DruidDataSource
  driver-class-name: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/springboot
  username: root
  password: root
http:
  multipart:
  max-file-size: 100MB
  max-request-size: 100MB
  enabled: true
  resources: # 指定静态资源的路径
      static-locations: classpath:/static/
     #cache-period，静态资源的缓存失效时间，此时间会在http response的时候
     #写入http response的head中让让浏览器按照此时间来缓存,秒，其优先级高于html网页中的设置的meta；
      cache-period: 600 
  redis:
      open: false  # 是否开启redis缓存  true开启  false关闭
      database: 0
      host: redis.open.renren.io
      port: 16379
      password:      # 密码（默认为空）
      timeout: 6000  # 连接超时时长（毫秒）
      pool:
          max-active: 1000  # 连接池最大连接数（使用负值表示没有限制）
          max-wait: -1      # 连接池最大阻塞等待时间（使用负值表示没有限制）
          max-idle: 10      # 连接池中的最大空闲连接
          min-idle: 5      # 连接池中的最小空闲连接
  devtools:
      restart:
          #热部署生效
        enabled: true
          #设置重启的目录
          #additional-paths: src/main/java
          #classpath目录下的WEB-INF文件夹内容修改不重启
        exclude: static/**,
jpa:
  hibernate:
      # 第一次简表create  后面用update
      #ddl-auto: create
      ddl-auto: update
      show-sql: true
  show-sql: true
  #base-package: com.tingfeng.dao
  #repository-impl-postfix: impl
  #entity-manager-factory-ref: entityManagerFactory
  #transaction-manager-ref: transactionManager
server:
  port: 8080
  connection-timeout: 5000
  context-path: /spring
  tomcat:
      uri-encoding: UTF-8
      max-threads: 1000
      min-spare-threads: 30
girl:
  cupSize: B
  age: 18

• 
  

可以配置application-dev.yml / application-pro.yml /application-test.yml用于不同的环境.

静态资源/文件配置

• 默认资源映射

其中默认配置的 /** 映射到 /static （或/public、/resources、/META-INF/resources） 
其中默认配置的 /webjars/** 映射到 classpath:/META-INF/resources/webjars/ 
PS：上面的 static、public、resources 等目录都在 classpath: 下面（如 src/main/resources/static）。

读取优先级顺序为：META/resources > resources > static > public

• 自定义资源映射

自定义目录 
以增加 /myres/* 映射到 classpath:/myres/* 为例的代码处理为： 
实现类继承 WebMvcConfigurerAdapter 并重写方法 addResourceHandlers

package org.springboot.sample.config;

import org.springboot.sample.interceptor.MyInterceptor1;
import org.springboot.sample.interceptor.MyInterceptor2;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MyWebAppConfigurer 
        extends WebMvcConfigurerAdapter {

    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        //可以针对具体的资源来设置不同的缓存时间
       //cache-period
        registry.addResourceHandler("/myres/**").addResourceLocations("classpath:/myres/");
        super.addResourceHandlers(registry);
    }

}

• 
  

访问myres 文件夹中的fengjing.jpg 图片的地址为 http://localhost:8080/myres/fengjing.jpg 
这样使用代码的方式自定义目录映射，并不影响Spring Boot的默认映射，可以同时使用。

如果我们将/myres/* 修改为 /* 与默认的相同时，则会覆盖系统的配置，可以多次使用 addResourceLocations 添加目录，优先级先添加的高于后添加的。

registry.addResourceHandler("/**").addResourceLocations("classpath:/myres/").addResourceLocations("classpath:/static/");

• 
  

其中 addResourceLocations 的参数是动参，可以这样写 addResourceLocations(“classpath:/img1/”, “classpath:/img2/”, “classpath:/img3/”);

• 使用外部目录 
  如果我们要指定一个绝对路径的文件夹（如 H:/myimgs/ ），则只需要使用 addResourceLocations 指定即可。 
  // 可以直接使用addResourceLocations 指定磁盘绝对路径，同样可以配置多个位置，注意路径写法需要加上file:

registry.addResourceHandler("/myimgs/**").addResourceLocations("file:H:/myimgs/");

• 
  

• 通过配置文件配置 
  上面是使用代码来定义静态资源的映射，其实Spring Boot也为我们提供了可以直接在 application.properties（或.yml）中配置的方法。 
  配置方法如下：

# 默认值为 /**
spring.mvc.static-path-pattern=
# 默认值为 classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/ 
spring.resources.static-locations=这里设置要指向的路径，多个使用英文逗号隔开，

• 
  

使用 spring.mvc.static-path-pattern 可以重新定义pattern，如修改为 /myres/** ，则访问static 等目录下的fengjing.jpg文件应该为 http://localhost:8080/myres/fengjing.jpg ，修改之前为 http://localhost:8080/fengjing.jpg 
使用 spring.resources.static-locations 可以重新定义 pattern 所指向的路径，支持 classpath: 和 file: （上面已经做过说明） 注意 spring.mvc.static-path-pattern 只可以定义一个，目前不支持多个逗号分割的方式。

• 页面中使用

上面几个例子中也已经说明了怎么访问静态资源，其实在页面中使用不管是jsp还是freemarker，并没有什么特殊之处，也我们平时开发web项目一样即可。 
下面是我的index.jsp：

<body>
    <img alt="读取默认配置中的图片" src="${pageContext.request.contextPath }/pic.jpg">
    <br/>
    <img alt="读取自定义配置myres中的图片" src="${pageContext.request.contextPath }/myres/fengjing.jpg">
body>

• 
  

• 使用webjars 
  先说一下什么是webjars？我们在Web开发中，前端页面中用了越来越多的JS或CSS，如jQuery等等，平时我们是将这些Web资源拷贝到Java的目录下，这种通过人工方式拷贝可能会产生版本误差，拷贝版本错误，前端页面就无法正确展示。 
  WebJars 就是为了解决这种问题衍生的，将这些Web前端资源打包成Java的Jar包，然后借助Maven这些依赖库的管理，保证这些Web资源版本唯一性。

WebJars 就是将js, css 等资源文件放到 classpath:/META-INF/resources/webjars/ 中，然后打包成jar 发布到maven仓库中。

简单应用

以jQuery为例，文件存放结构为：

META-INF/resources/webjars/jquery/2.1.4/jquery.js
META-INF/resources/webjars/jquery/2.1.4/jquery.min.js
META-INF/resources/webjars/jquery/2.1.4/jquery.min.map
META-INF/resources/webjars/jquery/2.1.4/webjars-requirejs.js

• 
  

Spring Boot 默认将 /webjars/** 映射到 classpath:/META-INF/resources/webjars/ ，结合我们上面讲到的访问资源的规则，便可以得知我们在JSP页面中引入jquery.js的方法为：

<script type="text/javascript" src="${pageContext.request.contextPath }/webjars/jquery/2.1.4/jquery.js">script>

• 
  

想实现这样，我们只需要在pom.xml 文件中添加jquery的webjars 依赖即可，如下：

<dependency>
    <groupId>org.webjarsgroupId>
    <artifactId>jqueryartifactId>
    <version>2.1.4version>
dependency>

• 
  

• 版本号统一管理 
  但是我们实际开发中，可能会遇到升级版本号的情况，如果我们有100多个页面，几乎每个页面上都有按上面引入jquery.js 那么我们要把版本号更换为3.0.0，一个一个替换显然不是最好的办法。 
  如何来解决？按如下方法处理即可。

首先在pom.xml 中添加依赖：

<dependency>
    <groupId>org.webjarsgroupId>
    <artifactId>webjars-locatorartifactId>
dependency>

• 
  

然后增加一个WebJarsController：

package org.springboot.sample.controller;

import javax.servlet.http.HttpServletRequest;

import org.springframework.core.io.ClassPathResource;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.HandlerMapping;
import org.webjars.WebJarAssetLocator;

/**
* 处理WebJars，自动读取版本号
*/
@Controller
public class WebJarsController {

    private final WebJarAssetLocator assetLocator = new WebJarAssetLocator();

    @ResponseBody
    @RequestMapping("/webjarslocator/{webjar}/**")
    public ResponseEntity