SpringBoot回顾

最新推荐文章于 2024-10-07 08:57:49 发布

GJOED

最新推荐文章于 2024-10-07 08:57:49 发布

阅读量176

点赞数

分类专栏： java 文章标签： spring boot

本文链接：https://blog.csdn.net/GJOED/article/details/118342776

版权

java 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1 SpringBoot应用回顾

1.1 约定优于配置

概念：本质上是对系统、类库或框架中一些东西假定一个大众化合理的默认值(缺省值)。

如果所用工具的约定与你的期待相符，便可省去配置；反之，你可以配置来达到你所期待的方式。

好处：大大减少了配置项

1.2 SpringBoot概念

Spring Boot 的设计是为了让你尽可能快的跑起来 Spring 应用程序并且尽可能减少你的配置文件

1.3 SpringBoot主要特性

1、 SpringBoot Starter：
他将常用的依赖分组进行了整合，将其合并到一个依赖中，这样就可以一次性添加到项目的Maven或Gradle构建中；

2、使编码变得简单，SpringBoot采用 JavaConfig的方式对Spring进行配置，并且提供了大量的注解，极大的提高了工作效率。

3、自动配置：
SpringBoot的自动配置特性利用了Spring对条件化配置的支持，合理地推测应用所需的 bean并自动化配置他们；

4、使部署变得简单，SpringBoot内置了三种Servlet容器，Tomcat，Jetty,undertow.我们只需要一个 Java的运行环境就可以跑SpringBoot的项目了，SpringBoot的项目可以打成一个jar包。

1.4 热部署

原理：就是我们在编辑器上启动项目，然后改动相关的代码，然后编辑器自动触发编译替换掉历史的.class文件后，项目检测到有文件变更后会重启srpring-boot项目。

这里对类加载采用了两种类加载器，对于第三方jar包采用base- classloader来加载，对于开发人员自己开发的代码则使用restartClassLoader来进行加载，这使得比停掉服务重启要快的多，因为使用插件只是重启开发人员编写的代码部分。

1.5 全局配置文件

全局配置文件能够对一些默认配置值进行修改及自定义配置。

Spring Boot使用一个application.properties或者application.yaml的文件作为全局配置文件
在这里插入图片描述

整个设计非常巧妙。SpringBoot会从这四个位置全部加载主配置文件，如果高优先级中配置文件属性与
低优先级配置文件不冲突的属性，则会共同存在

备注：
这里说的配置文件，都还是项目里面。最终都会被打进jar包里面的，需要注意。
1、如果同一个目录下，有application.yml也有application.properties，默认先读取 application.properties。
2、如果同一个配置属性，在多个配置文件都配置了，默认使用第1个读取到的，后面读取的不覆盖前面读取到的。
3、创建SpringBoot项目时，一般的配置文件放置在“项目的resources目录下”

Spring Boot 2.4 改进了处理 application.properties 和 application.yml 配置文件的方式，如果是2.4.0之前版本，优先级properties>yaml
但是如果是2.4.0的版本，优先级yaml>properties
如果想继续使用 Spring Boot 2.3 的配置逻辑，也可以通过在 application.properties 或者 application.yml 配置文件中添加以下参数：

spring.config.use-legacy-processing = true

1.5.1 application.properties配置文件

使用Spring Initializr方式构建Spring Boot项目时，会在resource目录下自动生成一个空的
application.properties文件，Spring Boot项目启动时会自动加载application.properties文件。

在这里插入图片描述

1.5.2 application.yaml配置文件

YAML文件格式是Spring Boot支持的一种JSON超集文件格式，以数据为中心，比properties、xml等更适合做配置文件
在这里插入图片描述

1.6 属性注入

使用Spring Boot全局配置文件设置属性时：
如果配置属性是Spring Boot已有属性，例如服务端口server.port，那么Spring Boot内部会自动扫描并读取这些配置文件中的属性值并覆盖默认属性。
如果配置的属性是用户自定义属性，例如刚刚自定义的Person实体类属性，还必须在程序中注入这些配置属性方可生效。

