public PathMappedEndpoints(String basePath, Collection<EndpointsSupplier<?>> suppliers) {
	Assert.notNull(suppliers, "Suppliers must not be null");
	this.basePath = (basePath != null) ? basePath : "";
	this.endpoints = getEndpoints(suppliers);
}

private Map<EndpointId, PathMappedEndpoint> getEndpoints(Collection<EndpointsSupplier<?>> suppliers) {
	Map<EndpointId, PathMappedEndpoint> endpoints = new LinkedHashMap<>();
	suppliers.forEach((supplier) -> {
		supplier.getEndpoints().forEach((endpoint) -> {
			if (endpoint instanceof PathMappedEndpoint) {
				endpoints.put(endpoint.getEndpointId(), (PathMappedEndpoint) endpoint);
			}
		});
	});
	return Collections.unmodifiableMap(endpoints);
}

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

private Collection<E> discoverEndpoints() {
	// 创建所有Endpoint
	Collection<EndpointBean> endpointBeans = createEndpointBeans();
	// 创建ExtensionBeans
	addExtensionBeans(endpointBeans);
	// 转换Exposed的Endpoints
	return convertToEndpoints(endpointBeans);
}

public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier,
		ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier,
		EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties,
		WebEndpointProperties webEndpointProperties, Environment environment) {
	List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
	// 从WebEndpointDiscoverer获取
	Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
	allEndpoints.addAll(webEndpoints);
	// 从ServletEndpointDiscoverer获取
	allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
	// 从ControllerEndpointDiscoverer获取
	allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
	// 即/actuator
	String basePath = webEndpointProperties.getBasePath();
	// 创建EndpointMapping
	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);
}

public void afterPropertiesSet() {
	initHandlerMethods();
}

// AbstractWebMvcEndpointHandlerMapping
protected void initHandlerMethods() {
	for (ExposableWebEndpoint endpoint : this.endpoints) {
		// 遍历其所有操作方法
		for (WebOperation operation : endpoint.getOperations()) {
			// 1.注册
			registerMappingForOperation(endpoint, operation);
		}
	}
	if (this.shouldRegisterLinksMapping) {
		// 2.注册链接地址映射
		registerLinksMapping();
	}
}

private void registerMappingForOperation(ExposableWebEndpoint endpoint, WebOperation operation) {
	// 请求阐明
	WebOperationRequestPredicate predicate = operation.getRequestPredicate();
	// 获取请求地址，例如：hello/{name}
	String path = predicate.getPath();
	// 获取所有路径变量名
	String matchAllRemainingPathSegmentsVariable = predicate.getMatchAllRemainingPathSegmentsVariable();
	if (matchAllRemainingPathSegmentsVariable != null) {
		path = path.replace("{*" + matchAllRemainingPathSegmentsVariable + "}", "**");
	}
	// ServletWebOperationAdapter，封装WebOperation
	ServletWebOperation servletWebOperation = wrapServletWebOperation(endpoint, operation,
			new ServletWebOperationAdapter(operation));
	registerMapping(createRequestMappingInfo(predicate, path), new OperationHandler(servletWebOperation),
			this.handleMethod);
}

private void registerLinksMapping() {
	// [/actuator]
	PatternsRequestCondition patterns = patternsRequestConditionForPattern("");
	// [GET]
	RequestMethodsRequestCondition methods = new RequestMethodsRequestCondition(RequestMethod.GET);
	// [application/vnd.spring-boot.actuator.v3+json || application/vnd.spring-boot.actuator.v2+json || application/json]
	ProducesRequestCondition produces = new ProducesRequestCondition(this.endpointMediaTypes.getProduced()
			.toArray(StringUtils.toStringArray(this.endpointMediaTypes.getProduced())));
	// {GET /actuator, produces [application/vnd.spring-boot.actuator.v3+json || application/vnd.spring-boot.actuator.v2+json || application/json]}
	RequestMappingInfo mapping = new RequestMappingInfo(patterns, methods, null, null, null, produces, null);
	LinksHandler linksHandler = getLinksHandler();
	registerMapping(mapping, linksHandler, ReflectionUtils.findMethod(linksHandler.getClass(), "links",
			HttpServletRequest.class, HttpServletResponse.class));
}

