// DubboRegistryZooKeeperConsumerBootstrap.java

private final Logger logger = LoggerFactory.getLogger(getClass());

@Reference(version = "${demo.service.version}")
private DemoService demoService;

@Bean
public ApplicationRunner runner() {
    return args -> logger.info(demoService.sayHello("mercyblitz")); // 发起调用
}

public static void main(String[] args) {
    SpringApplication.run(DubboRegistryZooKeeperConsumerBootstrap.class) // 启动
            .close(); // <X> 关闭
}

// DubboAutoConfiguration.java

@Configuration // 配置类
@ConditionalOnProperty(prefix = DUBBO_PREFIX, name = "enabled", matchIfMissing = true, havingValue = "true") // 要求配置了 "dubbo.enabled=true" 或者，"dubbo.enabled" 未配置
@ConditionalOnClass(AbstractConfig.class) // AbstractConfig 类存在的时候，即用于判断有 Dubbo 库
public class DubboAutoConfiguration {

    // ... 省略其它代码

}

// DubboAutoConfiguration.java

@ConditionalOnProperty(name = BASE_PACKAGES_PROPERTY_NAME) // 配置了 "dubbo.scan.base-package" 属性，即要扫描 Dubbo 注解的包
@ConditionalOnClass(ConfigurationPropertySources.class) // 有 Spring Boot 配置加载的功能
@Bean
public ServiceAnnotationBeanPostProcessor serviceAnnotationBeanPostProcessor(Environment environment) {
    // <1> 获得 "dubbo.scan.base-package" 属性
    Set<String> packagesToScan = environment.getProperty(BASE_PACKAGES_PROPERTY_NAME, Set.class, emptySet());
    // <2> 创建 ServiceAnnotationBeanPostProcessor 对象
    return new ServiceAnnotationBeanPostProcessor(packagesToScan);
}

// DubboAutoConfiguration.java

@ConditionalOnMissingBean // 不存在 ReferenceAnnotationBeanPostProcessor Bean 的时候
@Bean(name = ReferenceAnnotationBeanPostProcessor.BEAN_NAME) // Bean 的名字是 referenceAnnotationBeanPostProcessor
public ReferenceAnnotationBeanPostProcessor referenceAnnotationBeanPostProcessor() {
    return new ReferenceAnnotationBeanPostProcessor();
}

// DubboAutoConfiguration.java

@ConditionalOnClass(Binder.class) // 存在 Binder 类的时候
@Bean
@Scope(scopeName = SCOPE_PROTOTYPE) // 多例
public RelaxedDubboConfigBinder relaxedDubboConfigBinder() {
    return new RelaxedDubboConfigBinder();
}

// DubboAutoConfiguration.java

/**
 * Single Dubbo Config Configuration
 *
 * @see EnableDubboConfig
 * @see DubboConfigConfiguration.Single
 */
@EnableDubboConfig
protected static class SingleDubboConfigConfiguration {
}

/**
 * Multiple Dubbo Config Configuration , equals @EnableDubboConfig.multiple() == <code>true</code>
 *
 * @see EnableDubboConfig
 * @see DubboConfigConfiguration.Multiple
 */
@ConditionalOnProperty(name = MULTIPLE_CONFIG_PROPERTY_NAME, havingValue = "true") // 要求配置 "dubbo.config.multiple=true" 。默认情况下，Dubbo 自带 "dubbo.config.multiple=true"
@EnableDubboConfig(multiple = true)
protected static class MultipleDubboConfigConfiguration {
}

// RelaxedDubboConfigBinder.java

@Override
public <C extends AbstractConfig> void bind(String prefix, C dubboConfig) {
    // <1.1> 获得 PropertySource 数组
    Iterable<PropertySource<?>> propertySources = getPropertySources();
    // Converts ConfigurationPropertySources
    // <1.2> 转换成 ConfigurationPropertySource 数组
    Iterable<ConfigurationPropertySource> configurationPropertySources = from(propertySources);

    // Wrap Bindable from DubboConfig instance
    // <2> 将 dubboConfig 包装成 Bindable 对象
    Bindable<C> bindable = Bindable.ofInstance(dubboConfig);

    // <3.1> 创建 Binder 对象
    Binder binder = new Binder(configurationPropertySources, new PropertySourcesPlaceholdersResolver(propertySources));
    // Get BindHandler
    // <3.2> 获得 BindHandler 对象
    BindHandler bindHandler = getBindHandler();
    // Bind
    // <3.3> 执行绑定，会将 propertySources 属性，注入到 dubboConfig 对象中
    binder.bind(prefix, bindable, bindHandler);
}

