概述

Spring官网：https://spring.io/projects

Spring Boot 是在Spring框架基础上创建的一个全新框架，是Spring项目中的一个子工程，与Spring-framework 同属于Spring的产品。

Spring Boot 称为搭建程序的脚手架 。其最主要作用是快速的构建庞大的Spring项目，并且尽可能的减少一切xml配置，做到开箱即用，迅速上手，让开发者关注于业务而非配置。

Spring Boot 简化了基于Spring的应用开发，为Spring平台及第三方库提供开箱即用的设置（提供默认设置，存放默认配置的包就是启动器starter），多数Spring Boot应用只需要很少的Spring配置。 Spring Boot 内置了tomcat，无需再单独配置tomcat。

Spring Boot 设计的目的是简化 Spring 应用的搭建和开发过程，它不但具有Spring的所有优秀特性，而且具有如下显著的特点：

• 为 Spring 开发提供更加简单的使用和快速开发的技巧
• 具有开箱即用的默认配置功能，能根据项目依赖自动配置
• 具有功能更加强大的服务体系，包括嵌入式服务、安全、性能指标，健康检查等
• 绝对没有代码生成，可以不再需要 XML 配置，即可让应用更加轻巧和灵活
• Spring Boot 对于一些第三方技术的使用，提供了非常完美的整合，使用简单。

SpringBoot 项目搭建

基础依赖引入

Spring Boot 官网版本列表：https://spring.io/projects/spring-boot#learn

• RELEASE GA：General Availability,正式发布的版本，官方推荐使用此版本。
• SNAPSHOT：快照版，可以稳定使用，且仍在继续改进版本。
• PRE：预览版，内部测试版，主要是给开发人员和测试人员测试和找BUG用的，不建议使用。

<?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.test</groupId>
    <artifactId>spring-boot-ssm</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!-- 使用SpringBoot框架必须引入 spring-boot-starter-parent 作为父项目 -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.12.RELEASE</version>
    </parent>
    
    <properties>
        <!-- 设置JDK版本 -->
        <java.version>1.8</java.version>
    </properties>
    
    <dependencies>
        <!-- web启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!-- 单元测试启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        
        <!---- 数据库相关 ---->
        <!-- jdbc启动器，spring-boot-starter-jdbc默认集成了HikariCP连接池 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- druid连接池启动器 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.17</version>
        </dependency>
        <!-- 数据库驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- 持久层框架启动器 -->

        
        <!---- 工具类 ---->
        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

启动类

App.java

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

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

Spring Boot 配置

Spring 加载配置的注解

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

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

• @Value ：属性注入，替代 xml 中的属性注入

  格式： @Value(“${属性}”)

• @PropertySource ：加载指定的属性文件（*.properties）到 Spring 的 Environment 中

  可以配合 @Value 和 @ConfigurationProperties 使用

  • @PropertySource 和 @Value 组合使用：

    可以将自定义属性文件中的属性变量值注入到当前类的使用@Value注解的成员变量中。

  • @PropertySource 和 @ConfigurationProperties 组合使用：

    可以将属性文件与一个Java类绑定，将属性文件中的变量值注入到该Java类的成员变量中。

@ConfigurationProperties：自动配置绑定

@ConfigurationProperties：用于自动配置绑定 yml 配置文件的属性和 java 对象的属性

支持属性：

• value / prefix 属性：配置文件配置项前缀
• ignoreInvalidFields 属性：默认为false，值类型不匹配将会爆出异常
• ignoreUnknownFields 属性：默认为true，忽略掉对象中未知的字段

用法1：标注在类上，转换配置文件配置项为bean对象

• 注意：
  • 需要将标注了 @ConfigurationProperties 注解的类注册到spring容器中，方式有两种：
    • 方式1：在标注了@ConfigurationProperties 注解的类上使用 @componet 等 IOC 注解
    • 方式2：在标注了@componet 等 IOC 注解的类上或配置类上标注 @EnableConfigurationProperties(bean类名.class)
  • 需要有无参构造方法、getter和setter方法

