Spring-Boot学习笔记

摘要：学习笔记使用很容易创建一个独立运行运行内嵌容器准生产级别的基于框架的项目，使用你可以不用或者只需要很少的配置。异常消息如果这个错误是由异常引起的。错误发生时请求的路径。

使用Spring Boot很容易创建一个独立运行（运行jar,内嵌Servlet容器）、准生产级别的基于Spring框架的项目，使用Spring Boot你可以不用或者只需要很少的Spring配置。

Spring将很多魔法带入了Spring应用程序的开发之中，其中最重要的是以下四个核心。

自动配置：针对很多Spring应用程序常见的应用功能，Spring Boot能自动提供相关配置

起步依赖：告诉Spring Boot需要什么功能，它就能引入需要的库。

命令行界面：这是Spring Boot的可选特性，借此你只需写代码就能完成完整的应用程序，无需传统项目构建。

Actuator：让你能够深入运行中的Spring Boot应用程序，一探究竟。

Java版本：推荐使用java8

构建一个Sping Boot的Maven项目，强烈推荐Spring Initializr,它从本质上来说就是一个Web应用程序，它能为你生成Spring Boot项目结构。
Spring Initializr有几种用法：

1、通过Web界面使用，访问：http://start.spring.io/

2、通过ide相关插件创建

@SpringBootApplication是Sprnig Boot项目的核心注解，主要目的是开启自动配置。
使用命令 mvn spring-boot:run”在命令行启动该应用

spring-boot配置文件application.properties支持的属性列表：http://docs.spring.io/spring-...
1、直接在要使用的地方通过注解@Value(value=”${configName}”)就可以绑定到你想要的属性上面。
2、在application.properties中的各个参数之间也可以直接引用来使用。

com.name="111"
com.want="222"
com.dudu.yearhope=${com.name}-${com.want}

3、有时候属性太多了，一个个绑定到属性字段上太累，官方提倡绑定一个对象的bean，这里我们建一个ConfigBean.java类，顶部需要使用注解@ConfigurationProperties(prefix = “com.xxx”)来指明使用哪个.这点可以参考：org.springframework.boot.autoconfigure.jdbc.DataSourceProperties类的写法

这里配置完还需要在spring Boot入口类加上@EnableConfigurationProperties并指明要加载哪个bean
比如：@EnableConfigurationProperties(DataSourceProperties.class)

4、有时候我们不希望把所有配置都放在application.properties里面，这时候我们可以另外定义一个，如test.properties,路径跟也放在src/main/resources下面。
我们新建一个bean类,如下：

@Configuration
@ConfigurationProperties(prefix = "com.md") 
@PropertySource("classpath:test.properties")
public class ConfigTestBean {
    private String name;
    private String want;
    // 省略getter和setter
}

5、随机值配置
配置文件中${random} 可以用来生成各种不同类型的随机值，从而简化了代码生成的麻烦，例如 生成 int 值、long 值或者 string 字符串。

dudu.number=${random.int}
dudu.uuid=${random.uuid}
dudu.number.less.than.ten=${random.int(10)}
dudu.number.in.range=${random.int[1024,65536]}

6、外部配置-命令行参数配置
如java -jar xx.jar --server.port=9090
其中server.port是application.properties里面的选项

7、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

还可以像这样设置SPRING_PROFILES_ACTIVE环境变量：

$ export SPRING_PROFILES_ACTIVE=production

在代码里，我们还可以直接用@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

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@SpringBootApplication背后：打开源码看看，有三个Annotation原注解：

@Configuration（@SpringBootConfiguration点开查看发现里面还是应用了@Configuration）

@EnableAutoConfiguration

@ComponentScan(如果不指定basePackages等属性，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。)

@EnableAutoConfiguration这个Annotation最为重要(点开源码看看),Spring框架提供的各种名字为@Enable开头的Annotation定义？比如@EnableScheduling、@EnableCaching、@EnableMBeanExport等，@EnableAutoConfiguration的理念和做事方式其实一脉相承，简单概括一下就是，借助@Import的支持，收集和注册特定场景相关的bean定义。