// DubboDefaultPropertiesEnvironmentPostProcessor.java

@Override
public void postProcessEnvironment(ConfigurableEnvironment environment, SpringApplication application) {
    MutablePropertySources propertySources = environment.getPropertySources();
    // <1> 生成 Dubbo 默认配置
    Map<String, Object> defaultProperties = createDefaultProperties(environment);
    // <2> 有默认配置，则添加到 environment 中
    if (!CollectionUtils.isEmpty(defaultProperties)) {
        addOrReplace(propertySources, defaultProperties);
    }
}

// WelcomeLogoApplicationListener.java

@Order(LoggingApplicationListener.DEFAULT_ORDER + 1)
public class WelcomeLogoApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {

    /**
     * 是否执行过
     *
     * 通过该变量，保证有且仅处理一次 ApplicationEnvironmentPreparedEvent 事件
     */
    private static AtomicBoolean processed = new AtomicBoolean(false);

    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // Skip if processed before, prevent duplicated execution in Hierarchical ApplicationContext
        // 如果已经处理，则直接跳过
        if (processed.get()) {
            return;
        }

        // 获得 Logger 对象
        /**
         * Gets Logger After LoggingSystem configuration ready
         * @see LoggingApplicationListener
         */
        final Logger logger = LoggerFactory.getLogger(getClass());

        // 获得 Dubbo Banner 文本
        String bannerText = buildBannerText();
        if (logger.isInfoEnabled()) {
            logger.info(bannerText);
        } else {
            System.out.print(bannerText);
        }

        // mark processed to be true
        // 标记已执行
        processed.compareAndSet(false, true);
    }

    String buildBannerText() {
        StringBuilder bannerTextBuilder = new StringBuilder();
        bannerTextBuilder
                .append(LINE_SEPARATOR)
                .append(LINE_SEPARATOR)
                .append(" :: Dubbo Spring Boot (v").append(Version.getVersion(getClass(), "1.0.0")).append(") : ")
                .append(DUBBO_SPRING_BOOT_GITHUB_URL)
                .append(LINE_SEPARATOR)
                .append(" :: Dubbo (v").append(Version.getVersion()).append(") : ")
                .append(DUBBO_GITHUB_URL)
                .append(LINE_SEPARATOR)
                .append(" :: Discuss group : ")
                .append(DUBBO_MAILING_LIST)
                .append(LINE_SEPARATOR);
        return bannerTextBuilder.toString();
    }

}

// OverrideDubboConfigApplicationListener.java

@Order // LOWEST_PRECEDENCE Make sure last execution
public class OverrideDubboConfigApplicationListener implements ApplicationListener<ApplicationEnvironmentPreparedEvent> {

    @Override
    public void onApplicationEvent(ApplicationEnvironmentPreparedEvent event) {
        // 获得 Logger 对象
        /**
         * Gets Logger After LoggingSystem configuration ready
         * @see LoggingApplicationListener
         */
        final Logger logger = LoggerFactory.getLogger(getClass());

        // <1> 获得 "dubbo.config.override" 属性对应的值。默认情况下为 true
        ConfigurableEnvironment environment = event.getEnvironment();
        boolean override = environment.getProperty(OVERRIDE_CONFIG_PROPERTY_NAME, boolean.class, DEFAULT_OVERRIDE_CONFIG_PROPERTY_VALUE);
        // <2> 如果要重写，则覆盖添加到 Dubbo Properties 中
        if (override) {
            // <2.1> 从 environment 中，提取 "dubbo." 开头的配置
            SortedMap<String, Object> dubboProperties = filterDubboProperties(environment);
            // <2.2> 添加到 Dubbo Properties 中
            ConfigUtils.getProperties().putAll(dubboProperties);
            if (logger.isInfoEnabled()) {
                logger.info("Dubbo Config was overridden by externalized configuration {}", dubboProperties);
            }
        } else {
            if (logger.isInfoEnabled()) {
                logger.info("Disable override Dubbo Config caused by property {} = {}", OVERRIDE_CONFIG_PROPERTY_NAME, override);
            }
        }

    }

}

