Spring Boot 框架使用指南

柔情只为你懂 2023-09-23 18:03 65阅读 0赞

# 概述 #

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>
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.12.RELEASE</version>
        </parent>
        
        <properties>
            
            <java.version>1.8</java.version>
        </properties>
        
        <dependencies>
            
            <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>
            
            
            
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-jdbc</artifactId>
            </dependency>
            
            <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>
            
    
            
            
            
            <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方法执行...");
        }
    }

1.  **添加配置类（实现 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自动配置流程图**

![在这里插入图片描述][bbcf0d6bc3654587912d4365b8a82b93.png_pic_center]

使用的时候只需要引入相应的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 ##

**流程图**

![在这里插入图片描述][5a7609c05f3d4de28011b6e3892dd4d1.png_pic_center]

**查看源码**

![在这里插入图片描述][178c715f3dee4e3a8bd791141347c02d.png_pic_center]

重点的注解有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`方法：
    
    ![在这里插入图片描述][a0ba9896b7c045fbb7cb465552d7f73c.png_pic_center]
2.  继续跟进 getAutoConfigurationEntry 方法
    
    ![在这里插入图片描述][e261216e287c427e903d7a42308a814d.png_pic_center]
3.  在`getCandidateConfigurations`方法中有一段提示：
    
    ![在这里插入图片描述][afdad6ac9d8d4910b306a13c2223d5ca.png_pic_center]
4.  跟进`loadFactoryNames`方法：
    
    ![在这里插入图片描述][4b7d9ad921fb474186b0d4eeb4ecfd01.png_pic_center]
5.  可以看到从这个位置加载配置：
    
    ![在这里插入图片描述][54b057f1ce854cc9a10989cda54876e2.png_pic_center]
6.  找到配置文件
    
    ![在这里插入图片描述][371aa87e21914c20bee987006a6bd2e2.png_pic_center]
    
    这里有自动配置：
    
    ![在这里插入图片描述][ebf49a54371a4b7a82e001bf177301da.png_pic_center]
    
    在自动配置包中内置了大量的第三方中间件的配置类：

![在这里插入图片描述][8e54e005301440bcb0b96aeee702e85d.png_pic_center]

总结：`@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端点说明**

<table> 
 <thead> 
  <tr> 
   <th>端点</th> 
   <th>说明</th> 
   <th>默认开启</th> 
   <th>默认 HTTP</th> 
   <th>默认 JMX</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>auditevents</td> 
   <td>公开当前应用程序的审查事件信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>beans</td> 
   <td>显示Spring loC容器关于Bean的信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>caches</td> 
   <td>显示应用中的缓存</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>conditions</td> 
   <td>显示自动配置类的评估和配置条件，并且显示他们匹配或者不匹配的原因</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>configprops</td> 
   <td>显示当前项目的属性配置信息(通过@ConfigurationProperties配置)</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>env</td> 
   <td>显示当前Spring应用环境配置属性(ConfigurableEnvironment)</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>flyway</td> 
   <td>显示已经应用于flyway数据库迁移的信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>health</td> 
   <td>显示当前应用健康状态</td> 
   <td>Y</td> 
   <td><strong>Y</strong></td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>httptrace</td> 
   <td>显示最新追踪信息（默认为最新100次 HTTP请求)</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>info</td> 
   <td>显示当前应用信息</td> 
   <td>Y</td> 
   <td><strong>Y</strong></td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>loggers</td> 
   <td>显示并更新应用程序中记录器的配置</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>liquibase</td> 
   <td>显示已经应用于liquibase数据库迁移的信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>metrics</td> 
   <td>显示当前配置的各项“度量”指标</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>mappings</td> 
   <td>显示由@RequestMapping (@GetMapping和@PostMapping 等)配置的映射路径信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>scheduledtasks</td> 
   <td>显示当前应用的调度任务计划</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>sessions</td> 
   <td>允许从Spring会话支持的会话存储库检索和删除用户会话，只是Spring 会话对响应式Web 应用还暂时不能支持</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>shutdown</td> 
   <td>允许当前应用被优雅地进行关闭（在默认的情况下不启用这个端点)</td> 
   <td><strong>N</strong></td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>threaddump</td> 
   <td>显示线程泵</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>Y</td> 
  </tr> 
  <tr> 
   <td>heapdump</td> 
   <td>返回 Heap Dump 文件，格式为 HPROF</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>N/A</td> 
  </tr> 
  <tr> 
   <td>prometheus</td> 
   <td>返回可供 Prometheus 抓取的信息</td> 
   <td>Y</td> 
   <td>N</td> 
   <td>N/A</td> 
  </tr> 
 </tbody> 
</table>

**注意：**

*  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

具体详细的解释：

