Spring Boot Actuator-WEB Endpoints

男娘i 2022-12-28 08:12 250阅读 0赞

建议先预习Spring Boot Actuator，请戳《[初识篇][Link 1]》

--------------------

WEB Endpoints，以HTTP协议对外暴露提供访问接口。

--------------------

# **█ 自动配置** #

META-INF/spring.factories：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.actuate.autoconfigure.endpoint.EndpointAutoConfiguration,\
    org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointAutoConfiguration

*  ** EndpointAutoConfiguration**

公共配置，对于Web EndPoints与JMX EndPoints共用的配置。

@Configuration(proxyBeanMethods = false)
    public class EndpointAutoConfiguration {
    
       // 负责方法参数的转换的参数值映射器
       @Bean
       @ConditionalOnMissingBean
       public ParameterValueMapper endpointOperationParameterMapper(
           // 自动注入被@EndpointConverter标注的Converter与GenericConverter类型的bean
           // Spring Boot Actuator默认没有提供，可自定义添加
             @EndpointConverter ObjectProvider<Converter<?, ?>> converters,
             @EndpointConverter ObjectProvider<GenericConverter> genericConverters) {
          ConversionService conversionService = createConversionService(
                converters.orderedStream().collect(Collectors.toList()),
                genericConverters.orderedStream().collect(Collectors.toList()));
          return new ConversionServiceParameterValueMapper(conversionService);
       }
       // 参数转换器 
       private ConversionService createConversionService(List<Converter<?, ?>> converters,
             List<GenericConverter> genericConverters) {
          // 默认为空，满足if条件       
          if (genericConverters.isEmpty() && converters.isEmpty()) {
             // 添加Spring Boot默认提供的转换器 
             // ApplicationConversionService.getSharedInstance()也会调用new ApplicationConversionService();来添加默认提供的转换器
             return ApplicationConversionService.getSharedInstance();
          }
          // 如果有自定义的转换器，在自定义的基础上，加上Spring Boot默认提供的转化器
          ApplicationConversionService conversionService = new ApplicationConversionService();
          converters.forEach(conversionService::addConverter);
          genericConverters.forEach(conversionService::addConverter);
          return conversionService;
       }
    
       // 缓存切面，第一次访问后，会将结果缓存起来。下一次再获取直接从缓存中取
       // 可以设置缓存失效时间
       @Bean
       @ConditionalOnMissingBean
       public CachingOperationInvokerAdvisor endpointCachingOperationInvokerAdvisor(Environment environment) {
          return new CachingOperationInvokerAdvisor(new EndpointIdTimeToLivePropertyFunction(environment));
       }
    
    }

举例：自定义转换器

@Configuration
    public class CustomConversionConfiguration{
    
        /**
         * 自定义Converter
         * Converter接口是org.springframework.core.convert.converter.Converter
         *
         * 将Integer类型的值转换成String类型
         *
         */
        @Bean
        // 加上注解标注给EndPoint提供服务
        @EndpointConverter
        public Converter<Integer, String> customConverter() {
            return new CustomConverter();
        }
    
        static class CustomConverter implements Converter<Integer, String>{
            @Override
            public String convert(Integer source) {
                if (source == null) {
                    return null;
                }
                return source.toString();
            }
        }
    
        /**
         *
         * 自定义GenericConverter
         * GenericConverter接口是：org.springframework.core.convert.converter.GenericConverter
         *
         * @return
         */
        @Bean
        // 加上注解标注给EndPoint提供服务
        @EndpointConverter
        public GenericConverter customGenericConverter() {
            return new GenericConverter() {
                @Override
                public Set<ConvertiblePair> getConvertibleTypes() {
                    Set<ConvertiblePair> convertiblePairSet = new HashSet<>(2);
                    // 将Integer类型的值转换成String类型的值
                    convertiblePairSet.add(new ConvertiblePair(Integer.class, String.class));
                    return convertiblePairSet;
                }
    
                @Override
                public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
                    // 实现自定义逻辑
    
                    return null;
                }
            };
        }
    
    }

