zhangjun62

SpringBoot学习

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。

Java一直被人诟病的一点就是臃肿、麻烦。主要体现在两点：

复杂的配置

项目各种配置其实是开发时的损耗，因为在思考 Spring 特性配置和解决业务问题之间需要进行思维切换，所以写配置挤占了写应用程序逻辑的时间。

混乱的依赖管理

项目的依赖管理也是件吃力不讨好的事情。决定项目里要用哪些库就已经够让人头痛的了，你还要知道这些库的哪个版本和其他库不会有冲突，这也是件棘手的问题。并且，依赖管理也是一种损耗，添加依赖不是写应用程序代码。一旦选错了依赖的版本，随之而来的不兼容问题毫无疑问会是生产力杀手。

Spring Boot 主要特征是：

创建独立的spring应用程序

直接内嵌tomcat、jetty和undertow（不需要打包成war包部署）

提供了固定化的“starter”配置，以简化构建配置

尽可能的自动配置spring和第三方库

提供产品级的功能，如：安全指标、运行状况监测和外部化配置等

绝对不会生成代码，并且不需要XML配置

SpringBoot第一个例子

开发工具IDEA、JDK1.8

打开IDEA、创建Maven工程（跳过骨架）

输入项目Maven坐标

选择工程路径完成项目创建

添加依赖

SpringBoot提供了一个名为spring-boot-starter-parent的工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，自己创建的项目需要以这个项目为父工程，这样就不用操心依赖的版本问题，需要什么依赖，直接引入坐标即可！

添加父工程坐标


    org.springframework.boot
    spring-boot-starter-parent
    2.0.4.RELEASE

添加web启动器


    
        org.springframework.boot
        spring-boot-starter-web

添加依赖不需要版本，由SpringBoot管理。工程在加入以来后会出现很多jar包

POM文件



    4.0.0

    cn.zjut.demo
    springboot-demo
    1.0.0-SNAPSHOT

    
        org.springframework.boot
        spring-boot-starter-parent
        2.0.4.RELEASE
    

    
        
            org.springframework.boot
            spring-boot-starter-web

Spring Boot项目通过main函数即可启动，需要创建一个启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

创建Controller类

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

//@RestController注解相当于@ResponseBody ＋ @Controller合在一起的作用
@RestController
public class HelloController {
    //@GetMapping是一个组合注解，是@RequestMapping(method = RequestMethod.GET)的缩写
    //@PostMapping是一个组合注解，是@RequestMapping(method = RequestMethod.POST)的缩写
    @GetMapping("hello")
    public String hello(){
        return "Hello, SpringBoot";
    }
}

启动项目

启动项目看到控制台输出端口、访问路径、Controller映射等信息

访问http://localhost:8080/hello 得到Hello, SpringBoot表明整个工程测试成功

Java配置

传统配置Bean是通过xml方式，但是对于SpringBoot是没有xml文件，主要是通过Java配置方式来配置Bean。在Spring3.0开始，Spring官方就已经开始推荐使用java配置来代替传统的xml配置。

配置数据库连接池来使用Java配置

传统xml配置

init-method="init" destroy-method="close">

Java配置

Java配置主要靠java类和一些注解，比较常用的注解有：

@Configuration：声明一个类作为配置类，代替xml文件

@Bean：声明在方法上，将方法的返回值加入Bean容器，代替标签

@PropertySource：指定外部属性文件

首先引入druid数据源依赖


    com.alibaba
    druid
    1.1.16

创建jdbc.properties文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/leyou
jdbc.username=root
jdbc.password=1234

实现配置类

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

import javax.sql.DataSource;

@Configuration
@PropertySource("classpath:jdbc.properties")
public class JdbcConfig {
    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.driverClassName}")
    private String driverClassName;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;


    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

HelloController类注入DataSource dataSource属性

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.sql.DataSource;

@RestController
public class HelloController {
    @Autowired
    private DataSource dataSource;

    @GetMapping("hello")
    public String hello(){
        return "Hello, SpringBoot";
    }
}

