springboot篇

weixin_44231698

已于 2024-09-12 15:50:19 修改

阅读量219

点赞数 1

分类专栏： java 文章标签： java springboot

于 2024-08-30 10:58:52 首次发布

本文链接：https://blog.csdn.net/weixin_44231698/article/details/141712609

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

1.题目问答

1.SpringBoot的优点：
Spring Boot 不仅提供了自动装配、起步依赖，还自带了不少非功能性的特性，例如安全度量、健康检査、内嵌 Servlet 容器和外置配置。另外，Actuator 提供了运行时的Spring Boot 程序中的监控端点，可以监控服务及应用，做健康检测。
2.Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？
启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：
@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class })。
@ComponentScan ：Spring组件扫描。
3、运行Spring Boot有哪几种方式 ?
1)打包用命令或者放到容器中运行
2)用 Maven/Gradle 插件运行
3)直接执行 main 方法运行
4、如何理解 Spring Boot 中的 Starters？
Starters可以理解为启动器，它包含了一系列可以集成到应用里面的依赖包，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖。Spring Boot官方的启动器都是以spring-boot-starter-命名的，代表了一个特定的应用类型。第三方的启动器不能以spring-boot开头命名，它们都被Spring Boot官方保留。
它提供了一个自动化配置类，一般命名为 XXXAutoConfiguration ，在这个配置类中通过条件注解来决定一个配置是否生效，然后它还会提供一系列的默认配置，也允许开发者根据实际情况自定义相关配置，然后通过类型安全的属性注入将这些配置属性注入进来，新注入的属性会代替掉默认属性。
spring-boot-starter-parent 有什么用 ?

定义了 Java 编译版本为 1.8 。
使用 UTF-8 格式编码。
继承自 spring-boot-dependencies，这个里边定义了依赖的版本，也正是因为继承了这个依赖，所以我们在写依赖时才不需要写版本号。
执行打包操作的配置。
自动化的资源过滤。
自动化的插件配置。
针对 application.properties 和 application.yml 的资源过滤，包括通过 profile 定义的不同环境的配置文件，例如 applicationdev.properties 和 application-dev.yml

5、如何在Spring Boot启动的时候运行一些特定的代码？
如果你想在Spring Boot启动的时候运行一些特定的代码，你可以实现接口ApplicationRunner或者CommandLineRunner，这两个接口实现方式一样，它们都只提供了一个run方法。
CommandLineRunner：启动获取命令行参数
6、如何使用Spring Boot实现异常处理？
Spring提供了一种使用@ControllerAdvice处理异常的非常有用的方法。我们通过实现一个ControlerAdvice类，来处理控制器类抛出的所有异常。
新建一个类GlobalDefaultExceptionHandler，在class注解上@ControllerAdvice,
@ControllerAdvice ：即把@ControllerAdvice 注解内部使用 @ExceptionHandler、@InitBinder、@ModelAttribute注解的方法应用到所有的 @RequestMapping注解的方法。非常简单，不过只有当使用@ExceptionHandler最有用，另外两个用处不大。
在方法上注解上@ExceptionHandler(value = Exception.class)，具体代码如下

@ControllerAdvice 
public class GlobalDefaultExceptionHandler {  
    @ExceptionHandler(value = Exception.class) 
    public void defaultErrorHandler(HttpServletRequest req, Exception e)  { 
      //打印异常信息：
      e.printStackTrace(); 
  	  System.out.println("GlobalDefaultExceptionHandler.defaultErrorHandler()"); 
  } 
}

DemoController 加入方法：

@RequestMapping("/zeroException") 
    publicint zeroException(){ 
       return 100/0; 
    }

访问：http://127.0.0.1:8080/zeroException 这个方法肯定是抛出异常的,那么在控制台就可以看到我们全局捕捉的异常信息了。

7、 SpringBoot 实现热部署有哪几种方式？
主要有两种方式：

Spring Loaded
Spring-boot-devtools

8、 Spring Boot 的核心配置文件有哪几个？它们的区别是什么？
Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。
application 配置文件这个容易理解，主要用于 Spring Boot 项目的自动化配置。
bootstrap 配置文件有以下几个应用场景。