@Data
@AllArgsConstructor
@NoArgsConstructor
@Component
@ConfigurationProperties(prefix = "app.mycar")
public class Car {
    private int price;
    private String brand;
}

@Configuration
@EnableConfigurationProperties(Car.class) 
public class Config {
}

用法2：标注在配置类的方法上，搭配 @bean 使用，绑定第三方属性

@Configuration
public class DbConfig {
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.druid")
    public DataSource datasource(){
        return new DruidDataSource();
    }
}

Environment：获取运行环境变量

Spring中的Environment用来表示整个应用运行时的环境，可以使用Environment类获取整个运行环境中的配置信息。

方法：

public String getProperty(String key)
public <T> T getProperty(String key, Class<T> targetType)
    
// 注：key为配置文件中的key

示例：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

@Configuration  // 声明这个类是一个配置类
@PropertySource(value = "classpath:user.properties") //加载配置文件
public class UserConfig {
    @Autowired
    private Environment environment;
    
    @Bean   //创建User对象，交给spring容器 User对象中的值从配置文件中获取
    public User getUser() {
        User user = new User();
        user.setUsername(environment.getProperty("user.username"));
        user.setPassword(environment.getProperty("user.password"));
        return user;
    }
}

支持的配置文件类型及优先级

• application.properties
• application.yml
• application.yaml

配置文件被加载的优先级是：

• properties > yml > yaml

• 若相同的配置在多种配置文件类型中都配置了，则优先级高的配置生效

默认配置和常用基础配置

Spring Boot 封装了大量的默认配置：

• Spring boot 各版本文档目录：https://docs.spring.io/spring-boot/docs/

• SpringBoot 2.3.0.RELEASE版本的默认配置列表（其他版本类似）：

  https://docs.spring.io/spring-boot/docs/2.3.0.RELEASE/reference/html/appendix-application-properties.html

Spring Boot 常用基础配置：

server:
  # 服务端口号，默认8080
  port: 8080

logging:
  level:
    # 微服务的日志配置。格式：包路径: 日志级别
    com.test: debug

spring:
  application:
    name: test-service
  datasource:     # 数据源配置
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/leyou?useUnicode=true&characterEncoding=utf8&serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource

Spring MVC 配置

端口配置

设置web访问端口

server:
 port: 8080

日志配置

日志级别分为 FATAL、ERROR、WARN、INFO、DEBUG、ALL 或者自定义的级别。

Log4j 建议只使用四个级别，优先级从高到低分别是 ERROR、WARN、INFO、DEBUG

• 企业生产环境，一般设置为 INFO 级别，表示打印 INFO 及以上级别的日志，不打印 DEBUG 及以下级别的日志

• 开发和测试环境，一般设置为 DEBUG 级别，表示所有的级别的日志都能输出

日志级别控制：

logging:
  level:
    com.test: debug
    org.springframework.web: debug

说明：

• logging.level：固定写法，说明下面是日志级别配置，日志相关其它配置也可以使用
• com.test 和 org.springframework 是指定包名，后面的配置仅对这个包有效

静态资源

默认的静态资源路径为：

• classpath:/META-INF/resources/
• classpath:/resources/
• classpath:/static/
• classpath:/public

只要静态资源放在这些目录中任何一个，SpringMVC都会处理。

一般把静态资源放在classpath:/static/目录下。

拦截器

• 如果想要保持 Spring Boot 的一些默认 MVC 特征，同时又想自定义一些 MVC 配置（包括：拦截器，格式化器, 视图控制器、消息转换器 等等），可以让一个类实现 WebMvcConfigurer 接口，并且添加 @Configuration 注解，但不能添加@EnableWebMvc 注解

• 如果想要自定义 HandlerMapping、HandlerAdapter、ExceptionResolver 等组件，可以创建一个 WebMvcRegistrationsAdapter 实例来提供以上组件