// AwaitingNonWebApplicationListener.java

private static final Class<? extends ApplicationEvent>[] SUPPORTED_APPLICATION_EVENTS =
        of(ApplicationReadyEvent.class, ContextClosedEvent.class);
        
@Override
public boolean supportsEventType(Class<? extends ApplicationEvent> eventType) {
    return ObjectUtils.containsElement(SUPPORTED_APPLICATION_EVENTS, eventType);
}

private static <T> T[] of(T... values) {
    return values;
}

// AwaitingNonWebApplicationListener.java

@Override
public boolean supportsSourceType(Class<?> sourceType) {
    return true;
}

// AwaitingNonWebApplicationListener.java

@Override
public void onApplicationEvent(ApplicationEvent event) {
    if (event instanceof ApplicationReadyEvent) {
        onApplicationReadyEvent((ApplicationReadyEvent) event); // <1>
    } else if (event instanceof ContextClosedEvent) {
        onContextClosedEvent((ContextClosedEvent) event); // <2>
    }
}

// AwaitingNonWebApplicationListener.java

protected void onApplicationReadyEvent(ApplicationReadyEvent event) {
    // <1> 如果是 Web 环境，则直接返回
    final SpringApplication springApplication = event.getSpringApplication();
    if (!WebApplicationType.NONE.equals(springApplication.getWebApplicationType())) {
        return;
    }
    // <2> 启动一个用户线程，从而实现等待
    await();
}

// AwaitingNonWebApplicationListener.java

protected void onContextClosedEvent(ContextClosedEvent event) {
    // <1> 释放
    release();
    // <2> 关闭线程池
    shutdown();
}

// DubboEndpointsAutoConfiguration.java

@Configuration
@PropertySource(
        name = "Dubbo Endpoints Default Properties",
        value = "classpath:/META-INF/dubbo-endpoins-default.properties") // 导入该配置文件
