duanxz

Springboot Actuator之七：actuator 中原生endpoint源码解析1

看actuator项目的包结构，如下：

本文中的介绍Endpoints。

Endpoints（端点）介绍

Endpoints 是 Actuator 的核心部分，它用来监视应用程序及交互，spring-boot-actuator中已经内置了非常多的Endpoints（health、info、beans、httptrace、shutdown等等），同时也允许我们扩展自己的端点。

Endpoints 分成两类：原生端点和用户自定义端点：

原生端点是在应用程序里提供的众多 restful api 接口，通过它们可以监控应用程序运行时的内部状况。原生端点又可以分成三类：
- 应用配置类：可以查看应用在运行期间的静态信息：例如自动配置信息、加载的spring bean信息、yml文件配置信息、环境信息、请求映射信息；
- 度量指标类：主要是运行期间的动态信息，例如堆栈、请求连、一些健康指标、metrics信息等；
- 操作控制类：主要是指shutdown，用户可以发送一个请求将应用的监控功能关闭。
自定义端点主要是指扩展性，用户可以根据自己的实际应用，定义一些比较关心的指标，在运行期进行监控。

我们这里详细说明org.springframework.boot.actuate.endpoint中原生端点的实现.通过如下几个维度来进行分析:

xxxEndpoint的作用
xxxEndpoint的字段,构造器
xxxEndpoint核心方法invoke 实现分析
xxxEndpoint如何进行配置
xxxEndpoint如何自动化装配

在org.springframework.boot.actuate.endpoint 中还有2个子包-jmx(可通过jmx协议访问),mvc(通过spring mvc 暴露,可通过接口进行访问,在下篇文章进行分析).这里我们不关注这些,这看org.springframework.boot.actuate.endpoint 包下的类,类比较多,先看个类图吧,如下:

Endpoint接口：org.springframework.boot.actuate.endpoint.Endpoint.java

Endpoint接口：一个端点可以用于暴露（系统信息、操作入口等）信息。通常暴露方式是通过spring mvc的，如继承AbstractEndpoint的方式实现自己的endpoint。

public interface Endpoint {

    // 端点的逻辑标识(字母、数字和下划线('_') 组成)
    String getId();

    // 端点是否启用
    boolean isEnabled();

    // 端点是否输出敏感数据
    boolean isSensitive();

    // 调用端点，并返回调用结果
    T invoke();
}

其中泛型参数T为暴露的数据类型.方法的作用已经注释。

AbstractEndpoint抽象类

Endpoint的一个抽象子类：AbstractEndpoint(Endpoint接口实现的抽象基类),该类实现了EnvironmentAware,因此, AbstractEndpoint也就持有了Environment。

1、AbstractEndpoint 有如下属性:

// 匹配包括下划线的任何单词字符。类似但不等价于“[A-Za-z0-9_]”
private static final Pattern ID_PATTERN = Pattern.compile("\\w+");
// 通过EnvironmentAware接口注入
private Environment environment;
// 端点标识符
private String id;
// 是否默认敏感
private final boolean sensitiveDefault;
// 标识该端点是否暴露敏感信息
private Boolean sensitive;
// 是否端点可用
private Boolean enabled;

2、AbstractEndpoint方法

AbstractEndpoint方法实现了Endpoint接口中的getId, isEnabled, isSensitive,其中, getId只需返回AbstractEndpoint中的id属性即可,我们分别来看下其他方法的实现:

2.1、isEnabled,代码如下:

@Override
public boolean isEnabled() {
        return EndpointProperties.isEnabled(this.environment, this.enabled);
}
@ConfigurationProperties(prefix = "endpoints")
public class EndpointProperties {

    private static final String ENDPOINTS_ENABLED_PROPERTY = "endpoints.enabled";

    private static final String ENDPOINTS_SENSITIVE_PROPERTY = "endpoints.sensitive";

    public static boolean isEnabled(Environment environment, Boolean enabled) {
        //1、如果AbstractEndpoint#enabled属性有值,则使用AbstractEndpoint的配置
        if (enabled != null) {
            return enabled;
        }
        //如果Environment 不等于null 并且Environment 配置有endpoints.enabled的属性,则返回其配置的值
        if (environment != null
                && environment.containsProperty(ENDPOINTS_ENABLED_PROPERTY)) {
            return environment.getProperty(ENDPOINTS_ENABLED_PROPERTY, Boolean.class);
        }
        //3、如果1和2没有值，则返回默认值true
        return true;
    }

2.2、isSensitive和isEnabled实现差不多,如下:

    @Override
    public boolean isSensitive() {
        return EndpointProperties.isSensitive(this.environment, this.sensitive,
                this.sensitiveDefault);
    }
@ConfigurationProperties(prefix = "endpoints")
public class EndpointProperties {

    private static final String ENDPOINTS_ENABLED_PROPERTY = "endpoints.enabled";

    private static final String ENDPOINTS_SENSITIVE_PROPERTY = "endpoints.sensitive";

    public static boolean isSensitive(Environment environment, Boolean sensitive,
            boolean sensitiveDefault) {
        //1、如果abstractEndpoint的sensitive有值，则使用这个配置
        if (sensitive != null) {
            return sensitive;
        }
        //2、如果environment 不等于null 并且 environment中配置有endpoints.sensitive的属性,则返回其配置值
        if (environment != null
                && environment.containsProperty(ENDPOINTS_SENSITIVE_PROPERTY)) {
            return environment.getProperty(ENDPOINTS_SENSITIVE_PROPERTY, Boolean.class);
        }
        //3、返回指定的默认值(默认为false)
        return sensitiveDefault;
    }

EnvironmentEndpoint

AbstractEndpoint的实现类之EnvironmentEndpoint--敏感数据

1、构造函数

@ConfigurationProperties(prefix = "endpoints.env")
public class EnvironmentEndpoint extends AbstractEndpoint> {
    public EnvironmentEndpoint() {
        super("env");
    }
        //调用AbstractEndpoint的构造函数
    public AbstractEndpoint(String id) {
        this(id, true);
    }

最终,设置id为env,标识为敏感数据。

2、实现的invoke()，代码如下：

public Map invoke() {
    // 1. 先定义空的map返回值
    Map result = new LinkedHashMap();
    // 2. 将spring boot 中激活的profile 放入result中,key --> profile
    result.put("profiles", getEnvironment().getActiveProfiles());
    // 3. 获得PlaceholderSanitizingPropertyResolver --> 处理占位符,处理敏感数据
    PropertyResolver resolver = getResolver();
    // 4. 遍历environment 配置的PropertySource,依次处理之
    for (Entry> entry : getPropertySourcesAsMap()
            .entrySet()) {
        PropertySource source = entry.getValue();
        String sourceName = entry.getKey();
        if (source instanceof EnumerablePropertySource) {
            // 4.1 只针对EnumerablePropertySource 类型的PropertySource 进行处理--> 依次将属性添加到properties中,
            // 如果属性值为string,则在添加前进行占位符,数据脱敏的处理
            EnumerablePropertySource enumerable = (EnumerablePropertySource) source;
            Map properties = new LinkedHashMap();
            for (String name : enumerable.getPropertyNames()) {
                Object property = source.getProperty(name);
                Object resolved = property instanceof String
                        ? resolver.resolvePlaceholders((String) property) : property;
                //调用Sanitizer类进行脱敏
                properties.put(name, sanitize(name, resolved));
            }
            // 4.2 后置处理,该方法的实现是直接返回原始值,可以通过覆写的方式进行扩展
            properties = postProcessSourceProperties(sourceName, properties);
            if (properties != null) {
                // 4.3 如果不为空,则添加到result中
                result.put(sourceName, properties);
            }
        }
    }
    return result;
}

处理占位符,处理敏感数据：PlaceholderSanitizingPropertyResolver.java是EnvironmentEndpoint的内部类

public PropertyResolver getResolver() {
// 1. 实例化PlaceholderSanitizingPropertyResolver --> 处理占位符,处理敏感数据
PlaceholderSanitizingPropertyResolver resolver = new PlaceholderSanitizingPropertyResolver(
        getPropertySources(), this.sanitizer);
// 2. 设置ignoreUnresolvableNestedPlaceholders 为true
resolver.setIgnoreUnresolvableNestedPlaceholders(true);
return resolver;
}

PlaceholderSanitizingPropertyResolver继承了PropertySourcesPropertyResolver,这样就能对占位符进行处理了,又因为其内部持有Sanitizer(用于敏感数据脱敏),复写了getPropertyAsRawString,这样就能处理占位符,敏感数据了.代码如下:

        @Override
        protected String getPropertyAsRawString(String key) {
            String value = super.getPropertyAsRawString(key);
            return (String) this.sanitizer.sanitize(key, value);
        }

3、EnvironmentEndpoint的属性配置,由于EnvironmentEndpoint被@ConfigurationProperties(prefix = “endpoints.env”)注解,因此可通过如下配置进行个性化配置:

endpoints.env.id=env  
endpoints.env.sensitive=true  
endpoints.env.enabled=true

同时,又因为其声明了如下方法:

public void setKeysToSanitize(String... keysToSanitize) {
    this.sanitizer.setKeysToSanitize(keysToSanitize);
}

因此可以通过endpoints.env.keys-to-sanitize=xx,xx 来配置对指定的数据进行脱敏。脱敏配置

4、EnvironmentEndpoint的自动化装配

EnvironmentEndpoint的自动化装配是在EndpointAutoConfiguration中,代码如下:

@Configuration
@AutoConfigureAfter({ FlywayAutoConfiguration.class, LiquibaseAutoConfiguration.class })
@EnableConfigurationProperties(EndpointProperties.class)
public class EndpointAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public EnvironmentEndpoint environmentEndpoint() {
        return new EnvironmentEndpoint();
    }

@Bean注解：注册1个id为environmentEndpoint,类型为EnvironmentEndpoint的bean
@ConditionalOnMissingBean注解：当beanFactory中不存在EnvironmentEndpoint类型的bean时注册

InfoEndpoint

AbstractEndpoint的实现类之InfoEndpoint，用于暴露应用信息。

其字段和构造器如下:

private final List infoContributors;
public InfoEndpoint(List infoContributors) {
    super("info", false);
    Assert.notNull(infoContributors, "Info contributors must not be null");
    this.infoContributors = infoContributors;
}

其内部持有了BeanFactory中所有InfoContributor类型的bean,其通过构造器注入。

2、invoke 实现如下:

public Map invoke() {
        Info.Builder builder = new Info.Builder();
        for (InfoContributor contributor : this.infoContributors) {
            contributor.contribute(builder);
        }
        Info build = builder.build();
        return build.getDetails();
}

通过遍历其内部的持有infoContributors,因此调用其contribute将info的数据添加到Info.Builder中,最后通过Info.Builder构建出Info,返回Info持有的details(建造者模式). Info中的details为Map.

InfoContributor接口用于向Info$Builder添加信息,关于这部分的内容,我们后续文章有分析.这里就不在赘述了.

3、InfoEndpoint的属性配置

@ConfigurationProperties(prefix = "endpoints.info")
public class InfoEndpoint extends AbstractEndpoint> {

因此可通过如下进行配置:

endpoints.info.id=info  
endpoints.info.sensitive=true  
endpoints.info.enabled=true

4、InfoEndpoint的自动化装配–>在EndpointAutoConfiguration中,代码如下:

    @Bean
    @ConditionalOnMissingBean
    public InfoEndpoint infoEndpoint() throws Exception {
        return new InfoEndpoint(this.infoContributors == null
                ? Collections.emptyList() : this.infoContributors);
    }

和EnvironmentEndpoint一样。

RequestMappingEndpoint：

AbstractEndpoint的实现类之RequestMappingEndpoint，由于RequestMappingEndpoint同时也实现了ApplicationContextAware接口，因此,在初始化该类时会注入applicationContext。这个类的作用是打印Spring MVC 映射信息。

1、构造函数

    public RequestMappingEndpoint() {
        super("mappings");
    }

因此, RequestMappingEndpoint的id为 mappings,默认为敏感。

2、invoke 实现如下:

public Map invoke() {
    Map result = new LinkedHashMap();
    // 1. 从handlerMappings中获取HandlerMapping,默认情况下handlerMappings是不存在数据的
    extractHandlerMappings(this.handlerMappings, result);
    // 2. 从applicationContext中获取AbstractUrlHandlerMapping类型的bean,依次将其注册的handler 添加进去.
    extractHandlerMappings(this.applicationContext, result);
    // 3. 从methodMappings中获取HandlerMapping,默认情况下methodMappings是不存在数据的
    extractMethodMappings(this.methodMappings, result);
    // 3. 从applicationContext中获取AbstractUrlHandlerMapping类型的bean,依次获得其持有的HandlerMethods,进行处理.
    extractMethodMappings(this.applicationContext, result);
    return result;
}

从applicationContext中获取

