apollo客户端如何实时刷新配置数据？

于 2024-10-10 10:08:22 发布
阅读量402 收藏
点赞数 15
分类专栏： apollo 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_27496129/article/details/142814055
版权 
public class RemoteConfigLongPollService {
    // 日志
    private static final Logger logger = LoggerFactory.getLogger(RemoteConfigLongPollService.class);
    private static final Joiner STRING_JOINER = Joiner.on("+");
    private static final MapJoiner MAP_JOINER = Joiner.on("&").withKeyValueSeparator("=");
    private static final Escaper queryParamEscaper = UrlEscapers.urlFormParameterEscaper();
    private static final long INIT_NOTIFICATION_ID = -1L;
    // 读超时
    private static final int LONG_POLLING_READ_TIMEOUT = 90000;
    // 一个单线程的执行器
    private final ExecutorService m_longPollingService = Executors.newSingleThreadExecutor(ApolloThreadFactory.create("RemoteConfigLongPollService", true));
    private final AtomicBoolean m_longPollingStopped = new AtomicBoolean(false);
    // 策略
    private SchedulePolicy m_longPollFailSchedulePolicyInSecond = new ExponentialSchedulePolicy(1L, 120L);
    // 限流
    private RateLimiter m_longPollRateLimiter;
    private final AtomicBoolean m_longPollStarted = new AtomicBoolean(false);
    // 从apollo服务端拿到的不同namespace的结果数据集合：线程安全
    private final Multimap<String, RemoteConfigRepository> m_longPollNamespaces = Multimaps.synchronizedSetMultimap(HashMultimap.create());
    // 通知信息：<{namespaceName},{notificationId}>
    private final ConcurrentMap<String, Long> m_notifications = Maps.newConcurrentMap();
    // 通知内容
    private final Map<String, ApolloNotificationMessages> m_remoteNotificationMessages = Maps.newConcurrentMap();
    // apollo服务端请求数据应答类型
    private Type m_responseType = (new TypeToken<List<ApolloConfigNotification>>() {}).getType();
    private Gson gson = new Gson();
    // 
    private ConfigUtil m_configUtil = (ConfigUtil)ApolloInjector.getInstance(ConfigUtil.class);
    private HttpUtil m_httpUtil = (HttpUtil)ApolloInjector.getInstance(HttpUtil.class);
    // 注册中心服务：获取可用的apollo服务侧的机器信息，用于http通信时使用
    // ConfigServiceLocator内置机制：
    // （1）schedulePeriodicRefresh()：每隔5min刷新一次，注册中心服务列表的数据，可以通过：apollo.refreshInterval配置调整时间间隔和频率
    private ConfigServiceLocator m_serviceLocator = (ConfigServiceLocator)ApolloInjector.getInstance(ConfigServiceLocator.class);

    // 构造器
    public RemoteConfigLongPollService() {
        // 搞一个限流器
        // 默认QPS=2
        this.m_longPollRateLimiter = RateLimiter.create((double)this.m_configUtil.getLongPollQPS());
    }
    
    // 提交的任务从这里开始
    public boolean submit(String namespace, 	// 命名空间
                          RemoteConfigRepository remoteConfigRepository		// 上文传递过来的操作对象：this
     ) {
        // 保存当前要查询的namespace数据，主要是有上下文数据，为了数据安全一致，不会出现错乱问题
        boolean added = this.m_longPollNamespaces.put(namespace, remoteConfigRepository);
        this.m_notifications.putIfAbsent(namespace, -1L);
        // 如果尚未启动任务，则立即启动
        if (!this.m_longPollStarted.get()) {
            // 任务启动
            this.startLongPolling();
        }
        return added;
    }