打上断点，Debug方式启动，访问hello方法，查看dataSource对象相关属性有值表明注入成功

SpringBoot属性注入

创建一个类JdbcProperties用于属性注入

首先将属性文件名改为application.properties，SpringBoot自动识别这个文件

导入Lombok依赖，通过@Data注解为类生成setter/getter、hashCode、equals等方法

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

//SpringBoot扫描@ConfigurationProperties会将此类作为属性注入类,prefix表示属性文件里属性前缀
@ConfigurationProperties(prefix = "jdbc")
@Data
public class JdbcProperties {
    String url;
    String driverClassName;
    String username;
    String password;
}

JdbcConfig类通过@EnableConfigurationProperties注解使用属性注入类,为dataSource相关属性赋值

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
@EnableConfigurationProperties(JdbcProperties.class)
public class JdbcConfig {
    //使用方式一
//    @Autowired
//    JdbcProperties jdbcProperties;

    //使用方式二
//    public JdbcConfig(JdbcProperties jdbcProperties){
//        this.jdbcProperties = jdbcProperties
//    }
    
    //使用方式三
    @Bean
    public DataSource dataSource(JdbcProperties prop){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(prop.getDriverClassName());
        dataSource.setUrl(prop.getUrl());
        dataSource.setUsername(prop.getUsername());
        dataSource.setPassword(prop.getPassword());
        return dataSource;
    }
}

Debug启动工程，运行到断点位置，查看dataSource对象相关属性有值，表明测试成功

SpringBoot另外一种读取属性文件进行属性注入的方式更加简化

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import javax.sql.DataSource;

@Configuration
public class JdbcConfig {
    @Bean
    @ConfigurationProperties("jdbc")
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        return dataSource;
    }
}

Debug启动工程，运行到断点位置，查看dataSource对象相关属性有值，表明测试成功

Yaml配置文件

配置文件除了使用格式为 application.properties，还可以使用后缀名为.yaml或者yml，即application.yaml,application.yml

基本格式：

jdbc:
  driverClassName: com.mysql.jdbc.Driver
  url: jdbc:mysql://127.0.0.1:3306/leyou
  username: root
  password: 1234
  user:
    name: zhangsan
    age: 18
    language:
      - Java
      - C++
      - C
      - Pyhton

如果两个文件都存在，将两个配置文件合并，如果有重复，以properties为准

自动配置原理

启动类有注解@SpringBootApplication和SpringApplication.run()

点击@SpringBootApplication进入源码发现注解上有三个注解：

@SpringBootConfiguration
@EnableAutoConfiguration

@ComponentScan

点击 @SpringBootConfiguration进入源码

在这个注解上面，又有一个@Configuration注解。这个注解的作用就是声明当前类是一个配置类，然后Spring会自动扫描到添加了@Configuration的类，并且读取其中的配置信息。而@SpringBootConfiguration是来声明当前类是SpringBoot应用的配置类，项目中只能有一个。所以一般无需自己添加。

@EnableAutoConfiguration

关于这个注解，官网上有一段说明：

> The second class-level annotation is `@EnableAutoConfiguration`. This annotation
   > tells Spring Boot to “guess” how you want to configure Spring, based on the jar
   > dependencies that you have added. Since `spring-boot-starter-web` added Tomcat
   > and Spring MVC, the auto-configuration assumes that you are developing a web
   > application and sets up Spring accordingly.

基本翻译：第二级注解`@EnableAutoConfiguration`，告诉SpringBoot基于你所添加的依赖，去“猜测”你想要如何配置Spring。比如我们引入`spring-boot-starter-web`，而这个启动器中帮我们添加`tomcat`、`SpringMVC`的依赖。此时自动配置就知道你是要开发一个web应用，所以就帮你完成web及SpringMVC的默认配置！

SpringBoot内部对大量的第三方库或Spring内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有那么默认配置就会生效。所以，使用SpringBoot构建一个项目，只需要引入所需框架的依赖，配置就可以交给SpringBoot处理了。除非你不希望使用SpringBoot的默认配置，它也提供了自定义配置的入口。

