Nacos源码解读05——Client本地缓存和故障转移

已于 2023-12-03 16:54:04 修改
阅读量782 收藏
点赞数
分类专栏： Nacos 文章标签： java
于 2023-12-03 16:53:27 首次发布
原文链接：https://zhuanlan.zhihu.com/p/400891365
版权

Client本地缓存

ServiceInfoHolder功能概述

ServiceInfoHolder是服务信息的拥有者 ，比如服务注册，客户端从注册中心拉取服务新的服务信息时都会调用该类的。
processServiceInfo方法在前面的文章中出现过多次 他主要是来进行本地化的处理，包括更新缓存服务、发布事件、更新本地文件等操作。

ServiceInfo的本地内存缓存

ServiceInfo代表服务的注册信息，他包含了服务名称、分组名称、集群信息、实例列表信息、上次更新时间等信息
客户端从注册中心获取到的信息在本地都以ServiceInfo作为承载着。

public class ServiceInfo {
    
    @JsonIgnore
    private String jsonFromServer = EMPTY;
    
    private static final String EMPTY = "";
    
    private static final String ALL_IPS = "000--00-ALL_IPS--00--000";
    
    public static final String SPLITER = "@@";
    
    private static final String DEFAULT_CHARSET = "UTF-8";
    
    private String name;
    
    private String groupName;
    
    private String clusters;
    
    private long cacheMillis = 1000L;
    
    private List<Instance> hosts = new ArrayList<Instance>();
    
    private long lastRefTime = 0L;
    
    private String checksum = "";
    
    private volatile boolean allIPs = false;
    
    private volatile boolean reachProtectionThreshold = false;
    
    public ServiceInfo() {
    }
    
    public boolean isAllIPs() {
        return allIPs;
    }
    
    public void setAllIPs(boolean allIPs) {
        this.allIPs = allIPs;
    }
    }

ServiceInfoHolder 通过一个ConcurrentMap来维护着ServiceInfo信息在ServiceInfoHolder 构造方法初始化的时候会创建serviceInfoMap

    private final ConcurrentMap<String, ServiceInfo> serviceInfoMap;
      public ServiceInfoHolder(String namespace, Properties properties) {
        ......
        // 启动时是否从缓存目录读取信息，默认false。设置为true会读取缓存文件
        if (isLoadCacheAtStart(properties)) {
            this.serviceInfoMap = new ConcurrentHashMap<>(DiskCache.read(this.cacheDir));
        } else {
            this.serviceInfoMap = new ConcurrentHashMap<>(16);
        }
        ......
        }

当有服务发生变更时会调用processServiceInfo方法 在processServiceInfo中参考如下代码会往serviceInfoMap中添加数据缓存服务信息

        ServiceInfo oldService = serviceInfoMap.get(serviceInfo.getKey());
        if (isEmptyOrErrorPush(serviceInfo)) {
            //empty or error push, just ignore
            return oldService;
        }
        serviceInfoMap.put(serviceInfo.getKey(), serviceInfo);

本地缓存目录

当服务变更时会使用DiskCache往本地缓存目录中写入ServiceInfo信息

        if (changed) {
            NAMING_LOGGER.info("current ips:({}) service: {} -> {}", serviceInfo.ipCount(), serviceInfo.getKey(),
                    JacksonUtils.toJson(serviceInfo.getHosts()));
            NotifyCenter.publishEvent(new InstancesChangeEvent(serviceInfo.getName(), serviceInfo.getGroupName(),
                    serviceInfo.getClusters(), serviceInfo.getHosts()));
            DiskCache.write(serviceInfo, cacheDir);
        }

在ServiceInfoHolder构造方法初始化的时候会执行initCacheDir方法去构建一个本地缓存目录

    public ServiceInfoHolder(String namespace, Properties properties) {
        initCacheDir(namespace, properties);
         ......
    }