@EnableScheduling是通过@Import将Spring调度框架相关的bean定义都加载到IoC容器。

@EnableMBeanExport是通过@Import将JMX相关的bean定义加载到IoC容器。

而@EnableAutoConfiguration也是借助@Import的帮助，将所有符合自动配置条件的bean定义加载到IoC容器，仅此而已！

借助于Spring框架原有的一个工具类：SpringFactoriesLoader的支持，@EnableAutoConfiguration可以智能的自动配置
SpringFactoriesLoader属于Spring框架私有的一种扩展方案，其主要功能就是从指定的配置文件META-INF/spring.factories加载配置。
@EnableAutoConfiguration自动配置的魔法骑士是从classpath中搜寻所有的META-INF/spring.factories配置文件，并将其中org.springframework.boot.autoconfigure.EnableutoConfiguration对应的配置项(主要在SpringBoot的autoconfigure依赖包中)通过反射（Java Refletion）实例化为对应的标注了@Configuration的JavaConfig形式的IoC容器配置类，然后汇总为一个并加载到IoC容器。

1） 如果使用的是SpringApplication.run静态方法，那么，这个方法里面首先要创建一个SpringApplication实例，在初始化的时候，它会提前做几件事情：

根据classpath里面是否存在某个特征类（org.springframework.web.context.ConfigurableWebApplicationContext）来决定是否应该创建一个为Web应用使用的ApplicationContext类型。

使用SpringFactoriesLoader在应用的classpath中查找并加载所有可用的ApplicationContextInitializer,ApplicationListener

2）执行run方法的逻辑，首先遍历执行所有通过SpringFactoriesLoader可以查找到并加载的SpringApplicationRunListener。调用它们的started()方法。然后
创建并配置当前Spring Boot应用将要使用的Environment（包括配置要使用的PropertySource以及Profile）。然后遍历调用所有SpringApplicationRunListener的environmentPrepared()的方法。之后，如果SpringApplication的showBanner属性被设置为true，则打印banner。

3） 根据用户是否明确设置了applicationContextClass类型以及初始化阶段的推断结果，决定该为当前SpringBoot应用创建什么类型的ApplicationContext并创建完成，然后根据条件决定是否添加ShutdownHook，决定是否使用自定义的BeanNameGenerator，决定是否使用自定义的ResourceLoader，当然，最重要的，将之前准备好的Environment设置给创建好的ApplicationContext使用。

4） ApplicationContext创建好之后，遍历调用先前找到的ApplicationContextInitializer的initialize（applicationContext）方法来对已经创建好的ApplicationContext进行进一步的处理。
5） 遍历调用所有SpringApplicationRunListener的contextPrepared()方法。
6） 最核心的一步，将之前通过@EnableAutoConfiguration获取的所有配置以及其他形式的IoC容器配置加载到已经准备完毕的ApplicationContext。
7） 遍历调用所有SpringApplicationRunListener的contextLoaded()方法。
8） 调用ApplicationContext的refresh()方法，完成IoC容器可用的最后一道工序。
9） 查找当前ApplicationContext中是否注册有CommandLineRunner，如果有，则遍历执行它们。
10） 正常情况下，遍历执行SpringApplicationRunListener的finished()方法.

Spring Boot为Spring MVC提供适用于多数应用的自动配置功能。在Spring默认基础上，自动配置添加了以下特性：

引入ContentNegotiatingViewResolver和BeanNameViewResolver beans。

对静态资源的支持，包括对WebJars的支持。

自动注册Converter，GenericConverter，Formatter beans。

对HttpMessageConverters的支持。

自动注册MessageCodeResolver。

对静态index.html的支持。

对自定义Favicon的支持。

如果想全面控制Spring MVC，你可以添加自己的@Configuration，并使用@EnableWebMvc对其注解。如果想保留Spring Boot MVC的特性，并只是添加其他的MVC配置(拦截器，formatters，视图控制器等)，你可以添加自己的WebMvcConfigurerAdapter类型的@Bean（不使用@EnableWebMvc注解）
例如：配置一个拦截器