    // 任务核心逻辑
    private void startLongPolling() {
        // 原子操作：更新任务状态：true
        if (this.m_longPollStarted.compareAndSet(false, true)) {
            try {
                // 从配置对象中拿到相关apollo配置参数，可以从ConfigUtil.java找到控制参数
                final String appId = this.m_configUtil.getAppId();
                final String cluster = this.m_configUtil.getCluster();
                final String dataCenter = this.m_configUtil.getDataCenter();
                final String secret = this.m_configUtil.getAccessKeySecret();
                // 参数：apollo.longPollingInitialDelayInMills，默认2000L
                final long longPollingInitialDelayInMills = this.m_configUtil.getLongPollingInitialDelayInMills();
                // 一个单线程的执行器
                this.m_longPollingService.submit(new Runnable() {
                    public void run() {
                        if (longPollingInitialDelayInMills > 0L) {
                            try {
                                RemoteConfigLongPollService.logger.debug("Long polling will start in {} ms.", longPollingInitialDelayInMills);
                                // sleep休眠的方式，控制刷新频率
                                TimeUnit.MILLISECONDS.sleep(longPollingInitialDelayInMills);
                            } catch (InterruptedException var2) {
                            }
                        }
                        
                        // 开始从apollo获取配置数据
                        RemoteConfigLongPollService.this.doLongPollingRefresh(appId, cluster, dataCenter, secret);
                    }
                });
            } catch (Throwable var7) {
                this.m_longPollStarted.set(false);
                ApolloConfigException exception = new ApolloConfigException("Schedule long polling refresh failed", var7);
                Tracer.logError(exception);
                logger.warn(ExceptionUtil.getDetailMessage(exception));
            }

        }
    }

    // 任务关停
    void stopLongPollingRefresh() {
        this.m_longPollingStopped.compareAndSet(false, true);
    }

    // 从apollo获取配置数据
    private void doLongPollingRefresh(String appId, String cluster, String dataCenter, String secret) {
        Random random = new Random();
        // 通信目标服务信息
        ServiceDTO lastServiceDto = null;

        // 非停止状态，当前线程正常运行的情况下
        while(!this.m_longPollingStopped.get() && !Thread.currentThread().isInterrupted()) {
            // 限流机制（默认2次）
            if (!this.m_longPollRateLimiter.tryAcquire(5L, TimeUnit.SECONDS)) {
                try {
                    TimeUnit.SECONDS.sleep(5L);
                } catch (InterruptedException var21) {
                }
            }

            // 事务控制（Tracer追踪工具）
            Transaction transaction = Tracer.newTransaction("Apollo.ConfigService", "pollNotification");
            String url = null;

            try {
                if (lastServiceDto == null) {
                    // 从注册中心拿到机器注册列表
                    List<ServiceDTO> configServices = this.getConfigServices();
                    // 随便选举一个
                    lastServiceDto = (ServiceDTO)configServices.get(random.nextInt(configServices.size()));
                }

                // 组装目标服务的url
                url = this.assembleLongPollRefreshUrl(lastServiceDto.getHomepageUrl(), appId, cluster, dataCenter, this.m_notifications);
                logger.debug("Long polling from {}", url);
                // 组装request
                HttpRequest request = new HttpRequest(url);
                request.setReadTimeout(90000);
                // 密钥数据配置
                if (!StringUtils.isBlank(secret)) {
                    Map<String, String> headers = Signature.buildHttpHeaders(url, appId, secret);
                    request.setHeaders(headers);
                }

                transaction.addData("Url", url);
                // 主动发起GET请求，获取通知url：notifications/v2/***
                HttpResponse<List<ApolloConfigNotification>> response = this.m_httpUtil.doGet(request, this.m_responseType);
                logger.debug("Long polling response: {}, url: {}", response.getStatusCode(), url);
                // 结果数据检测&处理
                // 成功
                if (response.getStatusCode() == 200 && response.getBody() != null) {
                    // 收集通知目标数据·1
                    this.updateNotifications((List)response.getBody());
                    // 收集通知目标数据·2
                    this.updateRemoteNotifications((List)response.getBody());
                    transaction.addData("Result", ((List)response.getBody()).toString());
                    // 收集完成后，开始通知操作
                    this.notify(lastServiceDto, (List)response.getBody());
                }

                // 异常
                if (response.getStatusCode() == 304 && random.nextBoolean()) {
                    lastServiceDto = null;
                }
                
                // 一次longpoll完成
                this.m_longPollFailSchedulePolicyInSecond.success();
                transaction.addData("StatusCode", response.getStatusCode());
                transaction.setStatus("0");
            } catch (Throwable var19) {
                lastServiceDto = null;
                Tracer.logEvent("ApolloConfigException", ExceptionUtil.getDetailMessage(var19));
                transaction.setStatus(var19);
                // 失败时，有自己的休眠时间
                long sleepTimeInSecond = this.m_longPollFailSchedulePolicyInSecond.fail();
                logger.warn("Long polling failed, will retry in {} seconds. appId: {}, cluster: {}, namespaces: {}, long polling url: {}, reason: {}", new Object[]{sleepTimeInSecond, appId, cluster, this.assembleNamespaces(), url, ExceptionUtil.getDetailMessage(var19)});

                try {
                    // 休息一会
                    TimeUnit.SECONDS.sleep(sleepTimeInSecond);
                } catch (InterruptedException var18) {
                }
            } finally {
                // 事务完成
                transaction.complete();
            }
        }

    }

