Dubbo 服务本地缓存

最新推荐文章于 2024-09-06 09:17:12 发布
最新推荐文章于 2024-09-06 09:17:12 发布
阅读量2k 收藏 2
点赞数
分类专栏： java 文章标签： dubbo 缓存 java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67391377/article/details/126581067
版权

开篇

  • 根据官方图，dubbo调用者需要通过注册中心（例如：ZK）注册信息，获取提供者，但是如果频繁往ZK获取信息，肯定会存在单点故障问题，所以dubbo提供了将提供者信息缓存在本地的方法。

  • Dubbo在订阅注册中心的回调处理逻辑当中会保存服务提供者信息到本地缓存文件当中（同步/异步两种方式），以url纬度进行全量保存。

  • Dubbo在服务引用过程中会创建registry对象并加载本地缓存文件，会优先订阅注册中心，订阅注册中心失败后会访问本地缓存文件内容获取服务提供信息。

核心实现类

注册中心

  • 核心的实现类是AbstractRegistry。

AbstractRegistry

notify

public abstract class AbstractRegistry implements Registry {

    // URL address separator, used in file cache, service provider URL separation
    private static final char URL_SEPARATOR = ' ';
    // URL address separated regular expression for parsing the service provider URL list in the file cache
    private static final String URL_SPLIT = "\s+";
    // Log output
    protected final Logger logger = LoggerFactory.getLogger(getClass());
    // Local disk cache, where the special key value.registies records the list of registry centers, and the others are the list of notified service providers
    private final Properties properties = new Properties();
    // File cache timing writing
    private final ExecutorService registryCacheExecutor = Executors.newFixedThreadPool(1, new NamedThreadFactory("DubboSaveRegistryCache", true));
    // Is it synchronized to save the file
    private final boolean syncSaveFile;
    private final AtomicLong lastCacheChanged = new AtomicLong();
    private final Set<URL> registered = new ConcurrentHashSet<URL>();
    private final ConcurrentMap<URL, Set<NotifyListener>> subscribed = new ConcurrentHashMap<URL, Set<NotifyListener>>();
    private final ConcurrentMap<URL, Map<String, List<URL>>> notified = new ConcurrentHashMap<URL, Map<String, List<URL>>>();
    private URL registryUrl;
    // 本地缓存文件对象
    private File file;

    public AbstractRegistry(URL url) {
        setUrl(url);
        // Start file save timer
        syncSaveFile = url.getParameter(Constants.REGISTRY_FILESAVE_SYNC_KEY, false);
        // 本地缓存文件名
        String filename = url.getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/.dubbo/dubbo-registry-" + url.getParameter(Constants.APPLICATION_KEY) + "-" + url.getAddress() + ".cache");

        File file = null;
        if (ConfigUtils.isNotEmpty(filename)) {
            file = new File(filename);
            if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) {
                if (!file.getParentFile().mkdirs()) {
                    throw new IllegalArgumentException("Invalid registry store file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");
                }
            }
        }
        this.file = file;
        loadProperties();
        notify(url.getBackupUrls());
    }

    // 回调通知处理函数
    protected void notify(URL url, NotifyListener listener, List<URL> urls) {
        if (url == null) {
            throw new IllegalArgumentException("notify url == null");
        }
        if (listener == null) {
            throw new IllegalArgumentException("notify listener == null");
        }
        if ((urls == null || urls.isEmpty())
                && !Constants.ANY_VALUE.equals(url.getServiceInterface())) {
            logger.warn("Ignore empty notify urls for subscribe url " + url);
            return;
        }
        if (logger.isInfoEnabled()) {
            logger.info("Notify urls for subscribe url " + url + ", urls: " + urls);
        }
        Map<String, List<URL>> result = new HashMap<String, List<URL>>();
        for (URL u : urls) {
            if (UrlUtils.isMatch(url, u)) {
                String category = u.getParameter(Constants.CATEGORY_KEY, Constants.DEFAULT_CATEGORY);
                List<URL> categoryList = result.get(category);
                if (categoryList == null) {
                    categoryList = new ArrayList<URL>();
                    result.put(category, categoryList);
                }
                categoryList.add(u);
            }
        }

        if (result.size() == 0) {
            return;
        }

        Map<String, List<URL>> categoryNotified = notified.get(url);
        if (categoryNotified == null) {
            notified.putIfAbsent(url, new ConcurrentHashMap<String, List<URL>>());
            categoryNotified = notified.get(url);
        }
        for (Map.Entry<String, List<URL>> entry : result.entrySet()) {
            String category = entry.getKey();
            List<URL> categoryList = entry.getValue();
            categoryNotified.put(category, categoryList);
            // 保存配置信息到本地文件
            saveProperties(url);
            listener.notify(categoryList);
        }
    }
}
  • 注册中心的在服务变更过程中通过回调函数notify进行通知。
  • 在通知回调中通过saveProperties()方法进行属性保存。
  • AbstractRegistry的构造函数当中会创建本地缓存的持久化文件名。