@ComponentScan

配置组件扫描的指令。提供了类似与标签的作用。通过basePackageClasses或者basePackages属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包。而我们的@SpringBootApplication注解声明的类就是main函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，**一般启动类会放在一个比较前的包目录中。

使用IDEA的Spring Initiallizer创建Spring Boot工程

Service URL：这里的内容不用修改。该 URL 表示在创建 Spring starter 工程时若需要的一些资源在本地 Maven 仓库中没有，则需要从该 URL 中进行下载。另外，也可以打开该URL 地址，完成线上工程的创建。
Packaging：虽然创建的是 web 工程，这里要选择打 Jar 包。因为 Spring Boot 的 web 工程是作为一个可直接运行的 Java 工程出现的，其中已经内置了 Tomcat。Java 工程一旦启动，Tomcat 自动启动并会让应用程序开始运行。客户端可以通过浏览器直接对应用进行访问。
 Package：在域名倒序后至少要多写出一级，这一级一般都为工程名称。当然，若是一个项目中包含多个工程，那么这里应该多写出两级：项目名称+工程名称。后面所有的代码都要求必须出现在该级别的下面级别中，不能出现在平级包中。

工程编辑

IDEA会生成一个自动启动类PimaryApplication，与前面手动创建的SpringBoot工程一致

在启动类所在的包下再创建一个子包，在其中编写 SpringMVC 的处理器类。注意，要求代码所在的包必须是启动类所在包的子孙包，不能是同级包。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeHandler {
    @RequestMapping("/some")
    public String someHandle(){
        return "Hello, Spring Boot";
    }
}

运行工程并访问

工程解析

启动类在前面已经讲诉，故不再赘述

src/main/resources 目录

static目录：存放静态资源，例如CSS、JS、Image等资源

templates 目录：存放动态资源。Spring Boot 不建议使用 jsp 作为动态数据展示页面，而是建议使用 Thymeleaf。Thymeleaf 是一种 Java 模板引擎，可以显示动态数据。Thymeleaf文件的扩展名为 html，是对 html 的扩展。该目录用于存放 Thymeleaf 文件。

这两个目录中存放的资源都相当于存放在当前 Web 应用的根下，不过，一般不使用它们存放资源。

application.properties：Spring Boot 的主配置文件。

核心依赖与插件没有版本号

查看当前工程

在 pom 文件中包含 Spring Boot 的两个核心依赖及一个核心插件。一个是 Spring Boot 的Web 启动依赖，一个是 Spring Boot 的测试启动依赖；而这个核心插件是用于完成对 SpringBoot 工程打包结果的再打包。可以注意到，它们均没有版本号。

虽然它们都没有版本号，但打开工程中的 Maven Dependencies 可以看到，它们的版本号均为 2.1.6

它们的版本号均继承自父工程。从 pom 文件中可以看出，其父工程为spring-boot-starter-parent。

查看 spring-boot-starter-parent

打开 Maven 本地仓库，在 org.springframework 中找到工程 spring-boot-starter-parent

进入该工程目录，找到其 pom 文件。

打开该 pom 文件，发现该工程的中有对该插件的配置信息。注意，< pluginManagement >中声明的插件是选择性继承插件，而非全部继承插件。

从该插件的配置信息可以看出，其执行的目标是 repackage，即对工程进行重新打包。首次打包是由 Maven 的 package 插件完成的，其打包的结果仅仅是将当前工程中自定义的类打包为了一个普通的 Jar 包，没有 Spring Boot 的相关资源，无法直接运行。当然，其打包的结果是.jar 文件。
重新打包是由 spring-boot-maven-plugin 插件完成的，其是将前面打成的 jar 包进行了二次打包，将原来的软件包变为了 Spring Boot 可执行包，在其中不仅添加了 Spring Boot 依赖，还添加了很多其它配置。同时，其还将原来的.jar 文件扩展名变为了.orininal，而二次打包后的文件扩展名成为了.jar。

