soul数据同步nacos(1)

最新推荐文章于 2023-03-08 23:21:26 发布
最新推荐文章于 2023-03-08 23:21:26 发布
阅读量225 收藏
点赞数
分类专栏： 微服务 文章标签： 网关 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ti_an_di/article/details/113013937
版权

1. 在【soul-admin】中开启nacos同步

soul:

  sync:

    nacos:

      url: localhost:8848

      namespace: 1c10d748-af86-43b9-8265-75f487d20c6c

      acm:

        enabled: false

        endpoint: acm.aliyun.com

        namespace:

        accessKey:

        secretKey:

2. 在【soul-bootstrap】中添加nacos数据同步依赖

<dependency>

    <groupId>org.dromara</groupId>

    <artifactId>soul-spring-boot-starter-sync-data-nacos</artifactId>

    <version>${project.version}</version>

</dependency>

3.在【soul-bootstrap】中开启nacos同步

soul:

  sync:

    nacos:

      url: localhost:8848

      namespace: 1c10d748-af86-43b9-8265-75f487d20c6c

      acm:

        enabled: false

        endpoint: acm.aliyun.com

        namespace:

        accessKey:

        secretKey:

4. 这样启动 【soul-admin】和 【soul-bootstrap】，他们之间的数据就完成同步了。

带着问题读源码之【soul-admin】如何完成数据推送

上述第一步打开如下配置:

@Configuration
    @ConditionalOnProperty(prefix = "soul.sync.nacos", name = "url")
    @Import(NacosConfiguration.class)
    static class NacosListener {

        /**
         * Data changed listener data changed listener.
         *
         * @param configService the config service
         * @return the data changed listener
         */
        @Bean
        @ConditionalOnMissingBean(NacosDataChangedListener.class)
        public DataChangedListener nacosDataChangedListener(final ConfigService configService) {
            return new NacosDataChangedListener(configService);
        }
    }
@EnableConfigurationProperties(NacosProperties.class)
public class NacosConfiguration {

    /**
     * register configService in spring ioc.
     *
     * @param nacosProp the nacos configuration
     * @return ConfigService {@linkplain ConfigService}
     * @throws Exception the exception
     */
    @Bean
    @ConditionalOnMissingBean(ConfigService.class)
    public ConfigService nacosConfigService(final NacosProperties nacosProp) throws Exception {
        Properties properties = new Properties();
        if (nacosProp.getAcm() != null && nacosProp.getAcm().isEnabled()) {
            // Use aliyun ACM service
            properties.put(PropertyKeyConst.ENDPOINT, nacosProp.getAcm().getEndpoint());
            properties.put(PropertyKeyConst.NAMESPACE, nacosProp.getAcm().getNamespace());
            // Use subaccount ACM administrative authority
            properties.put(PropertyKeyConst.ACCESS_KEY, nacosProp.getAcm().getAccessKey());
            properties.put(PropertyKeyConst.SECRET_KEY, nacosProp.getAcm().getSecretKey());
        } else {
            properties.put(PropertyKeyConst.SERVER_ADDR, nacosProp.getUrl());
            properties.put(PropertyKeyConst.NAMESPACE, nacosProp.getNamespace());
        }
        return NacosFactory.createConfigService(properties);
    }
}

注册了数据变动监听器

public class NacosDataChangedListener implements DataChangedListener {

    private static final ConcurrentMap<String, PluginData> PLUGIN_MAP = Maps.newConcurrentMap();

    private static final ConcurrentMap<String, List<SelectorData>> SELECTOR_MAP = Maps.newConcurrentMap();

    private static final ConcurrentMap<String, List<RuleData>> RULE_MAP = Maps.newConcurrentMap();

    private static final ConcurrentMap<String, AppAuthData> AUTH_MAP = Maps.newConcurrentMap();

    private static final ConcurrentMap<String, MetaData> META_DATA = Maps.newConcurrentMap();

    private static final Comparator<SelectorData> SELECTOR_DATA_COMPARATOR = Comparator.comparing(SelectorData::getSort);

    private static final Comparator<RuleData> RULE_DATA_COMPARATOR = Comparator.comparing(RuleData::getSort);

    private static final String GROUP = "DEFAULT_GROUP";

    private static final String PLUGIN_DATA_ID = "soul.plugin.json";

    private static final String SELECTOR_DATA_ID = "soul.selector.json";

    private static final String RULE_DATA_ID = "soul.rule.json";

    private static final String AUTH_DATA_ID = "soul.auth.json";