*  **WebEndpointAutoConfiguration**

用于Web EndPoints构建的相关配置。

@Configuration(proxyBeanMethods = false)
    @ConditionalOnWebApplication
    @AutoConfigureAfter(EndpointAutoConfiguration.class)
    // WebEndpointProperties：management.endpoints.web前缀的配置
    @EnableConfigurationProperties(WebEndpointProperties.class)
    public class WebEndpointAutoConfiguration {
        
        private final ApplicationContext applicationContext;
    
       private final WebEndpointProperties properties;
       
       // 通过构造器注入ApplicationContext与WebEndpointProperties
       public WebEndpointAutoConfiguration(ApplicationContext applicationContext, WebEndpointProperties properties) {
           this.applicationContext = applicationContext;
           this.properties = properties;
       }
        // 访问路径映射
        // 默认EndPoint的id就是访问路径，可通过配置management.endpoints.web.pathMapping更改访问路径。
        @Bean
        public PathMapper webEndpointPathMapper() {
            // 默认this.properties.getPathMapping()是空集合
            return new MappingWebEndpointPathMapper(this.properties.getPathMapping());
        }
        
        // 默认的接口响应Media类型
        @Bean
        @ConditionalOnMissingBean
        public EndpointMediaTypes endpointMediaTypes() {
            // application/vnd.spring-boot.actuator.v3+json
            // application/vnd.spring-boot.actuator.v2+json
            // application/json
            return EndpointMediaTypes.DEFAULT;
        }
        
        // EndPoint http服务暴露过滤器
        // 根据配置：management.endpoints.web.exposure.include 设置暴露服务
        // 根据配置：management.endpoints.web.exposure.exclude 设置不暴露服务
        @Bean
        public ExposeExcludePropertyEndpointFilter<ExposableWebEndpoint> webExposeExcludePropertyEndpointFilter() {
            WebEndpointProperties.Exposure exposure = this.properties.getExposure();
           // 默认暴露 info、health 
           return new ExposeExcludePropertyEndpointFilter<>(ExposableWebEndpoint.class, exposure.getInclude(),
               exposure.getExclude(), "info", "health");
        }
        
        // Controller EndPoint服务暴露过滤
        @Bean
        public ExposeExcludePropertyEndpointFilter<ExposableControllerEndpoint> controllerExposeExcludePropertyEndpointFilter() {
            WebEndpointProperties.Exposure exposure = this.properties.getExposure();
            return new ExposeExcludePropertyEndpointFilter<>(ExposableControllerEndpoint.class, exposure.getInclude(),
            exposure.getExclude());
        }
        
        // 创建 Web EndPoints
        // 根据@EndPoint、@WebEndPoint注解标注的类
        @Bean
        @ConditionalOnMissingBean(WebEndpointsSupplier.class)
        public WebEndpointDiscoverer webEndpointDiscoverer(ParameterValueMapper parameterValueMapper,
            EndpointMediaTypes endpointMediaTypes, ObjectProvider<PathMapper> endpointPathMappers,
            ObjectProvider<OperationInvokerAdvisor> invokerAdvisors,
            ObjectProvider<EndpointFilter<ExposableWebEndpoint>> filters) {
           return new WebEndpointDiscoverer(this.applicationContext, parameterValueMapper, endpointMediaTypes,
             endpointPathMappers.orderedStream().collect(Collectors.toList()),
             invokerAdvisors.orderedStream().collect(Collectors.toList()),
             filters.orderedStream().collect(Collectors.toList()));
        }
        
        // 创建 Controller EndPoint
        // 根据@ControllerEndPoint标注的类
        @Bean
        @ConditionalOnMissingBean(ControllerEndpointsSupplier.class)
        public ControllerEndpointDiscoverer controllerEndpointDiscoverer(ObjectProvider<PathMapper> endpointPathMappers,
            ObjectProvider<Collection<EndpointFilter<ExposableControllerEndpoint>>> filters) {
           return new ControllerEndpointDiscoverer(this.applicationContext,
             endpointPathMappers.orderedStream().collect(Collectors.toList()),
             filters.getIfAvailable(Collections::emptyList));
        }
        
        // web应用类型为servlet，创建Servlet EndPoint
        // 根据ServletEndPoint标注的类
        @Configuration(proxyBeanMethods = false)
        @ConditionalOnWebApplication(type = Type.SERVLET)
        static class WebEndpointServletConfiguration {
    
           @Bean
           @ConditionalOnMissingBean(ServletEndpointsSupplier.class)
           ServletEndpointDiscoverer servletEndpointDiscoverer(ApplicationContext applicationContext,
                ObjectProvider<PathMapper> endpointPathMappers,
                ObjectProvider<EndpointFilter<ExposableServletEndpoint>> filters) {
              return new ServletEndpointDiscoverer(applicationContext,
                endpointPathMappers.orderedStream().collect(Collectors.toList()),
                filters.orderedStream().collect(Collectors.toList()));
           }
    
        }
        
        // 根据WebEndpointDiscoverer、ControllerEndpointDiscoverer、ServletEndpointDiscoverer 记录各个EndPoint的id与访问路径关系
        @Bean
        @ConditionalOnMissingBean
        public PathMappedEndpoints pathMappedEndpoints(Collection<EndpointsSupplier<?>> endpointSuppliers) {
            return new PathMappedEndpoints(this.properties.getBasePath(), endpointSuppliers);
            }
        
    }