1.6.1 属性注入常用注解

@Configuration：声明一个类作为配置类

@Bean：声明在方法上，将方法的返回值加入Bean容器 @Value：属性注入

@ConfigurationProperties(prefix = “jdbc”)：批量属性注入

@PropertySource(“classpath:/jdbc.properties”)指定外部属性文件。在类上添加

1.6.2 @Value属性值注入

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/springboot_h
jdbc.username=root
jdbc.password=123

   @Value("${jdbc.url}")
   String url;
   
   @Value("${jdbc.driverClassName}")    
   String driverClassName;
   
   @Value("${jdbc.username}")    
   String username;
   
   @Value("${jdbc.password}")    
   String password;

1.6.3 @ConfigurationProperties批量注入

@Component方可实现选中两注解内容
在这里插入图片描述

1.6.4 第三方配置

在这里插入图片描述

1.6.5 松散绑定

Spring Boot使用一些宽松的规则将环境属性绑定到@ConfigurationProperties bean，因此环境属性名和bean属性名之间不需要完全匹配

在这里插入图片描述

1.7 SpringBoot日志框架

1.7.1 日志框架介绍

在这里插入图片描述

1.7.2 SLF4J 的使用

在开发的时候不应该直接使用日志实现类，应该使用日志的抽象层

下图是 SLF4J 结合各种日志框架的官方示例，从图中可以清晰的看出 SLF4J API 永远作为日志的门面，直接应用与应用程序中。
在这里插入图片描述

1.7.3. 统一日志框架的使用

问题：A项目（slf4J + logback）: Spring（commons logging）、Hibernate（jboss-logging）、 mybatis…
一般情况下，在项目中存在着各种不同的第三方 jar ，且它们的日志选择也可能不尽相同，显然这样是不利于我们使用的

在 SLF4J 官方，也给了我们参考的例子

在这里插入图片描述
图中我们得到一种统一日志框架使用的方式，可以使用一种和要替换的日志框架类完全一样的 jar 进行替换，这样不至于原来的第三方 jar 报错，而这个替换的 jar 其实使用了 SLF4J API. 这样项目中的日志就都可以通过 SLF4J API 结合自己选择的框架进行日志输出。

统一日志框架使用步骤归纳如下：

排除系统中的其他日志框架。
使用中间包替换要替换的日志框架。
导入我们选择的 SLF4J 实现。

1.7.4. Spring Boot 的日志关系

① 排除其他日志框架
根据上面总结的要统一日志框架的使用，第一步要排除其他的日志框架，在 Spring Boot 的 Maven 依赖里可以清楚的看到 Spring Boot 排除了其他日志框架。

使用 exclusions 标签对 dependency 中的部分jar进行排除
在这里插入图片描述
② 统一框架引入替换包
Spring Boot 是使用了 SLF4J+logback 的日志框架组合，查看 Spring Boot 项目的 Maven 依赖关系可以看到 Spring Boot 的核心启动器 spring-boot-starter 引入了 spring-boot-starter-logging.

     <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-logging</artifactId>        <version>2.4.0.RELEASE</version>
     </dependency>

而 spring-boot-starter-logging 的 Maven 依赖主要引入了 logback-classic (包含了日志框架 Logback 的实现)，log4j-to-slf4j (在 log4j 日志框架作者开发此框架的时候还没有想到使用日志抽象层进行开发，因此出现了 log4j 向 slf4j 转换的工具)，jul-to-slf4j ( Java 自带的日志框架转换为 slf4j).

 <dependencies>
   <dependency>
     <groupId>ch.qos.logback</groupId>
     <artifactId>logback-classic</artifactId>
     <version>1.2.3</version>
     <scope>compile</scope>
   </dependency>
   <dependency>
     <groupId>org.apache.logging.log4j</groupId>
     <artifactId>log4j-to-slf4j</artifactId>
     <version>2.13.3</version>
     <scope>compile</scope>
   </dependency>
   <dependency>
     <groupId>org.slf4j</groupId>
     <artifactId>jul-to-slf4j</artifactId>      
     <version>1.7.30</version>
     <scope>compile</scope>    
   </dependency>
 </dependencies>