    private static final String META_DATA_ID = "soul.meta.json";

    private static final String EMPTY_CONFIG_DEFAULT_VALUE = "{}";

    private final ConfigService configService;

    public NacosDataChangedListener(final ConfigService configService) {
        this.configService = configService;
    }

    private void updateAuthMap(final String configInfo) {
        JsonObject jo = GsonUtils.getInstance().fromJson(configInfo, JsonObject.class);
        Set<String> set = new HashSet<>(AUTH_MAP.keySet());
        for (Entry<String, JsonElement> e : jo.entrySet()) {
            set.remove(e.getKey());
            AUTH_MAP.put(e.getKey(), GsonUtils.getInstance().fromJson(e.getValue(), AppAuthData.class));
        }
        AUTH_MAP.keySet().removeAll(set);
    }

    private void updatePluginMap(final String configInfo) {
        JsonObject jo = GsonUtils.getInstance().fromJson(configInfo, JsonObject.class);
        Set<String> set = new HashSet<>(PLUGIN_MAP.keySet());
        for (Entry<String, JsonElement> e : jo.entrySet()) {
            set.remove(e.getKey());
            PLUGIN_MAP.put(e.getKey(), GsonUtils.getInstance().fromJson(e.getValue(), PluginData.class));
        }
        PLUGIN_MAP.keySet().removeAll(set);
    }

    private void updateSelectorMap(final String configInfo) {
        JsonObject jo = GsonUtils.getInstance().fromJson(configInfo, JsonObject.class);
        Set<String> set = new HashSet<>(SELECTOR_MAP.keySet());
        for (Entry<String, JsonElement> e : jo.entrySet()) {
            set.remove(e.getKey());
            List<SelectorData> ls = new ArrayList<>();
            e.getValue().getAsJsonArray().forEach(je -> ls.add(GsonUtils.getInstance().fromJson(je, SelectorData.class)));
            SELECTOR_MAP.put(e.getKey(), ls);
        }
        SELECTOR_MAP.keySet().removeAll(set);
    }

    private void updateMetaDataMap(final String configInfo) {
        JsonObject jo = GsonUtils.getInstance().fromJson(configInfo, JsonObject.class);
        Set<String> set = new HashSet<>(META_DATA.keySet());
        for (Entry<String, JsonElement> e : jo.entrySet()) {
            set.remove(e.getKey());
            META_DATA.put(e.getKey(), GsonUtils.getInstance().fromJson(e.getValue(), MetaData.class));
        }
        META_DATA.keySet().removeAll(set);
    }

    private void updateRuleMap(final String configInfo) {
        JsonObject jo = GsonUtils.getInstance().fromJson(configInfo, JsonObject.class);
        Set<String> set = new HashSet<>(RULE_MAP.keySet());
        for (Entry<String, JsonElement> e : jo.entrySet()) {
            set.remove(e.getKey());
            List<RuleData> ls = new ArrayList<>();
            e.getValue().getAsJsonArray().forEach(je -> ls.add(GsonUtils.getInstance().fromJson(je, RuleData.class)));
            RULE_MAP.put(e.getKey(), ls);
        }
        RULE_MAP.keySet().removeAll(set);
    }

    @SneakyThrows
    private String getConfig(final String dataId) {
        String config = configService.getConfig(dataId, GROUP, 6000);
        return StringUtils.hasLength(config) ? config : EMPTY_CONFIG_DEFAULT_VALUE;
    }

    @SneakyThrows
    private void publishConfig(final String dataId, final Object data) {
        configService.publishConfig(dataId, GROUP, GsonUtils.getInstance().toJson(data));
    }

    @Override
    @SneakyThrows
    public void onAppAuthChanged(final List<AppAuthData> changed, final DataEventTypeEnum eventType) {
        updateAuthMap(getConfig(AUTH_DATA_ID));
        switch (eventType) {
            case DELETE:
                changed.forEach(appAuth -> AUTH_MAP.remove(appAuth.getAppKey()));
                break;
            case REFRESH:
            case MYSELF:
                Set<String> set = new HashSet<>(AUTH_MAP.keySet());
                changed.forEach(appAuth -> {
                    set.remove(appAuth.getAppKey());
                    AUTH_MAP.put(appAuth.getAppKey(), appAuth);
                });
                AUTH_MAP.keySet().removeAll(set);
                break;
            default:
                changed.forEach(appAuth -> AUTH_MAP.put(appAuth.getAppKey(), appAuth));
                break;
        }
        publishConfig(AUTH_DATA_ID, AUTH_MAP);
    }