@Configuration
public class WebConfiguration extends WebMvcConfigurerAdapter {
    @Bean    public RemoteIpFilter remoteIpFilter() {
        return new RemoteIpFilter();
    }

    @Bean    public LocaleChangeInterceptor localeChangeInterceptor() {
        return new LocaleChangeInterceptor();
    }
    @Override    public void addInterceptors(InterceptorRegistry registry {
        registry.addInterceptor(localeChangeInterceptor());
    }
}

Spring Boot 默认为我们提供了静态资源处理，使用 WebMvcAutoConfiguration 中的配置各种属性。
建议大家使用Spring Boot的默认配置方式，提供的静态资源映射如下:

classpath:/META-INF/resources

classpath:/resources

classpath:/static

classpath:/public

这使用了Spring MVC的ResourceHttpRequestHandler.

Spring Boot支持多种模版引擎包括：

FreeMarker

Groovy

Thymeleaf(官方推荐)

Mustache

JSP技术Spring Boot官方是不推荐的，原因有三：

tomcat只支持war的打包方式，不支持可执行的jar。

Jetty 嵌套的容器不支持jsp

创建自定义error.jsp页面不会覆盖错误处理的默认视图，而应该使用自定义错误页面

当你使用上述模板引擎中的任何一个，它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径

Spring Boot自动配置的默认错误处理器会查找名为error的视图，如果找不到就用默认的白标
错误视图，如图3-1所示。因此，最简单的方法就是创建一个自定义视图，让解析出的视图名为
error。
这一点归根到底取决于错误视图解析时的视图解析器。

 实现了Spring的View接口的Bean，其 ID为error（由Spring的BeanNameViewResolver所解析）。

 如果配置了Thymeleaf，则有名为error.html的Thymeleaf模板。

 如果配置了FreeMarker，则有名为error.ftl的FreeMarker模板。

 如果配置了Velocity，则有名为error.vm的Velocity模板。

 如果是用JSP视图，则有名为error.jsp的JSP模板。

Spring Boot会为错误视图提供如下错误属性。

 timestamp：错误发生的时间。

 status：HTTP状态码。

 error：错误原因。

 exception：异常的类名。

 message：异常消息（如果这个错误是由异常引起的）。

 errors：BindingResult异常里的各种错误（如果这个错误是由异常引起的）。

 trace：异常跟踪信息（如果这个错误是由异常引起的）。

 path：错误发生时请求的URL路径。

spring-boot-starter-logging
根据不同的日志系统，你可以按如下规则组织配置文件名，就能被正确加载：

Logback：logback-spring.xml, logback-spring.groovy, logback.xml

Log4j：log4j-spring.properties, log4j-spring.xml, log4j.properties, log4j.xml

Log4j2：log4j2-spring.xml, log4j2.xml

如果你不想用logback.xml作为Logback配置的名字，可以通过logging.config属性指定自定义的名字：
logging.config=classpath:logging-config.xml

据不同环境（prod:生产环境，test:测试环境，dev:开发环境）来定义不同的日志输出，在 logback-spring.xml中使用 springProfile 节点来定义，方法如下：
文件名称不是logback.xml，想使用spring扩展profile支持，要以logback-spring.xml命名

可以启动服务的时候指定 profile （如不指定使用默认），如指定prod 的方式为：
java -jar xxx.jar –spring.profiles.active=prod

1、使用普通jdbc

    org.springframework.boot
    spring-boot-starter-jdbc


    mysql
    mysql-connector-java

application.properties中配置数据源信息。

spring.datasource.url = jdbc:mysql://localhost:3306/spring?useUnicode=true&characterEncoding=utf-8
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.driver-class-name = com.mysql.jdbc.Driver

自定义数据源

    com.alibaba
    druid
    1.0.19

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Autowired
    private Environment env;