从上面的分析，Spring Boot 对日志框架的使用已经是清晰明了了
，我们使用 IDEA 工具查看 Maven 依赖关系，可以清晰的看到日志框架的引用
在这里插入图片描述

由此可见，Spring Boot 可以自动的适配日志框架，而且底层使用 SLF4j + LogBack 记录日志，如果我们自行引入其他框架，需要排除其日志框架。

1.7.5. Spring Boot 的日志使用

日志级别和格式
从上面的分析，发现 Spring Boot 默认已经使用了 SLF4J + LogBack . 所以我们在不进行任何额外操作的情况下就可以使用 SLF4J + Logback 进行日志输出。
编写 Java 测试类进行测试。

在这里插入图片描述

1.7.6 自定义日志输出

编写日志相关配置

# 日志配置
# 指定具体包的日志级别
logging.level.com.lagou=debug # 控制台和日志文件输出格式
logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
logging.pattern.file=%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n
# 日志输出路径，默认文件spring.log logging.file.path=spring.log #logging.file.name=log.log

在这里插入图片描述

1.7.7 替换日志框架

因为 Log4j 日志框架已经年久失修，原作者都觉得写的不好，所以下面演示替换日志框架为 Log4j2 的方式。根据官网我们 Log4j2 与 logging 需要二选一，因此修改 pom如下

<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
           <exclusions>
               <exclusion>
                   <artifactId>spring-boot-starter-logging</artifactId>
                   <groupId>org.springframework.boot</groupId>
               </exclusion>
           </exclusions>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-log4j2</artifactId>
</dependency>

2 SpringBoot数据访问

2.1 数据源配置方式

1.在maven中配置数据库驱动

2.配置数据库连接
在application.properties中配置数据库连接

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql:///springboot_h?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root
# spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

3 连接池配置方式
SpringBoot提供了三种数据库连接池：
1 HikariCP
2 Commons DBCP2
3 Tomcat JDBC Connection Pool

其中spring boot2.x版本默认使用HikariCP，maven中配置如下

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

2.2 Druid连接池的配置

1 在pom.xml中引入druid数据源

<dependency>
	<groupId>com.alibaba</groupId>
	<artifactId>druid-spring-boot-starter</artifactId>
	<version>1.1.10</version>
</dependency>

2 在application.yml中引入druid的相关配置

spring:
datasource:
  username: root   password: root
   url: jdbc:mysql:///springboot_h?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
   driver-class-name: com.mysql.cj.jdbc.Driver    
   initialization-mode: always
   # 使用druid数据源
   type: com.alibaba.druid.pool.DruidDataSource    
   # 数据源其他配置
   initialSize: 5    
   minIdle: 5
   maxActive: 20   
   maxWait: 60000
   timeBetweenEvictionRunsMillis: 60000    
   minEvictableIdleTimeMillis: 300000    
   validationQuery: SELECT 1 FROM DUAL
   testWhileIdle: true
   testOnBorrow: false
   testOnReturn: false
   poolPreparedStatements: true
   # 配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙    
   filters: stat,wall,log4j
   maxPoolPreparedStatementPerConnectionSize: 20    
   useGlobalDataSourceStat: true
   connectionProperties:
druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500

2.3 SpringBoot整合Mybatis

<!-- 配置数据库驱动和mybatis dependency -->
<dependency>
   <groupId>org.mybatis.spring.boot</groupId>
   <artifactId>mybatis-spring-boot-starter</artifactId>
   <version>1.3.2</version>
</dependency>
<dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <optional>true</optional>
</dependency>

application.yml配置 

