15-Dubbo的三大中心之元数据中心源码解析

    元数据中心在2.7.x版本开始支持，随着应用级别的服务注册和服务发现在Dubbo中落地，元数据中心也变的越来越重要。在以下几种情况下会需要部署元数据中心：

    • 对于一个原先采用老版本Dubbo搭建的应用服务，在迁移到Dubbo 3时，Dubbo 3 会需要一个元数据中心来维护RPC服务与应用的映射关系（即接口与应用的映射关系），因为如果采用了应用级别的服务发现和服务注册，在注册中心中将采用“应用 —— 实例列表”结构的数据组织形式，不再是以往的“接口 —— 实例列表”结构的数据组织形式，而以往用接口级别的服务注册和服务发现的应用服务在迁移到应用级别时，得不到接口与应用之间的对应关系，从而无法从注册中心得到实例列表信息，所以Dubbo为了兼容这种场景，在Provider端启动时，会往元数据中心存储接口与应用的映射关系。
    • 为了让注册中心更加聚焦与地址的发现和推送能力，减轻注册中心的负担，元数据中心承载了所有的服务元数据、大量接口/方法级别配置信息等，无论是接口粒度还是应用粒度的服务发现和注册，元数据中心都起到了重要的作用。
    • 如果有以上两种需求，都可以选择部署元数据中心，并通过Dubbo的配置来集成该元数据中心。

    元数据中心并不依赖于注册中心和配置中心，用户可以自由选择是否集成和部署元数据中心，如下图所示：

    该图中不配备配置中心，意味着可以不需要全局管理配置的能力。该图中不配备注册中心，意味着可能采用了Dubbo mesh的方案，也可能不需要进行服务注册，仅仅接收直连模式的服务调用。
    官网参考文章地址:

    综上所述可以用几句话概括下:

    • 元数据中心来维护RPC服务与应用的映射关系（即接口与应用的映射关系）来兼容接口与应用之间的对应关系
    • 让注册中心更加聚焦与地址的发现和推送能力

    注册中心的启动是在DefaultApplicationDeployer中的初始化方法 initialize() 中:如下所示

    这里只看下 startMetadataCenter();方法即可

    15.2 深入探究元数据中心的启动过程

    关于元数据中心我们看下 startMetadataCenter()方法来大致了解下整个流程

    2.         //如果未配置元数据中心的地址等配置则使用注册中心的地址等配置做为元数据中心的配置
    3.         useRegistryAsMetadataCenterIfNecessary();
    4.         //获取应用的配置信息
    5.         ApplicationConfig applicationConfig = getApplication();
    6.         //元数据配置类型 元数据类型， local 或 remote,，如果选择远程，则需要进一步指定元数据中心
    7.         String metadataType = applicationConfig.getMetadataType();
    8.         // FIXME, multiple metadata config support.
    9.         //查询元数据中心的地址等配置
    10.         Collection<MetadataReportConfig> metadataReportConfigs = configManager.getMetadataConfigs();
    12.         if (CollectionUtils.isEmpty(metadataReportConfigs)) {
    13.         //这个就是判断 如果选择远程，则需要进一步指定元数据中心 否则就抛出来异常
    14.             if (REMOTE_METADATA_STORAGE_TYPE.equals(metadataType)) {
    15.                 throw new IllegalStateException("No MetadataConfig found, Metadata Center address is required when 'metadata=remote' is enabled.");
    16.             }
    17.             return;
    18.         }
    19.         //MetadataReport实例的存储库对象获取
    20.         MetadataReportInstance metadataReportInstance = applicationModel.getBeanFactory().getBean(MetadataReportInstance.class);
    21.         List<MetadataReportConfig> validMetadataReportConfigs = new ArrayList<>(metadataReportConfigs.size());
    22.         for (MetadataReportConfig metadataReportConfig : metadataReportConfigs) {
    23.             ConfigValidationUtils.validateMetadataConfig(metadataReportConfig);
    24.             validMetadataReportConfigs.add(metadataReportConfig);
    25.         }
    26.         //初始化元数据
    27.         metadataReportInstance.init(validMetadataReportConfigs);
    28.         //MetadataReport实例的存储库对象初始化失败则抛出异常
    29.         if (!metadataReportInstance.inited()) {
    30.             throw new IllegalStateException(String.format("%s MetadataConfigs found, but none of them is valid.", metadataReportConfigs.size()));
    31.         }
    32.     }

    前面在说配置中心的时候有说过配置中心如果未配置会使用注册中心的地址等信息作为默认配置,这里元数据做了类似的操作:如代码:
    DefaultApplicationDeployer类型的 useRegistryAsMetadataCenterIfNecessary()方法

    1. private void useRegistryAsMetadataCenterIfNecessary() {
    2.         //配置缓存中查询元数据配置
    3.         Collection<MetadataReportConfig> metadataConfigs = configManager.getMetadataConfigs();
    4.         //配置存在则直接返回
    5.         if (CollectionUtils.isNotEmpty(metadataConfigs)) {
    6.             return;
    7.         }
    8.         ////查询是否有注册中心设置了默认配置isDefault 设置为true的注册中心则为默认注册中心列表,如果没有注册中心设置为默认注册中心,则获取所有未设置默认配置的注册中心列表
    9.         List<RegistryConfig> defaultRegistries = configManager.getDefaultRegistries();
    10.         if (defaultRegistries.size() > 0) {
    11.         //多注册中心遍历
    12.             defaultRegistries
    13.                 .stream()
    14.                 //筛选符合条件的注册中心 (筛选逻辑就是查看是否有对应协议的扩展支持)
    15.                 .filter(this::isUsedRegistryAsMetadataCenter)
    16.                 //注册中心配置映射为元数据中心  映射就是获取需要的配置
    17.                 .map(this::registryAsMetadataCenter)
    18.                 //将元数据中心配置存储在配置缓存中方便后续使用
    19.                 .forEach(metadataReportConfig -> {
    21.                     if (metadataReportConfig.getId() == null) {
    22.                         Collection<MetadataReportConfig> metadataReportConfigs = configManager.getMetadataConfigs();
    23.                         if (CollectionUtils.isNotEmpty(metadataReportConfigs)) {
    24.                             for (MetadataReportConfig existedConfig : metadataReportConfigs) {
    25.                                 if (existedConfig.getId() == null && existedConfig.getAddress().equals(metadataReportConfig.getAddress())) {
    26.                                     return;
    27.                                 }
    28.                             }
    29.                         }
    30.                         configManager.addMetadataReport(metadataReportConfig);
    31.                     } else {
    32.                         Optional<MetadataReportConfig> configOptional = configManager.getConfig(MetadataReportConfig.class, metadataReportConfig.getId());
    33.                         if (configOptional.isPresent()) {
    34.                             return;
    35.                         }
    36.                         configManager.addMetadataReport(metadataReportConfig);
    37.                     }
    38.                     logger.info("use registry as metadata-center: " + metadataReportConfig);
    39.                 });
    40.         }
    41.     }

    这个代码有些细节就不细说了 我们概括下顺序梳理下思路:

    • 配置缓存中查询元数据配置,配置存在则直接返回
    • 查询所有可用的默认注册中心列表
      • 多注册中心遍历
      • 选符合条件的注册中心 (筛选逻辑就是查看是否有对应协议的扩展支持)
      • 注册中心配置RegistryConfig映射转换为元数据中心配置类型MetadataReportConfig 映射就是获取需要的配置
      • 将元数据中心配置存储在配置缓存中方便后续使用

    元数据的配置可以参考官网:元数据参考手册

    这里主要看下可配置项有哪些 对应类型为MetadataReportConfig 在官网暂时未找到合适的文档,这里整理下属性列表方便后续配置说明查看:

    15.2.3.1 元数据中心的初始化调用逻辑

    主要看这一行比较重要的逻辑:

    1. //初始化元数据
    2. metadataReportInstance.init(validMetadataReportConfigs);

    在了解这一行逻辑之前我们先来看下元数据相关联的类型:

    MetadataReportInstance中的初始化方法init

    1. public void init(List<MetadataReportConfig> metadataReportConfigs) {
    2.         //CAS判断是否有初始化过
    3.        if (!init.compareAndSet(false, true)) {
    4.            return;
    5.        }
    6.     //元数据类型配置如果未配置则默认为local 
    7.        this.metadataType = applicationModel.getApplicationConfigManager().getApplicationOrElseThrow().getMetadataType();
    8.        if (metadataType == null) {
    9.            this.metadataType = DEFAULT_METADATA_STORAGE_TYPE;
    10.        }
    11.     //获取MetadataReportFactory 工厂类型
    12.        MetadataReportFactory metadataReportFactory = applicationModel.getExtensionLoader(MetadataReportFactory.class).getAdaptiveExtension();
    13.            //多元数据中心初始化
    14.        for (MetadataReportConfig metadataReportConfig : metadataReportConfigs) {
    15.            init(metadataReportConfig, metadataReportFactory);
    16.        }
    17.    }
    19.    private void init(MetadataReportConfig config, MetadataReportFactory metadataReportFactory) {
    20.    //配置转url
    21.        URL url = config.toUrl();
    22.        if (METADATA_REPORT_KEY.equals(url.getProtocol())) {
    23.            String protocol = url.getParameter(METADATA_REPORT_KEY, DEFAULT_DIRECTORY);
    24.            url = URLBuilder.from(url)
    25.                    .setProtocol(protocol)
    26.                    .setScopeModel(config.getScopeModel())
    27.                    .removeParameter(METADATA_REPORT_KEY)
    28.                    .build();
    29.        }
    30.        url = url.addParameterIfAbsent(APPLICATION_KEY, applicationModel.getCurrentConfig().getName());
    31.        String relatedRegistryId = isEmpty(config.getRegistry()) ? (isEmpty(config.getId()) ? DEFAULT_KEY : config.getId()) : config.getRegistry();
    32.         //从元数据工厂中获取元数据
    33.        MetadataReport metadataReport = metadataReportFactory.getMetadataReport(url);
    34.        //缓存元数据到内存
    35.        if (metadataReport != null) {
    36.            metadataReports.put(relatedRegistryId, metadataReport);
    37.        }
    38.    }

    关于元数据的初始化我们主要看两个位置:

    • 一个是元数据工厂对象的创建与初始化MetadataReportFactory
    • 一个是元数据对象的创建与初始化MetadataReport

    15.2.3.2 元数据工厂对象MetadataReportFactory

    我们这里主要以为Zookeeper扩展的元数据工厂ZookeeperMetadataReportFactory类型为例子:
    实现类型逻辑不复杂,这里就直接贴代码看看:

    1. public class ZookeeperMetadataReportFactory extends AbstractMetadataReportFactory {
    2.     //与Zookeeper交互的传输器
    3.     private ZookeeperTransporter zookeeperTransporter;
    4.     //应用程序模型
    5.     private ApplicationModel applicationModel;
    7.     public ZookeeperMetadataReportFactory(ApplicationModel applicationModel) {
    8.         this.applicationModel = applicationModel;
    9.         this.zookeeperTransporter = ZookeeperTransporter.getExtension(applicationModel);
    10.     }
    12.     @DisableInject
    13.     public void setZookeeperTransporter(ZookeeperTransporter zookeeperTransporter) {
    14.         this.zookeeperTransporter = zookeeperTransporter;
    15.     }
    17.     @Override
    18.     public MetadataReport createMetadataReport(URL url) {
    19.         return new ZookeeperMetadataReport(url, zookeeperTransporter);
    20.     }
    22. }

    元数据工厂的实现比较简单

    • 实现工厂方法createMetadataReport来创建一个元数据操作类型

    如果我们想要实现一个元数据工厂扩展可以参考Zookeeper的这个方式

    15.2.3.3 元数据操作对象MetadataReport的创建与初始化

    前面的从元数据工厂中获取元数据操作对象的逻辑处理代码如下:

    1. //从元数据工厂中获取元数据 ,url对象可以理解为配置
    2.  MetadataReport metadataReport = metadataReportFactory.getMetadataReport(url);

    关于元数据对象,用于元数据信息的增删改查等逻辑的操作与元数据信息的缓存

    在这里插入图片描述

    我们这里还是以Zookeeper的实现ZookeeperMetadataReportFactory类型做为参考:

    我们先来看这个逻辑

    1. //从元数据工厂中获取元数据 ,url对象可以理解为配置
    2.  MetadataReport metadataReport = metadataReportFactory.getMetadataReport(url);

    ZookeeperMetadataReportFactory的父类型AbstractMetadataReportFactory中的getMetadataReport方法如下:

    上面这个抽象类AbstractMetadataReportFactory中的获取元数据操作对象的模版方法getMetadataReport(URL url), 用了双重校验锁的逻辑来创建对象缓存对象,又用了模版方法设计模式,来让抽象类做通用的逻辑,让实现类型去做扩展, 虽然代码写的太长了些整体还是用了不少的设计思想.

    我们直接看这个代码:

    1. metadataReport = createMetadataReport(url);

    这个创建元数据操作对象的代码实际上走的是实现类型的逻辑:

    来自工厂Bean ZookeeperMetadataReportFactory的工厂方法如下所示:

    1. @Override
    2.     public MetadataReport createMetadataReport(URL url) {
    3.         return new ZookeeperMetadataReport(url, zookeeperTransporter);
    4.     }

    创建了元数据操作对象,这里我们继续看下元数据操作对象ZookeeperMetadataReport创建做了哪些逻辑:
    来自ZookeeperMetadataReport的构造器:

    1. public ZookeeperMetadataReport(URL url, ZookeeperTransporter zookeeperTransporter) {
    2.         //url即配置 配置传递给抽象类 做一些公共的逻辑
    3.         //url参考:zookeeper://127.0.0.1:2181/org.apache.dubbo.metadata.report.MetadataReport?application=dubbo-demo-api-provider&client=&port=2181&protocol=zookeeper
    5.         if (url.isAnyHost()) {
    6.             throw new IllegalStateException("registry address == null");
    7.         }
    8.         String group = url.getGroup(DEFAULT_ROOT);
    9.         if (!group.startsWith(PATH_SEPARATOR)) {
    10.             group = PATH_SEPARATOR + group;
    11.         }
    12.         this.root = group;
    13.         //连接Zookeeper
    14.         zkClient = zookeeperTransporter.connect(url);
    15.     }

    核心的公共的操作逻辑封装在父类AbstractMetadataReport里面
    我们来看前面super调用的构造器逻辑:
    如下所示:

    1. public AbstractMetadataReport(URL reportServerURL) {
    2. //设置url 如:zookeeper://127.0.0.1:2181/org.apache.dubbo.metadata.report.MetadataReport?application=dubbo-demo-api-provider&client=&port=2181&protocol=zookeeper
    3.        setUrl(reportServerURL);
    4.        // Start file save timer
    5.        //缓存的文件名字
    6.        //格式为: 用户目录+/.dubbo/dubbo-metadata- + 应用程序名字application + url地址(IP+端口) + 后缀.cache 如下所示
    7.        ///Users/song/.dubbo/dubbo-metadata-dubbo-demo-api-provider-127.0.0.1-2181.cache
    8.        String defaultFilename = System.getProperty(USER_HOME) + DUBBO_METADATA +
    9.            reportServerURL.getApplication() + "-" +
    10.            replace(reportServerURL.getAddress(), ":", "-") + CACHE;
    11.            //如果用户配置了缓存文件名字则以用户配置为准file
    12.        String filename = reportServerURL.getParameter(FILE_KEY, defaultFilename);
    13.        File file = null;
    14.        //文件名字不为空
    15.        if (ConfigUtils.isNotEmpty(filename)) {
    16.            file = new File(filename);
    17.            //文件和父目录不存在则创建文件目录
    18.            if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) {
    19.                if (!file.getParentFile().mkdirs()) {
    20.                    throw new IllegalArgumentException("Invalid service store file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");
    21.                }
    22.            }
    23.            // if this file exists, firstly delete it.
    24.            //还未初始化则已存在的历史文件删除掉
    25.            if (!initialized.getAndSet(true) && file.exists()) {
    26.                file.delete();
    27.            }
    28.        }
    29.        //赋值给成员变量后续继续可以用
    30.        this.file = file;
    31.        //文件存在则直接加载文件中的内容
    32.        loadProperties();
    33.        //sync-report配置的值为同步配置还异步配置,true是同步配置,默认为false为异步配置
    34.        syncReport = reportServerURL.getParameter(SYNC_REPORT_KEY, false);
    35.        //重试属性与逻辑也封装了一个类型 创建对象
    36.        //retry-times重试次数配置 默认为100次
    37.        //retry-period 重试间隔配置 默认为3000
    38.        metadataReportRetry = new MetadataReportRetry(reportServerURL.getParameter(RETRY_TIMES_KEY, DEFAULT_METADATA_REPORT_RETRY_TIMES),
    39.            reportServerURL.getParameter(RETRY_PERIOD_KEY, DEFAULT_METADATA_REPORT_RETRY_PERIOD));
    41.        // cycle report the data switch
    42.        //是否定期从元数据中心同步配置
    43.        //cycle-report配置默认为true
    44.        if (reportServerURL.getParameter(CYCLE_REPORT_KEY, DEFAULT_METADATA_REPORT_CYCLE_REPORT)) {
    45.        //开启重试定时器 24个小时间隔从元数据中心同步一次
    46.            reportTimerScheduler = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("DubboMetadataReportTimer", true));
    47.            reportTimerScheduler.scheduleAtFixedRate(this::publishAll, calculateStartTime(), ONE_DAY_IN_MILLISECONDS, TimeUnit.MILLISECONDS);
    48.        }
    50.        this.reportMetadata = reportServerURL.getParameter(REPORT_METADATA_KEY, false);
    51.        this.reportDefinition = reportServerURL.getParameter(REPORT_DEFINITION_KEY, true);
    52.    }

    15.2.3.4 内存中元数据自动同步到Zookeeper和本地文件

    这里来总结下元数据操作的初始化逻辑:

    • 首次初始化清理历史元数据文件如:
      Users/song/.dubbo/dubbo-metadata-dubbo-demo-api-provider-127.0.0.1-2181.cache
    • 如果非首次进来则直接加载缓存在本地的缓存文件,赋值给properties成员变量
    • 初始化同步配置是否异步(默认为false), sync-report配置的值为同步配置还异步配置,true是同步配置,默认为false为异步配置
    • 初始化重试属性
    • 是否定期从元数据中心同步配置初始化 默认为true 24小时自动同步一次
    1. reportTimerScheduler = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("DubboMetadataReportTimer", true));
    2.           reportTimerScheduler.scheduleAtFixedRate(this::publishAll, calculateStartTime(), ONE_DAY_IN_MILLISECONDS, TimeUnit.MILLISECONDS);

    这里有个方法叫做calculateStartTime 这个代码是随机时间的between 2:00 am to 6:00 am, the time is random. 2点到6点之间启动, 低峰期启动自动同步
    返回值:

    AbstractMetadataReport类型的

    1. void publishAll() {
    2.       logger.info("start to publish all metadata.");
    3.       this.doHandleMetadataCollection(allMetadataReports);
    4.   }

    AbstractMetadataReport类型的doHandleMetadataCollection

    1. private boolean doHandleMetadataCollection(Map<MetadataIdentifier, Object> metadataMap) {
    2.         if (metadataMap.isEmpty()) {
    3.             return true;
    4.         }
    5.         Iterator<Map.Entry<MetadataIdentifier, Object>> iterable = metadataMap.entrySet().iterator();
    6.         while (iterable.hasNext()) {
    7.             Map.Entry<MetadataIdentifier, Object> item = iterable.next();
    8.             if (PROVIDER_SIDE.equals(item.getKey().getSide())) {
    9.                 //提供端的元数据则存储提供端元数据
    10.                 this.storeProviderMetadata(item.getKey(), (FullServiceDefinition) item.getValue());
    11.             } else if (CONSUMER_SIDE.equals(item.getKey().getSide())) {
    12.             //消费端的元数据则存储提供端元数据
    13.                 this.storeConsumerMetadata(item.getKey(), (Map) item.getValue());
    14.             }
    16.         }
    17.         return false;
    18.     }

    提供端元数据的存储:
    AbstractMetadataReport类型的storeProviderMetadata

    AbstractMetadataReport类型的storeProviderMetadataTask
    具体同步代码:storeProviderMetadataTask

    1. private void storeProviderMetadataTask(MetadataIdentifier providerMetadataIdentifier, ServiceDefinition serviceDefinition) {
    2.         try {
    3.             if (logger.isInfoEnabled()) {
    4.                 logger.info("store provider metadata. Identifier : " + providerMetadataIdentifier + "; definition: " + serviceDefinition);
    5.             }
    6.             allMetadataReports.put(providerMetadataIdentifier, serviceDefinition);
    7.             failedReports.remove(providerMetadataIdentifier);
    8.             Gson gson = new Gson();
    9.             String data = gson.toJson(serviceDefinition);
    10.              //内存中的元数据同步到元数据中心
    11.             doStoreProviderMetadata(providerMetadataIdentifier, data);
    12.             //内存中的元数据同步到本地文件
    13.             saveProperties(providerMetadataIdentifier, data, true, !syncReport);
    14.         } catch (Exception e) {
    15.             // retry again. If failed again, throw exception.
    16.             failedReports.put(providerMetadataIdentifier, serviceDefinition);
    17.             metadataReportRetry.startRetryTask();
    18.             logger.error("Failed to put provider metadata " + providerMetadataIdentifier + " in  " + serviceDefinition + ", cause: " + e.getMessage(), e);
    19.         }
    20.     }

    上面代码我们主要看本地内存中的元数据同步到元数据中心和存本地的两个点:

    1. //内存中的元数据同步到元数据中心
    2. doStoreProviderMetadata(providerMetadataIdentifier, data);
    3. //内存中的元数据同步到本地文件
    4. saveProperties(providerMetadataIdentifier, data, true,

    //内存中的元数据同步到元数据中心

    这个方法会调用当前子类重写的具体存储逻辑:这里我们以
    ZookeeperMetadataReport的doStoreProviderMetadata举例:

    1. private void storeMetadata(MetadataIdentifier metadataIdentifier, String v) {
    2.         //使用zkClient创建一个节点数据为参数V v是前面说的服务定义数据
    3.      zkClient.create(getNodePath(metadataIdentifier), v, false);
    4.  }

    这里参数我们举个例子: 提供者的元数据内容如下:
    节点路径为:

    • /dubbo/metadata/link.elastic.dubbo.entity.DemoService/provider/dubbo-demo-api-provider

    格式:

    • /dubbo/metadata前缀
    • 服务提供者接口
    • 提供者类型provider
    • 应用名

    具体的元数据内容如下:
    比较详细的记录了应用信息,服务接口信息和服务接口对应的方法信息

    1. {
    2.   "parameters": {
    3.     "side": "provider",
    4.     "interface": "link.elastic.dubbo.entity.DemoService",
    5.     "pid": "38680",
    6.     "application": "dubbo-demo-api-provider",
    7.     "dubbo": "2.0.2",
    8.     "release": "3.0.8",
    9.     "anyhost": "true",
    10.     "bind.ip": "192.168.1.9",
    11.     "methods": "sayHello,sayHelloAsync",
    12.     "background": "false",
    13.     "deprecated": "false",
    14.     "dynamic": "true",
    15.     "service-name-mapping": "true",
    16.     "generic": "false",
    17.     "bind.port": "20880",
    18.     "timestamp": "1653097653865"
    19.   },
    20.   "canonicalName": "link.elastic.dubbo.entity.DemoService",
    21.   "methods": [
    22.     {
    23.       "name": "sayHello",
    24.       "parameterTypes": [
    25.         "java.lang.String"
    26.       ],
    27.       "returnType": "java.lang.String",
    28.       "annotations": [
    30.       ]
    32.     {
    33.       "name": "sayHelloAsync",
    34.       "parameterTypes": [
    35.         "java.lang.String"
    36.       ],
    37.       "returnType": "java.util.concurrent.CompletableFuture",
    38.       "annotations": [
    40.       ]
    41.     }
    42.   ],
    43.   "types": [
    44.     {
    45.       "type": "java.util.concurrent.CompletableFuture",
    46.       "properties": {
    47.         "result": "java.lang.Object",
    48.         "stack": "java.util.concurrent.CompletableFuture.Completion"
    49.       }
    50.     },
    51.     {
    52.       "type": "java.lang.Object"
    53.     },
    54.     {
    55.       "type": "java.lang.String"
    56.     },
    57.     {
    58.       "type": "java.util.concurrent.CompletableFuture.Completion",
    59.       "properties": {
    60.         "next": "java.util.concurrent.CompletableFuture.Completion",
    61.         "status": "int"
    62.       }
    63.     },
    64.     {
    65.       "type": "int"
    66.     }
    67.   ],
    68.   "annotations": [
    70.   ]
    71. }

    本地缓存文件的写入 可以看下如下代码
    AbstractMetadataReport类型的saveProperties方法

    1. private void saveProperties(MetadataIdentifier metadataIdentifier, String value, boolean add, boolean sync) {
    2.        if (file == null) {
    3.            return;
    4.        }
    6.        try {
    7.            if (add) {
    8.                properties.setProperty(metadataIdentifier.getUniqueKey(KeyTypeEnum.UNIQUE_KEY), value);
    9.            } else {
    10.                properties.remove(metadataIdentifier.getUniqueKey(KeyTypeEnum.UNIQUE_KEY));
    11.            }
    12.            long version = lastCacheChanged.incrementAndGet();
    13.            if (sync) {
    14.                //获取最新修改版本持久化到磁盘
    15.                new SaveProperties(version).run();
    16.            } else {
    17.                reportCacheExecutor.execute(new SaveProperties(version));
    18.            }
    20.        } catch (Throwable t) {
    21.            logger.warn(t.getMessage(), t);
    22.        }
    23.    }

    主要看如下代码:

    1. new SaveProperties(version).run();

    SaveProperties类型代码如下:

    1. private class SaveProperties implements Runnable {
    2.       private long version;
    4.       private SaveProperties(long version) {
    5.           this.version = version;
    6.       }
    8.       @Override
    9.       public void run() {
    10.           doSaveProperties(version);
    11.       }
    12.   }

    继续看doSaveProperties方法:

    写入文件的内容大致如下

    1. link.elastic.dubbo.entity.DemoService:::provider:dubbo-demo-api-provider -> {
    2.   "parameters": {
    3.     "side": "provider",
    4.     "interface": "link.elastic.dubbo.entity.DemoService",
    5.     "pid": "41457",
    6.     "application": "dubbo-demo-api-provider",
    7.     "dubbo": "2.0.2",
    8.     "release": "3.0.8",
    9.     "anyhost": "true",
    10.     "bind.ip": "192.168.1.9",
    11.     "methods": "sayHello,sayHelloAsync",
    12.     "background": "false",
    13.     "deprecated": "false",
    14.     "dynamic": "true",
    15.     "service-name-mapping": "true",
    16.     "generic": "false",
    17.     "bind.port": "20880",
    18.     "timestamp": "1653100253548"
    19.   },
    20.   "canonicalName": "link.elastic.dubbo.entity.DemoService",
    21.   "codeSource": "file:/Users/song/Desktop/Computer/A/code/gitee/weaving-a-net/weaving-test/dubbo-test/target/classes/",
    22.   "methods": [
    23.     {
    24.       "name": "sayHelloAsync",
    25.       "parameterTypes": [
    26.         "java.lang.String"
    27.       ],
    28.       "returnType": "java.util.concurrent.CompletableFuture",
    29.       "annotations": [
    31.       ]
    32.     },
    33.     {
    34.       "name": "sayHello",
    35.       "parameterTypes": [
    36.         "java.lang.String"
    37.       ],
    38.       "returnType": "java.lang.String",
    39.       "annotations": [
    41.       ]
    42.     }
    43.   ],
    44.   "types": [
    45.     {
    46.       "type": "java.util.concurrent.CompletableFuture",
    47.       "properties": {
    48.         "result": "java.lang.Object",
    49.         "stack": "java.util.concurrent.CompletableFuture.Completion"
    50.       }
    51.     },
    52.     {
    53.       "type": "java.lang.Object"
    54.     },
    55.     {
    56.       "type": "java.lang.String"
    57.     },
    58.     {
    59.       "type": "java.util.concurrent.CompletableFuture.Completion",
    60.       "properties": {
    61.         "next": "java.util.concurrent.CompletableFuture.Completion",
    62.         "status": "int"
    63.       }
    64.     },
    65.     {
    66.       "type": "int"
    67.     }
    68.   ],
    69.   "annotations": [
    72. }