--------------------

# **█** ManagementContextConfiguration #

四种ManagementContextConfiguration分别对应四种类型的WEB应用：Servlet、Spring WebFlux、Spring WebMVC、Jersey。

org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration=\
    org.springframework.boot.actuate.autoconfigure.endpoint.web.ServletEndpointManagementContextConfiguration,\
    org.springframework.boot.actuate.autoconfigure.endpoint.web.reactive.WebFluxEndpointManagementContextConfiguration,\
    org.springframework.boot.actuate.autoconfigure.endpoint.web.servlet.WebMvcEndpointManagementContextConfiguration,\
    org.springframework.boot.actuate.autoconfigure.endpoint.web.jersey.JerseyWebEndpointManagementContextConfiguration

org.springframework.boot.actuate.autoconfigure.web.**ManagementContextConfiguration**配置的类结合注解**@ManagementContextConfiguration**使用时会在**ManagementContextAutoConfiguration**自动配置时被创建，在ManagementContextAutoConfiguration中会触发**@EnableManagementContext**功能，关键在于**ManagementContextConfigurationImportSelector**的作用：

@Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Import(ManagementContextConfigurationImportSelector.class)
    @interface EnableManagementContext {
    
       /**
        * The management context type that should be enabled.
        * @return the management context type
        */
       ManagementContextType value();
    
    }

*  **WebMvcEndpointManagementContextConfiguration**

对Spring MVC类型的WEB应用对外提供HTTP访问接口。