// 最后都调用这个方法进行注册映射到map
public void registerMapping(T mapping, Object handler, Method method) {
	if (logger.isTraceEnabled()) {
		logger.trace("Register \"" + mapping + "\" to " + method.toGenericString());
	}
	this.mappingRegistry.register(mapping, handler, method);
}

public void register(T mapping, Object handler, Method method) {
	// Assert that the handler method is not a suspending one.
	if (KotlinDetector.isKotlinType(method.getDeclaringClass()) && KotlinDelegate.isSuspend(method)) {
		throw new IllegalStateException("Unsupported suspending handler method detected: " + method);
	}
	this.readWriteLock.writeLock().lock();
	try {
		// WebMvcEndpointHandlerMethod
		HandlerMethod handlerMethod = createHandlerMethod(handler, method);
		validateMethodMapping(handlerMethod, mapping);
		// Map<T, HandlerMethod> mappingLookup
		this.mappingLookup.put(mapping, handlerMethod);

		List<String> directUrls = getDirectUrls(mapping);
		for (String url : directUrls) {
			this.urlLookup.add(url, mapping);
		}

		String name = null;
		if (getNamingStrategy() != null) {
			name = getNamingStrategy().getName(handlerMethod, mapping);
			// mappingLookup
			addMappingName(name, handlerMethod);
		}

		// 跨域
		CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
		if (corsConfig != null) {
			this.corsLookup.put(handlerMethod, corsConfig);
		}
		// Map<T, MappingRegistration<T>> registry
		this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
	}
	finally {
		this.readWriteLock.writeLock().unlock();
	}
}

public ServletEndpointRegistrar servletEndpointRegistrar(WebEndpointProperties properties,
		ServletEndpointsSupplier servletEndpointsSupplier, DispatcherServletPath dispatcherServletPath) {
	// /actuator  和 之前创建的
	return new ServletEndpointRegistrar(dispatcherServletPath.getRelativePath(properties.getBasePath()),
			servletEndpointsSupplier.getEndpoints());
}

public void onStartup(ServletContext servletContext) throws ServletException {
	this.servletEndpoints.forEach((servletEndpoint) -> register(servletContext, servletEndpoint));
}

private void register(ServletContext servletContext, ExposableServletEndpoint endpoint) {
	String name = endpoint.getEndpointId().toLowerCaseString() + "-actuator-endpoint";
	String path = this.basePath + "/" + endpoint.getRootPath();
	String urlMapping = path.endsWith("/") ? path + "*" : path + "/*";
	EndpointServlet endpointServlet = endpoint.getEndpointServlet();
	// 使用了addServlet的方式
	Dynamic registration = servletContext.addServlet(name, endpointServlet.getServlet());
	registration.addMapping(urlMapping);
	registration.setInitParameters(endpointServlet.getInitParameters());
	registration.setLoadOnStartup(endpointServlet.getLoadOnStartup());
	logger.info("Registered '" + path + "' to " + name);
}

public JmxEndpointExporter jmxMBeanExporter(MBeanServer mBeanServer, Environment environment,
		ObjectProvider<ObjectMapper> objectMapper, JmxEndpointsSupplier jmxEndpointsSupplier) {
	String contextId = ObjectUtils.getIdentityHexString(this.applicationContext);
	EndpointObjectNameFactory objectNameFactory = new DefaultEndpointObjectNameFactory(this.properties, environment,
			mBeanServer, contextId);
	JmxOperationResponseMapper responseMapper = new JacksonJmxOperationResponseMapper(
			objectMapper.getIfAvailable());
	return new JmxEndpointExporter(mBeanServer, objectNameFactory, responseMapper,
			jmxEndpointsSupplier.getEndpoints());
}

public void afterPropertiesSet() {
	this.registered = register();
}

private Collection<ObjectName> register() {
	return this.endpoints.stream().map(this::register).collect(Collectors.toList());
}