saveProperties

public abstract class AbstractRegistry implements Registry {

    private void saveProperties(URL url) {
        if (file == null) {
            return;
        }

        try {
            // 将url的所有属性进行拼接，通过空格进行拼接。
            StringBuilder buf = new StringBuilder();
            Map<String, List<URL>> categoryNotified = notified.get(url);
            if (categoryNotified != null) {
                for (List<URL> us : categoryNotified.values()) {
                    for (URL u : us) {
                        if (buf.length() > 0) {
                            buf.append(URL_SEPARATOR);
                        }
                        buf.append(u.toFullString());
                    }
                }
            }
            // 通过properties设置属性
            properties.setProperty(url.getServiceKey(), buf.toString());
            long version = lastCacheChanged.incrementAndGet();
            if (syncSaveFile) {
                doSaveProperties(version);
            } else {
                registryCacheExecutor.execute(new SaveProperties(version));
            }
        } catch (Throwable t) {
            logger.warn(t.getMessage(), t);
        }
    }


    private class SaveProperties implements Runnable {
        private long version;

        private SaveProperties(long version) {
            this.version = version;
        }

        @Override
        public void run() {
            doSaveProperties(version);
        }
    }
}
  • 通过properties.setProperty(url.getServiceKey(), buf.toString())保存服务的属性。
  • 持久化到文件分为同步和异步，异步通过线程SaveProperties异步执行，同步调用doSaveProperties直接写文件。

doSaveProperties

public abstract class AbstractRegistry implements Registry {

    public void doSaveProperties(long version) {
        if (version < lastCacheChanged.get()) {
            return;
        }
        if (file == null) {
            return;
        }
        // Save
        try {
            File lockfile = new File(file.getAbsolutePath() + ".lock");
            if (!lockfile.exists()) {
                lockfile.createNewFile();
            }
            RandomAccessFile raf = new RandomAccessFile(lockfile, "rw");
            try {
                FileChannel channel = raf.getChannel();
                try {
                    FileLock lock = channel.tryLock();
                    if (lock == null) {
                        throw new IOException("Can not lock the registry cache file " + file.getAbsolutePath() + ", ignore and retry later, maybe multi java process use the file, please config: dubbo.registry.file=xxx.properties");
                    }
                    // Save
                    try {
                        if (!file.exists()) {
                            file.createNewFile();
                        }
                        FileOutputStream outputFile = new FileOutputStream(file);
                        try {
                            properties.store(outputFile, "Dubbo Registry Cache");
                        } finally {
                            outputFile.close();
                        }
                    } finally {
                        lock.release();
                    }
                } finally {
                    channel.close();
                }
            } finally {
                raf.close();
            }
        } catch (Throwable e) {
            if (version < lastCacheChanged.get()) {
                return;
            } else {
                registryCacheExecutor.execute(new SaveProperties(lastCacheChanged.incrementAndGet()));
            }
            logger.warn("Failed to save registry store file, cause: " + e.getMessage(), e);
        }
    }
}

  • doSaveProperties实现持久化动作。

  • dubbo:registry标签包含file属性，指定本地文件缓存的文件名。

  • 使用文件缓存注册中心地址列表及服务提供者列表，应用重启时将基于此文件恢复，注意：两个注册中心不能使用同一文件存储。

  • doSaveProperties执行真正的属性保存，通过文件的lock属性进行互斥实现。