@ManagementContextConfiguration(proxyBeanMethods = false)
    // Spring MVC环境
    @ConditionalOnWebApplication(type = Type.SERVLET)
    @ConditionalOnClass(DispatcherServlet.class)
    @ConditionalOnBean({ DispatcherServlet.class, WebEndpointsSupplier.class })
    // CorsEndpointProperties：management.endpoints.web.cors前缀的配置，与跨域有关
    @EnableConfigurationProperties(CorsEndpointProperties.class)
    public class WebMvcEndpointManagementContextConfiguration {
    
       // 将WEB EndPoints提供HTTP 访问接口
       // 通过参数注入WebEndpointAutoConfiguration中创建的各种类型的Bean
       @Bean
       @ConditionalOnMissingBean
       public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier,
             ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier,
             EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties,
             WebEndpointProperties webEndpointProperties, Environment environment) {
          List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
          // 获取WEB EndPoints
          Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
          allEndpoints.addAll(webEndpoints);
          allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
          allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
          String basePath = webEndpointProperties.getBasePath();
          EndpointMapping endpointMapping = new EndpointMapping(basePath);
          boolean shouldRegisterLinksMapping = StringUtils.hasText(basePath)
                || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT);
          return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes,
                corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath),
                shouldRegisterLinksMapping);
       }
       
       // 将Controller转换成EndPoints访问映射
       @Bean
       @ConditionalOnMissingBean
       public ControllerEndpointHandlerMapping controllerEndpointHandlerMapping(
             ControllerEndpointsSupplier controllerEndpointsSupplier, CorsEndpointProperties corsProperties,
             WebEndpointProperties webEndpointProperties) {
          EndpointMapping endpointMapping = new EndpointMapping(webEndpointProperties.getBasePath());
          return new ControllerEndpointHandlerMapping(endpointMapping, controllerEndpointsSupplier.getEndpoints(),
                corsProperties.toCorsConfiguration());
       }
    
    }

对于方法webEndpointServletHandlerMapping，会通过参数自动注入在配置类WebEndpointAutoConfiguration中创建的Bean：**WebEndpointDiscoverer**、**ServletEndpointDiscoverer**、**ControllerEndpointDiscoverer**、**EndpointMediaTypes**。

*  **JerseyWebEndpointManagementContextConfiguration**

对Spring WebFlux类型的WEB应用对外提供HTTP访问接口。

*  **WebFluxEndpointManagementContextConfiguration**

对Jersey类型的WEB应用对外提供HTTP访问接口。

*  **ServletEndpointManagementContextConfiguration**

对Servlet类型的WEB应用对外提供HTTP访问接口。

--------------------

# **█ 创建和暴露服务** #

以在Spring MVC环境为例，即**WebMvcEndpointManagementContextConfiguration**。

在webEndpointServletHandlerMapping方法中负责创建WEB EndPoints以及HTTP服务暴露。

public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier,
             ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier,
             EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties,
             WebEndpointProperties webEndpointProperties, Environment environment) {
          List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
          // 创建
          // 获取WEB EndPoints
          Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
          allEndpoints.addAll(webEndpoints);
          allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
          allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
          String basePath = webEndpointProperties.getBasePath();
          EndpointMapping endpointMapping = new EndpointMapping(basePath);
          boolean shouldRegisterLinksMapping = StringUtils.hasText(basePath)
                || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT);
          // 暴露      
          return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes,
                corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath),
                shouldRegisterLinksMapping);
       }

### **创建过程：** ###

1、webEndpointsSupplier\#getEndpoints：

从getEndPoints方法开始，调用webEndpointsSupplier.getEndpoints()，即调用**WebEndpointDiscoverer**的getEndpoints方法。getEndpoints方法是继承自抽象类**EndpointDiscoverer**：

public final Collection<E> getEndpoints() {
       // this.endpoints为：private volatile Collection<E> endpoints; 
       if (this.endpoints == null) {
          this.endpoints = discoverEndpoints();
       }
       return this.endpoints;
    }

当初始化时，第一次调用getEndpoints方法，this.endpoints是为null的，需要调用discoverEndpoints方法进行初始化。

private Collection<E> discoverEndpoints() {
       // 创建EndpointBean 
       Collection<EndpointBean> endpointBeans = createEndpointBeans();
       // 对EndpointBean添加扩展，@EndpointExtension的功能 
       addExtensionBeans(endpointBeans);
       // 将EndpointBean转换成EndPoint
       return convertToEndpoints(endpointBeans);
    }

（1）createEndpointBeans