可以打开这两个包，查看其中内容的不同。首先打开.orininal 包，发现其中只有当前工程中写入的类，没有 Spring Boot 的依赖。然后再打开 META-INF 中的清单文件 MANIFEST.MF，发现其中并没入口类 Main-Class。

再打开二次打包的.jar 文件，发现其中已经增加了 Spring Boot 的各种依赖了。其中：

BOOT-INF 目录：存放的是当前应用程序的类及其所依赖的类

META-INF 目录：存放的是 Maven 相关的配置文件

org 目录：存放的是 SpringBoot 启动所需的类

并且，打开其 META-INF 中的清单文件 MANIFEST.MF，不仅可以看到主类 Main-Class，还可以看到当前工程的启动类 Start-Class。

不过，这个插件配置信息中仍没有版本号。说明该工程仍存在父工程。在该pom 文件开头部分可以看到该工程的父工程为 spring-boot-dependencies。

查看 spring-boot-dependencies

在 Maven 本地仓库中找到 spring-boot-dependencies 工程。进入工程目录，找到该工程的 pom 文件。

打开该文件，在中可以找到这两个完整依赖。注意，中声明的依赖是选择性继承依赖，而非全部继承依赖。

在中可以看到 spring-boot-maven-plugin 的完整插件信息。

修改默认的 Jar 包依赖版本

找到 spring-boot-dependencies 工程的 pom 文件，可以看到其中已经定义好了很多依赖的版本号，其中就包含。

所以，若要使当前定义的 Spring Boot 项目依赖于其它版本的 Jar 包，例如依赖于 5.0.1版本的 Spring 的 Jar 包，则只需在当前项目的 pom.xml 文件中使用新的版本号将原版本号覆盖即可。

spring-boot-starter-parent 工程中主要声明了对选择性继承插件的详细配置，而spring-boot-dependencies 工程中主要定义了选择性继承依赖，选择性继承插件，及依赖的版本号。

mvnw

在 Spring Boot 工程中自带的有两个文件：mvnw 与 mvnw.cmd。

Maven 是一个常用的构建工具，但是 Maven 的版本和插件的配合并不是十分完美，有时为了保证有些插件的正常运行，不得不需要切换到一个稍微旧一些的版本。而这个切换工作需要用户重新安装一个 Maven，那么就太麻烦了。
   有一个工具 Maven Wrapper(包装器)，可以完成在 Maven 的某一版本下轻松切换到其它版本的目的。需要注意的是，Maven Wrapper 并不是 Maven 官方提供的工具，而是第三方工具，若要使用，则需要安装。
   Spring Boot工程中的mvnw即为安装好的Maven Wrapper工具。其中mvnw.cmd为MavenWrapper 的命令行运行窗口，而 mvnw 文件则为 Maven Wrapper 的配置文件。
   这两个文件可以删除。

官网创建

在点击了 Generate Project 按钮后，即可打开一个下载对话框。官网将配置好的 Spring Boot工程生成了一个 zip 压缩文件,只要将其下载到本地即可。下载后，将其解压到工作空间中，在 idea 中即可马上看到该工程。注意，此时该工程是作为一个 Module 出现的。然后，再通过“导入外部 Moduel 方式”将该工程导入为 Maven 工程即可。

基于 war 的的 Spring Boot

前面创建的 Spring Boot 工程最终被打为了 Jar 包，是以可执行文件的形式出现的，其使用了 Spring Boot 内嵌的 Tomcat 作为 Web 服务器来运行 web 应用的。新版 Dubbo 的监控中心工程就是典型的应用。但在实际生产环境下，对于 Web 工程，很多时候需要的是 war包，然后部署到企业级 Web 服务器中。

工程创建

工程编辑

添加一个处理器类

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeHandler {
    @RequestMapping("/some")
    public String someHandle(){
        return "Hello, Spring Boot";
    }
}

运行并访问

打包部署

