SpringBoot自動裝配的套路，直接看 spring.factories 文件，當我們使用的時候只需要引入如下依賴
|
1
2
3
4
|
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-actuator</artifactId></dependency> |
然后在 org.springframework.boot.spring-boot-actuator-autoconfigure 包下去就可以找到這個文件
自動裝配
查看這個文件發現引入了很多的配置類，這里先關注一下 XXXHealthIndicatorAutoConfiguration 系列的類，這里咱們拿第一個 RabbitHealthIndicatorAutoConfiguration 為例來解析一下。看名字就知道這個是RabbitMQ的健康檢查的自動配置類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
@Configuration@ConditionalOnClass(RabbitTemplate.class)@ConditionalOnBean(RabbitTemplate.class)@ConditionalOnEnabledHealthIndicator("rabbit")@AutoConfigureBefore(HealthIndicatorAutoConfiguration.class)@AutoConfigureAfter(RabbitAutoConfiguration.class)public class RabbitHealthIndicatorAutoConfiguration extends CompositeHealthIndicatorConfiguration<RabbitHealthIndicator, RabbitTemplate> { private final Map<String, RabbitTemplate> rabbitTemplates; public RabbitHealthIndicatorAutoConfiguration( Map<String, RabbitTemplate> rabbitTemplates) { this.rabbitTemplates = rabbitTemplates; } @Bean @ConditionalOnMissingBean(name = "rabbitHealthIndicator") public HealthIndicator rabbitHealthIndicator() { return createHealthIndicator(this.rabbitTemplates); }} |
按照以往的慣例，先解析注解
-
@ConditionalOnXXX系列又出現了，前兩個就是說如果當前存在RabbitTemplate這個bean也就是說我們的項目中使用到了RabbitMQ才能進行下去 -
@ConditionalOnEnabledHealthIndicator這個注解很明顯是SpringBoot actuator自定義的注解，看一下吧
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
@Conditional(OnEnabledHealthIndicatorCondition.class)public @interface ConditionalOnEnabledHealthIndicator { String value();}class OnEnabledHealthIndicatorCondition extends OnEndpointElementCondition { OnEnabledHealthIndicatorCondition() { super("management.health.", ConditionalOnEnabledHealthIndicator.class); }}public abstract class OnEndpointElementCondition extends SpringBootCondition { private final String prefix; private final Class<? extends Annotation> annotationType; protected OnEndpointElementCondition(String prefix, Class<? extends Annotation> annotationType) { this.prefix = prefix; this.annotationType = annotationType; } @Override public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) { AnnotationAttributes annotationAttributes = AnnotationAttributes .fromMap(metadata.getAnnotationAttributes(this.annotationType.getName())); String endpointName = annotationAttributes.getString("value"); ConditionOutcome outcome = getEndpointOutcome(context, endpointName); if (outcome != null) { return outcome; } return getDefaultEndpointsOutcome(context); } protected ConditionOutcome getEndpointOutcome(ConditionContext context, String endpointName) { Environment environment = context.getEnvironment(); String enabledProperty = this.prefix + endpointName + ".enabled"; if (environment.containsProperty(enabledProperty)) { boolean match = environment.getProperty(enabledProperty, Boolean.class, true); return new ConditionOutcome(match, ConditionMessage.forCondition(this.annotationType).because( this.prefix + endpointName + ".enabled is " + match)); } return null; } protected ConditionOutcome getDefaultEndpointsOutcome(ConditionContext context) { boolean match = Boolean.valueOf(context.getEnvironment() .getProperty(this.prefix + "defaults.enabled", "true")); return new ConditionOutcome(match, ConditionMessage.forCondition(this.annotationType).because( this.prefix + "defaults.enabled is considered " + match)); }}public abstract class SpringBootCondition implements Condition { private final Log logger = LogFactory.getLog(getClass()); @Override public final boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { String classOrMethodName = getClassOrMethodName(metadata); try { ConditionOutcome outcome = getMatchOutcome(context, metadata); logOutcome(classOrMethodName, outcome); recordEvaluation(context, classOrMethodName, outcome); return outcome.isMatch(); } catch (NoClassDefFoundError ex) { throw new IllegalStateException( "Could not evaluate condition on " + classOrMethodName + " due to " + ex.getMessage() + " not " + "found. Make sure your own configuration does not rely on " + "that class. This can also happen if you are " + "@ComponentScanning a springframework package (e.g. if you " + "put a @ComponentScan in the default package by mistake)", ex); } catch (RuntimeException ex) { throw new IllegalStateException( "Error processing condition on " + getName(metadata), ex); } } private void recordEvaluation(ConditionContext context, String classOrMethodName, ConditionOutcome outcome) { if (context.getBeanFactory() != null) { ConditionEvaluationReport.get(context.getBeanFactory()) .recordConditionEvaluation(classOrMethodName, this, outcome); } }} |
上方的入口方法是 SpringBootCondition 類的 matches 方法， getMatchOutcome 這個方法則是子類 OnEndpointElementCondition 的，這個方法首先會去環境變量中查找是否存在 management.health.rabbit.enabled 屬性，如果沒有的話則去查找 management.health.defaults.enabled 屬性，如果這個屬性還沒有的話則設置默認值為true
當這里返回true時整個 RabbitHealthIndicatorAutoConfiguration 類的自動配置才能繼續下去
-
@AutoConfigureBefore既然這樣那就先看看類HealthIndicatorAutoConfiguration都是干了啥再回來吧
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
@Configuration@EnableConfigurationProperties({ HealthIndicatorProperties.class })public class HealthIndicatorAutoConfiguration { private final HealthIndicatorProperties properties; public HealthIndicatorAutoConfiguration(HealthIndicatorProperties properties) { this.properties = properties; } @Bean @ConditionalOnMissingBean({ HealthIndicator.class, ReactiveHealthIndicator.class }) public ApplicationHealthIndicator applicationHealthIndicator() { return new ApplicationHealthIndicator(); } @Bean @ConditionalOnMissingBean(HealthAggregator.class) public OrderedHealthAggregator healthAggregator() { OrderedHealthAggregator healthAggregator = new OrderedHealthAggregator(); if (this.properties.getOrder() != null) { healthAggregator.setStatusOrder(this.properties.getOrder()); } return healthAggregator; }} |
首先這個類引入了配置文件 HealthIndicatorProperties 這個配置類是系統狀態相關的配置
|
1
2
3
4
5
6
7
|
@ConfigurationProperties(prefix = "management.health.status")public class HealthIndicatorProperties { private List<String> order = null; private final Map<String, Integer> httpMapping = new HashMap<>();} |
接著就是注冊了2個bean ApplicationHealthIndicator 和 OrderedHealthAggregator 這兩個bean的作用稍后再說，現在回到 RabbitHealthIndicatorAutoConfiguration 類
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
@AutoConfigureAfterHealthIndicatorpublic abstract class CompositeHealthIndicatorConfiguration<H extends HealthIndicator, S> { @Autowired private HealthAggregator healthAggregator; protected HealthIndicator createHealthIndicator(Map<String, S> beans) { if (beans.size() == 1) { return createHealthIndicator(beans.values().iterator().next()); } CompositeHealthIndicator composite = new CompositeHealthIndicator( this.healthAggregator); for (Map.Entry<String, S> entry : beans.entrySet()) { composite.addHealthIndicator(entry.getKey(), createHealthIndicator(entry.getValue())); } return composite; } @SuppressWarnings("unchecked") protected H createHealthIndicator(S source) { Class<?>[] generics = ResolvableType .forClass(CompositeHealthIndicatorConfiguration.class, getClass()) .resolveGenerics(); Class<H> indicatorClass = (Class<H>) generics[0]; Class<S> sourceClass = (Class<S>) generics[1]; try { return indicatorClass.getConstructor(sourceClass).newInstance(source); } catch (Exception ex) { throw new IllegalStateException("Unable to create indicator " + indicatorClass + " for source " + sourceClass, ex); } }} |
-
首先這里注入了一個對象
HealthAggregator，這個對象就是剛才注冊的OrderedHealthAggregator -
第一個
createHealthIndicator方法執行邏輯為：如果傳入的beans的size 為1,則調用createHealthIndicator創建HealthIndicator否則創建CompositeHealthIndicator,遍歷傳入的beans,依次創建HealthIndicator,加入到CompositeHealthIndicator中 -
第二個
createHealthIndicator的執行邏輯為：獲得CompositeHealthIndicatorConfiguration中的泛型參數根據泛型參數H對應的class和S對應的class,在H對應的class中找到聲明了參數為S類型的構造器進行實例化 -
最后這里創建出來的bean為
RabbitHealthIndicator -
回憶起之前學習健康檢查的使用時，如果我們需要自定義健康檢查項時一般的操作都是實現
HealthIndicator接口，由此可以猜測RabbitHealthIndicator應該也是這樣做的。觀察這個類的繼承關系可以發現這個類繼承了一個實現實現此接口的類AbstractHealthIndicator，而RabbitMQ的監控檢查流程則如下代碼所示
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
//這個方法是AbstractHealthIndicator的public final Health health() { Health.Builder builder = new Health.Builder(); try { doHealthCheck(builder); } catch (Exception ex) { if (this.logger.isWarnEnabled()) { String message = this.healthCheckFailedMessage.apply(ex); this.logger.warn(StringUtils.hasText(message) ? message : DEFAULT_MESSAGE, ex); } builder.down(ex); } return builder.build(); }//下方兩個方法是由類RabbitHealthIndicator實現的protected void doHealthCheck(Health.Builder builder) throws Exception { builder.up().withDetail("version", getVersion()); } private String getVersion() { return this.rabbitTemplate.execute((channel) -> channel.getConnection() .getServerProperties().get("version").toString()); } |
健康檢查
上方一系列的操作之后，其實就是搞出了一個RabbitMQ的 HealthIndicator 實現類，而負責檢查RabbitMQ健康不健康也是這個類來負責的。由此我們可以想象到如果當前環境存在MySQL、Redis、ES等情況應該也是這么個操作
那么接下來無非就是當有調用方訪問如下地址時，分別調用整個系統的所有的 HealthIndicator 的實現類的 health 方法即可了
http://ip:port/actuator/health
HealthEndpointAutoConfiguration
上邊說的這個操作過程就在類 HealthEndpointAutoConfiguration 中，這個配置類同樣也是在 spring.factories 文件中引入的
|
1
2
3
4
5
6
7
8
|
@Configuration@EnableConfigurationProperties({HealthEndpointProperties.class, HealthIndicatorProperties.class})@AutoConfigureAfter({HealthIndicatorAutoConfiguration.class})@Import({HealthEndpointConfiguration.class, HealthEndpointWebExtensionConfiguration.class})public class HealthEndpointAutoConfiguration { public HealthEndpointAutoConfiguration() { }} |
這里重點的地方在于引入的 HealthEndpointConfiguration 這個類
|
1
2
3
4
5
6
7
8
9
10
11
|
@Configurationclass HealthEndpointConfiguration { @Bean @ConditionalOnMissingBean @ConditionalOnEnabledEndpoint public HealthEndpoint healthEndpoint(ApplicationContext applicationContext) { return new HealthEndpoint(HealthIndicatorBeansComposite.get(applicationContext)); }} |
這個類只是構建了一個類 HealthEndpoint ，這個類我們可以理解為一個SpringMVC的Controller，也就是處理如下請求的
|
1
|
http://ip:port/actuator/health |
那么首先看一下它的構造方法傳入的是個啥對象吧
|
1
2
3
4
5
6
7
8
9
10
11
|
public static HealthIndicator get(ApplicationContext applicationContext) { HealthAggregator healthAggregator = getHealthAggregator(applicationContext); Map<String, HealthIndicator> indicators = new LinkedHashMap<>(); indicators.putAll(applicationContext.getBeansOfType(HealthIndicator.class)); if (ClassUtils.isPresent("reactor.core.publisher.Flux", null)) { new ReactiveHealthIndicators().get(applicationContext) .forEach(indicators::putIfAbsent); } CompositeHealthIndicatorFactory factory = new CompositeHealthIndicatorFactory(); return factory.createHealthIndicator(healthAggregator, indicators); } |
跟我們想象中的一樣，就是通過Spring容器獲取所有的 HealthIndicator 接口的實現類，我這里只有幾個默認的和RabbitMQ
然后都放入了其中一個聚合的實現類 CompositeHealthIndicator 中
既然 HealthEndpoint構建好了，那么只剩下最后一步處理請求了
|
1
2
3
4
5
6
7
8
9
10
11
|
@Endpoint(id = "health")public class HealthEndpoint { private final HealthIndicator healthIndicator; @ReadOperation public Health health() { return this.healthIndicator.health(); }} |
剛剛我們知道，這個類是通過 CompositeHealthIndicator 構建的，所以 health 方法的實現就在這個類中
|
1
2
3
4
5
6
7
8
9
|
public Health health() { Map<String, Health> healths = new LinkedHashMap<>(); for (Map.Entry<String, HealthIndicator> entry : this.indicators.entrySet()) { //循環調用 healths.put(entry.getKey(), entry.getValue().health()); } //對結果集排序 return this.healthAggregator.aggregate(healths); } |
至此SpringBoot的健康檢查實現原理全部解析完成
以上就是詳解SpringBoot健康檢查的實現原理的詳細內容，更多關于SpringBoot健康檢查實現原理的資料請關注服務器之家其它相關文章！
原文鏈接：https://www.cicoding.cn/springboot/Implementation-principle-of-springboot-health-check/