创建**EndpointBean**，首先获取Spring容器中被**@Endpoint、@WebEndpoint、@JmxEndpoint、@ServletEndpoint、@ControllerEndpoint**等标注的bean的名称，再根据bean的名称创建EndpointBean：

private Collection<EndpointBean> createEndpointBeans() {
       Map<EndpointId, EndpointBean> byId = new LinkedHashMap<>();
       // 去Spring容器中获取@Endpoint注解标注的bean名称
       String[] beanNames = BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(this.applicationContext,
             Endpoint.class);
       for (String beanName : beanNames) {
          if (!ScopedProxyUtils.isScopedTarget(beanName)) {
             // 根据bean的名称依次创建EndpointBean 
             EndpointBean endpointBean = createEndpointBean(beanName);
             // 校验id是否唯一，有重复报错
             EndpointBean previous = byId.putIfAbsent(endpointBean.getId(), endpointBean);
             Assert.state(previous == null, () -> "Found two endpoints with the id '" + endpointBean.getId() + "': '"
                   + endpointBean.getBeanName() + "' and '" + previous.getBeanName() + "'");
          }
       }
       // 返回EndpointBean集合
       return byId.values();
    }

createEndpointBean，根据bean的名称创建EndPointBean：

private EndpointBean createEndpointBean(String beanName) {
       Object bean = this.applicationContext.getBean(beanName);
       // 创建EndpointBean对象
       return new EndpointBean(this.applicationContext.getEnvironment(), beanName, bean);
    }

EndpointBean(Environment environment, String beanName, Object bean) {
       MergedAnnotation<Endpoint> annotation = MergedAnnotations
             .from(bean.getClass(), SearchStrategy.TYPE_HIERARCHY).get(Endpoint.class);
       // @Endpoint注解中的属性id值
       String id = annotation.getString("id");
       Assert.state(StringUtils.hasText(id),
             () -> "No @Endpoint id attribute specified for " + bean.getClass().getName());
       // bean的名称      
       this.beanName = beanName;
       this.bean = bean;
       // EndpointId
       this.id = EndpointId.of(environment, id);
       // 默认是否可用，@Endpoint注解中的属性enableByDefault值 
       this.enabledByDefault = annotation.getBoolean("enableByDefault");
       // 过滤器，比如@ServletEndpoint上标注了@FilteredEndpoint(ServletEndpointFilter.class)
       this.filter = getFilter(this.bean.getClass());
    }

（2）addExtensionBeans

对EndpointBean，添加扩展。是**@EndpointExtension**的功能的处理：

private void addExtensionBeans(Collection<EndpointBean> endpointBeans) {
       Map<EndpointId, EndpointBean> byId = endpointBeans.stream()
             .collect(Collectors.toMap(EndpointBean::getId, Function.identity()));
       // 去Spring容器中，获取所有被@EndpointExtension注解标注的bean      
       String[] beanNames = BeanFactoryUtils.beanNamesForAnnotationIncludingAncestors(this.applicationContext,
             EndpointExtension.class);
       for (String beanName : beanNames) {
          // 创建ExtensionBean
          ExtensionBean extensionBean = createExtensionBean(beanName);
          // 根据属性endpoint配置的值获取对应的Endpoint
          EndpointBean endpointBean = byId.get(extensionBean.getEndpointId());
          Assert.state(endpointBean != null, () -> ("Invalid extension '" + extensionBean.getBeanName()
                + "': no endpoint found with id '" + extensionBean.getEndpointId() + "'"));
          addExtensionBean(endpointBean, extensionBean);
       }
    }

创建ExtensionBean：

private ExtensionBean createExtensionBean(String beanName) {
       Object bean = this.applicationContext.getBean(beanName);
       return new ExtensionBean(this.applicationContext.getEnvironment(), beanName, bean);
    }

添加扩展：