运行 Maven 的 package 命令，将其打为 war 包。找到该 war 包，将其部署到 Tomcat 的 webapps 目录中，启动 Tomcat。在浏览器中可以访问到该工程。注意，由于工程是部署到了 Tomcat 的 webapps 中，不是部署到 webapps/ROOT 中，所以在访问时需要指定工程名。

工程解析

web环境初始化

在该工程中发现其自动增加了一个类 ServletInitializer，该类重写了父类的 configure()方法。该方法用于完成 web 环境的配置，即 web 环境的初始化工作。

打开 SpringBootServletInitializer 类，查看其 configure()方法的注释可知，该方法已经完成了所有应用程序配置的默认设置，用户只需要写代码即可。

/**
 * Configure the application. Normally all you would need to do is to add sources
 * (e.g. config classes) because other settings have sensible defaults. You might
 * choose (for instance) to add default command line arguments, or set an active
 * Spring profile.
 * @param builder a builder for the application context
 * @return the application builder
 * @see SpringApplicationBuilder
 */
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
   return builder;
}

ServletAPI 依赖

由于这是一个 war 包工程，将来需要部署到服务器，即在打包时无需 ServletAPI。然而在编译时是需要的，所以在工程的 pom 文件中专门添加了provided范围的ServletAPI 依赖。

SpringBoot热部署

Idea 中的 Spring Boot 工程若要使用热部署，需要完成两个步骤：导入 devtools 依赖，编辑当前工程的配置信息。这两个步骤是在每一个使用热部署的 Spring Boot 工程中均要设置的。

需要注意，Spring Boot 工程在 Idea 中的热部署与 Eclipse 中的热部署，工程修改后的重新启动时机是不同的。Eclipse 中只要修改过的文件被保存了，则工程会马上重新部署。而 Idea则不同，其对文件修改后的保存是自动的，所以其重新部署的时机是 Idea 整个 IDE 窗口被钝化时，即 Windows 窗口切换到其它窗口时，工程会重新部署。


    org.springframework.boot
    spring-boot-devtools

其意义是，当 Idea 被钝化时，即当 Idea 窗口被切换时，更新类与资源。

   在开发调试过程中，已经启动了工程的运行。此时又修改了代码或配置文件，若要使修改生效，则需要重新启动工程。这种方式降低了开发效率。
   热部署，即在修改了代码或配置文件后，一经保存，系统马上对工程进行自动重启，无需手工重启。若要实现热部署，只需在 pom 中增加一个依赖即可。
   不过，对于热部署的使用是有利有弊。利是无需手工重启工程，但弊端也很明显：在修改过代码或配置后，只要保存系统就会重启工程，即使这个修改还未完毕，其也会重启，从而导致代码重启后报错。

Ctrl + Shift + A，打开搜索框，输入 Registry。

找到如下条目后，勾选即可。

SpringBoot主配置文件

Spring Boot 的主配置文件是 src/main/resources 中默认创建的 spring.properties 文件。双击该文件，其默认会使用 Spring Properties Editor 编辑器打开。使用该编辑器打开后的文件在书写多级属性时会有自动提示功能。

server.port=8888
server.servlet.context-path=/primarywar

不过需要注意，这里指定的 Tomcat 的端口号及应用的根路径，仅仅是针对于内置 Tomcat的，是测试时使用的。将工程打为 war 包后部署到真正的 Tomcat，这些配置是不起作用的，即 Tomcat 的端口号为真正 Tomcat 的端口号，而项目的根路径为 war 包名称。

Spring Boot 的主配置文件也可使用 application.yml 文件。yml，也可写为 yaml。

在开发之初 YAML 的本意是 Yet Another Markup Language（仍是一种标记语言）。后来为了强调这种语言是以数据为中心，而不是以标记为中心，所以将 YAML 解释为 Yaml Ain'Markup Language（Yaml 不是一种标记语言）。它是一种直观的能够被电脑识别的数据序列化格式，是一个可读性高并且容易被人阅读，容易和脚本语言交互，用来表达多级资源序列的
编程语言。