    // 收集完成后，开始通知操作
    private void notify(ServiceDTO lastServiceDto, 		// 注册中心，续接前文中使用的目标机器的信息
                        List<ApolloConfigNotification> notifications   // 消息通知数据
    ) {
        if (notifications != null && !notifications.isEmpty()) {
            Iterator i$ = notifications.iterator();

            while(i$.hasNext()) {
                ApolloConfigNotification notification = (ApolloConfigNotification)i$.next();
                String namespaceName = notification.getNamespaceName();
                // 拿到需要被通知的ID
                List<RemoteConfigRepository> toBeNotified = Lists.newArrayList(this.m_longPollNamespaces.get(namespaceName));
                // 拿到需要被通知的Messages
                ApolloNotificationMessages originalMessages = (ApolloNotificationMessages)this.m_remoteNotificationMessages.get(namespaceName);
                // 克隆一份
                ApolloNotificationMessages remoteMessages = originalMessages == null ? null : originalMessages.clone();
                // 追加一种扩展数据：比如：application.properties，有则加入，没有
                toBeNotified.addAll(this.m_longPollNamespaces.get(String.format("%s.%s", namespaceName, ConfigFileFormat.Properties.getValue())));
                Iterator i$ = toBeNotified.iterator();
                // 迭代
                while(i$.hasNext()) {
                    // 拿到当前namespaceName在前文装配好的RemoteConfigRepository数据
                    RemoteConfigRepository remoteConfigRepository = (RemoteConfigRepository)i$.next();

                    try {
                        // 调用前文操作对象，启动通知逻辑（详细后续逻辑移步：RemoteConfigRepository.java文件）
                        // 通知内容：举例：remoteMessages的格式：123+default+java-project -> {Long@6682} 16
                        remoteConfigRepository.onLongPollNotified(lastServiceDto, remoteMessages);
                    } catch (Throwable var12) {
                        Tracer.logError(var12);
                    }
                }
            }

        }
    }

    // 收集通知目标数据·1
    private void updateNotifications(List<ApolloConfigNotification> deltaNotifications) {
        Iterator i$ = deltaNotifications.iterator();

        while(i$.hasNext()) {
            ApolloConfigNotification notification = (ApolloConfigNotification)i$.next();
            if (!Strings.isNullOrEmpty(notification.getNamespaceName())) {
                String namespaceName = notification.getNamespaceName();
                if (this.m_notifications.containsKey(namespaceName)) {
                    this.m_notifications.put(namespaceName, notification.getNotificationId());
                }
                // 待前缀的
                // 比如：java-project.properties 或者 application.properties
                String namespaceNameWithPropertiesSuffix = String.format("%s.%s", namespaceName, ConfigFileFormat.Properties.getValue());
                if (this.m_notifications.containsKey(namespaceNameWithPropertiesSuffix)) {
                    this.m_notifications.put(namespaceNameWithPropertiesSuffix, notification.getNotificationId());
                }
            }
        }

    }

    // 收集通知目标数据·2
    private void updateRemoteNotifications(List<ApolloConfigNotification> deltaNotifications) {
        Iterator i$ = deltaNotifications.iterator();

        while(i$.hasNext()) {
            ApolloConfigNotification notification = (ApolloConfigNotification)i$.next();
            if (!Strings.isNullOrEmpty(notification.getNamespaceName()) && notification.getMessages() != null && !notification.getMessages().isEmpty()) {
                ApolloNotificationMessages localRemoteMessages = (ApolloNotificationMessages)this.m_remoteNotificationMessages.get(notification.getNamespaceName());
                if (localRemoteMessages == null) {
                    localRemoteMessages = new ApolloNotificationMessages();
                    this.m_remoteNotificationMessages.put(notification.getNamespaceName(), localRemoteMessages);
                }
                // 收集数据：Messages：123+default+application -> {Long@6671} 19
                // 数据装填
                localRemoteMessages.mergeFrom(notification.getMessages());
            }
        }

    }

    private String assembleNamespaces() {
        return STRING_JOINER.join(this.m_longPollNamespaces.keySet());
    }