    //destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用.
    @Bean(destroyMethod =  "close")
    public DataSource dataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setUrl(env.getProperty("spring.datasource.url"));
        dataSource.setUsername(env.getProperty("spring.datasource.username"));//用户名
        dataSource.setPassword(env.getProperty("spring.datasource.password"));//密码
        dataSource.setDriverClassName(env.getProperty("spring.datasource.driver-class-name"));
        dataSource.setInitialSize(2);//初始化时建立物理连接的个数
        dataSource.setMaxActive(20);//最大连接池数量
        dataSource.setMinIdle(0);//最小连接池数量
        dataSource.setMaxWait(60000);//获取连接时最大等待时间，单位毫秒。
        dataSource.setValidationQuery("SELECT 1");//用来检测连接是否有效的sql
        dataSource.setTestOnBorrow(false);//申请连接时执行validationQuery检测连接是否有效
        dataSource.setTestWhileIdle(true);//建议配置为true，不影响性能，并且保证安全性。
        dataSource.setPoolPreparedStatements(false);//是否缓存preparedStatement，也就是PSCache
        return dataSource;
    }
}

Spring Boot自动配置自带了很多配置类，每一个都能运用
在你的应用程序里。它们都使用了Spring 4.0的条件化配置，可以在运行时判断这个配置是该被运
用，还是该被忽略。如:

@Bean
@ConditionalOnMissingBean(JdbcOperations.class)
public JdbcTemplate jdbcTemplate() {
return new JdbcTemplate(this.dataSource);
}

条件注解有如下：

@ConditionalOnBean 配置了某个特定Bean

@ConditionalOnMissingBean 没有配置特定的Bean

@ConditionalOnClass Classpath里有指定的类

@ConditionalOnMissingClass Classpath里缺少指定的类

@ConditionalOnExpression 给定的Spring Expression Language（SpEL）表达式计算结果为true

@ConditionalOnJava Java的版本匹配特定值或者一个范围值

@ConditionalOnJndi 参数中给定的JNDI位置必须存在一个，如果没有给参数，则要有JNDI

InitialContext

@ConditionalOnProperty 指定的配置属性要有一个明确的值

@ConditionalOnResource Classpath里有指定的资源

@ConditionalOnWebApplication 这是一个Web应用程序

@ConditionalOnNotWebApplication 这不是一个Web应用程序

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
public MyTest{
    @Test
    public void test1(){

    }
}

1、普通测试

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
@WebAppConfiguration
public class MockMvcWebTests {
    @Autowired
    private WebApplicationContext webContext;
    private MockMvc mockMvc;
    @Before
    public void setupMockMvc() {
        mockMvc = MockMvcBuilders.webAppContextSetup(webContext).build();
    }
    @Test
    public void homePage() throws Exception {
        mockMvc.perform(MockMvcRequestBuilders.get("/readingList"))
                .andExpect(MockMvcResultMatchers.status().isOk())
                .andExpect(MockMvcResultMatchers.view().name("readingList"))
                .andExpect(MockMvcResultMatchers.model().attributeExists("books"))
                .andExpect(MockMvcResultMatchers.model().attribute("books",
            Matchers.is(Matchers.empty())));
    }
}

首先向/readingList发起一个GET请求，接下来希望该
请求处理成功（isOk()会判断HTTP 200响应码），并且视图的逻辑名称为readingList。测试
还要断定模型包含一个名为books的属性，该属性是一个空集合。所有的断言都很直观。

2、测试运行中的应用程序
在测试类上添加@Web-IntegrationTest注解，可以声明你不仅希望Spring Boot为测试创建应用程序上下文，还要启动一个嵌入式的Servlet容器。一旦应用程序运行在嵌入式容器里，你就可以发起真实的HTTP请求，断言结果了。
这里采用@WebIntegration-Test，在服务器里启动了应用程序, 以Spring的RestTemplate对应用程序发起HTTP请求。
Spring-boot 1.4以后推荐采用SpringBootTest(webEnvironment=WebEnvironment.DEFINED_PORT) (or RANDOM_PORT)来代替@WebIntegrationTest,而此类在1.5已经被移除了。https://github.com/spring-pro...

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class,webEnvironment=WebEnvironment.RANDOM_PORT)
public class WebInRuntimeTest {
    @Value("${local.server.port}")
    private int port;
    @Autowired
    private TestRestTemplate template;
    @Test
    public void test1(){
//        Assert.state(true,"测试成功");
        System.out.println(port);
        ResponseEntity response=template.getForEntity("/test/111", String.class);
        System.out.println(response.getStatusCodeValue());
        System.out.println(response.getHeaders());
        
        System.out.println(response.getBody());
        Assert.hasText("111","true");
    }
}