private void addExtensionBean(EndpointBean endpointBean, ExtensionBean extensionBean) {
       // 判断，根据过滤器条件和EndpointBean是否对外暴露
       if (isExtensionExposed(endpointBean, extensionBean)) {
          Assert.state(isEndpointExposed(endpointBean) || isEndpointFiltered(endpointBean),
                () -> "Endpoint bean '" + endpointBean.getBeanName() + "' cannot support the extension bean '"
                      + extensionBean.getBeanName() + "'");
          // extensionBean添加到endpointBean中
          endpointBean.addExtension(extensionBean);
       }
    }

（3）convertToEndpoints

将EndpointBean转换成Endpoint。

private Collection<E> convertToEndpoints(Collection<EndpointBean> endpointBeans) {
       Set<E> endpoints = new LinkedHashSet<>();
       for (EndpointBean endpointBean : endpointBeans) {
           // 是否暴露
          if (isEndpointExposed(endpointBean)) {
             endpoints.add(convertToEndpoint(endpointBean));
          }
       }
       return Collections.unmodifiableSet(endpoints);
    }

private E convertToEndpoint(EndpointBean endpointBean) {
      // 使用 MultiValueMap，一个键可以对应多个值。
      // 一个OperationKey对应一个Operation注解方法
       MultiValueMap<OperationKey, O> indexed = new LinkedMultiValueMap<>();
       EndpointId id = endpointBean.getId();
       // 解析@ReadOperation、@WriteOperation、@DeleteOperation，并记录
       addOperations(indexed, id, endpointBean.getBean(), false);
       if (endpointBean.getExtensions().size() > 1) {
          String extensionBeans = endpointBean.getExtensions().stream().map(ExtensionBean::getBeanName)
                .collect(Collectors.joining(", "));
          throw new IllegalStateException("Found multiple extensions for the endpoint bean "
                + endpointBean.getBeanName() + " (" + extensionBeans + ")");
       }
       // 继续扩展ExtensionBean中的@ReadOperation、@WriteOperation、@DeleteOperation，并记录
       for (ExtensionBean extensionBean : endpointBean.getExtensions()) {
          addOperations(indexed, id, extensionBean.getBean(), true);
       }
       // 判断在一个Endpoint中是否存在多个相同的@*Operation注解
       // 即同一个注解只能在一个Endpoint用一次
       assertNoDuplicateOperations(endpointBean, indexed);
       List<O> operations = indexed.values().stream().map(this::getLast).filter(Objects::nonNull)
             .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
       return createEndpoint(endpointBean.getBean(), id, endpointBean.isEnabledByDefault(), operations);
    }

createEndpoint是抽象方法，具体由子类实现，创建什么类型的Endpoint，由子类决定：

protected abstract E createEndpoint(Object endpointBean, EndpointId id, boolean enabledByDefault,
          Collection<O> operations);

**WebEndpointDiscoverer**实现createEndpoint方法，创建**DiscoveredWebEndpoint**对象：

@Override
    protected ExposableWebEndpoint createEndpoint(Object endpointBean, EndpointId id, boolean enabledByDefault,
          Collection<WebOperation> operations) {
       String rootPath = PathMapper.getRootPath(this.endpointPathMappers, id);
       // 创建DiscoveredWebEndpoint
       return new DiscoveredWebEndpoint(this, endpointBean, id, rootPath, enabledByDefault, operations);
    }

2、servletEndpointsSupplier\#getEndpoints：

即调用**ServletEndpointDiscoverer**，ServletEndpointDiscoverer与webEndpointsSupplier有共同的父类EndpointDiscoverer，前面所有的方法调用都相同，就是最后createEndpoint实现不同，创建**DiscoveredServletEndpoint**对象：

@Override
    protected ExposableServletEndpoint createEndpoint(Object endpointBean, EndpointId id, boolean enabledByDefault,
          Collection<Operation> operations) {
       String rootPath = PathMapper.getRootPath(this.endpointPathMappers, id);
       return new DiscoveredServletEndpoint(this, endpointBean, id, rootPath, enabledByDefault);
    }