spring:
  datasource:
    username: root   password: root
    url: jdbc:mysql:///springboot_h?useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC
    driver-class-name: com.mysql.jdbc.Driver    
    # 使用druid数据源
    type: com.alibaba.druid.pool.DruidDataSource

基础类（使用lombok自动生成get/set方法）

package com.lagou.demo.domain; 
import lombok.Data;

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

package com.lagou.dao;
import com.lagou.pojo.User;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface UserDao {
   @Select("SELECT * FROM USER")    
   List<User> getUser();
}

2.4 SpringBoot + Mybatis实现动态数据源切换

业务背景
电商订单项目分正向和逆向两个部分：其中正向数据库记录了订单的基本信息，包括订单基本信息、订单商品信息、优惠卷信息、发票信息、账期信息、结算信息、订单备注信息、收货人信息等；逆向数据库主要包含了商品的退货信息和维修信息。数据量超过500万行就要考虑分库分表和读写分离，那么我们在正向操作和逆向操作的时候，就需要动态的切换到相应的数据库，进行相关的操作。

在这里插入图片描述
具体实现

第一步：配置多数据源
首先，我们在application.properties中配置两个数据源

spring.druid.datasource.master.password=root
spring.druid.datasource.master.username=root
spring.druid.datasource.master.jdbc-
url=jdbc:mysql://localhost:3306/product_master?
useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC

spring.druid.datasource.master.driver-class-name=com.mysql.cj.jdbc.Driver
spring.druid.datasource.slave.password=root
spring.druid.datasource.slave.username=root
spring.druid.datasource.slave.jdbc-
url=jdbc:mysql://localhost:3306/product_slave?
useUnicode=true&characterEncoding=utf-8&useSSL=true&serverTimezone=UTC 

spring.druid.datasource.slave.driver-class-name=com.mysql.cj.jdbc.Driver

在SpringBoot的配置代码中，初始化两个数据源：

@Configuration
public class MyDataSourceConfiguratioin {    
	Logger logger = LoggerFactory.getLogger(MyDataSourceConfiguratioin.class);    
    /**
    * Master data source.     
    */
    @Bean("masterDataSource")
    @ConfigurationProperties(prefix = "spring.druid.datasource.master")    
    DataSource masterDataSource() {
    	logger.info("create master datasource...");        
        return DataSourceBuilder.create().build();  
    }
    /**
     * Slave data source.     
     */
    @Bean("slaveDataSource")
    @ConfigurationProperties(prefix = "spring.druid.datasource.slave")    
    DataSource slaveDataSource() {
        logger.info("create slave datasource...");        
        return DataSourceBuilder.create().build();  
    }
}

public class RoutingDataSourceContext {
   // holds data source key in thread local:
   static final ThreadLocal<String> threadLocalDataSourceKey = new ThreadLocal<>();
   public static String getDataSourceRoutingKey() {
   	   String key = threadLocalDataSourceKey.get();        
   	   return key == null ? "masterDataSource" : key;  
   }
   
   public RoutingDataSourceContext(String key) {
       threadLocalDataSourceKey.set(key);
   }
   public void close() {
       threadLocalDataSourceKey.remove();  
   }
}

使用注解动态切换数据源

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME) public @interface RoutingWith {
   String value() default "master"; 
}

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

@Aspect @Component
public class RoutingAspect {
   @Around("@annotation(routingWith)")
   public Object routingWithDataSource(ProceedingJoinPoint joinPoint, RoutingWith routingWith) throws Throwable {
       String key = routingWith.value();
       RoutingDataSourceContext ctx = new RoutingDataSourceContext(key);
       return joinPoint.proceed();  
   }
}

   @RoutingWith("masterDataSource")
   @GetMapping("/findAllProductM")
   public String findAllProductM() { 
       productService.findAllProductM();        
       return "lagou";
     }
   @RoutingWith("slaveDataSource")
   @GetMapping("/findAllProductS")
   public String findAllProductS() { 
       productService.findAllProductS();        
       return "lagou";
 }