public class DubboEndpointsAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboEndpoint dubboEndpoint() {
        return new DubboEndpoint();
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboConfigsMetadataEndpoint dubboConfigsMetadataEndpoint() {
        return new DubboConfigsMetadataEndpoint();
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboPropertiesEndpoint dubboPropertiesEndpoint() {
        return new DubboPropertiesEndpoint();
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboReferencesMetadataEndpoint dubboReferencesMetadataEndpoint() {
        return new DubboReferencesMetadataEndpoint();
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboServicesMetadataEndpoint dubboServicesMetadataEndpoint() {
        return new DubboServicesMetadataEndpoint();
    }

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint
    public DubboShutdownEndpoint dubboShutdownEndpoint() {
        return new DubboShutdownEndpoint();
    }

}

// DubboHealthIndicatorAutoConfiguration.java

@Configuration
@ConditionalOnClass({HealthIndicator.class}) // 存在 HealthIndicator 类的情况
@AutoConfigureBefore({EndpointAutoConfiguration.class}) // 在 EndpointAutoConfiguration 自动配置类之前初始化
@AutoConfigureAfter(DubboAutoConfiguration.class) // 在 DubboAutoConfiguration 自动配置类之后初始化
@ConditionalOnEnabledHealthIndicator("dubbo")
@EnableConfigurationProperties(DubboHealthIndicatorProperties.class) // 自动配置 DubboHealthIndicatorProperties 类
public class DubboHealthIndicatorAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean
    public DubboHealthIndicator dubboHealthIndicator() {
        return new DubboHealthIndicator();
    }

}

// DubboHealthIndicatorProperties.java

@ConfigurationProperties(prefix = PREFIX, ignoreUnknownFields = false) // "management.health.dubbo" 开头的配置
public class DubboHealthIndicatorProperties {

    /**
     * The prefix of {@link DubboHealthIndicatorProperties}
     */
    public static final String PREFIX = "management.health.dubbo";

    private Status status = new Status();

    // ... 省略 setting/getting 方法

    /**
     * The nested class for {@link StatusChecker}'s names
     * <pre>
     * registry=com.alibaba.dubbo.registry.status.RegistryStatusChecker
     * spring=com.alibaba.dubbo.config.spring.status.SpringStatusChecker
     * datasource=com.alibaba.dubbo.config.spring.status.DataSourceStatusChecker
     * memory=com.alibaba.dubbo.common.status.support.MemoryStatusChecker
     * load=com.alibaba.dubbo.common.status.support.LoadStatusChecker
     * server=com.alibaba.dubbo.rpc.protocol.dubbo.status.ServerStatusChecker
     * threadpool=com.alibaba.dubbo.rpc.protocol.dubbo.status.ThreadPoolStatusChecker
     * </pre>
     *
     * @see StatusChecker
     */
    public static class Status {

        /**
         * The defaults names of {@link StatusChecker}
         * <p>
         * The defaults : "memory", "load"
         */
        private Set<String> defaults = new LinkedHashSet<>(Arrays.asList("memory", "load"));

        /**
         * The extra names of {@link StatusChecker}
         *
         * 配置的 "management.health.dubbo.extras" 集合
         *
         * 每个元素，是 StatusChecker 的实现类
         */
        private Set<String> extras = new LinkedHashSet<>();

        // ... 省略 setting/getting 方法
        
    }

}

// DubboHealthIndicator.java

@Override
protected void doHealthCheck(Health.Builder builder) throws Exception {
    // <1> 获得 StatusChecker 对应的 Dubbo ExtensionLoader 对象
    ExtensionLoader<StatusChecker> extensionLoader = getExtensionLoader(StatusChecker.class);
    // <2> 解析 StatusChecker 的名字的 Map
    Map<String, String> statusCheckerNamesMap = resolveStatusCheckerNamesMap();

    // <3> 声明 hasError、hasUnknown 变量
    boolean hasError = false; // 是否有错误的返回
    boolean hasUnknown = false; // 是否有未知的返回

    // Up first
    // <4> 先 builder 标记状态是 UP
    builder.up();

    // <5> 遍历 statusCheckerNamesMap 元素
    for (Map.Entry<String, String> entry : statusCheckerNamesMap.entrySet()) {
        // <6.1> 获得 StatusChecker 的名字
        String statusCheckerName = entry.getKey();
        // <6.2> 获得 source
        String source = entry.getValue();
        // <6.3> 获得 StatusChecker 对象
        StatusChecker checker = extensionLoader.getExtension(statusCheckerName);
        // <6.4> 执行校验
        com.alibaba.dubbo.common.status.Status status = checker.check();

        // <7.1> 获得校验结果
        com.alibaba.dubbo.common.status.Status.Level level = status.getLevel();
        // <7.2> 如果是 ERROR 检验结果，则标记 hasError 为 true ，并标记 builder 状态为 down
        if (!hasError // 不存在 hasError 的时候
                && level.equals(com.alibaba.dubbo.common.status.Status.Level.ERROR)) {
            hasError = true;
            builder.down();
        }
        // <7.3> 如果是 UNKNOWN 检验结果，则标记 hasUnknown 为 true ，并标记 builder 状态为 unknown
        if (!hasError && !hasUnknown // 不存在 hasError 且不存在 hasUnknown
                && level.equals(com.alibaba.dubbo.common.status.Status.Level.UNKNOWN)) {
            hasUnknown = true;
            builder.unknown();
        }

        // <8.1> 创建 detail Map
        Map<String, Object> detail = new LinkedHashMap<>();
        // <8.2> 设置 detail 属性值
        detail.put("source", source);
        detail.put("status", status); // 校验结果
        // <8.3> 添加到 builder 中
        builder.withDetail(statusCheckerName, detail);
    }
}

// DubboHealthIndicator.java

/**
 * Resolves the map of {@link StatusChecker}'s name and its' source.
 *
 * 解析 StatusChecker 的名字的 Map
 *
 * KEY：StatusChecker 的名字
 * VALUE：配置的来源
 *
 * @return non-null {@link Map}
 */
protected Map<String, String> resolveStatusCheckerNamesMap() {
    // 创建 Map
    Map<String, String> statusCheckerNamesMap = new LinkedHashMap<>();
    // <1> 从 DubboHealthIndicatorProperties 中获取
    statusCheckerNamesMap.putAll(resolveStatusCheckerNamesMapFromDubboHealthIndicatorProperties());
    // <2> 从 ProtocolConfig 中获取
    statusCheckerNamesMap.putAll(resolveStatusCheckerNamesMapFromProtocolConfigs());
    // <3> 从 ProviderConfig 中获取
    statusCheckerNamesMap.putAll(resolveStatusCheckerNamesMapFromProviderConfig());
    return statusCheckerNamesMap;
}

// AbstractDubboEndpoint.java

protected ApplicationContext applicationContext;

protected ConfigurableEnvironment environment;

@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    this.applicationContext = applicationContext;
}

@Override
public void setEnvironment(Environment environment) {
    if (environment instanceof ConfigurableEnvironment) {
        this.environment = (ConfigurableEnvironment) environment;
    }
}

// AbstractDubboEndpoint.java

protected Map<String, Object> resolveBeanMetadata(final Object bean) {
    // 创建 Map
    final Map<String, Object> beanMetadata = new LinkedHashMap<>();
    try {
        // 获得 BeanInfo 对象
        BeanInfo beanInfo = Introspector.getBeanInfo(bean.getClass());
        // 获得 PropertyDescriptor 数组
        PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors();
        // 遍历 PropertyDescriptor 数组
        for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
            // 获得 Method 对象
            Method readMethod = propertyDescriptor.getReadMethod();
            // 读取属性，添加到 beanMetadata 中
            if (readMethod != null && isSimpleType(propertyDescriptor.getPropertyType())) {
                String name = Introspector.decapitalize(propertyDescriptor.getName());
                Object value = readMethod.invoke(bean);
                beanMetadata.put(name, value);
            }
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return beanMetadata;
}

private static boolean isSimpleType(Class<?> type) {
    return isPrimitiveOrWrapper(type) // 基本类型 or 包装类型
            || type == String.class
            || type == BigDecimal.class
            || type == BigInteger.class
            || type == Date.class
            || type == URL.class
            || type == Class.class
            ;
}

// AbstractDubboEndpoint.java

protected Map<String, ServiceBean> getServiceBeansMap() {
    return BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ServiceBean.class);
}

// AbstractDubboEndpoint.java

protected Map<String, ProtocolConfig> getProtocolConfigsBeanMap() {
    return BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, ProtocolConfig.class);
}

