Dubbo 服务本地缓存

最新推荐文章于 2024-09-06 09:17:12 发布
最新推荐文章于 2024-09-06 09:17:12 发布
阅读量4.7k 收藏 5
点赞数
文章标签： dubbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huotongwangbs/article/details/120786966
版权
Dubbo为解决ZK等注册中心单点故障问题，实现了服务提供者信息的本地缓存。当注册中心不可达时，应用可以从本地缓存文件获取服务提供者列表。本地缓存文件按URL维度全量保存，并在启动时加载。注册中心订阅失败后，Dubbo会尝试从缓存中恢复。缓存内容包括服务提供者URL，文件格式为properties，内容以空格分隔。
摘要由CSDN通过智能技术生成

开篇

  • 根据官方图，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+zookeeper缓存方案
06-03
dubbo+zookeeper缓存方案 dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案dubbo+zookeeper缓存方案
dubbo 问题整理
m0_67391121的博客
08-14 296
服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，服务消费者向注册中心获取服务提供者地址列表，并根据负载算法直接调用提供者，注册中心，服务提供者，服务消费者三者之间均为长连接，监控中心除外，注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者。点对点直联方式，将以服务接口为单位，忽略注册中心的提供者列表，.
Dubbo缓存
最新发布
Flying_Fish_roe的博客
09-06 1231
Dubbo 允许用户实现自定义的缓存策略。通过实现Cache接口，可以定义适合特定业务需求的缓存策略。例如，你可以结合 Redis 或 Memcached 等分布式缓存系统来实现跨节点的缓存共享。适用场景适合需要跨节点共享缓存的分布式系统。适用于对缓存管理有特定需求的场景，如复杂的失效策略、多级缓存等。配置示例在实现自定义缓存时，需要继承接口，并配置在 SPI 文件中。Dubbo 提供的结果缓存功能，能够帮助开发者有效地减少重复调用、降低系统负载、提高响应速度。
Dubbo——本地缓存和重试机制原理
庄小焱
04-09 1997
摘要 主要是的分析的Dubbo的注册中心。首先介绍整个注册中心的总体工作流程;其次讲解不同类型注册中心的数据结构和实现原理;接着讲解注册中心支持的通用特性，如缓存机制、重试机制;最后会对整个注册中心的设计模式做深入解析读者可以深入理解Dubbo各种注册中心的实现原理，方便后续快速理解并扩展注册中心。 注册中心的工作流程 在 Dubbo微服务体系中，注册中心是其核心组件之一。Dubbo通过注册中心实现了分布式环境中各服务之间的注册与发现，是各个分布式节点之间的纽带。其主要作用如下: 动态加入。一个服务
dubbo关于修改了window的用户名之后出现没有权限写文件的问题
madman
06-26 663
dubbo的缓存文件 dubbo的默认缓存文件是在{user.home}/.dubbo/目录下，默认会跟进提供者和消费者生成一些文件，比如 [cddubbo@qtbj-dmz-102 .dubbo]$ pwd /home/cddubbo/.dubbo [cddubbo@qtbj-dmz-102 .dubbo]$ ll total 16 -rw-rw-r-- 1 cddubbo cddubbo ...
dubbo的disconected问题
bhegi_seg的博客
09-06 1025
本文中出现的disconect连接我觉得本不该出现，因为dubbo使用长连接，查看了provider和consumer之间的连接数也充足（配置的20个connection），所以除了这些之外的连接都是多余的，而且超过了20个之后再发起连接就只能失败，额外出现的这些试图发起的连接应该是在provider地址列表更新的时候，consumer的缓存文件缓存失败导致的错误。这是consumer发起连接的时候调用的代码，先获取一个新连接，如果原来有个连接，就先把旧连接关掉，替换成新的连接，算是重连。
Dubbo——注册中心缓存机制、重试机制
吴声子夜歌的博客
06-28 3333
缓存机制 缓存的存在就是用空间换取时间，如果每次远程调用都要从注册中心获取一次可调用的服务列表，则会让注册中心承受巨大的流量压力。另外，每次额外的网络请求也会让整个系统的性能下降。因此，Dubbo的注册中心实现了通用的缓存机制，在抽象类AbstractRegistry中实现。 消费者或服务治理中心获取注册信息后会做本地缓存。内存中会有一份，保存在Properties对象里，磁盘上也会持久化一份文件，通过file对象引用。 在AbstractRegistry抽象类中有如下定义： 内存中的缓存notifie
dubbo-cache:@DubboCache提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务
04-27
提供dubbo消费者直接使用缓存的能力，当缓存不存在时，再访问远程dubbo服务。 相对于dubbo默认的缓存机制，此项目具有如下优点： 原生dubbo cache机制只能缓存结果到消费者jvm中，并且cache key不能选择。 缓存key...
Dubbo服务框架-其他
06-12
注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯 服务提供者无状态，任意一台宕掉后，不影响使用 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复 (3) 伸缩性： ...
Dubbo服务框架 v3.0.0
04-21
注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯 服务提供者无状态，任意一台宕掉后，不影响使用 服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复 (3) 伸缩性...
解决Dubbo 本地启动多个应用的缓存冲突问题
飞一站的博客
01-19 1573
解决Dubbo 本地启动多个应用的缓存冲突问题
dubbo-registry-xxxx.cache、dubbo-registry-xxxx.cache.lock，及Failed to save registry store file问题
daobuxinzi的博客
09-01 1686
dubbo的日志中出现了这种信息： [WARN ] 2017-11-03 15:15:20,988--DubboSaveRegistryCache-thread-1--[com.alibaba.dubbo.registry.zookeeper.ZookeeperRegistry] [DUBBO] Failed to save registry store file,cause: Can not lock the registry cache file /root/.dubbo/dubbo-regist
dubbo用户文档摘选
noob_can的博客
06-28 616
dubbo使用文档摘选
dubbo 结果缓存
weixin_43931625的博客
02-22 2909
dubbo 结果缓存
原来Dubbo中的缓存玩的这么花
todoitbo的博客
04-11 1102
本文将深入探讨 Dubbo 中的缓存机制，这是优化微服务性能的重要组成部分。我们将介绍 Dubbo 缓存的基本概念和工作原理，并提供实际案例，演示如何在 Dubbo 微服务架构中有效地利用缓存来提升响应速度和降低系统负载。无论您是刚入门 Dubbo 还是想要进一步了解其高级特性，本文都将为您详细解读 Dubbo 缓存，帮助您优化微服务架构的性能。
Dubbo服务启动报错
m0_54850467的博客
09-06 1925
经过查阅资料发现出现该问题的原因是因为Dubbo在向Zookeeper注册的同时，也会缓存一份Consumer文件列表、写入/pub/.dubbo/dubbo-registry-224.5.6.7.cache 这个文件中，当在同一台机器上启动多台provider的时候，同时启动会出现并发问题、同时创建或者写入该文件，就会出现该问题。一个服务有多个应用有用到dubbo的时候更新注册中心的本地缓存，在更新本地缓存冲突时，就报了上面的warning；Linux环境 + Dubbo 2.5.3。
Dubbo如何传输java对象？注册中心挂了，服务可以正常访问吗？什么是超时和重试？
wsq19980112的博客
04-04 1196
序列化 地址缓存 注册中心挂了，服务是否可以正常访问？ 可以，因为dubbo服务消费者在第一次调用时，会将服务提供方地址缓存到本地，以后在调用则不会访问注册中心。当服务提供者地址发生变化时，注册中心会通知服务消费者。新的服务不可用，老的服务仍可以使用 超时 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。 dubbo 利用超时机制来...
Dubbo缓存机制
tianjingle
08-10 663
通过之前的学习，我们大概了解到Dubbo服务在启动的时候会全量从注册中心获取所有的服务信息，但是我们不可能每次每次都是全量的从注册中心获取，否则会导致注册中心的压力很大，所以增量是一个关键的话题。我们在写业务代码也是同样的道理，要合理的利用cache这种理念，将80%的非关键流量拦截在cache层面。Dubbo册中心的缓存是实现在AbstractRegistry抽象类中的...
Dubbo 4 Dubbo 高级特性 4.2 Dubbo 常用高级配置 4.2.2 地址缓存 & 4.2.3 超时
谢谢你们的关注
12-17 538
Dubbo 4 Dubbo 高级特性 4.2 Dubbo 常用高级配置 4.2.2 地址缓存 & 4.2.3 超时
dubbo zk node缓存清理
08-10
当节点发生变更时，比如服务提供者下线或上线，Dubbo 会自动更新本地缓存。但有时候可能需要手动清理 Dubbo 的 ZooKeeper 节点缓存。 要手动清理 Dubbo 的 ZooKeeper 节点缓存，可以执行以下步骤： 1. 找到 Dubbo ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值