使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中添加连接到配置中心的配置属性来加载外部配置中心的配置信息；
一些固定的不能被覆盖的属性；
一些加密/解密的场景；

9. Spring Boot 自动配置原理是什么？
注解 @EnableAutoConfiguration, @Configuration, @ConditionalOnClass 就是自动配置的核心，@EnableAutoConfiguration 给容器导入META-INF/spring.factories 里定义的自动配置类。筛选有效的自动配置类。
每一个自动配置类结合对应的 xxxProperties.java 读取配置文件进行自动配置功能。
条件化配置允许配置存在于应用程序中，但在满足某些特定条件之前都忽略这个配置。
在Spring里可以方便地编写你自己的条件，通过实现Condition接口，覆盖它的matches()方法。举例来说，下面这个简单的条件类只有在Classpath里存在JdbcTemplate时
才会生效：

public class JdbcTemplateCondition implements Condition { 
  @Override 
  public boolean matches(ConditionContext context,  AnnotatedTypeMetadata metadata) { 
    try { 
      context.getClassLoader().loadClass( "org.springframework.jdbc.core.JdbcTemplate"); 
      return true; 
    } catch (Exception e) { 
      return false; 
    } 
  } 
}

当你用Java来声明Bean的时候，可以使用这个自定义条件类：

@Conditional(JdbcTemplateCondition.class) 
public MyService myService() { 
    ... 
}

在这个例子里，只有当JdbcTemplateCondition类的条件成立时才会创建MyService这个
Bean。也就是说MyService Bean创建的条件是Classpath里有JdbcTemplate。否则，这个Bean的声明就会被忽略掉。下表列出了Spring Boot提供的条件化注解。

条件化注解	配置生效条件
@ConditionalOnBean	配置了某个特定Bean
@ConditionalOnMissingBean	没有配置特定的Bean
@ConditionalOnClass	Classpath里有指定的类
@ConditionalOnMissingClass	Classpath里缺少指定的类
@ConditionalOnExpression	给定的Spring Expression Language（SpEL）表达式计算结果为true
@ConditionalOnJava	Java的版本匹配特定值或者一个范围值
@ConditionalOnJndi	参数中给定的JNDI位置必须存在一个，如果没有给参数，则要有JNDI InitialContext
@ConditionalOnProperty	指定的配置属性要有一个明确的值
@ConditionalOnResource	Classpath里有指定的资源
@ConditionalOnWebApplication	这是一个Web应用程序
@ConditionalOnNotWebApplication	这不是一个Web应用程序

10.什么是 Spring Batch？
Spring Boot Batch 提供可重用的函数，这些函数在处理大量记录时非常重要，包括日志/跟踪，事务管理，作业处理统计信息，作业重新启动，跳过和资源管理。它还提供了更先进的技术服务和功能，通过优化和分区技术，可以实现极高批量和高性能批处理作业。简单以及复杂的大批量批处理作业可以高度可扩展的方式利用框架处理重要大量的信息。
11.Spring Boot 打成的 jar 和普通的 jar 有什么区别 ?
Spring Boot 项目终打包成的 jar 是可执行 jar ，这种 jar 可以直接通过 java jar xxx.jar 命令来运行，这种 jar 不可以作为普通的 jar 被其他项目依赖，即使依赖了也无法使用其中的类。
Spring Boot 的 jar 无法被其他项目依赖，主要还是他和普通 jar 的结构不同。普通的 jar 包，解压后直接就是包名，包里就是我们的代码，而 Spring Boot 打包成的可执行 jar 解压后，在 \BOOT-INF\classes 目录下才是我们的代码，因此无法被直接引用。如果非要引用，可以在 pom.xml 文件中增加配置，将 Spring Boot 项目打包成两个 jar ，一个可执行，一个可引用。
12.Spring Boot 中如何实现定时任务 ?
定时任务也是一个常见的需求，Spring Boot 中对于定时任务的支持主要还是来自 Spring 框架。在 Spring Boot 中使用定时任务主要有两种不同的方式，一个就是使用 Spring 中的 @Scheduled 注解，另一个则是使用第三方框架 Quartz。使用 Spring 中的 @Scheduled 的方式主要通过 @Scheduled 注解来实现。使用 Quartz ，则按照 Quartz 的方式，定义 Job 和 Trigger 即可。
@Scheduled方式需要在调度类头上添加@Configuration，然后再调度方法上添加@Schuldle 注解，并为@Schuldle指定CronExpress表达式。代码如下：