// AbstractDubboEndpoint.java

protected ReferenceAnnotationBeanPostProcessor getReferenceAnnotationBeanPostProcessor() {
    return applicationContext.getBean(ReferenceAnnotationBeanPostProcessor.BEAN_NAME, ReferenceAnnotationBeanPostProcessor.class);
}

// DubboEndpoint.java

/**
 * Actuator {@link Endpoint} to expose Dubbo Meta Data
 */
@Endpoint(id = "dubbo")
public class DubboEndpoint {

    @ReadOperation
    public Map<String, Object> invoke() {
        // 创建 Map
        Map<String, Object> metaData = new LinkedHashMap<>();

        // timestamp
        metaData.put("timestamp", System.currentTimeMillis());

        // versions
        Map<String, String> versions = new LinkedHashMap<>();
        versions.put("dubbo-spring-boot", Version.getVersion(DubboUtils.class, "1.0.0"));
        versions.put("dubbo", Version.getVersion());

        // urls
        Map<String, String> urls = new LinkedHashMap<>();
        urls.put("dubbo", DUBBO_GITHUB_URL);
        urls.put("mailing-list", DUBBO_MAILING_LIST);
        urls.put("github", DUBBO_SPRING_BOOT_GITHUB_URL);
        urls.put("issues", DUBBO_SPRING_BOOT_ISSUES_URL);
        urls.put("git", DUBBO_SPRING_BOOT_GIT_URL);

        metaData.put("versions", versions);
        metaData.put("urls", urls);
        return metaData;
    }

}

// DubboConfigsMetadataEndpoint.java

/**
 * Dubbo Configs Metadata {@link Endpoint}
 */
@Endpoint(id = "dubboconfigs")
public class DubboConfigsMetadataEndpoint extends AbstractDubboEndpoint {