private ObjectName register(ExposableJmxEndpoint endpoint) {
	// ...
	ObjectName name = this.objectNameFactory.getObjectName(endpoint);
	EndpointMBean mbean = new EndpointMBean(this.responseMapper, this.classLoader, endpoint);
	// 注册到MBeanServer
	this.mBeanServer.registerMBean(mbean, name);
	return name;
	// ...
}

return this.getBridgedMethod().invoke(this.getBean(), args);

@ResponseBody
Object handle(HttpServletRequest request, @RequestBody(required = false) Map<String, String> body) {
	// AbstractWebMvcEndpointHandlerMapping$ServletWebOperationAdapter
	return this.operation.handle(request, body);
}

public Object handle(HttpServletRequest request, @RequestBody(required = false) Map<String, String> body) {
	HttpHeaders headers = new ServletServerHttpRequest(request).getHeaders();
	Map<String, Object> arguments = getArguments(request, body);
	try {
		ApiVersion apiVersion = ApiVersion.fromHttpHeaders(headers);
		ServletSecurityContext securityContext = new ServletSecurityContext(request);
		InvocationContext invocationContext = new InvocationContext(apiVersion, securityContext, arguments);
		// this.operation就是DiscoveredWebOperation，就是通过endpoint.getOperations()遍历得到的
		return handleResult(this.operation.invoke(invocationContext), HttpMethod.resolve(request.getMethod()));
	}
	catch (InvalidEndpointRequestException ex) {
		throw new BadOperationRequestException(ex.getReason());
	}
}

// AbstractDiscoveredOperation
public Object invoke(InvocationContext context) {
	return this.invoker.invoke(context);
}

// AbstractHandlerMethodMapping
protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception {
	// /actuator/hello/zz
	String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
	request.setAttribute(LOOKUP_PATH, lookupPath);
	this.mappingRegistry.acquireReadLock();
	try {
		HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);
		return (handlerMethod != null ? handlerMethod.createWithResolvedBean() : null);
	}
	finally {
		this.mappingRegistry.releaseReadLock();
	}
}

// EndpointMBean
public Object invoke(String actionName, Object[] params, String[] signature)
		throws MBeanException, ReflectionException {
	// actionName = health;    operations = ["health" -> {DiscoveredJmxOperation}]
	JmxOperation operation = this.operations.get(actionName);
	if (operation == null) {
		String message = "Endpoint with id '" + this.endpoint.getEndpointId() + "' has no operation named "
				+ actionName;
		throw new ReflectionException(new IllegalArgumentException(message), message);
	}
	ClassLoader previousClassLoader = overrideThreadContextClassLoader(this.classLoader);
	try {
		return invoke(operation, params);
	}
	finally {
		overrideThreadContextClassLoader(previousClassLoader);
	}
}

// AbstractDiscoveredOperation
public Object invoke(InvocationContext context) {
	// org.springframework.boot.actuate.endpoint.invoke.reflect.ReflectiveOperationInvoker
	return this.invoker.invoke(context);
}

// ReflectiveOperationInvoker
public Object invoke(InvocationContext context) {
	validateRequiredParameters(context);
	// HealthEndpoint.health()
	Method method = this.operationMethod.getMethod();
	Object[] resolvedArguments = resolveArguments(context);
	ReflectionUtils.makeAccessible(method);
	return ReflectionUtils.invokeMethod(method, this.target, resolvedArguments);
}

@ReadOperation
public HealthComponent health() {
	HealthComponent health = health(ApiVersion.V3, EMPTY_PATH);
	return (health != null) ? health : DEFAULT_HEALTH;
}

// HealthEndpointSupport
HealthResult<T> getHealth(ApiVersion apiVersion, SecurityContext securityContext, boolean showAll, String... path) {
	HealthEndpointGroup group = (path.length > 0) ? this.groups.get(path[0]) : null;
	if (group != null) {
		return getHealth(apiVersion, group, securityContext, showAll, path, 1);
	}
	return getHealth(apiVersion, this.groups.getPrimary(), securityContext, showAll, path, 0);
}