@Configuration // 声明类为系统配置类 
@EnableScheduling // 开启调度任务 
public class MyScheduleConfig { 
private Logger logger = Logger.getLogger(getClass()); 
	@Scheduled(cron = "0 0/1 * * * ?") // 定义调度器 
	public void job1() { 
		logger.info("this is my first job execute"); 
	} 
}

@RestController 注解的功能相当于@Controller注解和@ResponseBody 注解之和。

对比之前的 Spring，Spring Boot有三大特点:自动配置、起步依赖和 Actuator 对运行状态的监控。
Spring Boot的宗旨是希望通过设计大量的自动化配置等方式来简化 Spring 原有样板化的配置,使得开发者可以快速构建应用。除了解决配置问题之外，Spring Boot 对于构建、部署等做了优化,Spring Boot还通过一系列Starter POMs的定义，让我们整合各项功能的时候，不需要在Maven的pom.xml中维护那些错综复杂的依赖关系，而是通过类似模块化的 Starter 模块定义来引用，使得依赖管理工作变得更为简单。
在如今容器化大行其道的时代，Spring Boot除了可以很好融入Docker之外，其自身就支持嵌入式的 Tomcat、Jetty 等容器。所以，通过 Spring Boot 构建的应用不再需要安装Tomcat，将应用打包成war，再部署到 Tomcat 这样复杂的构建与部署动作，只需将 SpringBoot 应用打成jar 包，并通过 java -jar 命令直接运行就能启动一个标准化的 Web 应用,这使得 Spring Boot 应用变得非常轻便。
1.启动 Spring Boot 应用的方式：

作为一个 Java 应用程序，可以直接通过运行拥有 main 函数的类来启动。
在 Maven 配置中，之前提到了 spring-boot插件，可以使用它来启动，比如执行 mvn spring-boot:run命令,或是直接单击IDE中对 Maven 插件的工具,例如Intelli]中的支持:
在服务器上部署运行时，通常先使用mvn insta11将应用打包成jar 包，再通过
java -jar xxx.jar 来启动应用。

2.配置详情

2.1配置文件

src/main/resources目录是Spring Boot 的配置目录，默认的配置文件位置为src/main/resources/application.properties。关于 Spring Boot 应用的配置内容都可以集中在该文件中，比如定义容器端口号、数据库连接信息、日志级别等各种配置信息。
Spring Boot 的配置文件除了可以使用传统的properties文件之外,还支持现在被广泛推荐使用的 YAML 文件。YAML可以通过使用 spring.profiles属性来定义多个不同的环境配置。
注意 YAML目前还有一些不足，它无法通过@PropertySource 注解来加载配置。但是，YAML 将属性加载到内存中保存的时候是有序的，所以当配置文件中的信息需要具备顺序含义时，YAML的配置方式比起 properties 配置文件更有优势。

2.2多环境配置

对于多环境的配置，在 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 配置文件内容。

2.3自定义参数

可以在配置文件 application.properties中定义一些我们需要的自定义属性。然后，在应用中可以通过@Value 注解来加载这些自定义的参数。
@Value 注解加载属性值的时候可以支持两种表达式来进行配置，如下所示

一种是上面介绍的 PlaceHolder 方式，格式为${…}，大括号内为 PlaceHolder。
另一种是使用 SpEL表达式(SpringExpressionLanguage)，格式为#{…}，大括号内为 SpEL 表达式。
**参数引用：**在 application.properties中的各个参数之间可以直接通过使用PlaceHolder 的方式来进行引用。
使用随机数：在 Spring Boot 的属性配置文件中，可以通过使用${random}配置来产生随机的 int 值、long 值或者 string 字符串,这样我们就可以容易地通过配置随机生成属性,而不是在程序中通过编码来实现这些逻辑。