默认缓存目录为${user.home}/nacos/naming/public，可以通过System.setProperty(“JM.SNAPSHOT.PATH”)自定义根目录。当这个目录初始化完成之后 故障转移信息也存储在该目录下

    private String cacheDir;
    
    private void initCacheDir(String namespace, Properties properties) {
        String jmSnapshotPath = System.getProperty(JM_SNAPSHOT_PATH_PROPERTY);
    
        String namingCacheRegistryDir = "";
        if (properties.getProperty(PropertyKeyConst.NAMING_CACHE_REGISTRY_DIR) != null) {
            namingCacheRegistryDir = File.separator + properties.getProperty(PropertyKeyConst.NAMING_CACHE_REGISTRY_DIR);
        }
        
        if (!StringUtils.isBlank(jmSnapshotPath)) {
            cacheDir = jmSnapshotPath + File.separator + FILE_PATH_NACOS + namingCacheRegistryDir
                    + File.separator + FILE_PATH_NAMING + File.separator + namespace;
        } else {
            cacheDir = System.getProperty(USER_HOME_PROPERTY) + File.separator + FILE_PATH_NACOS + namingCacheRegistryDir
                    + File.separator + FILE_PATH_NAMING + File.separator + namespace;
        }
    }

故障转移

作用

当开启故障转移后当发生故障时，可以从故障转移定时备份的文件中来获得服务实例信息

实现

ServiceInfoHolder的构造方法初始化的时候会创建一个FailoverReactor这个类是专门去处理故障转移的

 public ServiceInfoHolder(String namespace, Properties properties) {
  ......
   this.failoverReactor = new FailoverReactor(this, cacheDir);
  ......
  }

    public FailoverReactor(ServiceInfoHolder serviceInfoHolder, String cacheDir) {
        this.serviceInfoHolder = serviceInfoHolder;
          // 拼接故障根目录：${user.home}/nacos/naming/public/failover
        this.failoverDir = cacheDir + FAILOVER_DIR;
        // init executorService
        //初始化一个定时任务线程池以守护线程模式运行
        this.executorService = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread thread = new Thread(r);
                thread.setDaemon(true);
                thread.setName("com.alibaba.nacos.naming.failover");
                return thread;
            }
        });
        //初始化通过executorService 开始多个定时任务执行
        this.init();
    }

    public void init() {
        //执行间隔5秒，执行任务为SwitchRefresher
        executorService.scheduleWithFixedDelay(new SwitchRefresher(), 0L, 5000L, TimeUnit.MILLISECONDS);
        //初始化延迟30分钟执行，执行间隔24小时，执行任务为DiskFileWriter；
        executorService.scheduleWithFixedDelay(new DiskFileWriter(), 30, DAY_PERIOD_MINUTES, TimeUnit.MINUTES);
        
        // backup file on startup if failover directory is empty.
        //初始化立即执行，执行间隔10秒，执行核心操作为DiskFileWriter；
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                try {
                    File cacheDir = new File(failoverDir);
                    
                    if (!cacheDir.exists() && !cacheDir.mkdirs()) {
                        throw new IllegalStateException("failed to create cache dir: " + failoverDir);
                    }
                    
                    File[] files = cacheDir.listFiles();
                    if (files == null || files.length <= 0) {
                        new DiskFileWriter().run();
                    }
                } catch (Throwable e) {
                    NAMING_LOGGER.error("[NA] failed to backup file on startup.", e);
                }
                
            }
        }, 10000L, TimeUnit.MILLISECONDS);
    }

SwitchRefresher执行