<table> 
 <thead> 
  <tr> 
   <th><strong>路径</strong></th> 
   <th><strong>描述</strong></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>/<strong>beans</strong></td> 
   <td><strong>描述应用程序上下文里全部的Bean，以及它们的关系</strong></td> 
  </tr> 
  <tr> 
   <td><strong>/env</strong></td> 
   <td><strong>获取全部环境属性</strong></td> 
  </tr> 
  <tr> 
   <td>/env/{name}</td> 
   <td>根据名称获取特定的环境属性值</td> 
  </tr> 
  <tr> 
   <td>/health</td> 
   <td>报告应用程序的健康指标，这些值由HealthIndicator的实现类提供</td> 
  </tr> 
  <tr> 
   <td>/info</td> 
   <td>获取应用程序的定制信息，这些信息由info打头的属性提供</td> 
  </tr> 
  <tr> 
   <td><strong>/mappings</strong></td> 
   <td><strong>描述全部的URI路径，以及它们和控制器(包含Actuator端点)的映射关系</strong></td> 
  </tr> 
  <tr> 
   <td>/metrics</td> 
   <td>报告各种应用程序度量信息，比如内存用量和HTTP请求计数</td> 
  </tr> 
  <tr> 
   <td>/metrics/{name}</td> 
   <td>报告指定名称的应用程序度量值</td> 
  </tr> 
  <tr> 
   <td>/trace</td> 
   <td>提供基本的HTTP请求跟踪信息(时间戳、HTTP头等)</td> 
  </tr> 
 </tbody> 
</table>

### 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/> 
            </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>demo</finalName>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
3.  找到 idea 右侧的 maven 区域，找到想打包的项目，点击clean，清除缓存，如图
    
    ![在这里插入图片描述][cab1dc65271f416b89b869987e607163.png_pic_center]
    
    如果点击test，会将在 test/java 下所有的测试用例都跑一边，所有测试用例都通过后才会执行后面的流程，这里的流程都是下一步会包含上一步。
    
    如果在打包时不想运行测试用例，有两种方式跳过：
    
     *  方式1：可以在 pom 中添加如下设置：
        
            <properties>
                
                <skipTests>true</skipTests>
            </properties>
     *  方式2：在IDEA中配置如下
        
        ![在这里插入图片描述][2f99abaeedce47ddb359c6e018f6c4c3.png_pic_center]
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 中指定配置生效：
    
    ![在这里插入图片描述][123fc5364aca481f996577346538e4b7.png_pic_center]
 *  方式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

[bbcf0d6bc3654587912d4365b8a82b93.png_pic_center]: https://img-blog.csdnimg.cn/bbcf0d6bc3654587912d4365b8a82b93.png#pic_center
[5a7609c05f3d4de28011b6e3892dd4d1.png_pic_center]: https://img-blog.csdnimg.cn/5a7609c05f3d4de28011b6e3892dd4d1.png#pic_center
[178c715f3dee4e3a8bd791141347c02d.png_pic_center]: https://img-blog.csdnimg.cn/178c715f3dee4e3a8bd791141347c02d.png#pic_center
[a0ba9896b7c045fbb7cb465552d7f73c.png_pic_center]: https://img-blog.csdnimg.cn/a0ba9896b7c045fbb7cb465552d7f73c.png#pic_center
[e261216e287c427e903d7a42308a814d.png_pic_center]: https://img-blog.csdnimg.cn/e261216e287c427e903d7a42308a814d.png#pic_center
[afdad6ac9d8d4910b306a13c2223d5ca.png_pic_center]: https://img-blog.csdnimg.cn/afdad6ac9d8d4910b306a13c2223d5ca.png#pic_center
[4b7d9ad921fb474186b0d4eeb4ecfd01.png_pic_center]: https://img-blog.csdnimg.cn/4b7d9ad921fb474186b0d4eeb4ecfd01.png#pic_center
[54b057f1ce854cc9a10989cda54876e2.png_pic_center]: https://img-blog.csdnimg.cn/54b057f1ce854cc9a10989cda54876e2.png#pic_center
[371aa87e21914c20bee987006a6bd2e2.png_pic_center]: https://img-blog.csdnimg.cn/371aa87e21914c20bee987006a6bd2e2.png#pic_center
[ebf49a54371a4b7a82e001bf177301da.png_pic_center]: https://img-blog.csdnimg.cn/ebf49a54371a4b7a82e001bf177301da.png#pic_center
[8e54e005301440bcb0b96aeee702e85d.png_pic_center]: https://img-blog.csdnimg.cn/8e54e005301440bcb0b96aeee702e85d.png#pic_center
[cab1dc65271f416b89b869987e607163.png_pic_center]: https://img-blog.csdnimg.cn/cab1dc65271f416b89b869987e607163.png#pic_center
[2f99abaeedce47ddb359c6e018f6c4c3.png_pic_center]: https://img-blog.csdnimg.cn/2f99abaeedce47ddb359c6e018f6c4c3.png#pic_center
[123fc5364aca481f996577346538e4b7.png_pic_center]: https://img-blog.csdnimg.cn/123fc5364aca481f996577346538e4b7.png#pic_center