3 SpringBoot缓存深入

3.1 JSR107

JSR是Java Specification Requests 的缩写，Java规范请求，故名思议提交Java规范， JSR-107呢就是关于如何使用缓存的规范，是java提供的一个接口规范，类似于JDBC规范，没有具体的实现，具体的实现就是reids等这些缓存。

JSR107核心接口

Java Caching（JSR-107）定义了5个核心接口，分别是CachingProvider、CacheManager、 Cache、Entry和Expiry。

CachingProvider（缓存提供者）：创建、配置、获取、管理和控制多个CacheManager

CacheManager（缓存管理器）：创建、配置、获取、管理和控制多个唯一命名的Cache，
Cache存在于CacheManager的上下文中。一个CacheManager仅对应一个CachingProvider

Cache（缓存）：是由CacheManager管理的，CacheManager管理Cache的生命周期，
Cache存在于CacheManager的上下文中，是一个类似map的数据结构，并临时存储以key为索引的值。一个Cache仅被一个CacheManager所拥有

Entry（缓存键值对）：是一个存储在Cache中的key-value对

Expiry（缓存时效）：每一个存储在Cache中的条目都有一个定义的有效期。一旦超过这个时间，条目就自动过期，过期后，条目将不可以访问、更新和删除操作。缓存有效期可以通过ExpiryPolicy设置

在这里插入图片描述
一个应用里面可以有多个缓存提供者(CachingProvider)，一个缓存提供者可以获取到多个缓存管理器(CacheManager)，一个缓存管理器管理着不同的缓存(Cache)，缓存中是一个个的缓存键值对(Entry)，每个entry都有一个有效期(Expiry)。缓存管理器和缓存之间的关系有点类似于数据库中连接池和连接的关系。

3.2 Spring的缓存抽象

Spring从3.1开始定义了org.springframework.cache.Cache和org.springframework.cache.CacheManager接口来统一不同的缓存技术；并支持使用Java Caching（JSR-107）注解简化我们进行缓存开发。

Spring Cache 只负责维护抽象层，具体的实现由自己的技术选型来决定。将缓存处理和缓存技术解除耦合。
每次调用需要缓存功能的方法时，Spring会检查指定参数的指定的目标方法是否已经被调用过，如果有就直接从缓存中获取方法调用后的结果，如果没有就调用方法并缓存结果后返回给用户。下次调用直接从缓存中获取。

使用Spring缓存抽象时我们需要关注以下两点：
① 确定那些方法需要被缓存
② 缓存策略

3.3 Spring缓存使用

在这里插入图片描述
① @Cacheable标注在方法上，表示该方法的结果需要被缓存起来，缓存的键由keyGenerator的策略决定，缓存的值的形式则由serialize序列化策略决定(序列化还是json格式)；标注上该注解之后，在缓存时效内再次调用该方法时将不会调用方法本身而是直接从缓存获取结果

② @CachePut也标注在方法上，和@Cacheable相似也会将方法的返回值缓存起来，不同的是标注@CachePut的方法每次都会被调用，而且每次都会将结果缓存起来，适用于对象的更新

@SpringBootApplication
@MapperScan(basePackages = "com.cache.mappers") 
@EnableCaching //开启基于注解的缓存
public class SpringbootCacheApplication {    
	public static void main(String[] args) {
    	SpringApplication.run(SpringbootCacheApplication.class, args);  
    }
}

② 标注缓存相关注解：@Cacheable、CacheEvict、CachePut

@Cacheable：将方法运行的结果进行缓存，以后再获取相同的数据时，直接从缓存中获取，不再调用方法

@Cacheable(cacheNames = {"emp"})
public Employee getEmpById(Integer id){ 
	Employee emp = employeeMapper.getEmpById(id); 
	return emp;
}