yml 与 properties 文件的主要区别是对于多级属性，即 key 的显示方式不同。yml 文件在输入时，只需按照点(.)的方式输出 key 即可，输入完毕后回车即出现了如下形式。该形式要求冒号后与值之间要有一个空格。

server:
  port: 8888
  servlet:
    context-path: /primarywar

Actuator

Actuator['æktʃʊˌeɪtə]( 激励者;执行器)是 Spring Boot 提供的对应用系统的自省和监控的集成功能，可以对应用系统进行配置查看、相关功能统计等。在 Spring Cloud 中主要是完成微服务的监控，完成监控治理。可以查看微服务间的数据处理和调用，当它们之间出现了异常，就可以快速定位到出现问题的地方。
其功能与 Dubbo 的监控中心类似，不同的是，Dubbo 的监控中心是需要专门部署的，而 Spring Boot 的 Actuator 是存在于每一个工程中的。

创建工程

创建工程，导入依赖


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

修改配置文件

#当前应用的端口号与上下文路径
server.port=8888
server.servlet.context-path=/actuatortest

#Actuator监控的端口号与上下文路径
management.server.port=9999
management.server.servlet.context-path=/monitor
#指定监控终端的基本路径,默认为actuator
management.endpoints.web.base-path=/base

访问测试

添加 Info 信息

修改配置文件

在配置文件中添加如下 Info 信息，则可以通过 info 监控终端查看到。

#当前应用的端口号与上下文路径
server.port=8888
server.servlet.context-path=/actuatortest

#Actuator监控的端口号与上下文路径
management.server.port=9999
management.server.servlet.context-path=/monitor
#指定监控终端的基本路径,默认为actuator
management.endpoints.web.base-path=/base

#自定义info信息
info.company.name=abc
info.company.url=http://www.abc.com
info.company.addr=Hangzhou China

info.auth.name=zhangsan
info.auth.dep=development

#从pom.xml文件中读取相应值
[email protected]@
[email protected]@
[email protected]@
[email protected]@

访问测试

开放其它监控终端

默认情况下，Actuator 仅开放了 health 与 info 两个监控终端，但其还有很多终端可用，不过，需要手动开放。

修改配置文件

#开放所有监控终端,默认只开启health和info监控终端
#在yml中*号为关键字,需要使用双引号将其括起来
management.endpoints.web.exposure.include=*

management:
  server:
    port: 9999
    servlet:
      context-path: /monitor
  endpoints:
    web:
      base-path: /base
      exposure:
        include: '*' #开放所有终端
        #include: ['env', 'beans'] #开放制定终端

访问测试

mappings终端

下面是使用 mappings 终端，可以看到当前工程中所有的 URI 与处理器的映射关系，及详细的处理器方法及其映射规则。很实用。

beans终端

env 终端

可以看到当前应用程序运行主机的所有软硬件环境信息。

单独关闭某些监控终端

在开放了所有监控终端的情况下，有些终端显示的信息并不想公开，此时可以单独关闭这些终端。

修改配置文件

management.endpoints.web.exposure.exclude=env,beans

访问测试

在关闭这些终端后，其它终端仍可继续使用。

常用的监控终端

SpringBoot重要用法

自定义异常页面

对于 404、405、500 等异常状态，服务器会给出默认的异常页面，而这些异常页面一般都是英文的，且非常不友好。我们可以通过简单的方式使用自定义异常页面，并将默认状态码页面进行替换。

定义目录

在 src/main/resources 目录下再定义新的目录 public/error。

定义异常页面

在 error 目录中定义异常页面。这些异常页面的名称必须为相应的状态码，扩展名为 html。

单元测试

总步骤

Spring Boot 下的单元测试比较简单，首先工程要具有 spring boot 的 test 依赖。

其次需要在测试类上添加两个注解：@RunWith(SpringRunner.class) @SpringBootTest(classes=SpringBoot 启动类.class)

定义工程

定义 Service

public interface ISomeService {
    void doSome();
}

定义 Service 实现类

import cn.zjut.springboottest.service.ISomeService;
import org.springframework.stereotype.Service;

@Service
public class SomeServiceImpl implements ISomeService {

    @Override
    public void doSome() {
        System.out.println("执行doSome方法");
    }
}

定义测试类

@SpringBootTest 注解的 classes 属性的值为被测试内容的的启动类。

import cn.zjut.springboottest.service.ISomeService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = SpringboottestApplication.class)
public class SpringboottestApplicationTests {
    @Autowired
    private ISomeService someService;