${random}的配置方式主要有以下几种，读者可作为参考使用。
com.didispace.blog.value=${random.value}#随机字符串
com.didispace.blog.number=${random.int}#随机 int
com.didispace.blog.bignumber=${random.long }#随机 long
com.didispace.blog.test1=${random.int(10)}# 10 以内的随机数
com.didispace.blog.test2=${random.int[10,20]}# 10~20的随机数
com.didispace.blog.test3=${random.uuid}# 随机生成一个 uuid

2.3.1.将配置文件的属性赋给实体类

当有很多配置属性时，如果逐个地读取属性会非常麻烦。通常的做法会把这些属性名作为变量名来创建一个JavaBean的变量，并将属性值赋给JavaBean变量的值。在配置文件 application.yml中添加如下属性:

my :
	name: forezp
		age:12
		number:${random.int}
		uuid : ${random.uuid}
		max:${random.int(10)}
		value:${random.value)
		greeting:hi,i'm ${my.name}

创建一个JavaBean，其代码清单如下:

@ConfigurationProperties(prefix="my")
@Component
public class ConfigBean{
	private String name;
	private int age;
	private int number;
	private String uuid;
	private int max;
	private String value;
	private String greeting;
	//省略了getter setter...
}

在上面的代码中，在 ConfigBean 类上加一个注解@ConfigurationProperties，表明该类为配置属性类，并加上配置的prefx，例如本案例的“my”。另外需要在ConfigBean 类上加@Component 注解，Spring Boot 在启动时通过包扫描将该类作为一个 Bean 注入 IoC 容器中。创建一个Controller，读取ConfigBean类的属性。在Controller类上，加@EnableConfigurationProperties 注解，并指明ConfigBean 类，其代码清单如下:

@RestController
@EnableConfigurationProperties({ConfigBean.class})
public class LucyController{
	@Autowired
	ConfigBean confiqBean;
	@RequestMapping(value="/lucy")public String miya(){
	return configBean.getGreeting()+"_"+configBean.getName ()+"_"+configBean.getUuid()+ "-"+configBean.getMax();
	}
}

2.3.2.自定义配置文件

如果属性太多，把所有的配置属性都写到application.yml配置文件中不太合适，这时需要自定义配置文件。例如在 src/main/resources 目录下自定义一个 test.properties 配置文件。其配置信息如下:

com.forezp.name=forezp
com.forezp.age=12

配置文件 test.properties的属性和属性值赋给一个 JavaBean，需要在类名上加@Configuration、@PropertySource 和@ConfigurationProperties 这3个注解。需要在@PropertySource 注解上加location，并指明该配置文件的路径。

@Configuration
@PropertySource(value="classpath:test.properties")
@ConfigurationProperties(prefix="com.forezp")
public class User{
	private String name;
	private int age;
	//...省略getter、setter

写一个 LucyController 的类，在类的上方加上@RestController 注解，开启RestController的功能;加上@EnableConfigurationProperties 注解，并指明需要引用的JavaBean 的类，开启引用配置属性的功能，其代码清单如下:

@RestController
@EnableConfiaurationProperties(iConfiaBean.class,User.class})
public class LucyController{
	@Autowired
	ConfigBean configBean;
	@RequestMapping(value ="/lucy")
	public String miya(){
		return configBean.getGreeting()+configBean.getName()+configBean.getUuid()+ configBean.getMax();
		}
	@Autowired
	User user;
	@RequestMapping(value ="/user")
	public String user(){
		return user.getName()+":"+user.getAge();
		}
	}

2.4命令行参数

可以在命令行中指定应用的参数，比如java-jarxxx.jar–server.port=8888，连续的两个减号–就是对application.properties中的属性值进行赋值的标识。

2.5加载顺序