在这里插入图片描述
注：
①既满足condition又满足unless条件的也不进行缓存
②使用异步模式进行缓存时(sync=true)：unless条件将不被支持可用的SpEL表达式见下表：

在这里插入图片描述

3.4 @CachePut&@CacheEvict&@CacheConfig

@CachePut
1、说明：既调用方法，又更新缓存数据，一般用于更新操作，在更新缓存时一定要和想更新的缓存有相同的缓存名称和相同的key(可类比同一张表的同一条数据)
2、运行时机：
①先调用目标方法
②将目标方法的结果缓存起来
3、示例：

@CachePut(value = "emp",key = "#employee.id") 
public Employee updateEmp(
	Employee employee){
		employeeMapper.updateEmp(employee); 
		return employee;
	}
}

总结：@CachePut标注的方法总会被调用，且调用之后才将结果放入缓存，因此可以使用#result 获取到方法的返回值。

@CacheEvict
1、说明：
缓存清除，清除缓存时要指明缓存的名字和key，相当于告诉数据库要删除哪个表中的哪条数据，key默认为参数的值

2、属性：
value/cacheNames：缓存的名字 key：缓存的键

allEntries：是否清除指定缓存中的所有键值对，默认为false，设置为true时会清除缓存中的所有键值对，与key属性二选一使用

beforeInvocation：在@CacheEvict注解的方法调用之前清除指定缓存，默认为false，即在方法调用之后清除缓存，设置为true时则会在方法调用之前清除缓存(在方法调用之前还是之后清除缓存的区别在于方法调用时是否会出现异常，若不出现异常，这两种设置没有区别，若出现异常，设置为在方法调用之后清除缓存将不起作用，因为方法调用失败了)

3、示例：

@CacheEvict(value = "emp",key = "#id",beforeInvocation = true) 
public void delEmp(Integer id){
	employeeMapper.deleteEmpById(id); 
}

@CacheConfig

在这里插入图片描述

3.5 基于Redis的缓存实现

SpringBoot默认开启的缓存管理器是ConcurrentMapCacheManager，创建缓存组件是 ConcurrentMapCache，将缓存数据保存在一个个的ConcurrentHashMap<Object, Object>中。开发时我们可以使用缓存中间件：redis、memcache、ehcache等，这些缓存中间件的启用很简
单——只要向容器中加入相关的bean就会启用，可以启用多个缓存中间件

4 SpringBoot部署与监控

4.1 SpringBoot 项目部署

目前，前后端分离的架构已成主流，而使用SpringBoot构建Web应用是非常快速的，项目发布到服务器上的时候，只需要打成一个jar包，然后通过命令 : java -jar jar包名称即可启动服务了

4.1.1 jar包(官方推荐)

在这里插入图片描述

4.1.2 war包

在这里插入图片描述

7、使用外部Tomcat运行该 war 文件（把 war 文件直接丢到 tomcat的webapps目录，启动 tomcat）

注意事项：
将项目打成war包，部署到外部的tomcat中，这个时候，不能直接访问spring boot 项目中配置文件配置的端口。application.yml中配置的server.port配置的是spring boot内置的 tomcat的端口号, 打成war包部署在独立的tomcat上之后, 配置的server.port是不起作用的。一定要注意这一点！！

4.1.2 多环境部署

在项目运行中，包括多种环境，例如线上环境prod(product)、开发环境dev(development)、测试环境test、提测环境qa、单元测试unitest等等。不同的环境需要进行不同的配置，从而在不同的场景中跑我们的程序。例如prod环境和dev环境通常需要连接不同的数据库、需要配置不同的日志输出配置。还有一些类和方法，在不同的环境下有不同的实现方式。

Spring Boot 对此提供了支持，一方面是注解@Profile，另一方面还有多资源配置文件。

@Profile

@profile注解的作用是指定类或方法在特定的 Profile 环境生效，任何 @Component或
@Configuration注解的类都可以使用 @Profile注解。在使用DI来依赖注入的时候，能够根据 @profile标明的环境，将注入符合当前运行环境的相应的bean。