    @ReadOperation
    public Map<String, Map<String, Map<String, Object>>> configs() {
        // 创建 Map
        // KEY：获得类的简称。例如：ApplicationConfig、ConsumerConfig
        // KEY2：Bean 的名称
        // VALUE：Bean 的元数据
        Map<String, Map<String, Map<String, Object>>> configsMap = new LinkedHashMap<>();

        // 遍历每个配置类，添加其的 Bean 们，到 configsMap 中
        addDubboConfigBeans(ApplicationConfig.class, configsMap);
        addDubboConfigBeans(ConsumerConfig.class, configsMap);
        addDubboConfigBeans(MethodConfig.class, configsMap);
        addDubboConfigBeans(ModuleConfig.class, configsMap);
        addDubboConfigBeans(MonitorConfig.class, configsMap);
        addDubboConfigBeans(ProtocolConfig.class, configsMap);
        addDubboConfigBeans(ProviderConfig.class, configsMap);
        addDubboConfigBeans(ReferenceConfig.class, configsMap);
        addDubboConfigBeans(RegistryConfig.class, configsMap);
        addDubboConfigBeans(ServiceConfig.class, configsMap);
        return configsMap;
    }

    private void addDubboConfigBeans(Class<? extends AbstractConfig> dubboConfigClass, Map<String, Map<String, Map<String, Object>>> configsMap) {
        // 获得指定类 dubboConfigClass 的 Map
        Map<String, ? extends AbstractConfig> dubboConfigBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(applicationContext, dubboConfigClass);
        // 获得类的简称。例如：ApplicationConfig、ConsumerConfig
        String name = dubboConfigClass.getSimpleName();
        // 创建 Map
        Map<String, Map<String, Object>> beansMetadata = new TreeMap<>();
        // 遍历 dubboConfigBeans 数组
        for (Map.Entry<String, ? extends AbstractConfig> entry : dubboConfigBeans.entrySet()) {
            // 获得 Bean 的名字
            String beanName = entry.getKey();
            // 获得 Bean 的元数据
            AbstractConfig configBean = entry.getValue();
            Map<String, Object> configBeanMeta = super.resolveBeanMetadata(configBean);
            // 添加到 beansMetadata 中
            beansMetadata.put(beanName, configBeanMeta);
        }
        // 添加到 configsMap 中
        configsMap.put(name, beansMetadata);
    }

}

// DubboPropertiesEndpoint.java

/**
 * Dubbo Properties {@link Endpoint}
 */
@Endpoint(id = "dubboproperties")
public class DubboPropertiesEndpoint extends AbstractDubboEndpoint {

    @ReadOperation
    public SortedMap<String, Object> properties() {
        return DubboUtils.filterDubboProperties(environment);
    }

}

// DubboReferencesMetadataEndpoint.java

/**
 * Dubbo {@link Reference} Metadata {@link Endpoint}
 */
@Endpoint(id = "dubboreferences")
public class DubboReferencesMetadataEndpoint extends AbstractDubboEndpoint {

    @ReadOperation
    public Map<String, Map<String, Object>> references() {
        // 创建 Map
        // KEY：Bean 的名字
        // VALUE：Bean 的元数据
        Map<String, Map<String, Object>> referencesMetadata = new LinkedHashMap<>();

        // 获得 ReferenceAnnotationBeanPostProcessor Bean 对象
        ReferenceAnnotationBeanPostProcessor beanPostProcessor = super.getReferenceAnnotationBeanPostProcessor();

        // injected Field ReferenceBean Cache
        referencesMetadata.putAll(buildReferencesMetadata(beanPostProcessor.getInjectedFieldReferenceBeanMap()));
        // injected Method ReferenceBean Cache
        referencesMetadata.putAll(buildReferencesMetadata(beanPostProcessor.getInjectedMethodReferenceBeanMap()));
        return referencesMetadata;
    }

    private Map<String, Map<String, Object>> buildReferencesMetadata(Map<InjectionMetadata.InjectedElement, ReferenceBean<?>> injectedElementReferenceBeanMap) {
        // 创建 Map
        // KEY：Bean 的名字
        // VALUE：Bean 的元数据
        Map<String, Map<String, Object>> referencesMetadata = new LinkedHashMap<>();
        // 遍历 injectedElementReferenceBeanMap 元素
        for (Map.Entry<InjectionMetadata.InjectedElement, ReferenceBean<?>> entry : injectedElementReferenceBeanMap.entrySet()) {
            InjectionMetadata.InjectedElement injectedElement = entry.getKey();
            // 获得 ReferenceBean 对象
            ReferenceBean<?> referenceBean = entry.getValue();
            // 获得 Bean 元数据
            Map<String, Object> beanMetadata = super.resolveBeanMetadata(referenceBean);
            // 获得 invoker 属性
            beanMetadata.put("invoker", super.resolveBeanMetadata(referenceBean.get()));
            // 添加到 referencesMetadata 中
            referencesMetadata.put(String.valueOf(injectedElement.getMember()), beanMetadata);
        }
        return referencesMetadata;
    }

}