Spring Boot 使用了下面这种较为特别的属性加载顺序：
1.在命令行中传入参数
2.SPRING_APPLICATION_JSON中的属性。SPRING_APPLICATION_JSON是以JSON格式配置在系统环境变量中的内容。
3.java:comp/env中的JNDI 属性。
4.Java的系统属性，可以通过 System.getProperties()获得的内容。
5.操作系统的环境变量。
6.通过 random.*配置的随机属性。
7.位于当前应用jar包之外，针对不同{profile}环境的配置文件内容，例如application-{profile}.properties 或是YAML 定义的配置文件。
8.位于当前应用jar包之内，针对不同{profile}环境的配置文件内容，例如application-{profile}.properties 或是 YAML 定义的配置文件。
9.位于当前应用jar 包之外的 application.properties 和 YAML 配置内容
10.位于当前应用jar 包之内的 application.properties 和 YAML 配置内容。
11.在@Configuration 注解修改的类中，通过@PropertySource 注解定义的属性。
12.应用默认属性，使用 SpringApplication.setDefaultProperties 定义的内容。
优先级按上面的顺序由高到低，数字越小优先级越高。
可以看到，其中第7项和第9项都是从应用iar包之外读取配置文件，所以，实现外部化配置的原理就是从此切入,为其指定外部配置文件的加载位置来取代jar 包之内的配置内容。通过这样的实现，我们的工程在配置中就变得非常干净，只需在本地放置开发需要的配置即可，而不用关心其他环境的配置，由其对应环境的负责人去维护即可。

3.Starter POMs

Spring Boot 的 Starter POMs采用 spring-boot-starter-*的命名方式,*代表一个特别的应用功能模块，比如web、test。

4.监控与管理—actuator

Spring Boot 的 Actuator 提供了运行状态监控的功能，Actuator 的监控数据可以通过 REST、远程 shell 和JMX方式获得。通过 REST方式査看 Actuator 的节点的方法是最常见且简单的方法。
在配置文件 application.yml中配置 management.port 和 management.security.enabled，这两个配置分别配置了 Actuator 对外暴露REST API接口的端口号和 Actuator 采取非安全验证方式，其代码清单如下:

management:
	port:9001
	security:
		enabled:false

在上述的配置代码中指定了Actuator对外暴露REST API接口的端口为9001，如果不指定，端口为应用程序的启动端口，这样做的目的是将程序端口和程序的监控端口分开。SpringBoot 1.5x版本默认开启了 Actuator 的安全验证，为了能够在浏览器上展示效果，不做安全验证，将management.security.enables=false。
监控系统采集信息有很大一部分指标都是类似的，比如环境变量、垃圾收集信息、内存信息、线程池信息等。
Spring Boot在 Starter POMs 中提供了一个特殊依赖模块 spring-boot-starter-actuator。引入该模块能够自动为 Spring Boot 构建的应用提供一系列用于监控的端点。包括原生提供的端点以及一些常用的扩展和配置方式等。
在pom.xml中添加依赖

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

根据端点的作用，原生端点分为以下三类：

应用配置类:获取应用程序中加载的应用配置、环境变量、自动化配置报告等与Spring Boot 应用密切相关的配置类信息。
度量指标类:获取应用程序运行过程中用于监控的度量指标，比如内存信息、线程池信息、HTTP请求统计等。
操作控制类:提供了对应用的关闭等操作类功能。

4.1. 应用配置类

由于 Spring Boot 为了改善传统 Spring 应用繁杂的配置内容,采用了包扫描和自动化配置的机制来加载原本集中于XML文件中的各项内容。虽然这样的做法让我们的代码变得非常简洁,但是整个应用的实例创建和依赖关系等信息都被离散到了各个配置类的注解上,这使我们分析整个应用中资源和实例的各种关系变得非常困难。而这类端点可以帮助我们轻松获取一系列关于 Spring 应用配置内容的详细报告，比如自动化配置的报告、Bean 创建的报告、环境属性的报告等。

4.1.1./autoconfg

/autoconfg:该端点用来获取应用的自动化配置报告，其中包括所有自动化配置的候选项。同时还列出了每个候选项是否满足自动化配置的各个先决条件。所以，该端点可以帮助我们方便地找到一些自动化配置为什么没有生效的具体原因。该报告内容将自动化配置内容分为以下两部分。

positiveMatches中返回的是条件匹配成功的自动化配置。
negativeMatches中返回的是条件匹配不成功的自动化配置。

4.1.2. /beans

/beans:该端点用来获取应用上下文中创建的所有Bean。
在每个Bean中都包含了下面这些信息

bean:Bean的名称。
scope:Bean的作用域。
type:Bean的Java类型
resource:class文件的具体路径
dependencies:依赖的Bean 名称。