    // 组装目标服务的url
    String assembleLongPollRefreshUrl(String uri, String appId, String cluster, String dataCenter, Map<String, Long> notificationsMap) {
        Map<String, String> queryParams = Maps.newHashMap();
        queryParams.put("appId", queryParamEscaper.escape(appId));
        queryParams.put("cluster", queryParamEscaper.escape(cluster));
        queryParams.put("notifications", queryParamEscaper.escape(this.assembleNotifications(notificationsMap)));
        if (!Strings.isNullOrEmpty(dataCenter)) {
            queryParams.put("dataCenter", queryParamEscaper.escape(dataCenter));
        }

        String localIp = this.m_configUtil.getLocalIp();
        if (!Strings.isNullOrEmpty(localIp)) {
            queryParams.put("ip", queryParamEscaper.escape(localIp));
        }

        String params = MAP_JOINER.join(queryParams);
        if (!uri.endsWith("/")) {
            uri = uri + "/";
        }

        return uri + "notifications/v2?" + params;
    }

    String assembleNotifications(Map<String, Long> notificationsMap) {
        List<ApolloConfigNotification> notifications = Lists.newArrayList();
        Iterator i$ = notificationsMap.entrySet().iterator();

        while(i$.hasNext()) {
            Entry<String, Long> entry = (Entry)i$.next();
            ApolloConfigNotification notification = new ApolloConfigNotification((String)entry.getKey(), (Long)entry.getValue());
            notifications.add(notification);
        }

        return this.gson.toJson(notifications);
    }

    private List<ServiceDTO> getConfigServices() {
        List<ServiceDTO> services = this.m_serviceLocator.getConfigServices();
        if (services.size() == 0) {
            throw new ApolloConfigException("No available config service");
        } else {
            return services;
        }
    }
}

......
// longpoll的注册中心选举出的目标服务信息（具有原子性）
private final AtomicReference<ServiceDTO> m_longPollServiceDto;
// 当前namespaceName对应的通知remoteMessages信息（具有原子性）
private final AtomicReference<ApolloNotificationMessages> m_remoteMessages;
// 单线程任务执行器
private static final ScheduledExecutorService m_executorService = 
            Executors.newScheduledThreadPool(1, ApolloThreadFactory.create("RemoteConfigRepository", true));
......
// 来之RemoteConfigLongPollService.java触发的方法
public void onLongPollNotified(ServiceDTO longPollNotifiedServiceDto, // 注册中心，续接前文中使用的目标机器的信息
                               // 通知内容：举例：remoteMessages的格式：123+default+java-project -> {Long@6682} 16
                               ApolloNotificationMessages remoteMessages 
  ) {
    // longpoll的注册中心选举出的目标服务信息（具有原子性）
    this.m_longPollServiceDto.set(longPollNotifiedServiceDto);
    // 当前namespaceName对应的通知remoteMessages信息（具有原子性）
    this.m_remoteMessages.set(remoteMessages);
    // 单线程任务执行器
    m_executorService.submit(new Runnable() {
        public void run() {
            // 强制刷新标记：true
            RemoteConfigRepository.this.m_configNeedForceRefresh.set(true);
            // 使用抽象父类中的trySync()，触发当前类的：this.sync(); （后文会详细说明这块）
            // 主动触发一次同步操作（和服务启动时，主动触发的方式一致，只不过这里在longpoll机制中添加了触发锚点）
            RemoteConfigRepository.this.trySync();
        }
    });
}

具体的 “RemoteConfigRepository.this.trySync();”请查看前文中对应的逻辑

此处为语雀内容卡片，点击链接查看：https://www.yuque.com/xiaofengweiling/fkrpy5/ltzdv77vbvrzdi06