本地缓存文件

所在目录 
/Users/lebron374/.dubbo

文件
dubbo-registry-demo-consumer-127.0.0.1:2181.cache
dubbo-registry-demo-consumer-127.0.0.1:2181.cache.lock
dubbo-registry-demo-provider-127.0.0.1:2181.cache
dubbo-registry-demo-provider-127.0.0.1:2181.cache.lock

文件内容
#Dubbo Registry Cache
#Wed Jan 22 20:59:44 CST 2020
com.alibaba.dubbo.demo.DemoService=empty://192.168.1.106/com.alibaba.dubbo.demo.DemoService?application=demo-consumer&category=configurators&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=31961&qos.port=33333&side=consumer&timestamp=1579697802111 empty://192.168.1.106/com.alibaba.dubbo.demo.DemoService?application=demo-consumer&category=routers&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=31961&qos.port=33333&side=consumer&timestamp=1579697802111 dubbo://192.168.1.106:20881/com.alibaba.dubbo.demo.DemoService?anyhost=true&application=demo-provider&bean.name=com.alibaba.dubbo.demo.DemoService&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=31565&side=provider&timestamp=1579696923081 empty://192.168.1.106/com.alibaba.dubbo.demo.DemoService?application=demo-consumer&category=providers,configurators,routers&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.DemoService&methods=sayHello&pid=31961&qos.port=33333&side=consumer&timestamp=1579697802111
com.alibaba.dubbo.demo.AnotherService=empty://192.168.1.106/com.alibaba.dubbo.demo.AnotherService?application=demo-consumer&category=configurators&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.AnotherService&methods=sayHello&pid=31796&qos.port=33333&side=consumer&timestamp=1579697435025 empty://192.168.1.106/com.alibaba.dubbo.demo.AnotherService?application=demo-consumer&category=routers&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.AnotherService&methods=sayHello&pid=31796&qos.port=33333&side=consumer&timestamp=1579697435025 dubbo://192.168.1.106:20881/com.alibaba.dubbo.demo.AnotherService?anyhost=true&application=demo-provider&bean.name=com.alibaba.dubbo.demo.AnotherService&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.AnotherService&methods=sayHello&pid=31565&side=provider&timestamp=1579697270262
com.alibaba.dubbo.demo.AnotherServiceV2=empty://192.168.1.106/com.alibaba.dubbo.demo.AnotherServiceV2?application=demo-consumer&category=configurators&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.AnotherServiceV2&methods=sayHello&pid=31796&qos.port=33333&side=consumer&timestamp=1579697439692 empty://192.168.1.106/com.alibaba.dubbo.demo.AnotherServiceV2?application=demo-consumer&category=routers&check=false&dubbo=2.0.2&interface=com.alibaba.dubbo.demo.AnotherServiceV2&methods=sayHello&pid=31796&qos.port=33333&side=consumer&timestamp=1579697439692 dubbo://192.168.1.106:20881/com.alibaba.dubbo.demo.AnotherServiceV2?anyhost=true&application=demo-provider&bean.name=com.alibaba.dubbo.demo.AnotherServiceV2&dubbo=2.0.2&generic=false&interface=com.alibaba.dubbo.demo.AnotherServiceV2&methods=sayHello&pid=31565&side=provider&timestamp=1579697270512

缓存加载