如果故障转移文件不存在，则直接返回。故障转移【开关】文件为名为“00-00—000-VIPSRV_FAILOVER_SWITCH-000—00-00”。
比较文件修改时间，如果已经修改，则获取故障转移文件中的内容。
故障转移文件中存储了0和1标识。0表示关闭，1表示开启。
当为开启状态时，执行线程FailoverFileReader。

    @Override
        public void run() {
            try {
                File switchFile = new File(failoverDir + UtilAndComs.FAILOVER_SWITCH);
                //判断文件是否存在 不存在直接return 
                if (!switchFile.exists()) {
                    switchParams.put(FAILOVER_MODE_PARAM, Boolean.FALSE.toString());
                    NAMING_LOGGER.debug("failover switch is not found, {}", switchFile.getName());
                    return;
                }
                
                long modified = switchFile.lastModified();
                
                if (lastModifiedMillis < modified) {
                    lastModifiedMillis = modified;
                     // 获取故障转移文件内容
                    String failover = ConcurrentDiskUtil.getFileContent(failoverDir + UtilAndComs.FAILOVER_SWITCH,
                            Charset.defaultCharset().toString());
                    if (!StringUtils.isEmpty(failover)) {
                        String[] lines = failover.split(DiskCache.getLineSeparator());
                        
                        for (String line : lines) {
                            String line1 = line.trim();
                            // 1表示开启故障转移模式
                            if (IS_FAILOVER_MODE.equals(line1)) {
                                switchParams.put(FAILOVER_MODE_PARAM, Boolean.TRUE.toString());
                                NAMING_LOGGER.info("failover-mode is on");
                                new FailoverFileReader().run();
                            } else if (NO_FAILOVER_MODE.equals(line1)) {
                             // 0表示关闭故障转移模式
                                switchParams.put(FAILOVER_MODE_PARAM, Boolean.FALSE.toString());
                                NAMING_LOGGER.info("failover-mode is off");
                            }
                        }
                    } else {
                        switchParams.put(FAILOVER_MODE_PARAM, Boolean.FALSE.toString());
                    }
                }
                
            } catch (Throwable e) {
                NAMING_LOGGER.error("[NA] failed to read failover switch.", e);
            }
        }
    }

DiskFileWriter执行

这里就是回判断是否满足写入磁盘文件如果满足则将服务信息写入前面拼接的故障转移目录：${user.home}/nacos/naming/public/failover。只不过第二个定时任务和第三个定时任务的区别时，第三个定时任务有前置判断，只有当文件不存在时才执行。

    class DiskFileWriter extends TimerTask {
        
        @Override
        public void run() {
            Map<String, ServiceInfo> map = serviceInfoHolder.getServiceInfoMap();
            for (Map.Entry<String, ServiceInfo> entry : map.entrySet()) {
                ServiceInfo serviceInfo = entry.getValue();
                if (StringUtils.equals(serviceInfo.getKey(), UtilAndComs.ALL_IPS) || StringUtils
                        .equals(serviceInfo.getName(), UtilAndComs.ENV_LIST_KEY) || StringUtils
                        .equals(serviceInfo.getName(), UtilAndComs.ENV_CONFIGS) || StringUtils
                        .equals(serviceInfo.getName(), UtilAndComs.VIP_CLIENT_FILE) || StringUtils
                        .equals(serviceInfo.getName(), UtilAndComs.ALL_HOSTS)) {
                    continue;
                }
                // 将缓存内容写入磁盘文件
                DiskCache.write(serviceInfo, failoverDir);
            }
        }
    }

FailoverFileReader

故障转移文件读取。基本操作就是读取failover目录存储ServiceInfo的文件内容，然后转换成ServiceInfo，并用将所有的ServiceInfo存储在FailoverReactor的serviceMap属性中。

    class FailoverFileReader implements Runnable {
        
        @Override
        public void run() {
            Map<String, ServiceInfo> domMap = new HashMap<String, ServiceInfo>(16);
            
            BufferedReader reader = null;
            try {
                //拿故障文件
                File cacheDir = new File(failoverDir);
                if (!cacheDir.exists() && !cacheDir.mkdirs()) {
                    throw new IllegalStateException("failed to create cache dir: " + failoverDir);
                }
                
                File[] files = cacheDir.listFiles();
                if (files == null) {
                    return;
                }
                //遍历
                for (File file : files) {
                    if (!file.isFile()) {
                        continue;
                    }
                    
                    if (file.getName().equals(UtilAndComs.FAILOVER_SWITCH)) {
                        continue;
                    }
                    
                    ServiceInfo dom = new ServiceInfo(file.getName());
                    
                    try {
                    //读文件
                        String dataString = ConcurrentDiskUtil
                                .getFileContent(file, Charset.defaultCharset().toString());
                        reader = new BufferedReader(new StringReader(dataString));
                        
                        String json;
                        if ((json = reader.readLine()) != null) {
                            try {
                               //构建SeriviceInfo
                                dom = JacksonUtils.toObj(json, ServiceInfo.class);
                            } catch (Exception e) {
                                NAMING_LOGGER.error("[NA] error while parsing cached dom : {}", json, e);
                            }
                        }
                        
                    } catch (Exception e) {
                        NAMING_LOGGER.error("[NA] failed to read cache for dom: {}", file.getName(), e);
                    } finally {
                        try {
                            if (reader != null) {
                                reader.close();
                            }
                        } catch (Exception e) {
                            //ignore
                        }
                    }
                    //将dom放到临时存储的map中
                    if (!CollectionUtils.isEmpty(dom.getHosts())) {
                        domMap.put(dom.getKey(), dom);
                    }
                }
            } catch (Exception e) {
                NAMING_LOGGER.error("[NA] failed to read cache file", e);
            }
            //当domMap 的Size 大于0 恢复serviceMap 缓存
            if (domMap.size() > 0) {
                serviceMap = domMap;
            }
        }
    }