用随机端口启动服务器,@WebIntegrationTest的value属性接受一个String数组，数组中的每项都是键值对，形如name=value，用来设置测试中使用的属性。要设置server.port，你可以这样做：**@WebIntegrationTest("server.port:0") //使用0表示端口号随机，也可以具体指定如8888这样的固定端口.
或者直接这样@WebIntegrationTest(randomPort=true)**

Spring Boot将local.server.port的值设置为了选中的端口。我们只需使用Spring的@Value注解将其注入即可：

@Value("${local.server.port}")
private int port;

3、使用Selenium 测试HTML 页面

@RunWith(SpringRunner.class)
@SpringBootTest(classes = App.class)
@WebIntegrationTest(randomPort=true)
public class ServerWebTests {
    private static FirefoxDriver browser;
    @Value("${local.server.port}")
    private int port;
    @BeforeClass
    public static void openBrowser() {
        browser = new FirefoxDriver();
        browser.manage().timeouts().implicitlyWait(10, TimeUnit.SECONDS);
    }
    @Test
    public void addBookToEmptyList() {
        String baseUrl = "http://localhost:" + port;
        browser.get(baseUrl);
        assertEquals("You have no books in your book list",browser.findElementByTagName("div").getText());
        browser.findElementByName("title").sendKeys("BOOK TITLE");
        browser.findElementByTagName("form").submit();
        WebElement dl =
            browser.findElementByCssSelector("dt.bookHeadline");
        assertEquals("BOOK TITLE by BOOK AUTHOR (ISBN: 1234567890)",dl.getText());
    }
    @AfterClass
    public static void closeBrowser() {
        browser.quit();
    }
}

当我们不想使用内嵌tomcat部署时，我们也可以使用外部tomcat，并打包成war：
https://docs.spring.io/spring...

Spring Loaded

spring-boot-devtools

IDE的JRebel插件

1、Spring Loaded 实现热部署
Spring Loaded是一个用于在JVM运行时重新加载类文件更改的JVM代理,Spring Loaded允许你动态的新增/修改/删除某个方法/字段/构造方法,同样可以修改作用在类/方法/字段/构造方法上的注解.也可以新增/删除/改变枚举中的值。

spring-loaded是一个开源项目,项目地址:https://github.com/spring-pro...

Spring Loaded有两种方式实现，分别是Maven引入依赖方式或者添加启动参数方式

    org.springframework.boot
    spring-boot-maven-plugin
    
        
        org.springframework
        springloaded
        1.2.6.RELEASE
        
    

启动：mvn spring-boot:run
注意：maven依赖的方式只适合spring-boot:run的启动方式，右键那种方式不行。