    @Test
    public void test(){
        someService.doSome();
    }
}

多环境选择

在开发应用时，通常同一套程序会被运行在多个不同的环境，例如，开发、测试、生产环境等。每个环境的数据库地址、服务器端口号等配置都会不同。若在不同环境下运行时将配置文件修改为不同内容，那么，这种做法不仅非常繁琐，而且很容易发生错误。

在开发应用时，有时不同的环境，其需要运行的接口的实现类也是不同的。例如，若要开发一个具有短信发送功能的应用，开发环境中要执行的 send()方法仅需调用短信模拟器即可，而生产环境中要执行的 send()则需要调用短信运营商所提供的短信发送接口。这种情况下，就需要开发两个相关接口的实现类去实现 send()方法。

对于不同的环境，需要使用不同的配置文件，执行不同的类。而这个选择只需在 SpringBoot 的主配置文件中指定即可。

下面以不同的环境“使用配置有不同的端口号的配置文件，及调用不同接口实现类”为例来演示多环境选择问题的解决。

总步骤

定义多个子配置文件或在 application.yml 中定义多个环境

在主配置文件中做环境选择

在接口实现类上通过@Profile 做环境选择

多配置文件实现方式

定义工程

定义配置文件

定义多个配置文件

在 src/main/resources 中再定义两个配置文件，分别对应开发环境与生产环境。

说明

在 Spring Boot 中多环境配置文件名需要满足 application-{profile}.properties 的格式，其中{profile}为对应的环境标识，例如，

application-dev.properties：开发环境

application-test.properties：测试环境

application-prod.properties：生产环境

至于哪个配置文件会被加载，则需要在 application.properties 文件中通过spring.profiles.active 属性来设置，其值对应{profile}值。例如，spring.profiles.active=test 就会加载 application-test.properties 配置文件内容。

在生产环境下，application.properties 中一般配置通用内容，并设置 spring.profiles.active属性的值为 dev，即，直接指定要使用的配置文件为开发时的配置文件，而对于其它环境的选择，一般是通过命令行方式去激活。配置文件application-{profile}.properties 中则配置各个环境的不同内容。

定义业务代码

public interface ISomeService {
    String send();
}

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Service
@Profile("dev")
public class DevelopServiceImpl implements ISomeService {
    @Override
    public String send() {
        return "开发环境实现类";
    }
}

import org.springframework.context.annotation.Profile;
import org.springframework.stereotype.Service;

@Service
@Profile("prod")
public class ProduceServiceImpl implements ISomeService {
    @Override
    public String send() {
        return "生产环境实现类";
    }
}

在实现类上添加@Profile 注解，并在注解参数中指定前述配置文件中的{profile}值，用于指定该实现类所适用的环境。

定义处理器

import cn.zjut.multienv.service.ISomeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeController {
    @Autowired
    private ISomeService someService;
    @RequestMapping("/some")
    public String someHandle(){
        return someService.send();
    }
}

运行

打开主类直接运行，即可在控制台看到默认使用的是开发环境，即端口号使用的是 8888，而工程的根路径为/ddd。

访问

从页面显示内容可知，其执行的业务接口实现类为 DevelopServiceImpl，即开发阶段应使用的实现类。

修改配置文件

运行

将上次运行停掉后再次运行主类，即可在控制台看到使用的是生产环境，即端口号使用的是 9999，而工程的根路径为/ppp。

访问