使用要求：
@Component或 @Configuration注解的类可以使用 @profile @Profile中需要指定一个字符串，约定生效的环境

在这里插入图片描述

2、profile激活

实际使用中，注解中标示了prod、test、qa等多个环境，运行时使用哪个profile由 spring.profiles.active控制，以下说明2种方式：配置文件方式、命令行方式。

（1）配置文件方式激活profile

确定当前使用的是哪个环境，这边环境的值与application-prod.properties中-后面的值对应，这是SpringBoot约定好的。
在resources/application.properties中添加下面的配置。需要注意的是，spring.profiles.active的取值应该与 @Profile注解中的标示保持一致。

在这里插入图片描述
多Profile的资源文件

除了@profile注解的可以标明某些方法和类具体在哪个环境下注入。springboot的环境隔离还可以使用多资源文件的方式，进行一些参数的配置。

①资源配置文件

Springboot的资源配置文件除了application.properties之外，还可以有对应的资源文件 application-{profile}.properties。
假设，一个应用的工作环境有：dev、test、prod 那么，我们可以添加 4 个配置文件：

applcation.properties - 公共配置
application-dev.properties - 开发环境配置
application-test.properties - 测试环境配置
application-prod.properties - 生产环境配置

不同的properties配置文件也可以是在 applcation.properties 文件中来激活 profile：

spring.profiles.active = test

在这里插入图片描述

4.2 SpringBoot 监控

微服务的特点决定了功能模块的部署是分布式的，大部分功能模块都是运行在不同的机器上，彼此通过服务调用进行交互，前后台的业务流会经过很多个微服务的处理和传递，出现了异常如何快速定位是哪个环节出现了问题？

在这种情况下，微服务的监控显得尤为重要。springboot作为微服务框架，除了它强大的快速开发功能外，还有就是它提供了actuator模块，引入该模块能够自动为springboot应用提供一系列用于监控的端点

4.2.1 Acturator

Actuator是spring boot的一个附加功能,可帮助你在应用程序生产环境时监视和管理应用程序。可以使用HTTP的各种请求来监管,审计,收集应用的运行情况。Spring Boot Actuator提供了对单个 Spring Boot的监控，信息包含：应用状态、内存、线程、堆栈等等，比较全面的监控了Spring Boot应用的整个生命周期。特别对于微服务管理十分有意义。

Actuator 的 REST 接口

Actuator 监控分成两类：原生端点和用户自定义端点；自定义端点主要是指扩展性，用户可以根据自己的实际应用，定义一些比较关心的指标，在运行期进行监控。

原生端点是在应用程序里提供众多 Web 接口，通过它们了解应用程序运行时的内部状况。原生端点又可以分成三类：

应用配置类：可以查看应用在运行期的静态信息：例如自动配置信息、加载的 springbean 信息、yml 文件配置信息、环境信息、请求映射信息；
度量指标类：主要是运行期的动态信息，例如堆栈、请求链、一些健康指标、metrics 信息等；
操作控制类：主要是指 shutdown,用户可以发送一个请求将应用的监控功能关闭。

Actuator 提供了 13 个接口，具体如下表所示。

在这里插入图片描述

4.2.1 Spring Boot Admin

对于spring actuator而言，最大的缺点在于是以json形式来进行展示，为了更好的进行监控显示，我们来介绍一个更加方便的工具：spring boot admin。

Spring Boot Admin：可视化后台管理系统

Spring Boot Admin 是一个针对spring-boot的actuator接口进行UI美化封装的监控工具。他可以返回在列表中浏览所有被监控spring-boot项目的基本信息比如：Spring容器管理的所有的bean、详细的Health信息、内存信息、JVM信息、垃圾回收信息、各种配置信息（比如数据源、缓存列表和命中率）等，Threads 线程管理，Environment 管理等。

利用springbootadmin进行监控的架构图如下：

在这里插入图片描述