4.1.3. /configprops

/configprops:该端点用来获取应用中配置的属性信息报告。prefix属性代表了属性的配置前缀，properties代表了各个属性的名称和值。可以通过该报告来看到各个属性的配置路径，可以通过使用endpoints.configprops.enabled=false来关闭该端点。

4.1.4 /env

**/env:**该端点与/confgprops不同，它用来获取应用所有可用的环境属性报告。包括环境变量、JVM 属性、应用的配置属性、命令行中的参数。它可以帮助我们方便地看到当前应用可以加载的配置信息，并配合@ConfigurationProperties注解将它们引入到我们的应用程序中来进行使用。另外，为了配置属性的安全，对于一些类似密码等敏感信息，该端点都会进行隐私保护，但是我们需要让属性名中包含 password、secret、key 这些关键词，这样该端点在返回它们的时候会使用*来替代实际的属性值。

4.1.5./mappings

**/mappings:**该端点用来返回所有 Spring MVC的控制器映射关系报告。bean属性标识了该映射关系的请求处理器，method属性标识了该映射关系的具体处理类和处理函数。

4.1.6./info

/info:该端点用来返回一些应用自定义的信息。默认情况下，该端点只会返回一个空的 JSON 内容。我们可以在 application.properties 配置文件中通过 info前缀来设置一些属性，比如下面这样:

info.app.name-spring-boot-hello
info.app.version=v1.0.0

再访问/info端点，我们可以得到下面的返回报告，其中就包含了上面我们在应用中自定义的两个参数。

{
	"app":{
	"name":"spring-boot-hello"
	"version":"v1.0.0"
	}
}

4.2. 度量指标类

应用配置类端点所提供的信息报告在应用启动的时候就已经基本确定了其返回内容，可以说是一个静态报告。而度量指标类端点提供的报告内容则是动态变化的，这些端点提供了应用程序在运行过程中的一些快照信息，比如内存使用情况、HTTP请求统计、外部资源指标等。这些端点对于我们构建微服务架构中的监控系统非常有帮助。

4.2.1. /metrics

/metrics:该端点用来返回当前应用的各类重要度量指标，比如内存信息、线程信息垃圾回收信息等。包含以下度量值：

系统信息:包括处理器数量processors、运行时间uptime和instance.uptime、系统平均负载systemload.average。
mem.*:内存概要信息,包括分配给应用的总内存数量以及当前空闲的内存数量。这些信息来自java.lang.Runtime。
heap.*:堆内存使用情况。这些信息来自java.lang.management.MemoryMXBean 接口中getHeapMemoryUsage 方法获取的 java.lang.management.MemoryUsage.
nonheap.*:非堆内存使用情况。这些信息来自java.lang.managementMemoryMXBean接口中getNonHeapMemoryUsage方法获取的java.lang.management.MemoryUsage.
threads.*:线程使用情况,包括线程数、守护线程数(daemon)、线程峰值(peak)等，这些数据均来自java.lang.management.ThreadMXBean。
classes.*:应用加载和卸载的类统计。这些数据均来自java.lang.management.ClassLoadinqMxBean。
gc.*:垃圾收集器的详细信息,包括垃圾回收次数gc.ps scavenge.count、垃圾回收消耗时间 gc.ps scavenge.time、标记-清除算法的次数 gc.psmarksweep.count、标记-清除算法的消耗时间gc.ps marksweep.time。这些数据均来自java,lang.management.GarbageCollectorMXBean。
httpsessions.*:Tomcat容器的会话使用情况。包括最大会话数httpsessions.max和活跃会话数httpsessions.active。该度量指标信息仅在引入嵌入式 Tomcat 作为应用容器的时候才会提供。
gauge.*:HTTP请求的性能指标之一，它主要用来反映一个绝对数值。比如上面示例中的 gauge.response.hello:5，它表示上一次hello 请求的延迟时间为5 毫秒。
counter.*:HTTP请求的性能指标之一，它主要作为计数器来使用，记录了增加量和减少量。上述示例中的counter.status.200.hello:11，它代表了 he1lo请求返回 200状态的次数为11。
对于 gauge.*和counter.*的统计，这里有一个特殊的内容请求star-star,它代表了对静态资源的访问。这两类度量指标非常有用，我们不仅可以使用它默认的统计指标，还可以在程序中轻松地增加自定义统计值。只需要通过注入org.springframework.boot.actuate.metrics.CounterService 和 orgspringframework.boot.actuate.metrics.GaugeService 来实现自定义的统计指标信息。比如我们可以像下面这样自定义实现对hello接口的访问次数统计。