3、controllerEndpointsSupplier\#getEndpoints：

调用的是**ControllerEndpointDiscoverer**，创建**DiscoveredControllerEndpoint**对象：

@Override
    protected ExposableControllerEndpoint createEndpoint(Object endpointBean, EndpointId id, boolean enabledByDefault,
          Collection<Operation> operations) {
       String rootPath = PathMapper.getRootPath(this.endpointPathMappers, id);
       return new DiscoveredControllerEndpoint(this, endpointBean, id, rootPath, enabledByDefault);
    }

**补充：**如何判断重复Operation方法：

在《[初识篇][Link 1]》的末尾测试了在同一个Endpoint多次使用同一个Operation注解的情况，下面来具体看看对于重复的Operation是如何判断的。

在上面的代码中，convertToEndpoint方法中有解析Endpoint中Operation注解的过程，解析后的结果放进了**MultiValueMap**中：

MultiValueMap<OperationKey, O> indexed = new LinkedMultiValueMap<>();

MultiValueMap是一个键可以对应多个值的map，一个OperationKey就是对应一个Operation注解方法。当一个Operation注解方法对应了相同的OperationKey就表示重复了。所以需要查看对于OperationKey是如何判断是否是同一个对象的。判断是MultiValueMap的功能，通过key的equals与hashCode方法，查看OperationKey的equals和hashCode方法：

@Override
    public boolean equals(Object obj) {
       if (obj == this) {
          return true;
       }
       if (obj == null || getClass() != obj.getClass()) {
          return false;
       }
       return this.key.equals(((OperationKey) obj).key);
    }
    
    @Override
    public int hashCode() {
       return this.key.hashCode();
    }

从equals方法可以看出，对于不同的Operation对象，如何它们的key相等就表示相等了，于是下面就要对key的比较了，key是在调用构造器的时候被赋值的：

public OperationKey(Object key, Supplier<String> description) {
       Assert.notNull(key, "Key must not be null");
       Assert.notNull(description, "Description must not be null");
       this.key = key;
       this.description = description;
    }

在**JmxEndpointDiscoverer**调用，key是Operation的name属性值（operation\#getName），也就是方法名，是String类型的，通过String的equals方法比较两个对象：

@Override
    protected OperationKey createOperationKey(JmxOperation operation) {
       return new OperationKey(operation.getName(), () -> "MBean call '" + operation.getName() + "'");
    }

在**WebEndpointDiscoverer**调用，key是requestPredicate属性值，是**WebOperationRequestPredicate**类型的，通过WebOperationRequestPredicate的equals方法比较两个对象：

@Override
    protected OperationKey createOperationKey(WebOperation operation) {
       return new OperationKey(operation.getRequestPredicate(),
             () -> "web request predicate " + operation.getRequestPredicate());
    }

查看WebOperationRequestPredicate的equals方法，需要consumes，httpMethod（Operation注解类型），id（注解@Endpoint的id属性值），produces的值全都相等，两个对象才是相等的。在同一个WEB Endpoint中，同一种Operation注解方法的httpMethod和id都是相同的：

@Override
    public boolean equals(Object obj) {
       if (this == obj) {
          return true;
       }
       if (obj == null || getClass() != obj.getClass()) {
          return false;
       }
       WebOperationRequestPredicate other = (WebOperationRequestPredicate) obj;
       boolean result = true;
       result = result && this.consumes.equals(other.consumes);
       result = result && this.httpMethod == other.httpMethod;
       result = result && this.canonicalPath.equals(other.canonicalPath);
       result = result && this.produces.equals(other.produces);
       return result;
    }

综上所述，对于JMX Endpoint，在同一个Endpoint中，重复的Operation的判断条件就是方法名是否相同。对于WEB Endpoint，在同一个Endpoint中，重复的Operation的判断条件就是consumes，httpMethod，id，produces的值全都相等。