public abstract class FailbackRegistry extends AbstractRegistry {
    public void subscribe(URL url, NotifyListener listener) {
        super.subscribe(url, listener);
        removeFailedSubscribed(url, listener);
        try {
            // Sending a subscription request to the server side
            doSubscribe(url, listener);
        } catch (Exception e) {
            Throwable t = e;
            // 注册中心订阅失败后读取本地缓存文件获取服务
            List<URL> urls = getCacheUrls(url);
            if (urls != null && !urls.isEmpty()) {
                notify(url, listener, urls);
                logger.error("Failed to subscribe " + url + ", Using cached list: " + urls + " from cache file: " + getUrl().getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/dubbo-registry-" + url.getHost() + ".cache") + ", cause: " + t.getMessage(), t);
            } else {
                // If the startup detection is opened, the Exception is thrown directly.
                boolean check = getUrl().getParameter(Constants.CHECK_KEY, true)
                        && url.getParameter(Constants.CHECK_KEY, true);
                boolean skipFailback = t instanceof SkipFailbackWrapperException;
                if (check || skipFailback) {
                    if (skipFailback) {
                        t = t.getCause();
                    }
                    throw new IllegalStateException("Failed to subscribe " + url + ", cause: " + t.getMessage(), t);
                } else {
                    logger.error("Failed to subscribe " + url + ", waiting for retry, cause: " + t.getMessage(), t);
                }
            }

            // Record a failed registration request to a failed list, retry regularly
            addFailedSubscribed(url, listener);
        }
    }
}

  • 优先订阅注册中心获取服务提供者，如果注册中心访问异常，获取本地缓存的服务提供者。

    public abstract class AbstractRegistry implements Registry {

    public AbstractRegistry(URL url) {
    setUrl(url);
    // Start file save timer
    syncSaveFile = url.getParameter(Constants.REGISTRY_FILESAVE_SYNC_KEY, false);
    String filename = url.getParameter(Constants.FILE_KEY, System.getProperty("user.home") + "/.dubbo/dubbo-registry-" + url.getParameter(Constants.APPLICATION_KEY) + "-" + url.getAddress() + ".cache");
    File file = null;
    if (ConfigUtils.isNotEmpty(filename)) {
        file = new File(filename);
        if (!file.exists() && file.getParentFile() != null && !file.getParentFile().exists()) {
            if (!file.getParentFile().mkdirs()) {
                throw new IllegalArgumentException("Invalid registry store file " + file + ", cause: Failed to create directory " + file.getParentFile() + "!");
            }
        }
    }
    this.file = file;
    // registry对象创建的时候加载本地缓存对象
    loadProperties();
    notify(url.getBackupUrls());
}

private void loadProperties() {
    if (file != null && file.exists()) {
        InputStream in = null;
        try {
            in = new FileInputStream(file);
            // 本地缓存文件保存至properties当中
            properties.load(in);
            if (logger.isInfoEnabled()) {
                logger.info("Load registry store file " + file + ", data: " + properties);
            }
        } catch (Throwable e) {
            logger.warn("Failed to load registry store file " + file, e);
        } finally {
            if (in != null) {
                try {
                    in.close();
                } catch (IOException e) {
                    logger.warn(e.getMessage(), e);
                }
            }
        }
    }
}


public List<URL> getCacheUrls(URL url) {
    // properties保存的是本地缓存文件内容
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
        String key = (String) entry.getKey();
        String value = (String) entry.getValue();
        if (key != null && key.length() > 0 && key.equals(url.getServiceKey())
                && (Character.isLetter(key.charAt(0)) || key.charAt(0) == '_')
                && value != null && value.length() > 0) {
            String[] arr = value.trim().split(URL_SPLIT);
            List<URL> urls = new ArrayList<URL>();
            for (String u : arr) {
                urls.add(URL.valueOf(u));
            }
            return urls;
        }
    }
    return null;
}

    }

  • 在创建Registry对象的构造函数当中会加载本地缓存文件并保存至properties对象当中。

  • getCacheUrls负责根据url获取缓存的服务提供者信息。

3人点赞

dubbo