@RestController
public class HelloController{
	@Autowired
	private CounterService counterService;
	@RequestMapping("/hello")
	public String greet(){
		counterService.increment("didispace.hello.count");
		return "";
	}
}

/metrics端点可以提供应用运行状态的完整度量指标报告，这项功能非常实用，但是对于监控系统中的各项监控功能，它们的监控内容、数据收集频率都有所不同，如果每次都通过全量获取报告的方式来收集，略显粗暴。所以，我们还可以通过/metrics/{name}接口来更细粒度地获取度量信息，比如可以通过访问/metrics/mem.free来获取当前可用内存数量。

4.2.2. /health

/health:用来获取应用的各类健康指标信息。在 spring-boot-starter-actuator 模块中自带实现了一些常用资源的健康指标检测器。这些检测器都通过 HealthIndicator接口实现，并且会根据依赖关系的引入实现自动化装配，比如下面列出的这些。

检测器	功能
DiskSpaceHealthIndicator	低磁盘空间检测
DataSourceHealthIndicator	检测 DataSource 的连接是否可用
MongoHealthIndicator	检测 Mongo 数据库是否可用
RabbitHealthIndicator	检测 Rabbit 服务器是否可用
RedisHealthIndicator	检测 Redis 服务器是否可用
SolrHealthIndicator	检测 Solr 服务器是否可用

有时候，我们可能还会用到一些 Spring Boot的 Starter POMs 中还没有封装的产品来进行开发，比如，当使用 RocketMQ 作为消息代理时，由于没有自动化配置的检测器，所以需要自己来实现一个用来采集健康信息的检测器。我们可以在 Spring Boot 的应用中，为org.springframework.boot.actuate.health.HealthIndicator 接口实现一个对 RocketMQ的检测器类:

@Component
public class RocketMQHealthIndicator implements HealthIndicator{
	@Override
	public Health health(){
		int errorCode=check();
		if(errorCode !=0){
			return Health.down().withDetail("Error Code", errorCode) .build();
		}
			return Health.up().build();
		private int check(){
		//对监控对象的检测操作
		}
	}

通过重写 health()函数可实现健康检查，在返回的Heath 对象中，共有两项内容，一个是状态信息，除了该示例中的UP与DOWN之外，还有UNKNOWN和OUT_OF_SERVICE，可以根据需要来实现返回;还有一个详细信息，采用Map的方式存储，在这里通过withDetail函数，注入了一个Error Code 信息，我们也可以填入其他信息，比如，检测对象的IP地址、端口等。重新启动应用，并访问/health接口，我们在返回的JSON字符串中，将会包含如下信息:

"rocketMQ" :{"status": "UP"}

4.2.3./dump

/dump:该端点用来暴露程序运行中的线程信息。它使用java.lang.management
ThreadMxBean的dumpAllThreads方法来返回所有含有同步信息的活动线程详情。

4.2.3./trace

**/trace:**该端点用来返回基本的HTTP 跟踪信息。默认情况下，跟踪信息的存储采用org.springframework.boot.actuate.trace.InMemoryTraceRepository实现的内存方式，始终保留最近的100条请求记录。

4.3 操作控制类

操作控制类端点拥有更强大的控制能力，如果要使用它们的话，需要通过属性来配置开启操作。
在原生端点中，只提供了一个用来关闭应用的端点:/shutdown。可以通过如下配置开启它:endpoints.shutdown.enabled=true
在配置了上述属性之后,只需要访问该应用的/shutdown端点就能实现关闭该应用的远程操作。由于开放关闭应用的操作本身是一件非常危险的事，所以真正在线上使用的时候，需要对其加入一定的保护机制，比如定制actuator 的端点路径、整合 Spring Security 进行安全校验等。