## ##

### 暴露过程： ###

**WebMvcEndpointHandlerMapping**

new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes,
                corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath),
                shouldRegisterLinksMapping);

类图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70][]

**WebMvcEndpointHandlerMapping**继承抽象类**AbstractWebMvcEndpointHandlerMapping**，间接实现了**InitializingBean**。Spring初始化Bean的时候，会调用InitializingBean的**afterPropertiesSet**。所以入口就从afterPropertiesSet的方法实现找起，在抽象类AbstractHandlerMethodMapping中实现了afterPropertiesSet方法：

@Override
    public void afterPropertiesSet() {
       // 调用 initHandlerMethods
       initHandlerMethods();
    }

（1）此时调用的initHandlerMethods方法并不是AbstractHandlerMethodMapping中自身的这个方法，因为在AbstractWebMvcEndpointHandlerMapping中重写了此方法：

// AbstractWebMvcEndpointHandlerMapping#initHandlerMethods
    @Override
    protected void initHandlerMethods() {
       // 遍历webEndpoints集合 
       for (ExposableWebEndpoint endpoint : this.endpoints) {
          for (WebOperation operation : endpoint.getOperations()) {
             // 创建和注册请求接口
             registerMappingForOperation(endpoint, operation);
          }
       }
       // 注册根目录接口，即/actuator
       if (this.shouldRegisterLinksMapping) {
          registerLinksMapping();
       }
    }

this.endpoints是在创建WebMvcEndpointHandlerMapping对象的时候，传进来的参数webEndpoints：

public WebMvcEndpointHandlerMapping(EndpointMapping endpointMapping, Collection<ExposableWebEndpoint> endpoints,
          EndpointMediaTypes endpointMediaTypes, CorsConfiguration corsConfiguration,
          EndpointLinksResolver linksResolver, boolean shouldRegisterLinksMapping) {
       super(endpointMapping, endpoints, endpointMediaTypes, corsConfiguration, shouldRegisterLinksMapping);
       this.linksResolver = linksResolver;
       setOrder(-100);
    }

（2）registerMappingForOperation

// AbstractWebMvcEndpointHandlerMapping#registerMappingForOperation
    private void registerMappingForOperation(ExposableWebEndpoint endpoint, WebOperation operation) {
       // 获取请求方式、consumers、produces等值 
       WebOperationRequestPredicate predicate = operation.getRequestPredicate();
       // 请求路径，即@Endpoint注解的id值
       String path = predicate.getPath();
       String matchAllRemainingPathSegmentsVariable = predicate.getMatchAllRemainingPathSegmentsVariable();
       if (matchAllRemainingPathSegmentsVariable != null) {
          path = path.replace("{*" + matchAllRemainingPathSegmentsVariable + "}", "**");
       }
       // 创建ServletWebOperation，可以理解成Spring MVC中的HandlerAdapter
       ServletWebOperation servletWebOperation = wrapServletWebOperation(endpoint, operation,
             new ServletWebOperationAdapter(operation));
       // createRequestMappingInfo创建HanlderMapping接口路径映射信息      
       registerMapping(createRequestMappingInfo(predicate, path), new OperationHandler(servletWebOperation),
             this.handleMethod);
    }

（3）registerMapping

public void registerMapping(T mapping, Object handler, Method method) {
       if (logger.isTraceEnabled()) {
          logger.trace("Register \"" + mapping + "\" to " + method.toGenericString());
       }
       // 往Spring容器中注册接口信息
       this.mappingRegistry.register(mapping, handler, method);
    }

接下来就是Spring MVC的功能了。

[Link 1]: https://blog.csdn.net/weixin_50518271/article/details/111183826
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl81MDUxODI3MQ_size_16_color_FFFFFF_t_70]: /images/20221120/f701c9ef8c3542ae83df06783b987e2c.png