    protected void extractHandlerMappings(ApplicationContext applicationContext,
            Map result) {
        if (applicationContext != null) {
            Map mappings = applicationContext
                    .getBeansOfType(AbstractUrlHandlerMapping.class);
            for (Entry mapping : mappings.entrySet()) {
                Map handlers = getHandlerMap(mapping.getValue());
                for (Entry handler : handlers.entrySet()) {
                    result.put(handler.getKey(),
                            Collections.singletonMap("bean", mapping.getKey()));
                }
            }
        }
    }

获得AbstractUrlHandlerMapping类型的bean,此时有4个:
beanNameHandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping
resourceHandlerMapping=org.springframework.web.servlet.handler.SimpleUrlHandlerMapping
faviconHandlerMapping=org.springframework.web.servlet.handler.SimpleUrlHandlerMapping
welcomePageHandlerMapping=org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration$WelcomePageHandlerMapping

依次遍历mappings:
获得AbstractUrlHandlerMapping中注册的handler,key–> path,value–>handler
依次遍历handlerss,存入结果集中,存入的key–>AbstractUrlHandlerMapping的id,value={bean=AbstractUrlHandlerMapping中注册的handler的路径}

从methodMappings中获取HandlerMapping,默认情况下methodMappings是不存在数据的

从applicationContext中获取AbstractUrlHandlerMapping类型的bean,依次获得其持有的HandlerMethods,进行处理.代码如下:

    protected void extractMethodMappings(
            Collection> methodMappings,
            Map result) {
        for (AbstractHandlerMethodMapping mapping : methodMappings) {
            Map methods = mapping.getHandlerMethods();
            for (Map.Entry entry : methods.entrySet()) {
                result.put(String.valueOf(entry.getKey()), Collections
                        .singletonMap("method", String.valueOf(entry.getValue())));
            }
        }
    }

获得AbstractUrlHandlerMapping类型的bean
依次遍历AbstractUrlHandlerMapping中注册的handler,添加至结果集中,key–> Handler 映射路径 ,value = {bean = AbstractHandlerMethodMapping的id,method=HandlerMethod}

3、RequestMappingEndpoint的配置

@ConfigurationProperties(prefix = "endpoints.mappings")
public class RequestMappingEndpoint extends AbstractEndpoint>
        implements ApplicationContextAware {

从类上的配置注解，可知：

endpoints.mappings.enabled= # Enable the endpoint.
endpoints.mappings.id= # Endpoint identifier.
endpoints.mappings.sensitive= # Mark if the endpoint exposes sensitive information.

4、RequestMappingEndpoint的自动装配

    @Configuration
    @ConditionalOnClass(AbstractHandlerMethodMapping.class)
    protected static class RequestMappingEndpointConfiguration {

        @Bean
        @ConditionalOnMissingBean
        public RequestMappingEndpoint requestMappingEndpoint() {
            RequestMappingEndpoint endpoint = new RequestMappingEndpoint();
            return endpoint;
        }

    }

当满足如下两个条件时创建requestMappingEndpoint,即注册1个id为requestMappingEndpoint,类型为RequestMappingEndpoint的bean:

@ConditionalOnClass(AbstractHandlerMethodMapping.class) –> 在beanFactory中存在AbstractHandlerMethodMapping类型的bean时生效
@ConditionalOnMissingBean–>在beanFactory中不存在RequestMappingEndpoint类型的bean时生效

DumpEndpoint

AbstractEndpoint的实现类之DumpEndpoint，这个类的作用是打印线程信息，为敏感。

1、构造函数

    public DumpEndpoint() {
        super("dump");
    }

2、invoke()方法实现

    @Override
    public List invoke() {
        return Arrays
                .asList(ManagementFactory.getThreadMXBean().dumpAllThreads(true, true));
    }

调用了ThreadMXBean的dumpAllThreads来返回所有活动线程的线程信息，并带有堆栈跟踪和同步信息。当此方法返回时，返回数组中包含的一些线程可能已经终止。其中两个参数指的意义如下:

第1个–>如果为 true，则转储所有锁定的监视器。
第2个–>如果为 true，则转储所有锁定的可拥有同步器。

ThreadMXBean怎么读取Thread信息见《JMX学习一》

3、DumpEndpoint的配置

@ConfigurationProperties(prefix = "endpoints.dump")
public class DumpEndpoint extends AbstractEndpoint> {

可知：

endpoints.dump.enabled= # Enable the endpoint.
endpoints.dump.id= # Endpoint identifier.
endpoints.dump.sensitive= # Mark if the endpoint exposes sensitive information.

4、DumpEndpoint自动化装配:

@Bean
@ConditionalOnMissingBean
public DumpEndpoint dumpEndpoint() {
    return new DumpEndpoint();
}

FlywayEndpoint

AbstractEndpoint的实现类之FlywayEndpoint，Flyway是一款开源的数据库版本管理工具。

ShutdownEndpoint

AbstractEndpoint的实现类之ShutdownEndpoint，作用是关闭应用。这个类继承了ApplicationAware,得到applicationContext，关闭spring容器调用applicationContext.close()方法。

1、构造函数

    public ShutdownEndpoint() {
        super("shutdown", true, false);
    }

id为shutdown，为敏感，关闭应用的endpoin默认是关闭的，不启用的。

2、invoke()方法实现

    @Override
    public Map invoke() {
                //如果context为null，直接返回
        if (this.context == null) {
            return NO_CONTEXT_MESSAGE;
        }
                //context不为null,先返回，再启动一个线程，在该线程中,先sleep 5秒后,然后调用了ShutdownEndpoint中持有的context的close方法进行关闭.
        try {
            return SHUTDOWN_MESSAGE;
        }
        finally {
            Thread thread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(500L);
                    }
                    catch (InterruptedException ex) {
                        Thread.currentThread().interrupt();
                    }
                    ShutdownEndpoint.this.context.close();
                }
            });
            thread.setContextClassLoader(getClass().getClassLoader());
            thread.start();
        }
    }

在返回后，还希望做点啥，用try--finally。

3、ShutdownEndpoint的配置

@ConfigurationProperties(prefix = "endpoints.shutdown")
public class ShutdownEndpoint extends AbstractEndpoint>
        implements ApplicationContextAware {

可知配置有：

endpoints.shutdown.enabled= # Enable the endpoint.
endpoints.shutdown.id= # Endpoint identifier.
endpoints.shutdown.sensitive= # Mark if the endpoint exposes sensitive information.

4、ShutdownEndpoint自动化装配:

@Bean
@ConditionalOnMissingBean
public ShutdownEndpoint shutdownEndpoint() {
    return new ShutdownEndpoint();
}

AutoConfigurationReportEndpoint

AbstractEndpoint的实现类之AutoConfigurationReportEndpoint，作用是暴露ConditionEvaluationReport.。

1、构造函数

    public AutoConfigurationReportEndpoint() {
        super("autoconfig");
    }

id为autoconfig，为敏感。

2、invoke()方法实现

    @Override
    public Report invoke() {
        return new Report(this.autoConfigurationReport);
    }

Report为其内部类

    @JsonPropertyOrder({ "positiveMatches", "negativeMatches", "exclusions" })
    @JsonInclude(Include.NON_EMPTY)
    public static class Report {

@JsonPropertyOrder–>作用在类上，被用来指明当序列化时需要对属性做排序，它有2个属性:一个是alphabetic：布尔类型，表示是否采用字母拼音顺序排序，默认是为false，即不排序
@JsonInclude–> Report中的属性值为空集合则不进行展示

Report 有如下字段:

// 匹配的
private final MultiValueMap positiveMatches;

// 不匹配的
private final Map negativeMatches;

// 去除的
private final List exclusions;

// 一般为null
private final Report parent;

其中MessageAndCondition封装了ConditionAndOutcome中的condition,message以进行更好的展示(json友好).其类上声明了如下注解:

@JsonPropertyOrder({ "condition", "message" })

因此在进行输出的时候,先输出condition,再输出message.

构造器如下:

        public MessageAndCondition(ConditionAndOutcome conditionAndOutcome) {
            Condition condition = conditionAndOutcome.getCondition();
            ConditionOutcome outcome = conditionAndOutcome.getOutcome();
            this.condition = ClassUtils.getShortName(condition.getClass());
            if (StringUtils.hasLength(outcome.getMessage())) {
                this.message = outcome.getMessage();
            }
            else {
                this.message = (outcome.isMatch() ? "matched" : "did not match");
            }
        }

赋值condition为ConditionAndOutcome中的Condition的短类名.
赋值message:如果ConditionAndOutcome中的Message有值则直接赋值,否则,如果对应的Condition匹配,则赋值为matched,否则赋值为did not match。

回到report，构造器如下:

public Report(ConditionEvaluationReport report) {
this.positiveMatches = new LinkedMultiValueMap();
this.negativeMatches = new LinkedHashMap();
// 1. 通过report#getExclusions 获得不进行加载的bean
this.exclusions = report.getExclusions();
// 2. 
for (Map.Entry entry : report
.getConditionAndOutcomesBySource().entrySet()) {
// 2.1 如果该配置生效条件都匹配,则加入到positiveMatches,否则,加入到negativeMatches
if (entry.getValue().isFullMatch()) {
    add(this.positiveMatches, entry.getKey(), entry.getValue());
}
else {
    add(this.negativeMatches, entry.getKey(), entry.getValue());
}
}
// 3. 如果report存在父report,则进行初始化Report 赋值为当前类的parent 属性
boolean hasParent = report.getParent() != null;
this.parent = (hasParent ? new Report(report.getParent()) : null);
}

通过ConditionEvaluationReport#getExclusions 获得不进行加载的bean,赋值为exclusions
调用ConditionEvaluationReport#getConditionAndOutcomesBySource 获得ConditionEvaluationReport中持有匹配信息,返回的map中,key–> 匹配类名,ConditionAndOutcomes–> 匹配结果.

依次遍历第2步的返回值–>如果该配置生效条件都匹配,则加入到positiveMatches,否则,加入到negativeMatches.其中add 代码如下:

        private void add(MultiValueMap map, String source,
                ConditionAndOutcomes conditionAndOutcomes) {
            String name = ClassUtils.getShortName(source);
            for (ConditionAndOutcome conditionAndOutcome : conditionAndOutcomes) {
                map.add(name, new MessageAndCondition(conditionAndOutcome));
            }
        }

因此positiveMatches,negativeMatches 中的key为配置类的简单类名.
如果report存在父report,则进行初始化Report 赋值为当前类的parent 属性.一般来说，是不存在父report的

属性配置(因为有@ConfigurationProperties(prefix = “endpoints.autoconfig”) 注解):

endpoints.autoconfig.enabled= # Enable the endpoint.
endpoints.autoconfig.id= # Endpoint identifier.
endpoints.autoconfig.sensitive= # Mark if the endpoint exposes sensitive information.

自动装配:

同样还是在EndpointAutoConfiguration中,代码如下:

@Bean
@ConditionalOnBean(ConditionEvaluationReport.class)
@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
public AutoConfigurationReportEndpoint autoConfigurationReportEndpoint() {
    return new AutoConfigurationReportEndpoint();
}

@Bean –> 注册1个id为autoConfigurationReportEndpoint,类型为AutoConfigurationReportEndpoint的bean
@ConditionalOnBean(ConditionEvaluationReport.class)–>beanFactory中存在ConditionEvaluationReport类型的bean时生效
@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)–> 在当前上下文中不存在AutoConfigurationReportEndpoint类型的bean时生效

ConditionEvaluationReport

AutoConfigurationReportEndpoint 是通过ConditionEvaluationReport 来进行暴露信息.

ConditionEvaluationReport 字段如下:

private static final String BEAN_NAME = "autoConfigurationReport";

// 如果一个配置类中内部配置类不匹配,则在其外部类的所对应的ConditionAndOutcomes中添加1个AncestorsMatchedCondition
private static final AncestorsMatchedCondition ANCESTOR_CONDITION = new AncestorsMatchedCondition();

// key-->配置类类名,ConditionAndOutcomes-->匹配条件结果的封装
private final SortedMap outcomes = new TreeMap();

// 是否添加AncestorsMatchedCondition,默认为false
private boolean addedAncestorOutcomes;

// 父ConditionEvaluationReport,一般为null
private ConditionEvaluationReport parent;

// 去除加载的配置
private List exclusions = Collections.emptyList();

// 在ConditionEvaluationReportAutoConfigurationImportListener#onAutoConfigurationImportEvent 添加,用于保存还没有
// 执行判断的class
private Set unconditionalClasses = new HashSet();

ConditionEvaluationReport 实例化过程如下:

在SpringApplication#run中会调用AbstractApplicationContext#refresh,在refresh会调用PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors,在该方法中最终会调用到AutoConfigurationImportSelector#selectImports方法.在该方法中会调用fireAutoConfigurationImportEvents,代码如下:AutoConfigurationImportSelector.fireAutoConfigurationImportEvents()

    private void fireAutoConfigurationImportEvents(List configurations,
            Set exclusions) {
        List listeners = getAutoConfigurationImportListeners();
        if (!listeners.isEmpty()) {
            AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this,
                    configurations, exclusions);
            for (AutoConfigurationImportListener listener : listeners) {
                invokeAwareMethods(listener);
                listener.onAutoConfigurationImportEvent(event);
            }
        }
    }

会加载/META-INF/spring.factories 中配置的org.springframework.boot.autoconfigure.AutoConfigurationImportListener,实例化后,依次调用其onAutoConfigurationImportEvent 方法. spring.factories 配置如下:

org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

因此此处会调用ConditionEvaluationReportAutoConfigurationImportListener#onAutoConfigurationImportEvent.代码如下:

    @Override
    public void onAutoConfigurationImportEvent(AutoConfigurationImportEvent event) {
        if (this.beanFactory != null) {
            ConditionEvaluationReport report = ConditionEvaluationReport
                    .get(this.beanFactory);
            report.recordEvaluationCandidates(event.getCandidateConfigurations());
            report.recordExclusions(event.getExclusions());
        }
    }

A、实例化ConditionEvaluationReport,代码如下:

public static ConditionEvaluationReport get(
ConfigurableListableBeanFactory beanFactory) {
    synchronized (beanFactory) {
        ConditionEvaluationReport report;
        // 1. 如果当前beanFactory包含autoConfigurationReport定义的话,就从beanFactory中获取,
        if (beanFactory.containsSingleton(BEAN_NAME)) {
            report = beanFactory.getBean(BEAN_NAME,         ConditionEvaluationReport.class);
        }
        else {
            // 否则就实例化一个,然后进行注册
            report = new ConditionEvaluationReport();
            beanFactory.registerSingleton(BEAN_NAME, report);
        }
        // 2. 如果存在父容器的话,就从父容器中获取。
        locateParent(beanFactory.getParentBeanFactory(), report);
        return report;
    }
}

如果当前beanFactory包含autoConfigurationReport定义的话,就从beanFactory中获取,否则就实例化一个,然后进行注册

如果存在父容器的话,就从父容器中获取,并将其赋值为当前context中获得的ConditionEvaluationReport的父ConditionEvaluationReport.代码如下:

    private static void locateParent(BeanFactory beanFactory,
            ConditionEvaluationReport report) {
        if (beanFactory != null && report.parent == null
                && beanFactory.containsBean(BEAN_NAME)) {
            report.parent = beanFactory.getBean(BEAN_NAME,
                    ConditionEvaluationReport.class);
        }
    }

一般都是null,不会执行的。

B、设置unconditionalClasses为event#getCandidateConfigurations的返回值。
C、设置exclusions为event#getExclusions的返回值。

在AutoConfigurationReportEndpoint中是通过Report来进行暴露信息的,而在其构造器中,调用了ConditionEvaluationReport#getConditionAndOutcomesBySource方法,代码如下:

public Map getConditionAndOutcomesBySource() {
    if (!this.addedAncestorOutcomes) {
        // 1. 如果addedAncestorOutcomes 设为false,则依次遍历outcomes,如果一个配置类中内部配置类不匹配,则在其外部类的所对应的ConditionAndOutcomes中添加1个AncestorsMatchedCondition
        for (Map.Entry entry : this.outcomes.entrySet()) {
            if (!entry.getValue().isFullMatch()) {
                addNoMatchOutcomeToAncestors(entry.getKey());
            }
        }
        this.addedAncestorOutcomes = true;
    }
    return Collections.unmodifiableMap(this.outcomes);
}

如果addedAncestorOutcomes 设为false,则依次遍历outcomes,如果一个配置类中内部配置类不匹配,则在其外部类的所对应的ConditionAndOutcomes中添加1个AncestorsMatchedCondition

返回outcomes.

问题来了, outcomes 中的数据是如何添加的?

答案: 有2处.

还是在AutoConfigurationImportSelector#selectImports中,会调用其filter方法.代码如下

private List filter(List configurations,
AutoConfigurationMetadata autoConfigurationMetadata) {
    long startTime = System.nanoTime();
    String[] candidates = configurations.toArray(new     String[configurations.size()]);
    boolean[] skip = new boolean[candidates.length];
    boolean skipped = false;
    // 1. 获取META-INFspring.factories/中配置的org.springframework.boot.autoconfigure.AutoConfigurationImportFilter,.OnClassCondition.依次进行遍历之
    // 此时获得的是org.springframework.boot.autoconfigure.condition
    for (AutoConfigurationImportFilter filter : getAutoConfigurationImportFilters()) {
        // 1.1 进行属性注入
        invokeAwareMethods(filter);
        // 1.2 调用AutoConfigurationImportFilter#match 进行判断,依次遍历其返回值,如果返回的是false,则说明该配置为跳过,并将skipped设置为true
        // 获得AutoConfigurationMetadata中配置的            ConditionalOnClass,如果不会空,则依次遍历之,看是否在当前类路径下存在
        // 如果不匹配的话,则调用            ConditionEvaluationReport.#ecordConditionEvaluation 进行记录
        // 由于此时AutoConfigurationMetadata 什么都没有配置,因此此步骤相当于空操作,最终会在第2步返回
        boolean[] match = filter.match(candidates, autoConfigurationMetadata);
        for (int i = 0; i < match.length; i++) {
            if (!match[i]) {
                skip[i] = true;
                skipped = true;
            }
        }
    }
    // 2. 如果skipped 等于false,则直接返回configurations,说明没有配置是需要跳过的
    if (!skipped) {
        return configurations;
    }
    // 3. 依次遍历candidates,如果该配置是不进行跳过的,则添加至result中进行返回
    List result = new ArrayList(candidates.length);
    for (int i = 0; i < candidates.length; i++) {
        if (!skip[i]) {
            result.add(candidates[i]);
        }
    }
    return new ArrayList(result);
}

获取META-INFspring.factories/中配置的org.springframework.boot.autoconfigure.AutoConfigurationImportFilter,.OnClassCondition.依次进行遍历之.此时获得的是org.springframework.boot.autoconfigure.condition
进行属性注入
调用AutoConfigurationImportFilter#match 进行判断,依次遍历其返回值,如果返回的是false,则说明该配置为跳过,并将skipped设置为true.由于此时调用的是OnClassCondition,其判断逻辑为获得AutoConfigurationMetadata中配置的ConditionalOnClass,如果不会空,则依次遍历之,看是否在当前类路径下存在.如果不匹配的话,则调用ConditionEvaluationReport#ecordConditionEvaluation 进行记录.由于此时AutoConfigurationMetadata 什么都没有配置,因此此步骤相当于空操作,最终会在第2步返回

如果skipped 等于false,则直接返回configurations,说明没有配置是需要跳过的
依次遍历candidates,如果该配置是不进行跳过的,则添加至result中进行返回

在ConfigurationClassParser#processConfigurationClass进行解析加载配置类时,会调用ConditionEvaluator#shouldSkip,在该方法中,会因此遍历配置类配置的@Conditional所对应的处理类.此时,如果处理类是SpringBootCondition的子类的话,就会调用ConditionEvaluationReport进行记录匹配结果. 代码如下:

private void recordEvaluation(ConditionContext context, String classOrMethodName,
ConditionOutcome outcome) {
    if (context.getBeanFactory() != null) {
        ConditionEvaluationReport.get(context.getBeanFactory())
.recordConditionEvaluation(classOrMethodName, this, outcome);
    }
}

LiquibaseEndpoint

默认不生效,这里就不进行分析了
BeansEndpoint

BeansEndpoint的作用 –> 暴露关于beans的json视图.如果Environment 中设置了spring.liveBeansView.mbeanDomain,则所有spring 上下文的bean都会展示.否则只会展示当前的上下文中的bean.默认是没有配置的

BeansEndpoint,构造器如下：