从页面显示内容可知，此次执行的业务接口实现类为 ProduceServiceImpl，即生产环境下应使用的实现类。

在命令行下选择环境

将工程打为 Jar 包后，在命令行运行。若要想切换运行环境，不需要修改主配置文件，只需添加一个命令参数即可动态指定。

现在的主配置文件中指定的是 dev 环境。

将当前工程打为 Jar 包后，在命令行运行时添加如下参数。

此时执行的就是生产环境，调用的就是 ProduceServiceImpl 类。

在命令行中添加的参数可以是写在配置文件中的任意属性。其原理是命令行设置的属性值的优选级高于配置文件的。

单配置文件实现方式

这种实现方式只能使用 application.yml 文件，使用 application.properties 文件好像文件本身就会出错。

修改配置文件

spring:
  profiles:
    active:
    - dev
---
spring:
  profiles: dev
server:
  port: 8888
  servlet:
    context-path: /ddd
---
spring:
  profiles: prod
server:
  port: 9999
  servlet:
    context-path: /ppp

运行与访问方式与前面的多配置文件的完全相同。

读取自定义配置

自定义配置，可以是定义在主配置文件 application.properties 中的自定义属性，也可以是自定义配置文件中的属性。

总步骤

通过@Value(“${ }”)读取指定的自定义属性

若要读取自定义配置文件，则需要在该读取类上添加@PropertySource 注解

自定义配置文件不能是 yml 文件，只能是 properties 文件

读取主配置文件中的属性

修改主配置文件

student.name=张三

修改 SomeController

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeController {
    @Value("${student.name}")
    private String name;
    @RequestMapping("/some")
    public String someHandle(){
        return name;
    }
}

在@Value 注解中通过${ }符号可以读取指定的属性值

读取指定配置文件中的属性

一般情况下，主配置文件中存放系统中定义好的属性设置，而自定义属性一般会写入自定义的配置文件中。也就是说，Java 代码除了可以读取主配置文件中的属性外，还可以读取指定配置文件中的属性，可以通过@PropertySource 注解加载指定的配置文件。

不能自定义 yml

spring boot 官网给出说明，@PropertySource 注解不能加载 yml 文件。所以其建议自定义配置文件就使用属性文件。

修改主配置文件

自定义配置文件

该配置文件为 properties 文件，文件名随意，存放在 src/main/resources 目录中。

修改 SomeHandler

若属性的值存在中文，则需要添加 encoding 属性。

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
@PropertySource(value = "classpath:myapp.properties", encoding = "utf-8")
public class SomeController {
    @Value("${student.name}")
    private String name;
    @RequestMapping("/some")
    public String someHandle(){
        return name;
    }
}

读取对象属性

修改自定义配置文件

此时的 student 称为对象属性。

定义配置属性类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:myapp.properties")
@ConfigurationProperties("student")
@Data
public class Student {
    private String name;
    private int age;
    private double score;
}

@ProertySource 用于指定要读取的配置文件

@ConfigurationProperties 用于指定要读取配置文件中的对象属性

@Component 表示当前从配置文件读取来的对象，由 Spring 容器创建

@Data生成Get/Set方法

修改 SomeHandler

import cn.zjut.customconfig.config.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeController {
    @Autowired
    private Student student;
    @RequestMapping("/some")
    public String someHandle(){
        return student.getName();
    }
}

读取 List 属性

修改自定义配置文件

country.cities[0]=beijing
country.cities[1]=shanghai
country.cities[2]=guangzhou

定义配置属性类

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

import java.util.List;

@Component
@PropertySource("classpath:myapp.properties")
@ConfigurationProperties("country")
@Data
public class Country {
    private List cities;
}

修改 SomeHandler

import cn.zjut.customconfig.config.Country;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/test")
public class SomeController {
    @Autowired
    private Country country;
    @RequestMapping("/some")
    public String someHandle(){
        for (String city : country.getCities()) {
            System.out.println(city);
        }
        return country.toString();
    }
}

读取 List