private T getContribution(ApiVersion apiVersion, HealthEndpointGroup group, Object contributor,
		boolean showComponents, boolean showDetails, Set<String> groupNames) {
	if (contributor instanceof NamedContributors) {
		return getAggregateHealth(apiVersion, group, (NamedContributors<C>) contributor, showComponents,
				showDetails, groupNames);
	}
	// 调用HealthEndpoint的getHealth，传入contributor
	return (contributor != null) ? getHealth((C) contributor, showDetails) : null;
}


private T getAggregateHealth(ApiVersion apiVersion, HealthEndpointGroup group,
			NamedContributors<C> namedContributors, boolean showComponents, boolean showDetails,
			Set<String> groupNames) {
	Map<String, T> contributions = new LinkedHashMap<>();
	for (NamedContributor<C> namedContributor : namedContributors) {
		String name = namedContributor.getName();
		C contributor = namedContributor.getContributor();
		if (group.isMember(name)) {
			// 掉回上面的getContribution方法
			T contribution = getContribution(apiVersion, group, contributor, showComponents, showDetails, null);
			if (contribution != null) {
				contributions.put(name, contribution);
			}
		}
	}
	if (contributions.isEmpty()) {
		return null;
	}
	return aggregateContributions(apiVersion, contributions, group.getStatusAggregator(), showComponents,
			groupNames);
}

// HealthEndpointWebExtension
protected HealthComponent getHealth(HealthContributor contributor, boolean includeDetails) {
	return ((HealthIndicator) contributor).getHealth(includeDetails);
}

// MyHealthIndicator(implements HealthIndicator)
default Health getHealth(boolean includeDetails) {
	Health health = health();
	return includeDetails ? health : health.withoutDetails();
}

public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
	if (bean instanceof MeterRegistry) {
		// 为MeterRegistryConfigurer
		getConfigurer().configure((MeterRegistry) bean);
	}
	return bean;
}

// MeterRegistryConfigurer
void configure(MeterRegistry registry) {
	// Customizers must be applied before binders, as they may add custom
	// tags or alter timer or summary configuration.
	customize(registry);
	addFilters(registry);
	if (!this.hasCompositeMeterRegistry || registry instanceof CompositeMeterRegistry) {
		addBinders(registry);
	}
	if (this.addToGlobalRegistry && registry != Metrics.globalRegistry) {
		Metrics.addRegistry(registry);
	}
}

private void addBinders(MeterRegistry registry) {
	this.binders.orderedStream().forEach((binder) -> binder.bindTo(registry));
}

@ReadOperation
public ListNamesResponse listNames() {
	Set<String> names = new LinkedHashSet<>();
	collectNames(names, this.registry);
	return new ListNamesResponse(names);
}

private void collectNames(Set<String> names, MeterRegistry registry) {
	if (registry instanceof CompositeMeterRegistry) {
		((CompositeMeterRegistry) registry).getRegistries().forEach((member) -> collectNames(names, member));
	}
	else {
		registry.getMeters().stream().map(this::getName).forEach(names::add);
	}
}

public MetricResponse metric(@Selector String requiredMetricName, @Nullable List<String> tag) {
	List<Tag> tags = parseTags(tag);
	// 此例中，其value是个lambda，因此就可以进行数值的变化(累加)
	Collection<Meter> meters = findFirstMatchingMeters(this.registry, requiredMetricName, tags);
	if (meters.isEmpty()) {
		return null;
	}
	// 获取算出来的具体数值
	Map<Statistic, Double> samples = getSamples(meters);
	// 标签等
	Map<String, Set<String>> availableTags = getAvailableTags(meters);
	tags.forEach((t) -> availableTags.remove(t.getKey()));
	Meter.Id meterId = meters.iterator().next().getId();
	// 最后封装返回
	return new MetricResponse(requiredMetricName, meterId.getDescription(), meterId.getBaseUnit(),
			asList(samples, Sample::new), asList(availableTags, AvailableTag::new));
}

public void onApplicationEvent(ContextRefreshedEvent event) {
    // healthCheckerProcessor init
    healthCheckerProcessor.init();
    // healthIndicatorProcessor init
    healthIndicatorProcessor.init();
    // afterReadinessCheckCallbackProcessor init
    afterReadinessCheckCallbackProcessor.init();
    // readiness health check execute
    readinessHealthCheck();