    @Override
    public void onPluginChanged(final List<PluginData> changed, final DataEventTypeEnum eventType) {
        updatePluginMap(getConfig(PLUGIN_DATA_ID));
        switch (eventType) {
            case DELETE:
                changed.forEach(plugin -> PLUGIN_MAP.remove(plugin.getName()));
                break;
            case REFRESH:
            case MYSELF:
                Set<String> set = new HashSet<>(PLUGIN_MAP.keySet());
                changed.forEach(plugin -> {
                    set.remove(plugin.getName());
                    PLUGIN_MAP.put(plugin.getName(), plugin);
                });
                PLUGIN_MAP.keySet().removeAll(set);
                break;
            default:
                changed.forEach(plugin -> PLUGIN_MAP.put(plugin.getName(), plugin));
                break;
        }
        publishConfig(PLUGIN_DATA_ID, PLUGIN_MAP);
    }

    @Override
    public void onSelectorChanged(final List<SelectorData> changed, final DataEventTypeEnum eventType) {
        updateSelectorMap(getConfig(SELECTOR_DATA_ID));
        switch (eventType) {
            case DELETE:
                changed.forEach(selector -> {
                    List<SelectorData> ls = SELECTOR_MAP
                            .getOrDefault(selector.getPluginName(), new ArrayList<>())
                            .stream()
                            .filter(s -> !s.getId().equals(selector.getId()))
                            .sorted(SELECTOR_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    SELECTOR_MAP.put(selector.getPluginName(), ls);
                });
                break;
            case REFRESH:
            case MYSELF:
                // 将原来的数据删除并加入新的数据进去，全量更新
                Set<String> set = new HashSet<>(SELECTOR_MAP.keySet());
                changed.forEach(selector -> {
                    set.remove(selector.getPluginName());
                    List<SelectorData> ls = SELECTOR_MAP
                            .getOrDefault(selector.getPluginName(), new ArrayList<>())
                            .stream()
                            .sorted(SELECTOR_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    SELECTOR_MAP.put(selector.getPluginName(), ls);
                });
                SELECTOR_MAP.keySet().removeAll(set);
                break;
            default:
                // 增量更新
                changed.forEach(selector -> {
                    List<SelectorData> ls = SELECTOR_MAP
                            .getOrDefault(selector.getPluginName(), new ArrayList<>())
                            .stream()
                            .filter(s -> !s.getId().equals(selector.getId()))
                            .sorted(SELECTOR_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    ls.add(selector);
                    SELECTOR_MAP.put(selector.getPluginName(), ls);
                });
                break;
        }
        publishConfig(SELECTOR_DATA_ID, SELECTOR_MAP);
    }

    @Override
    public void onMetaDataChanged(final List<MetaData> changed, final DataEventTypeEnum eventType) {
        updateMetaDataMap(getConfig(META_DATA_ID));
        switch (eventType) {
            case DELETE:
                changed.forEach(meta -> META_DATA.remove(meta.getPath()));
                break;
            case REFRESH:
            case MYSELF:
                Set<String> set = new HashSet<>(META_DATA.keySet());
                changed.forEach(meta -> {
                    set.remove(meta.getPath());
                    META_DATA.put(meta.getPath(), meta);
                });
                META_DATA.keySet().removeAll(set);
                break;
            default:
                changed.forEach(meta -> {
                    META_DATA
                            .values()
                            .stream()
                            .filter(md -> Objects.equals(md.getId(), meta.getId()))
                            .forEach(md -> META_DATA.remove(md.getPath()));

                    META_DATA.put(meta.getPath(), meta);
                });
                break;
        }
        publishConfig(META_DATA_ID, META_DATA);
    }

    @Override
    public void onRuleChanged(final List<RuleData> changed, final DataEventTypeEnum eventType) {
        updateRuleMap(getConfig(RULE_DATA_ID));
        switch (eventType) {
            case DELETE:
                changed.forEach(rule -> {
                    List<RuleData> ls = RULE_MAP
                            .getOrDefault(rule.getSelectorId(), new ArrayList<>())
                            .stream()
                            .filter(s -> !s.getId().equals(rule.getId()))
                            .sorted(RULE_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    RULE_MAP.put(rule.getSelectorId(), ls);
                });
                break;
            case REFRESH:
            case MYSELF:
                Set<String> set = new HashSet<>(RULE_MAP.keySet());
                changed.forEach(rule -> {
                    set.remove(rule.getSelectorId());
                    List<RuleData> ls = RULE_MAP
                            .getOrDefault(rule.getSelectorId(), new ArrayList<>())
                            .stream()
                            .sorted(RULE_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    RULE_MAP.put(rule.getSelectorId(), ls);
                });
                RULE_MAP.keySet().removeAll(set);
                break;
            default:
                changed.forEach(rule -> {
                    List<RuleData> ls = RULE_MAP
                            .getOrDefault(rule.getSelectorId(), new ArrayList<>())
                            .stream()
                            .filter(s -> !s.getId().equals(rule.getSelectorId()))
                            .sorted(RULE_DATA_COMPARATOR)
                            .collect(Collectors.toList());
                    ls.add(rule);
                    RULE_MAP.put(rule.getSelectorId(), ls);
                });
                break;
        }

        publishConfig(RULE_DATA_ID, RULE_MAP);
    }
}

可见，nacos数据同步并没有直接【soul-bootstrap】通信，而是将数据更新到nacos后，就不管了，相当于异步的更新。

Ti_an_Di
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
spring-dubbo-hdsx-x2:JAVA脚手架集成dubbo 、springboot 、seata、swagger、nacos、soul等等
05-14
[toc] 前言 基于微服务的思想，构建在 B2C 电商场景下的项目实战。 架构图 整体的功能如下图： 技术 项目结构 模块 名称 端口 admin-web 【前端】管理后台 HTTP 8080 user-application 用户 HTTP 服务 HTTP 18082 product-application 商品 HTTP 服务 HTTP 18081 order-application 订单 HTTP 服务 HTTP 18088 后端项目，目前的项目结构如下： [-] xxx ├──[-] xxx-restful // 提供对外 HTTP API 。 ├──[-] xxx-service-api // 提供 Dubbo 服务 API 。 ├──[-] xxx-service-impl // 提供 Dubbo 服务 Service 实现。 考虑到大多数公司，无需拆分的特别细，
soul网关-18-数据同步机制之nacos
nemointellego的专栏
02-04 434
关于soul网关的数据同步机制，已经从源码里面大致了解了websocket数据同步、http长轮询数据同步、zookeeper数据同步，今天来看一下soul网关是怎么使用nacos进行数据同步的。 先来了解一下nacos，根据nacos官方文档的介绍，可以知道： Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。 Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心
Soul网关中的数据同步之ZooKeeper
子夜的博客
01-21 194
在上一篇文章中，跟踪了基于WebSocket的数据同步原理，本篇文件将要跟踪基于ZoomKeeper的数据同步原理。 基于 zookeeper 的同步原理很简单，主要是依赖 zookeeper 的 watch 机制，soul-web 会监听配置的节点，soul-admin 在启动的时候，会将数据全量写入 zookeeper，后续数据发生变更时，会增量更新 zookeeper 的节点，与此同时，soul-web 会监听配置信息的节点，一旦有信息变更时，会更新本地缓存。 同步的核心逻辑是：在soul-a
Nacos 服务注册与发现客户端示例与源码解析（一）
qq_39098853的博客
03-08 1157
spring-cloud-nacos2.0源码分析
菜鸟学源码之Nacos v1.1.3源码学习-Client模块(1):NacosNamingService初始化
crystonesc的专栏
09-03 8036
一.源码下载 1.首先Fork一份Nacos源码到自己的github账号下面。 2.用git clone自己账号下的github项目到本地。 3.本地创建一个用于学习的分支，方便自己对源码进行一些标注，同时不会污染到主干分支的源码。 4.另外还可以创建一个开发的分支，以便进行一些源码的修改。 5.在本地搭建一套Nacos的运行环境，以便进行运行测试和调试。 二.从何入手 1.Nacos的源码采用的...
nacos-sync:服务同步组件
05-14
Nacos Sync 功能 控制台：提供用于管理的API和控制台 工作者：提供者服务注册同步。 建筑学 建筑拓扑 +-------------+ +----> |NacosClusterA| | +-------------+ +-------------+ | |NacosClusterB| Pull | ...
nacos多数据源版本
08-26
nacos多数据源版本,支持oracle，mysql，postgresql其中mysql可以兼容达梦数据库
nacos适配达梦数据源
02-22
nacos适配达梦数据源，包含window linux版可直接使用，包含源码部分可自行修改内容自行编译。可导入idea自行编译，已编译好可直接使用的从nacos-2.1.2\distribution\target拷贝使用内含脚本sql文件自行导入达梦...
nacos2.2.1 oracle数据源版
06-08
nacos2.2.1 oracle数据源版 在原版2.2.1的基础上进行适配改造同时修改了部分源码中存在的逻辑问题 工作中处理【CNVD-2023-17316】漏洞时需要对当前版本nacos进行升级，发现不存在类似的资源，故自己对原版2.2.1版本...
nacos中数据库数据导入
最新发布
02-05
nacos中数据库数据导入
springboot项目父工程parent报错，Project build error: Non-resolvable parent POM for model:maven01:0.0.1-SNA
qq_42282321的博客
10-11 1687
springboot项目父工程parent报错，Project build error: Non-resolvable parent POM for model:maven01:0.0.1-SNAPSHOT 所遇到的问题 1.eclipse在创建springboot项目父工程时，导入依赖报错： 2.在maven配置无误的情况下，发现需要在maven的setting.xml里配置阿里云的mirror。 <mirror> <id>CN</id>
微服务网关soul搭建
mask哥
07-04 5814
1.git clonehttps://github.com/Dromara/soul.git源码 2.安装zk 3.刷入 源码目录scripts/下soul.sql到数据库 4.修改soul-admin目录下相关参数 5.启动SoulAdminApplication ，访问http://localhost:8888/index.html输入 admin /123456 6...
OCR相关资源
Gavinmiaoc的博客
09-03 549
1.收集并整理有关OCR的数据集
微服务网关 Soul搭建和集成SpringCloud+Nacos案例(二)
oracl_10g的博客
05-29 1727
微服务网关 Soul搭建和集成SpringCloud Nacos案例（二）前情回顾Soul接入Spring Cloud + Nacos应用一、接入架构图二、搭建 Spring Cloud + Nacos 示例项目、 前情回顾 在微服务网关 Soul搭建和集成SpringCloud Nacos案例（一）中，主要讲解了Soul的搭建工作，在接下来的内容中，将要讲解关于SpringCloud + Nacos使用Soul网关和Soul网关的限流、熔断。 Soul接入Spring Cloud + Nacos应用 一、
微服务网关 Soul搭建和集成SpringCloud+Nacos案例(一)
oracl_10g的博客
05-28 2389
微服务网关 Soul搭建和集成SpringCloud Nacos案例（一）欢迎进入Soul世界Soul概述soul架构图Soul部署MySQL 安装，配置soul数据库redis配置管理台soul-admin配置部署一、修改配置文件1、application.yml文件修改2、application-dev.yml文件修改二、启动Soul-Admin网关soul-bootstrap+nacos配置部署一、nacos配置二、soul-bootstrap配置文件修改1、application.yml文件修改2、
apollo 与 nacos 功能对比
热门推荐
果冻小玩纸的博客
02-09 2万+
apollo与nacos 都为目前比较流行且维护活跃的2个配置中心，笔者对nacos（1.1.4版本）与 apollo(2020.1月更新源码部署)版本从几个方面进行了详细的对比。 一：界面对比 在界面上对2个对比，个人感觉2者都差不多，nacos可能看起来比较简洁，直接把所有项目和配置都直接展示出来了，但是apollo再项目划分概念上就比较清晰，进入后首先需要选择项目，选择项...
Nacos1# 服务注册与发现客户端示例与源码解析（一）
gaoliang1719的专栏
05-16 1694
引言Nacos在业界注册中心的选型中举足轻重，值得去深入分析和研究。本文就注册和发现客户端的初始话逻辑从源码角度分析其做了什么事情，另外，其服务发现的设计架构可作为我们相似场景设计的模型作...
Sentinel dashboard持久化，持久化到nacos和数据库中（基于sentinel 1.8.2)
LeoHan
12-14 2820
我们知道，Sentinel dashboard默认是是没有持久化功能的，都是保存在内存中的，对于sentinel客户端同样如此，当在sentinel dashboard配置规则的时候，dashboard会获取对应应用配置的dashboard给应用传递消息的http，将规则通过HTTP请求发送给sentinel客户端，同样，sentinel客户端也是没有持久化的都是放在内存中的。 sentinel dashbord通过HTTP向sentinel客户端获取客户端的限流配置，而在dashboard更新配置之后则通
nacos数据同步机制
08-19
Nacos是一个开源的分布式服务发现和配置管理系统，它提供了一种数据同步机制，可以实现在不同的Nacos实例之间同步数据。具体的数据同步机制如下： 1. Nacos采用了基于Raft算法的一致性协议来保证数据的一致性和可靠...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值