出现如下配置表实配置成功：
[INFO] Attaching agents: [C:Userstengj.m2repositoryorgspringframeworkspringloaded1.2.6.R

添加启动参数方式
这种方式是右键运行启动类.首先先下载对应的springloaded-xxx.RELEASE.jar，可以去上面提到的官网获取,在VM options中输入-javaagent:< pathTo >/springloaded-{VERSION}.jar

上面2种方式随便选择一种即可,当系统通过 mvn spring-boot:run启动或者 右键application debug启动Java文件时，系统会监视classes文件，当有classes文件被改动时，系统会重新加载类文件，不用重启启动服务。
注：IDEA下需要重新编译文件 Ctrl+Shift+F9或者编译项目 Ctrl+F9

在 Spring Boot，模板引擎的页面默认是开启缓存，如果修改页面内容，刷新页面是无法获取修改后的页面内容，所以，如果我们不需要模板引擎的缓存，可以进行关闭。

spring.freemarker.cache=false
spring.thymeleaf.cache=false
spring.velocity.cache=false
spring.mustache.cache=false

不过还是有一些情况下需要重新启动，不可用的情况如下：

1：对于一些第三方框架的注解的修改，不能自动加载，比如：spring mvc的@RequestMapping

2：application.properties的修改也不行

3：log4j的配置文件的修改不能即时生效

2、spring-boot-devtools 实现热部署
spring-boot-devtools为应用提供一些开发时特性，包括默认值设置，自动重启，livereload等。

    
        org.springframework.boot
        spring-boot-devtools
        true
    

将依赖关系标记为可选< optional >true< /optional>是一种最佳做法，可以防止使用项目将devtools传递性地应用于其他模块。
在Spring Boot集成Thymeleaf时，spring.thymeleaf.cache属性设置为false可以禁用模板引擎编译的缓存结果。
现在，devtools会自动帮你做到这些，禁用所有模板的缓存，包括Thymeleaf, Freemarker, Groovy Templates, Velocity, Mustache等。

自动重启的原理在于spring boot使用两个classloader：不改变的类（如第三方jar）由base类加载器加载，正在开发的类由restart类加载器加载。应用重启时，restart类加载器被扔掉重建，而base类加载器不变，这种方法意味着应用程序重新启动通常比“冷启动”快得多，因为base类加载器已经可用并已填充。

所以，当我们开启devtools后，classpath中的文件变化会导致应用自动重启。
当然不同的IDE效果不一样，Eclipse中保存文件即可引起classpath更新(注：需要打开自动编译)，从而触发重启。而IDEA则需要自己手动CTRL+F9重新编译一下（感觉IDEA这种更好，不然每修改一个地方就重启，好蛋疼）

排除静态资源文件
静态资源文件在改变之后有时候没必要触发应用程序重启，例如thymeleaf模板文件就可以实时编辑，默认情况下，更改/META-INF/maven, /META-INF/resources ,/resources ,/static ,/public 或/templates下的资源不会触发重启，而是触发live reload（devtools内嵌了一个LiveReload server，当资源发生改变时，浏览器刷新,需要浏览器插件支持）。

可以使用spring.devtools.restart.exclude属性配置，例如

spring.devtools.restart.exclude=static/**,public/**

如果想保留默认配置，同时增加新的配置，则可使用
spring.devtools.restart.additional-exclude属性

观察额外的路径
如果你想观察不在classpath中的路径的文件变化并触发重启，则可以配置 spring.devtools.restart.additional-paths 属性。

不在classpath内的path可以配置spring.devtools.restart.additionalpaths属性来增加到监视中，同时配置spring.devtools.restart.exclude可以选择这些path的变化是导致restart还是live reload。

关闭自动重启
设置 spring.devtools.restart.enabled 属性为false，可以关闭该特性。可以在application.properties中设置，也可以通过设置环境变量的方式。

public static void main(String[] args) {
    System.setProperty("spring.devtools.restart.enabled", "false");
    SpringApplication.run(MyApp.class, args);
}

使用一个触发文件
若不想每次修改都触发自动重启，可以设置spring.devtools.restart.trigger-file指向某个文件，只有更改这个文件时才触发自动重启。

自定义自动重启类加载器
默认时，IDE中打开的项目都会由restart加载器加载，jar文件由Base加载器加载，但是若你使用multi-module的项目，并且不是所有模块都被导入到IDE中，此时会导致加载器不一致。这时你可以创建META-INF/spring-devtools.properties文件，并增加restart.exclude.XXX，restart.include.XXX来配置哪些jar被restart加载，哪些被base加载。如：

restart.include.companycommonlibs=/mycorp-common-[w-]+.jar
restart.include.projectcommon=/mycorp-myproj-[w-]+.jar

如果您不想在应用程序运行时启动LiveReload服务器，则可以将spring.devtools.livereload.enabled属性设置为false。
一次只能运行一个LiveReload服务器。开始应用程序之前，请确保没有其他LiveReload服务器正在运行。
如果你的IDE启动多个应用程序，则只有第一个应用程序将支持LiveReload。

3、JRebel插件方式 ：略

Spring Boot为两款流行的数据库迁移库提供了自动配置支持。
 Flyway（http://flywaydb.org）
 Liquibase（http://www.liquibase.org）

用Flyway定义数据库迁移过程

org.flywayfb
flyway-core

Flyway是一个非常简单的开源数据库迁移库，使用SQL来定义迁移脚本。它的理念是，每个
脚本都有一个版本号，Flyway会顺序执行这些脚本，让数据库达到期望的状态。它也会记录已执
行的脚本状态，不会重复执行。
，Flyway脚本就是SQL。让其发挥作用的是其在Classpath里的位置和文件名。Flyway
脚本都遵循一个命名规范，V版本号__描述.sql,如V1__initdb.sql
Flyway脚本需要放在src/main/resources/db/migration里。
你还需要将spring.jpa.hibernate.ddl-auto设置为none，由此告知Hibernate不要创建
数据表。

原理：在应用程序部署并运行起来后，Spring Boot会检测到Classpath里的Flyway，自动配置所需的
Bean。Flyway会依次查看/db/migration里的脚本，如果没有执行过就运行这些脚本。每个脚本都
执行过后，向schema_version表里写一条记录。应用程序下次启动时，Flyway会先看schema_version
里的记录，跳过那些脚本。

用Liquibase定义数据库迁移过程

相比Flyway的优点，数据库无关性，脚本不是用sql写，而是支持yaml,json,xml等格式。

org.liquibase
liquibase-core

具体介绍：略。

运行中的应用程序就像礼物盒。你可以刺探它，作出合理的推测，猜测它的运行情况。但如
何了解真实的情况呢？有没有一种办法能让你深入应用程序内部一窥究竟，了解它的行为，检查
它的健康状况，甚至触发一些操作来影响应用程序呢？
Spring Boot的Actuator。它提供了很多生产级的特性，比如监控和度
量Spring Boot应用程序。Actuator的这些特性可以通过众多REST端点、远程shell和JMX获得。

org.springframework.boot
spring-boot-starter-actuator

1、Actuator的Web端点
端点可以分为三大类：配置端点、度量端点和其他端点

GET /autoconfig 提供了一份自动配置报告，记录哪些自动配置条件通过了，哪些没通过

GET /configprops 描述配置属性（包含默认值）如何注入Bean

GET /beans 描述应用程序上下文里全部的Bean，以及它们的关系

GET /dump 获取线程活动的快照

GET /env 获取全部环境属性

GET /env/{name} 根据名称获取特定的环境属性值

GET /health 报告应用程序的健康指标，这些值由HealthIndicator的实现类提供

GET /info 获取应用程序的定制信息，这些信息由info打头的属性提供

GET /mappings 描述全部的URI路径，以及它们和控制器（包含Actuator端点）的映射关系

GET /metrics 报告各种应用程序度量信息，比如内存用量和HTTP请求计数

GET /metrics/{name} 报告指定名称的应用程序度量值

POST /shutdown 关闭应用程序，要求endpoints.shutdown.enabled设置为true

GET /trace 提供基本的HTTP请求跟踪信息（时间戳、HTTP头等）

/beans端点产生的报告能告诉你Spring应用程序上下文里都有哪些Bean。
/autoconfig端点能告
诉你为什么会有这个Bean，或者为什么没有这个Bean。
Spring Boot自动配置构建于Spring的条件化配置之上。它提供了众多带有
@Conditional注解的配置类，根据条件决定是否要自动配置这些Bean。/autoconfig端点提供了
一个报告，列出了计算过的所有条件，根据条件是否通过进行分组。

/env端点会生成应用程序可用的所有环境属性的列表，无论这些属性是否用到。这其中包括
环境变量、JVM属性、命令行参数，以及applicaition.properties或application.yml文件提供的属性。

/metrics端点提供了一些针对Web请求的基本计数器和计时器，但那些度量值缺少详细信
息。知道所处理请求的更多信息是很有帮助的，尤其是在调试时，所以就有了/trace这个端点。
/trace端点能报告所有Web请求的详细信息，包括请求方法、路径、时间戳以及请求和响应的
头信息

2、使用:CRaSH shell

3、通过JMX 监控应用程序

Book: Spring-Boot In Action
嘟嘟独立博客
https://github.com/tengj/Spri...