• 如果想要完全自定义 Spring MVC，不保留 Spring Boot 提供的一切特征，可以自己定义类并且添加 @Configuration 注解和 @EnableWebMvc 注解

1. 自定义拦截器（实现 HandlerInterceptor 接口）

@Slf4j
public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.debug("preHandle方法执行...");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.debug("postHandle方法执行...");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.debug("afterCompletion方法执行...");
    }
}

2. 添加配置类（实现 WebMvcConfigurer 接口），注册拦截器

@Configuration
public class MyWebConfig implements WebMvcConfigurer {
    /**
     * 注册自定义拦截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 通过registry来注册拦截器，通过addPathPatterns来添加拦截路径
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/user/**")
                .excludePathPatterns("/user/login");  // 这个地址的不拦截
    }
}

ApplicationRunner 接口

• 方法：

  只定义了一个 run(ApplicationArguments args) 方法

  run 方法的参数 ApplicationArguments 可以获取到当前项目执行的命令参数（比如把这个项目打成 jar 执行的时候，带的参数可以通过 ApplicationArguments 获取到）。

  由于该方法是在容器启动完成之后，才执行的，所以，这里也可以从 spring 容器中拿到其他已经注入的 bean。

• 使用场景：

  springBoot 项目启动时，若想在启动之后直接执行某一段代码，就可以自定义一个类实现 ApplicationRunner 这个接口，并重写接口的 run 方法。

@Component  // 此类必须要交给spring管理才生效
public class ConsumerRunner implements Application{
	@Oberride
	public void run(ApplicationArgumers args) throws Exception{
		//代码
		System.out.println("需要在springBoot项目启动时执行的代码---");
	}
}

• 在同一个项目中，可以定义多个 ApplicationRunner 的实现类。

  如果有多个实现类，同时又需要它们按一定顺序执行，可以通过在实现类上加上 @Order 注解或者实现 Ordered 接口来实现。

  SpringBoot 会按照 @Order 中的 value 值从小到大依次执行。即值越小拥有越高的优先级，值越小越先被加载。

  注：值可为负数。

自动配置原理

概述

Spring Boot 内部集成了大量第三方服务，提供了默认配置，而默认配置生效的步骤：

• @EnableAutoConfiguration 注解会去所有包下寻找 META-INF/spring.factories 文件，读取其中以 EnableAutoConfiguration为 key 的所有类的名称，这些类就是提前写好的自动配置类
• 这些类都声明了 @Configuration注解，并且通过 @Bean 注解提前配置了所需要的一切实例
• 但是，这些配置不一定生效，因为有 @Conditional注解，满足一定条件才会生效
• 只需要引入了相关依赖（启动器），上面的配置需要的条件成立，自动配置生效
• 如果自己配置了相关Bean，那么会覆盖默认的自动配置的Bean
• 还可以通过配置 application.properties(yml) 文件，来覆盖自动配置中的属性

Spring Boot 能够快速开发的原因就在于内置了很多第三方组件的默认配置，使用的步骤如下：

1. 使用启动器

   如果不想自己配置，只需要引入启动器依赖即可，而依赖版本也不用操心，因为只要引入了 Spring Boot 提供的 stater（启动器），就会自动管理依赖及版本了。

2. 替换默认配置

   SpringBoot 的配置，都会有默认属性，而这些属性可以通过修改 application.properties 文件来进行覆盖。

关键注解

@Conditional

@Condition 是在 Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作

@Conditional 标注在配置类上或配置类的方法上，和 @Configuration 配合使用，@Conditional 指定的条件成立，配置类里面的内容才生效

SpringBoot常用条件注解：

• @ConditionalOnBean：容器中存在指定Bean
• @ConditionalOnMissingBean ：容器中不存在指定Bean
• @ConditionalOnProperty：系统中指定的属性是否有指定的值
• @ConditionalOnClass ：系统中有指定的类
• @ConditionalOnMissingClass： 系统中没有指定的类
• @ConditionalOnExpression ：满足SpEL表达式指定
• @ConditionalOnSingleCandidate ：容器中只有一个指定的Bean，或者这个Bean是首选Bean
• @ConditionalOnResource ：类路径下是否存在指定资源文件
• @ConditionalOnWebApplication ：当前是web环境
• @ConditionalOnNotWebApplication ：当前不是web环境
• @ConditionalOnJava：系统的java版本是否符合要求

示例：

User类

@Data
public class User {
    private String username;
    private Integer age;
}

配置类

@Configuration
@ConditionalOnProperty(value = "user.enable")	// 配置文件存在该配置项时该配置类才生效
public class UserConfig {
    @Bean
    public User user(){
        User user = new User();
        user.setUsername("tom");
        user.setAge(18);
        return user;
    }
}

配置文件中添加如下配置：

user:
  enable: true

添加测试用例

@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTests {
    
    @Autowired
    private User user;
    @Test
    public void testUser(){
        System.out.println(user);
    }
}

SpringBoot自动配置流程图

使用的时候只需要引入相应的starter，starter是一个指示信号，引入这个依赖之后，相应的条件满足了，就会注册相应的Bean。

@Import

参考：

• https://blog.csdn.net/weixin_44360895/article/details/112758122
• https://blog.csdn.net/mamamalululu00000000/article/details/86711079

@Import 注解：把类导入 Spring IOC容器

有多种方式能让类加 IOC容器管理，如@Bean、@Component等，@Import 是另外一种方式，更加快捷。

支持三种方式：

• 带有 @Configuration 的配置类（4.2版本之前只可以导入配置类，4.2版本之后 也可以导入普通类）
• ImportSelector 的实现
• ImportBeanDefinitionRegistrar 的实现

主要用法：

• 直接填 class 数组方式

  @Configuration
  @Import({User.class})   // 大括号中可以添加多个类，使用逗号分隔，例如 {User.class,UserInfo.class}
  public class UserConfig {}
  

• ImportSelector 方式（Spring Boot 底层采用比较得多的方式）

  // 自定义ImportSelector
  public class MyImportSelector implements ImportSelector {
      @Override
      public String[] selectImports(AnnotationMetadata importingClassMetadata) {
          // 返回的是需要加载的类名数组  注意这里需要的是类的全路径
          return new String[]{"com.itheima.redis.entity.User"};
      }
  }
  

  @Configuration
  @Import(MyImportSelector.class)
  public class UserConfig {}
  

• ImportBeanDefinitionRegistrar 方式

  这种方式和 ImportSelector 方式类似，不过这种方式可以自定义Bean在容器中的名称

  // 自定义ImportBeanDefinitionRegistrar
  public class TestImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar {
      @Override
      public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
          RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(TestD.class);
          //自定义注册bean
          registry.registerBeanDefinition("testD1111",rootBeanDefinition);
      }
  }
  

  @Import({TestImportBeanDefinitionRegistrar.class})
  @Configuration
  public class ImportConfig {}
  

• 注意：三种用法方式都可在一个@Import中使用，需要注意的是class 数组方式、ImportSelector 方式在IOC容器中bean名称是类的全限定类名，而ImportBeanDefinitionRegistrar 方式是自定义的名称

@SpringBootApplication

流程图

查看源码

重点的注解有3个：

• @SpringBootConfiguration
• @EnableAutoConfiguration
• @ComponentScan

@SpringBootConfiguration

源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

这个注解上面有一个 @Configuration 注解，@Configuration 注解的作用为声明当前类是一个配置类，然后 Spring 会自动扫描到添加了@Configuration的类，并且读取其中的配置信息。

@SpringBootConfiguration 是来声明当前类是 SpringBoot 应用的配置类 。

@EnableAutoConfiguration

源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

借助@Import(AutoConfigurationImportSelector.class)，@EnableAutoConfiguration 可以帮助 Spring Boot 应用将所有符合条件的 @Configuration 配置都加载到当前 Spring Boot 创建并使用的IOC容器。

1. AutoConfigurationImportSelector 源码，查看selectImports方法：

   

2. 继续跟进 getAutoConfigurationEntry 方法

   

3. 在getCandidateConfigurations方法中有一段提示：

   

4. 跟进loadFactoryNames方法：

   

5. 可以看到从这个位置加载配置：

   

6. 找到配置文件

   

   这里有自动配置：

   

   在自动配置包中内置了大量的第三方中间件的配置类：

总结：@EnableAutoConfiguration 从 classpath 中搜寻所有 META-INF/spring.factories 配置文件，并将其中org.springframework.boot.autoconfigure.EnableAutoConfiguration 对应的配置项通过反射实例化为对应的标注了 @Configuration 的 JavaConfig 形式的 IOC 容器配置类，然后汇总为一个，并加载到IOC容器。

@ComponentScan

开启组件扫描。提供了类似与 <context:component-scan> 标签的作用

通过 basePackageClasses 或者 basePackages 属性来指定要扫描的包。如果没有指定这些属性，那么将从声明这个注解的类所在的包开始，扫描包及子包

而@SpringBootApplication注解声明的类就是 main 函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中

SpringBoot 监控

Actuator

概念

SpringBoot 自带监控功能 Actuator，可以帮助实现对程序内部运行情况监控，比如监控状况、Bean加载情况、配置属性、日志信息等；同时也可以通过Actuator管理应用程序，例如通过Actuator去做一个shutdown功能（默认是不开启的），另外还可以在运行的过程中对日志进行调整。

Endpoints：端点

可以把 Endpoints 理解为一个功能模块，功能模块可以监控 Spring Boot 应用，甚至可以与 Spring Boot 进行交互（比如读取信息，关闭应用等操作）。Spring Boot内置了很多 Endpoints，最重要的 Endpoints 是 health，即健康检查模块。

Actuator端点说明

注意：

• shutdown 端点默认不启用
• 只有health和 info 默认是可以通过 http 进行访问的

快速入门

依赖坐标

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

如果想看更多的信息，在配置文件中配置：

management:
  endpoint:
    health:
      show-details: always
  endpoints:
    web:
      exposure:
        include: "*"

Actuator监控接口：

http://localhost:8080/actuator/beans

http://localhost:8080/actuator/env

http://localhost:8080/actuator/mappings

具体详细的解释：

Actuator 的详细配置

management:
  server:
    # Actuator的管理端口号，默认跟服务端口号（server.port）一致
    port: 8085
  endpoint:
    health:
      # 是否开启health端点，默认为true
      enabled: true
      # 展示健康检查中所有指标的详细信息
      show-details: always
  endpoints:
    # web：http方式
    web:
      exposure:
        # 暴露可以通过web访问的端点。默认"health,info"，用 * 可以包含全部端点
        include: "*"
        # 不暴露的端点
        exclude: 
      # 自定义监控路径前缀。默认 /actuator
      base-path: /actuator
      # 修改端点的访问路径(映射)，例如将 /beans 更改为 /request_beans
      path-mapping:
        beans: request_beans
    # 所有端点是否默认启动，默认true。若设置为false，则默认情况下所有端点都不启用，此时需要按需启用端点
    enabled-by-default: true

Spring Boot Admin

概述及快速入门

Actuator 的监控内容够详细，但是阅读性比较差，所以可以使用 Spring Boot Admin 提供一个可视化的界面查阅信息，Spring Boot Admin 是一个第三方提供的开源社区项目，用于管理和监控 SpringBoot 应用程序。

源码库：https://github.com/codecentric/spring-boot-admin

Spring Boot Admin 有两个角色，客户端（Client）和服务端（Server）：

• 应用程序作为 Spring Boot Admin Client 向为 Spring Boot Admin Server 注册

• Spring Boot Admin Server 的界面将展示 Spring Boot Admin Client 的监控信息

开发步骤如下：

admin-server：

1. 创建 admin-server 模块

2. 导入依赖坐标 admin-starter-server

       <dependency>
           <groupId>de.codecentric</groupId>
           <artifactId>spring-boot-admin-starter-server</artifactId>
           <version>2.3.0</version>
       </dependency>
   

3. 在启动类上标注 @EnableAdminServer 注解，启用 Admin 监控功能

4. 配置相关信息

   server:
     port: 8888
   

5. 启动 server 服务，访问：http://localhost:8888/#/applications

admin-client： 自己创建的项目就是所谓的client端

1. 创建 admin-client 模块

2. 导入依赖坐标 admin-starter-client

   <dependency>
       <groupId>de.codecentric</groupId>
       <artifactId>spring-boot-admin-starter-client</artifactId>
       <version>2.3.0</version>
   </dependency>
   

3. 配置相关信息：server地址等

   spring:
     boot:
       admin:
         client:
           url: http://localhost:8888
   management:
     endpoint:
       health:
         show-details: always
     endpoints:
       web:
         exposure:
           include: "*"
   

4. 启动 client 服务

Admin Server 的详细配置

参考：https://www.jianshu.com/p/b0528b52772c

spring:
  boot:
    admin:
      # server端的访问路径。默认为 /
      context-path: /
      monitor:
        # 更新client端状态的时间间隔，默认为10000，单位是毫秒
        period: 10000
        # client端状态的生命周期，该生命周期内不会更新client状态，默认为100000，单位是毫秒
        status-lifetime: 100000
        # 查询client状态信息时的连接超时时间，默认为2000，单位是毫秒
          # 如果2秒内没有获取到client的状态信息，则认为连接已经断开
        connect-timeout: 2000
        # 查询client状态信息时的读取超时时间，默认为2000，单位是毫秒（如果2秒内没有获取到client的状态信息，则认为读取失败）
        read-timeout: 2000
      # 要被过滤掉的元数据（当与正则表达式相匹配时，这些数据会在输出的json数据中过滤掉）
        # 默认值是".password", ".secret",".∗secret", ".key", ".",".token", ".credentials.", ".*vcap_services", ".credentials.", ".∗vcap services"	
      metadata-keys-to-sanitize:
      # 要获取的client的端点信息
        # 默认是 "health", "env", "metrics", "httptrace:trace", "threaddump:dump", "jolokia", "info", "logfile", "refresh", "flyway", "liquibase", "heapdump", "loggers", "auditevents"	
      probed-endpoints: 
      instance-proxy:
        # 向client发起请求时不会被转发的headers信息。默认值是"Cookie", "Set-Cookie", "Authorization"
        ignored-headers: 
      ui:
        # 在导航栏中显示的brand值
        brand: 
        # 显示的页面标题。默认是"Spring Boot Admin"
        title: 

Admin Client 的详细配置

参考：https://www.jianshu.com/p/b0528b52772c

spring:
  boot:
    admin:
      client:
        # 是否启用spring boot Admin客户端，默认为true
        enabled: true
        # 要注册的Admin Server端的url地址。如果要同时在多个server端口注册，则用逗号分隔各个server端的url地址
        url: http://localhost:8888
        # server端获取client信息的路径，默认情况下server通过访问/instances请求来获取到client端的信息。（client端向server端注册，注册成功后server端会给该client创建一个唯一的clientID值。当server端需要获取client的信息，比如health信息时，server端会发送http://IP:PORT/instances/clientID/actuator/health即可，这里的http://IP:PORT是client所在服务器的IP地址，instances就是该属性的值）
        api-path: instances
        # 如果server端需要进行认证时，该属性用于配置用户名
        username: user
        # 如果server端需要进行认证时，该属性用于配置密码
        password: 123456
        # 注册时间间隔，默认10000，单位是毫秒（client通过持续不断地向server端进行注册来保持client端与server端的连接）
        period: 10000
        # 注册连接超时时间，默认5000，单位是毫秒。当client向server进行注册时，如果5秒钟没有注册完成则认为本次注册失败
        connect-timeout: 5000
        # 注册读取超时，默认5000，单位是毫秒
        read-timeout: 5000
        # 是否开启自动注册，默认为true
        auto-registration: true
        # 是否开启自动注销，如果服务端运行在云平台，默认值是true
        auto-deregistration: null
        # 默认为true，client只会在一个server端进行注册（按照spring.boot.admin.client.url中设置的server的顺序），如果该server端宕机，会自动在下一个server端进行注册。如果该属性值为false，则会在所有的server端进行注册
        egister-once: true
        instance:
          # 注册的management-url，如果可用的url不同的话，可以重写该值。
          	# 默认该属性值与management-base-url 和 management.context-path两个属性值有关
          management-url:
          # 用于计算management-url的基本URL。该路径值在运行时进行获取并赋值给 base url
          	# 默认该属性值与management.port, service-url 以及server.servlet-path有关
          management-base-url:
          # 用于计算service-url的基本URL。该路径值在运行时进行获取并赋值给 base url
          service-base-url:
          # 注册的health-url地址，如果可用的url不同可以重写该值
          health-url:
          # 注册的service-url值
          service-url: http://192.168.0.66:22586
          # 客户端工程的名字。默认值是配置的spring.application.name的值	
          name:
          # 是否使用注册的ip地址来取代上述各个url中hostname的值，默认为false
          prefer-ip: true

自己开发 Starter 启动器

启动器一般都是以spring-boot-starter-开头，这种方式一般都是Spring 官方的命名方式。

其他企业开发的启动器命名方式类似于：XXX-boot-starter

启动器一般都是一个空壳子，里面没有代码，主要用于管理依赖

开发步骤：

1. 创建 starter 项目，示例：test-hello-spring-boot-starter

2. 创建自动配置项目，示例：test-spring-boot-autoconfigure

   • （1）添加基本的springboot依赖（因为要用@Bean等注解）

     <parent>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-parent</artifactId>
         <version>2.1.3.RELEASE</version>
         <relativePath/> <!-- lookup parent from repository -->
     </parent>
     <dependencies>
         <dependency>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter</artifactId>
         </dependency>
     </dependencies>
     

   • （2）定义自动配置类，示例：在配置类中将HelloTemplate定义为一个Bean

     @Configuration
     public class HelloAutoConfiguration {
     
         @Bean   //实例化HelloTemplate，交给Spring IOC 容器管理
         public HelloTemplate helloTemplate(){
             return new HelloTemplate();
         }
     }
     

   • （3）在resources下创建META-INF目录，在META-INF目录下创建 spring.factories 文件，在 spring.factories 中编辑要扫描的配置类（HelloAutoConfiguration），这样spring就会扫描到 HelloAutoConfiguration 了

     # 第一行固定写法，第二行这个是我们写的配置类的类名全路径 这样spring就能扫描到了
     org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
     com.itheima.hellospringbootdemo.util.HelloAutoConfiguration
     

3. 在 starter 项目的 pom 文件中添加自动配置项目的依赖

   <dependencies>
       <dependency>
           <groupId>com.test</groupId>
           <artifactId>test-spring-boot-autoconfigure</artifactId>
           <version>1.0-SNAPSHOT</version>
       </dependency>
   </dependencies>
   

4. 在其它工程中添加 stater 项目的依赖，即可通过 @Autowired 使用自动配置项目中注入到Spring容器的 Bean

部署SpringBoot项目

项目打包

在SpringBoot项目中，都是通过将项目打成 jar 包，然后直接运行（因为内置了tomcat）

1. 准备一个开发完的 SpringBoot 项目，因为是 SpringBoot 项目，所以一定要有启动类

2. 在准备打包的项目中的 pom 文件中，添加如下内容

   <build>
       <!--finalName 可以不写，写了就是要打包的项目的名称 -->
       <finalName>demo</finalName>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </plugin>
       </plugins>
   </build>
   

3. 找到 idea 右侧的 maven 区域，找到想打包的项目，点击clean，清除缓存，如图

   

   如果点击test，会将在 test/java 下所有的测试用例都跑一边，所有测试用例都通过后才会执行后面的流程，这里的流程都是下一步会包含上一步。

   如果在打包时不想运行测试用例，有两种方式跳过：

   • 方式1：可以在 pom 中添加如下设置：

     <properties>
         <!--打包时跳过测试用例-->
         <skipTests>true</skipTests>
     </properties>
     

   • 方式2：在IDEA中配置如下

     

4. 点击 package 进行打包操作，最后显示 BUILD SUCCESS 即为打包成功

   注意：如果项目有自定义的依赖，则需要先点击 install，将依赖包安装到本地仓库；否则若直接点击package，会报找不到类等错误

5. 在 idea 左侧项目的 target 目录下，可以找到刚打好的 jar 包

6. 在 jar 包文件夹地址栏上输入cmd，打开命令窗口，在命令行中输入java -jar 项目名.jar，回车即可启动应用

Spring Boot 多环境配置切换

一般在一个项目中，总是会有好多个环境。比如：开发环境 -> 测试环境 -> 预发布环境 -> 生产环境。

每个环境上的配置文件总是不一样的，甚至开发环境中每个开发者的环境可能也会有一点不同。

在 Spring Boot中，多环境配置的文件名需要满足 application-{profile}.yml 或者 application-{profile}.properties的格式，其中{profile} 对应环境，比如：

• application-dev.yml：开发环境
• application-test.yml：测试环境
• application-prod.yml：生产环境

配置环境的常用方式：

• 方式1：直接在 application.yml中配置：

  spring:
    profiles:
      active: dev
  

• 方式2：在 IDEA 中指定配置生效：

  

• 方式3：在启动时添加参数来指定使用哪个配置

  # 使用测试环境配置文件
  java -jar xxx.jar --spring.profiles.active=test
  

Spring Boot 配置加载顺序

Spring Boot 若在优先级更高的位置找到了相同的配置，那么它就会无视低级的配置。如果不同的配置是可以同时生效的。

根据 Spring Boot 的文档，配置使用的优先级从高到低的顺序，具体如下所示：

1. 命令行参数
2. 通过 System.getProperties() 获取的 Java 系统参数
3. 操作系统环境变量
4. 从 java:comp/env 得到的 JNDI 属性
5. 通过 RandomValuePropertySource 生成的 “random.*” 属性
6. 应用 Jar 文件之外的属性文件（application-{profile}.properties/yml）
7. 应用 Jar 文件内部的属性文件（application-{profile}.properties/yml）
8. 应用 Jar 文件之外的属性文件（application.properties/yml）
9. 应用 Jar 文件内部的属性文件（application.properties/yml）
10. 在应用配置 Java 类（包含“@Configuration”注解的 Java 类）中通过 “@PropertySource” 注解声明的属性文件
11. 通过 “SpringApplication.setDefaultProperties” 声明的默认属性

Spring Boot 加载外部的配置文件

• 方式1：通过环境变量 spring.config.location 指定

  注意：使用 location 参数指定配置文件后，会使项目默认配置文件（application.properties 或 application.yml ）失效，Spring Boot 将只加载指定的外部配置文件

  java -jar springbootdemo-0.0.1-SNAPSHOT.jar --spring.config.location=./my-application.yml
  

• 方式2：通过环境变量 spring.config.additional-location 指定

  注意：使用 additional-location 参数不会使项目默认的配置文件失效，外部配置文件会与项目默认的配置文件共同生效，形成互补配置，且其优先级比所有默认配置文件的优先级都高

  java -jar springbootdemo-0.0.1-SNAPSHOT.jar --spring.config.additional-location=./my-application.yml