嗯嗯嗯吧
关注
专栏目录
Dubbo源码分析十、服务目录
vinylon的博客
12-29 141
关于服务目录，之前在讲到服务引用时提到过。我们可以简单的理解为远程服务在本地的缓存，缓存的对象就是invoker。那么关于服务目录有哪些需要搞清楚的呢？整理了一下： 列举Invoker-- 运行时调用时需要得到和当前调用相符合的invoker列表 通知notify–服务发生变更时能收到通知更新本地缓存 我们知道注册中心记录的是服务url，那么通知过来的就是url列表，应该有一个当前invoker列表和通知的url列表的差值计算的过程。 路由 – 这个是列举的一个子功能，这里单独拎出来说。运行时调
dubbo-cache 测试用例
10-03
介绍dubbo缓存配置,已经LRU缓存策略的使用.
dubbo+zookeeper缓存方案
06-03
dubbo+zookeeper缓存方案 dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案
Dubbo缓存
最新发布
Flying_Fish_roe的博客
09-06 1280
Dubbo 允许用户实现自定义的缓存策略。通过实现Cache接口，可以定义适合特定业务需求的缓存策略。例如，你可以结合 Redis 或 Memcached 等分布式缓存系统来实现跨节点的缓存共享。适用场景适合需要跨节点共享缓存的分布式系统。适用于对缓存管理有特定需求的场景，如复杂的失效策略、多级缓存等。配置示例在实现自定义缓存时，需要继承接口，并配置在 SPI 文件中。Dubbo 提供的结果缓存功能，能够帮助开发者有效地减少重复调用、降低系统负载、提高响应速度。
Dubbo 缓存
weixin_33724046的博客
04-08 366
为什么80%的码农都做不了架构师？>>> ...
Dubbo——本地缓存和重试机制原理
庄小焱
04-09 2021
摘要 主要是的分析的Dubbo的注册中心。首先介绍整个注册中心的总体工作流程;其次讲解不同类型注册中心的数据结构和实现原理;接着讲解注册中心支持的通用特性，如缓存机制、重试机制;最后会对整个注册中心的设计模式做深入解析读者可以深入理解Dubbo各种注册中心的实现原理，方便后续快速理解并扩展注册中心。 注册中心的工作流程 在 Dubbo微服务体系中，注册中心是其核心组件之一。Dubbo通过注册中心实现了分布式环境中各服务之间的注册与发现，是各个分布式节点之间的纽带。其主要作用如下: 动态加入。一个服务
dubbo-cache:@DubboCache提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务
04-27
提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务。 相对于dubbo默认的缓存机制，此项目具有如下优点： 原生dubbo cache机制只能缓存结果到消费者jvm中，并且cache key不能选择。 缓存key...
Dubbo服务框架-其他
06-12
注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯 服务提供者无状态，任意一台宕掉后，不影响使用 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复 (3) 伸缩性： ...
使用dubbo实现分布式缓存
# 1. 介绍Dubbo和分布式缓存 ## 1.1 什么是Dubbo？...Dubbo可以与分布式缓存系统（如Redis、Memcached等）结合，实现分布式环境下的缓存服务，提高系统的性能和并发能力。在本章后续内容中，我们将详细介
Dubbo声明式缓存
嗯哼的博客
09-03 233
dubbo官网---结果缓存 结果缓存 通过缓存结果加速访问速度 结果缓存，用于加速热门数据的访问速度，Dubbo 提供声明式缓存，以减少用户加缓存的工作量。 缓存类型 lru基于最近最少使用原则删除多余缓存，保持最热的数据被缓存。 threadlocal当前线程缓存，比如一个页面渲染，用到很多 portal，每个 portal 都要去查用户信息，通过线程缓存，可以减少这种多余访问。 jcache与JSR107集成，可以桥接各种缓存实现。 缓存类型可扩展，参见：缓存扩展 配置 ...
springboot+dubbo分布式架构，提供分布式缓存、分布式锁、分布式Session、读写分离
05-15
数据库：Druid数据库连接池，监控数据库访问性能，统计SQL的执行性能。 持久层：mybatis持久化，使用MyBatis-Plus优化，减少sql开发量；aop切换数据库实现读写分离。Transtraction注解事务。 MVC： 基于spring mvc注解,Rest风格Controller。Exception统一管理。 缓存和Session：注解redis缓存数据，Spring-session和redis实现分布式session同步，重启服务会话不丢失。 数据同步：基于redis的分布式锁。 Web安全：实现XSS过滤和CSR过滤。 多系统交互：Dubbo,ActiveMQ多系统交互。 前后端分离：前端使用ajax访问后端的rest服务，后端返回json格式数据。页面用nginx反向代理访问。 支付功能：实现微信和支付宝支付客户端。 日志：Logback打印日志，默认打印Web和Service简要日志。 工具类：字符串处理，类型转换，日期处理，IO和文件，Excel读写，加密解密，HTTP客户端，XML处理，转码，各种Util等等。 代码生成器：根据数据库表结构生成简单的增删改查功能代码，包括model、mapper、service、controller。
Dubbo高级篇_13_Dubbo缓存
热门推荐
君子敏于行而讷于言
07-30 2万+
结果缓存，用于加速热门数据的访问速度， Dubbo提供声明式缓存，以减少用户加缓存的工作量。 按照SPI的要求，我们从配置文件中可以看到dubbo提供的三种缓存接口的入口： threadlocal=com.alibaba.dubbo.cache.support.threadlocal.ThreadLocalCacheFactory lru=com.alibaba.dubbo.cache...
dubbo 结果缓存
weixin_43931625的博客
02-22 2935
dubbo 结果缓存
Dubbo缓存机制
tianjingle
08-10 675
通过之前的学习，我们大概了解到Dubbo服务在启动的时候会全量从注册中心获取所有的服务信息，但是我们不可能每次每次都是全量的从注册中心获取，否则会导致注册中心的压力很大，所以增量是一个关键的话题。我们在写业务代码也是同样的道理，要合理的利用cache这种理念，将80%的非关键流量拦截在cache层面。Dubbo册中心的缓存是实现在AbstractRegistry抽象类中的...
(九)轻松dubbo--结果缓存
Xinghf
10-10 6025
缓存的应用非常广泛，为了提高数据访问的速度。Dubbo也不例外，它提供了声明式缓存，以减少用户加缓存的工作量。 一、Dubbo中缓存策略 lru 基于最近最少使用原则删除多余缓存，保持最热的数据被缓存。threadlocal 当前线程缓存，比如一个页面渲染，用到很多portal，每个portal都要去查用户信息，通过线程缓存，可以减少这种多余访问。 jcache 与JSR107集成，
dubbo 缓存的使用和实现解析
weixin_34023863的博客
04-04 1161
2019独角兽企业重金招聘Python工程师标准>>> ...
Dubbo之结果缓存。
孤芳不自赏
03-20 690
博文中的内容来源《Dubbo用户指南》这一本书，感激不尽。
dubbo zk node缓存清理
08-10
Dubbo 中使用 ZooKeeper 作为注册中心，会在本地缓存中保存服务提供者和消费者的节点信息。当节点发生变更时，比如服务提供者下线或上线，Dubbo 会自动更新本地缓存。但有时候可能需要手动清理 Dubbo 的 ZooKeeper 节点缓存。 要手动清理 Dubbo 的 ZooKeeper 节点缓存，可以执行以下步骤： 1. 找到 Dubbo 的配置文件，一般是 `dubbo.properties` 或 `dubbo.xml`。 2. 在配置文件中搜索 `registry` 相关的配置项，找到与 ZooKeeper 相关的配置。通常会有类似下面的配置项： ``` dubbo.registry.address=zookeeper://127.0.0.1:2181 dubbo.registry.group=dubbo ``` 3. 连接到 ZooKeeper 控制台或使用 ZooKeeper 客户端工具（如 zkCli）登录到对应的 ZooKeeper 服务器。 4. 找到 Dubbo 在 ZooKeeper 上注册的节点路径，一般是 `/dubbo/{应用名称}/providers` 和 `/dubbo/{应用名称}/consumers`。 5. 删除这些节点路径下的所有子节点。 6. 重启使用 Dubbo 的应用程序，Dubbo 会重新从 ZooKeeper 注册中心拉取最新的节点信息并进行缓存。 请注意，在清理 ZooKeeper 节点缓存之前，请确保你真正需要手动清理，并了解清理缓存可能带来的影响。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值