成熟的小白
关注
专栏目录
SpringBoot——》Apollo客户端监听配置变化、动态刷新
小仙~
01-18 7872
@Value ，动态刷新 @ConfigurationProperties , 需要添加apollo配置监听器 @ApolloConfigChangeListener 实现动态刷新 一、配置 1、pom.xml <dependency> <groupId>com.ctrip.framework.apollo</groupId> <artifactId>apollo-client</artifactId> <.
springboot整合apollo实现配置实时更新
qq_43618698的博客
12-17 4245
springboot整合apollo实现配置实时更新 首先导入apollo客户端依赖： <dependency> <groupId>com.ctrip.framework.apollo</groupId> <artifactId>apollo-client</artifactId> <version>1.3.0</version> </dependency> 然后在配置文件中编写apol
一文读懂Apollo客户端配置加载流程
听得到微笑的博客
05-26 4797
Apollo 启动时会在扩展点开始加载远端配置，而Apollo客户端获取配置采用多层设计->->，最终由完成远端配置拉取负责拉取远端配置并通知更新配置。负责将远端配置缓存至本地文件，设计这一层主要是为了在Apollo Server 不可用时保证业务服务的可用性。当配置发生变更时负责通知更新配置。负责缓存Apollo配置信息在内存中，当配置发生变更时，会回调方法更新Java Bean 中的属性。
携程一面：分布式配置系统Apollo是如何实时更新配置的？
Java笔记虾
11-27 3528
点击上方“Java金融”，选择“设为星标”后台回复"888"获取bat面试题集引言记得我们那时候刚开始学习Java的时候都只是一个单体项目，项目里面的配置基本都是写在项目里面的proper...
apollo客户端-首次获取server数据？
最新发布
qq_27496129的博客
10-09 296
通过被添加到 Spring 的环境属性源集合中，利用 Spring 的属性查找和依赖注入机制，以及自动更新机制（如果启用），使得新的配置能够在应用中生效。至此，可以看到，从 apollo 服务端侧拿到了配置数据，接下来要看一下，拿到的数据时如何更新到客户端参数的。还需要续接前文的：ApolloApplicationContextInitializer.java。
Apollo客户端源码解析
Lisam Blog
05-17 1064
本节主要对 Apollo 客户端设计原理进行解析。 设计原理 简要描述了 Apollo 客户端的实现原理 注册bean spring启动时调用bean初始化 获取namespace并初始化配置并写一份配置到文件中，开启线程长轮训+定时拉取配置 添加监听listener 扫描字段、方法转化成SpringValue，保存在SpringValueRegistry中 http长轮训+定时拉取服务端配置 更新SpringValue 准备工作 利用EnableApolloConfig...
apollo修改配置刷新bean_2020年了还不知道配置中心？
weixin_39604516的博客
11-20 445
点击上方蓝字关注我~添加星标置顶公众号第一时间收到推送Hi，好久不见，我是你们的walking，在这个高燃BGM下又和大家见面了????。今天分享一个分布式、微服务架构中重要的一个组件：配置中心。也许你们现在的项目不是分布式、微服务架构，没有用到配置中心，也没听说过配置中心，对它完全很陌生，那你就很有必要阅读本文了。本文将从1)什么是配置、什么是配置中心以及配置中心的诞生讲起，2)然后简单介绍...
apollo修改配置刷新bean_springboot实战之整合配置中心实现动态刷新（Apollo篇）
weixin_39941262的博客
11-21 1414
分布式apollo简介Apollo(阿波罗)是携程框架部门研发的开源配置管理中心，能够集中化管理应用不同环境、不同集群的配置，配置修改后能够实时推送到应用端，并且具备规范的权限、流程治理等特性。本文主要介绍如何使用apollo与springboot实现动态刷新配置，如果之前不了解apollo可以查看如下文档https://github.com/ctripcorp/apollo学习了解一下...
Apollo/Nacos配置动态刷新原理及优劣
fengbird的博客
02-10 4099
Apollo、nacos配置动态刷新的原理及优劣对比
Apollo配置中心客户端使用案例源码
02-24
在某些情况下，可能需要手动刷新配置，例如在测试环境中。客户端提供了`ApolloConfig.reload()`方法，调用后会从服务器拉取最新的配置。 5. **应用元数据** Apollo客户端需要应用的元数据（如应用ID、IP等）来...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 931
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1223
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 364
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 705
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Java中的break、continue和return语句
weixin_73230994的博客
10-05 377
break语句用于终止某个语句块的执行，一般使用在switch或者循环【for, while ,do-while】（提前退出或结束循环不是终止程序）1.continue语句用于结束本次循环，继续执行下一次循环2.continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和前面的标签的使用规则一样。
Netty 相比原生IO模型的优势
lssffy的博客
10-09 356
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
11.2 Linux_线程_同步与互斥
Fresh_man111的博客
10-03 195
同一时刻只允许一个任务访问的共享资源。比如写入文件，就是一个临界资源，当写入文件时，不允许两个任务同时往里面写。如果A写入abc，B写入def，同时写的情况下文件中的值不一定为abcdef，这时就需要在某一时刻只允许A写入abc，在另一时刻只允许B写入def。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

成熟的小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值