// DubboServicesMetadataEndpoint.java

/**
 * Dubbo {@link Service} Metadata {@link Endpoint}
 */
@Endpoint(id = "dubboservices")
public class DubboServicesMetadataEndpoint extends AbstractDubboEndpoint {

    @ReadOperation
    public Map<String, Map<String, Object>> services() {
        // 获得所有的 ServiceBean
        Map<String, ServiceBean> serviceBeansMap = super.getServiceBeansMap();
        // 创建 Map
        // KEY：Bean 的名字
        // VALUE：Bean 的元数据
        Map<String, Map<String, Object>> servicesMetadata = new LinkedHashMap<>(serviceBeansMap.size());

        // 遍历 serviceBeansMap 元素
        for (Map.Entry<String, ServiceBean> entry : serviceBeansMap.entrySet()) {
            // 获得 Bean 的名字
            String serviceBeanName = entry.getKey();
            // 获得 ServiceBean 对象
            ServiceBean serviceBean = entry.getValue();
            // 获得 Bean 的元数据
            Map<String, Object> serviceBeanMetadata = super.resolveBeanMetadata(serviceBean);
            // 获得 Service 对象。若获得到，则添加到 serviceBeanMetadata 中
            Object service = resolveServiceBean(serviceBeanName, serviceBean);
            if (service != null) {
                // Add Service implementation class
                serviceBeanMetadata.put("serviceClass", service.getClass().getName());
            }
            // 添加到 servicesMetadata 中
            servicesMetadata.put(serviceBeanName, serviceBeanMetadata);
        }
        return servicesMetadata;
    }

    private Object resolveServiceBean(String serviceBeanName, ServiceBean serviceBean) {
        int index = serviceBeanName.indexOf("#");
        if (index > -1) {
            Class<?> interfaceClass = serviceBean.getInterfaceClass();
            String serviceName = serviceBeanName.substring(index + 1);
            if (applicationContext.containsBean(serviceName)) {
                return applicationContext.getBean(serviceName, interfaceClass);
            }
        }
        return null;
    }

}

// DubboShutdownEndpoint.java

/**
 * Dubbo Shutdown
 */
@Endpoint(id = "dubboshutdown")
public class DubboShutdownEndpoint extends AbstractDubboEndpoint {

    @WriteOperation
    public Map<String, Object> shutdown() throws Exception {
        // 创建 Map
        Map<String, Object> shutdownCountData = new LinkedHashMap<>();

        // registries
        // 获得注册的数量
        int registriesCount = AbstractRegistryFactory.getRegistries().size();
        // protocols
        // 获得 Protocol 的数量
        int protocolsCount = super.getProtocolConfigsBeanMap().size();
        // 销毁 ProtocolConfig
        ProtocolConfig.destroyAll();
        // 添加到 shutdownCountData 中
        shutdownCountData.put("registries", registriesCount);
        shutdownCountData.put("protocols", protocolsCount);

        // Service Beans
        // 获得所有 ServiceBean ，然后逐个销毁
        Map<String, ServiceBean> serviceBeansMap = super.getServiceBeansMap();
        if (!serviceBeansMap.isEmpty()) {
            for (ServiceBean serviceBean : serviceBeansMap.values()) {
                serviceBean.destroy();
            }
        }
        // 添加到 shutdownCountData 中
        shutdownCountData.put("services", serviceBeansMap.size());

        // Reference Beans
        // 获得 ReferenceAnnotationBeanPostProcessor 对象
        ReferenceAnnotationBeanPostProcessor beanPostProcessor = super.getReferenceAnnotationBeanPostProcessor();
        // 获得 Reference Bean 的数量
        int referencesCount = beanPostProcessor.getReferenceBeans().size();
        // 销毁所有 Reference Bean
        beanPostProcessor.destroy();
        // 添加到 shutdownCountData 中
        shutdownCountData.put("references", referencesCount);

        // Set Result to complete
        Map<String, Object> shutdownData = new TreeMap<>();
        shutdownData.put("shutdown.count", shutdownCountData);
        return shutdownData;
    }

}