代码基本流程如下：

读取failover目录下的所有文件，进行遍历处理；
如果文件不存在，跳过；
如果文件是故障转移标志文件，跳过；
读取文件中的json内容，转化为ServiceInfo对象；
将ServiceInfo对象放入domMap当中；
当domMap的Size大于0将domMap赋值给serviceMap达到服务的缓存恢复

参考链接

https://zhuanlan.zhihu.com/p/400891365

qq_41956309
关注
专栏目录
Nacos 故障转移源码分析（FailoverReactor）
weixin_42118323的博客
07-19 1420
SwitchRefresher 实现了 Runnable 接口，业务逻辑都在 run 方法中，首先会判断故障转移文件是否存在，不存在则直接返回，然后判断文件是否修改了，如果已经修改，则获取故障转移文件中的内容，故障转移文件内容中存储了 0 和 1 标识，0 表示故障转移关闭、1 表示故障转移开启，当为开启状态时，会执行线程 FailoverFileReader#run 方法。本篇我们来简单分析一下 Nacos 的故障转移。至此，Nacos 故障转移源码分析完毕，希望可以帮助到有需要的朋友。
Nacos 配置中心 Client 端配置热更新源码分析
weixin_42118323的博客
07-23 1356
作为配置中心，热更新功能是必不可少的，Nacos 配置中心当然也是支持热更新功能的，上一篇我们分析了 Nacos 配置中心配置是如何加载的，本篇我们一起从源码的角度来分析一下 Nacos 配置中心的热更新源码。
Nacos客户端本地缓存和故障转移
03-30 7329
在Nacos客户端从Server获得服务的时候，在某些时候出现了一些故障， 这时候为了保证服务正常，Nacos进行了故障转移，原理就是将之前缓存的服务信息拿出来用，防止服务出现问题，涉及到的核心类为ServiceInfoHolder和FailoverReactor。 本地缓存有两方面，第一方面是从注册中心获得实例信息会缓存在内存当中，也就是通过Map的形式承载，这样查询操作都方便。第二方面便是通过磁盘文件的形式定时缓存起来，以备不时之需。 故障转移也分两方面，第一方面是故障转...
查看nacos在应用中的本地缓存
xu990128638的专栏
06-16 3158
每个项目可能路径不一样。
nacos client 本地缓存问题
最新发布
一个写了10年bug的程序员日常笔记。
09-30 729
Nacos Client 在进行服务发现时，也会将服务实例的信息缓存在本地。这样，即使 Nacos 服务器不可用，客户端仍然可以使用缓存的服务实例信息进行服务调用。Nacos Client 会将从 Nacos 服务器获取的配置信息缓存在本地。：当 Nacos 服务器上的配置发生变化时，Nacos Client 会通过长轮询机制（Long Polling）及时获取最新的配置，并更新本地缓存。：Nacos Client 会定期从 Nacos 服务器拉取最新的服务实例信息，并更新本地缓存。缓存文件的路径通常是。
Nacos 客户端本地缓存及故障转移源码分析（四）
vnjohn 博主 > 主线分享后端领域业务设计知识、源码思想、架构设计
01-21 2999
ServiceInfoHolder：顾名思义，服务信息的持有者；缓存 ServiceInfo判断 ServiceInfo 是否更新发起写入本地缓存发布变更事件除了这些核心功能以外，该类在实例化时，还做了本地缓存目录初始化、故障转移初始化等操作，下面来进行详细分析。
nacos客户端缓存失败
zuidenaoshi的专栏
07-25 581
springcloud 集成naocs 作为配置中心。
21 Nacos客户端本地缓存及故障转移
weixin_39563769的博客
03-03 2335
nacos本地缓存以及故障转移
nacos 源码和安装包
08-08
4. **数据存储**：Nacos 使用 MySQL 或者内存（ephemeral mode）存储服务注册和配置信息，源码中可以看到如何与数据库交互以及缓存策略。 5. **RESTful API**：Nacos 提供了 RESTful API 接口供外部系统调用，通过...
nacos源码分析
weixin_45596022的博客
03-06 2073
一，nacos核心功能点 服务注册: Nacos Client会通过发送REST请求的方式向Nacos Server注册自己的服务，提供自身的元 数据，比如ip地址、端口等信息。Nacos Server接收到注册请求后，就会把这些元数据信息存储在一个双层的内存Map中。 服务心跳:在服务注册后，Nacos Client会维护一个定时心跳来持续通知Nacos Server,说明服务一直处于可用状态，防止被剔除。默认5s发送一-次心跳。 服务同步: Nacos Server集群之间会互相同步服务实例,用来保证服
Nacos源码分析
qq_40011574的博客
10-18 643
Nacos源码分析
本地服务注册远程nacos 会在本地生成缓存文件
纯洁的明依
06-11 2981
```bash /Users/apple/nacos/config/fixed-10.0.201.98_8848-tech_wzkf_app_nacos/snapshot-tenant/tech_wzkf_app/DEFAULT_GROUP‘ 次目录下会生成 **-dev.properties。 ** 代表服务名称 jdbc.url=jdbc:mysql://*:3306/appclient?useUnicode=true&characterEncoding=utf-8 jdbc.userna.
用缓存存储Nacos元数据
weixin_37632716的博客
03-29 688
@Component public class DataStore{ //内存缓存对象 private Map<String,Datum> dataMap = new ConcurrentHashMap<>(1024); public void put(String key,Datum value){ dataMap.put(key,value); } public Datum remove(String key){ return dataMa
06篇 Nacos Client本地缓存及故障转移
程序新视界
08-18 3418
学习不用那么功利，二师兄带你从更高维度轻松阅读源码～ 本篇文章我们来通过源码分析一下Nacos的本地缓存及故障转移功能，涉及到核心类为ServiceInfoHolder和FailoverReactor。 ServiceInfoHolder功能概述 ServiceInfoHolder类，顾名思义，服务信息的持有者。前面文章已经多次涉及到ServiceInfoHolder类，比如每次客户端从注册中心获取新的服务信息时都会调用该类的processServiceInfo方法来进行本地化的处理，包括更新缓存服务、.
源码篇--Nacos服务--中章(6):Nacos客户端启动-grpc通道建立&客户端服务信息获取(故障转移)细节
拽着尾巴的鱼儿的博客
04-24 1280
在源码篇–Nacos服务–中章(5) 对nacos 客户端的创建及grpc 连接的建立，心跳检查，实例注册进行了介绍；本文对grpc通道建立&客户端服务信息获取(故障转移)细节进行介绍。本文对客户端服务信息获取的故障转移细节，及客户端同服务端的grpc 连接建立进行介绍。
微服务: nacos配置中心开启-＞ 创建jvm的本地缓存(减少数据库压力)实战,遇到的问题,以及解决方式(双重校验)
pingzhuyan的博客
02-08 1995
目录 先看一个测试案例 微服务在后面!!! 应用场景: 01 测试代码:(放到后面, 主要看效果) 进行测试: --------------------> 异常问题修改 修改方案一:(不推荐) 修改方案二: ( jdk1.5推出,推荐) 数据添加错误(重复添加修复) 添加一个同步代码块 查看测试结果: 成功!!! 写一个好代码真难 微服务 使用场景 当并发量大的时候选择开启 不需要的时候关闭 先看一个测试案例 微服务在后面!!! 应用场景: ...
JAVA 简单缓存实现-nacos
shadow_zed的博客
11-30 578
JAVA 缓存实现-nacos实现。
优化springCloud节点下线后因nacos本地缓存发生的异常事件
weixin_54963915的博客
09-07 885
系统优化
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值