    public BeansEndpoint() {
        super("beans");
    }

id为beans,默认为敏感

BeansEndpoint的字段如下:

// 继承自LiveBeansView,用于生成json格式的数据
private final HierarchyAwareLiveBeansView liveBeansView = new HierarchyAwareLiveBeansView();

// json 解析器对象
private final JsonParser parser = JsonParserFactory.getJsonParser();

由于BeansEndpoint实现了ApplicationContextAware接口,因此当前初始化时,会调用其setApplicationContext方法,代码如下:

    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        if (context.getEnvironment()
                .getProperty(LiveBeansView.MBEAN_DOMAIN_PROPERTY_NAME) == null) {
            this.liveBeansView.setLeafContext(context);
        }
    }

如果没有设置spring.liveBeansView.mbeanDomain的属性,则将HierarchyAwareLiveBeansView中的leafContext设置为传入的ApplicationContext(通常是当前应用所对应的上下文)

invoke实现如下:

    @Override
    public List

Springboot Actuator之七：actuator 中原生endpoint源码解析1

Endpoints（端点）介绍

Endpoint接口：org.springframework.boot.actuate.endpoint.Endpoint.java

AbstractEndpoint抽象类

1、AbstractEndpoint 有如下属性:

2、AbstractEndpoint方法

InfoEndpoint

DumpEndpoint

你可能感兴趣的:(Springboot Actuator之七：actuator 中原生endpoint源码解析1)