SpringBoot+ZooKeeper+ZKUI+Drools 实现应用配置中心及业务规则动态加载

最新推荐文章于 2025-01-07 06:15:00 发布
最新推荐文章于 2025-01-07 06:15:00 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： Spring Boot
本文介绍如何使用ZooKeeper作为SpringBoot应用的配置中心，实现业务规则的动态加载和更新，无需重启即可生效。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

本文目的：

  1. 使用ZooKeeper作为SpringBoot应用的配置中心
  2. 应用中使用到的业务规则存储在Zookeeper中，规则更新后在不重启应用的情况下通知应用动态重载规则
1.zookeeper简介

Zookeeper是一个高性能，分布式的，开源分布式应用协调服务。它提供了简单原始的功能，分布式应用可以基于它实现更高级的服务，比如同步，配置管理，集群管理，命名空间。它被设计为易于编程，使用文件系统目录树作为数据模型。服务端跑在java上，并且提供java和C的客户端API。

数据模型：

特点：

  • 采用树形结构，每个节点叫Znode，节点路径已/分隔，如：/zoo/foo,每个节点路径必须唯一，且没有相对路径
  • 每个Znode都可以存储数据，数据类型byte[]，都可以有子节点
  • 每个Znode都有一个stat数据结构来存储数据的版本，ACL及时间戳等
  • 每个Znode都可以进行CRWD操作

由此可见，采用zookeeper可以很方便的管理应用的配置，如：名为cyzy-gpserver的springboot应用，可以将配置存储在：

  • /cyzy-gpserver ## 等同 application.yml
  • /cyzy-gpserver,dev ## 等同 application-dev.yml
  • /cyzy-gpserver,prod ## 等同 application-prod.yml

这些节点下，每个节点下再分别存储相关配置项，如：

2.zookeeper及其ui客户端安装
zookeeper：

前往http://www.apache.org/dyn/closer.cgi/zookeeper/，下载3.4.6

修改如下配置，zookeeper-3.4.6\conf\zoo.cfg:

# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just 
# example sakes.
dataDir=D:\dev\zookeeper-3.4.6\datas
  • 1
  • 2
  • 3
  • 4
  • 5

运行：

  • windows：zookeeper-3.4.6\bin\zkServer.cmd
  • linux：zookeeper-3.4.6\bin\zkServer.sh
ui客户端zkui：

前往https://github.com/DeemOpen/zkui，参考文档自行编译打包。 
或使用别人做好的 
http://download.youkuaiyun.com/detail/lirenzuo/9640272

登陆用户名/密码配置，zkui\config.cfg:

userSet = {"users": [{ "username":"admin" , "password":"admin","role": "ADMIN" }
  • 1
  • 2

运行： 
java -jar xxx.jar

3.与SpringBoot整合

pom：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>1.4.0.RELEASE</version>
</parent>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-zookeeper-config</artifactId>
  </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>Camden.SR2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

src\main\resources下的bootstrap.yml：

spring:
  application:
    name: cyzy-gpserver
  profiles:
      active: prod
  cloud:
    zookeeper:
      enabled: true  # true:开启zookeeper外部化配置, false:读取本地配置; 需要将config.enabled,config.watcher.enabled同时设置
      connect-string: 127.0.0.1:2181
      config:
        enabled: true
        watcher:
          enabled: false
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

这样默认情况下应用会去/config/application,prod 和 /config/cyzy-gpserver,prod节点下读取配置

注意：/config/application节点下的配置项会应用到所有应用

具体参考： 
http://cloud.spring.io/spring-cloud-static/spring-cloud-zookeeper/1.0.3.RELEASE/#spring-cloud-zookeeper-config

4.业务规则动态加载
基本思路:

1.规则存储在zookeeper中，按照不同的Znode进行分组，如：某类规则存储在/drools.rules/group1下, 某类存储在/drools.rules/group2

2.每个存储了规则的Znode下创建一个“状态节点”和一个“结果反馈节点”，如： 
/drools.rules/group1/a_push_node, /drools.rules/group1/a_result_node

3.应用使用curator客户端的TreeCacheListener方式来监控/drools.rules下所有”状态节点”的变化，根据其状态值，进行相应操作。如：在/drools.rules/group1下修改了某个规则节点，此时设置a_push_node值为0,则应用重载/drools.rules/group1下的规则进行编译测试；设置为1，应用重载规则。应用操作结果反馈回result_node。

4.应用在使用时可以按照Znode的路径来fire rules，如：fireRules(String ruleInZKPath, String agendaGroup, AgendaFilter filter, Object… facts)

这样就可以实现一个轻量级的简易的规则管理和动态重载规则的系统……

整合Drools：
    <dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-core</artifactId>
        <version>6.4.0.Final</version>
    </dependency>
    <dependency>
        <groupId>org.drools</groupId>
        <artifactId>drools-compiler</artifactId>
        <version>6.4.0.Final</version>
    </dependency>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
动态加载规则服务：
/**
 * 可动态加载Drools规则的服务，加载方式：
 * 1.从本地文件加载，通过http get：/app/drools/reload 或 /app/drools/test 重载规则
 * 2.从远程zookeeper节点上加载，通过设置节点下a_push_node值的方式重载规则：0，测试模式；非0，正式加载
 * @ClassName: DroolsService 
 */
@Service
@RestController
public class DroolsService{
    private static final Logger LOG = LoggerFactory.getLogger(DroolsService.class);

    private static final String GROUP_NAME = "com.cyzy";
    private static final String VERSION = "1.0.0";
    private static final String ZK_ENABLED = "spring.cloud.zookeeper.enabled";
    private static final String ZK_PRIFEX_NODE_PATH = "/drools.rules.test";
    private static final String ZK_NODE_TEST_VALUE = "0";
    private static final String PRIFEX_DIR="drools.prefixDir";
    private static final String TARGET_DIR="drools.targetDir";
    private static final String RELOAD_RULES_OK = "reload drools's rules ok......";

    @Autowired
    private Environment env;

    @Autowired
    private ApplicationContext appCtx;

    private CuratorFramework client;

    private KieServices kieServices;

    private KieRepository repository;

    private ConcurrentHashMap<String, KieContainer> kieContainers = new ConcurrentHashMap<String, KieContainer>();

    @PostConstruct
    protected void initKieContainer() throws Exception {
        kieServices = KieServices.Factory.get();
        repository = kieServices.getRepository();

        boolean isZKEnabled = env.getProperty(ZK_ENABLED, Boolean.class);
        if (isZKEnabled) {
            client = appCtx.getBean(CuratorFramework.class);
            loadRulesFromZK();
        } else {
            loadConfigFromLocalFile();
        }
    }

    /**
     * 从ZK加载规则
     * @Title: loadRulesFromZK 
     * @throws Exception
     * @return: void
     */
    private void loadRulesFromZK() throws Exception{
        ZkNodeListenerAdapter.getInstance()
        //设置watcher
        .watcher(new ZKNodeWatcher(ZK_PRIFEX_NODE_PATH, client))
        //默认处理器
        .setDefaultHandler(new ZkNodeHandler() {
            @Override
            public String execute(CuratorFramework client, TreeCache tc, TreeCacheEvent event, ChildData targetChildData,
                    Map<String, ChildData> filterChildren) {
                String msg = RELOAD_RULES_OK;
                try {
                    String pathName = genPathName(event.getData().getPath());
                    loadRules(pathName, getRulesFromZKNodes(pathName, filterChildren));
                } catch (Exception e) {
                    msg = e.getMessage();
                    LOG.error(msg);
                }
                return msg;
            }
        })
        //a_push_node节点值为0时的处理器
        .addHandler(ZK_NODE_TEST_VALUE, new ZkNodeHandler() {
            @Override
            public String execute(CuratorFramework client, TreeCache tc, TreeCacheEvent event, ChildData targetChildData,
                    Map<String, ChildData> filterChildren) {
                String msg = RELOAD_RULES_OK;
                try {
                    String pathName = genPathName(event.getData().getPath());
                    testRules(pathName, getRulesFromZKNodes(pathName, filterChildren));
                } catch (Exception e) {
                    msg = e.getMessage();
                    LOG.error(msg);
                }
                return msg;
            }
        })
        //增加此监听器到watcher
        .addToWatcher(ZK_PRIFEX_NODE_PATH+"/gps/zte")
        .addToWatcher(ZK_PRIFEX_NODE_PATH+"/gps/zte2")
        .addToWatcher(ZK_PRIFEX_NODE_PATH+"/group1")
        .addToWatcher(ZK_PRIFEX_NODE_PATH+"/group2")
        //启动监听
        .start();
    }

    /**
     * 从本地文件加载规则
     * @Title: loadConfigFromLocalFile 
     * @throws Exception
     * @return: void
     */
    private void loadConfigFromLocalFile() throws Exception{
        String targetDir = env.getProperty(TARGET_DIR);
        loadRules(targetDir, getRulesFromLocalFile(targetDir));
    }

    /**
     * 正式加载规则文件进行使用
     */
    private void loadRules(String ruleInZKPath, List<ResourceWrapper> resourceWrappers) throws Exception {
        // if failed throws Exception
        ReleaseId releaseId = kieServices.newReleaseId(GROUP_NAME, ruleInZKPath, VERSION);
        InternalKieModule kieModule = DroolsUtils.createKieModule(kieServices, releaseId, resourceWrappers);
        // if succeed will add new module
        repository.addKieModule(kieModule);
        KieContainer kieContainer = kieServices.newKieContainer(releaseId);
        kieContainer.updateToVersion(releaseId);
        kieContainers.put(ruleInZKPath, kieContainer);
    }

    /**
     * 测试加载规则文件
     */
    private void testRules(String ruleInZKPath, List<ResourceWrapper> resourceWrappers) throws Exception{
        ReleaseId releaseId = kieServices.newReleaseId(GROUP_NAME, ruleInZKPath, VERSION);
        DroolsUtils.createKieModule(kieServices, releaseId, resourceWrappers);
    }

    /**
     * 从ENV配置的指定文件夹中获取规则文件
     */
    private List<ResourceWrapper> getRulesFromLocalFile(String path) {
        String prefixDir = env.getProperty(PRIFEX_DIR);
        String targetDir = env.getProperty(TARGET_DIR);
        List<ResourceWrapper> resourceWrappers = new ArrayList<ResourceWrapper>();
        List<File> ruleFiles = new ArrayList<File>();
        try {
            ruleFiles = DroolsUtils.getDefaultRuleFiles(prefixDir, targetDir);
        } catch (Exception e) {}
        if(ruleFiles.isEmpty()){
            throw new RuntimeException("can't load rules from " + prefixDir +"/"+ targetDir);
        }
        LOG.info("################################load ["+path+"] rules################################");
        for (File file : ruleFiles) {
            LOG.info(file.getName());
            resourceWrappers.add(new ResourceWrapper(ResourceFactory.newFileResource(file), file.getName()));
        }
        LOG.info("################################load ["+path+"] rules################################");
        return resourceWrappers;
    }

    /**
     * 从ZK节点上获取规则文件
     */
    private List<ResourceWrapper> getRulesFromZKNodes(String path, Map<String, ChildData> filterChildren) {
        List<ResourceWrapper> resourceWrappers = new ArrayList<ResourceWrapper>();
        LOG.info("################################load ["+path+"] rules################################");
        for (Entry<String, ChildData> entry : filterChildren.entrySet()) {
            LOG.info(entry.getKey());
            resourceWrappers.add(
                    new ResourceWrapper(ResourceFactory.newByteArrayResource(entry.getValue().getData()),entry.getKey()));
        }
        LOG.info("################################load ["+path+"] rules################################");
        return resourceWrappers;
    }

    private String genPathName(String zkNodePath) {
        String name = "";
        Matcher matcher = Pattern.compile("(.*?)/a_push_node").matcher(zkNodePath);
        if (matcher.matches()) {
            name = matcher.group(1);
        }
        return name;
    }

    /**
     * 创建指定ZK节点路径下的KieSession
     * @Title: newSession 
     * @Description: TODO
     * @param ruleInZKPath
     * @return: KieSession
     */
    private KieSession newSession(String ruleInZKPath) {
        KieContainer kieContainer = kieContainers.get(ruleInZKPath);
        if(kieContainer==null){
            throw new RuntimeException("can't get KieContainer with the name:" + ruleInZKPath);
        }
        KieSession session = kieContainer.newKieSession();
        // 默认配置
        session.setGlobal("appCtx", appCtx);
        return session;
    }

    /**
     * 执行指定ZK节点路径下的所有“MAIN”议程组(使用agenda-group定义，默认是MAIN)的规则
     * @Title: fireAllRules 
     * @param ruleInZKPath
     * @param facts
     * @return: void
     */
    public void fireMainGroupRules(String ruleInZKPath, Object... facts) {
        fireRules(ruleInZKPath, null, null, facts);
    }

    /**
     * 执行指定ZK节点路径下的所有“MAIN”议程组(使用agenda-group定义，默认是MAIN)的并且经过AgendaFilter过滤的规则
     * @Title: fireAllRules 
     * @param ruleInZKPath
     * @param filter
     * @param facts
     * @return: void
     */
    public void fireMainGroupRules(String ruleInZKPath, AgendaFilter filter, Object... facts) {
        fireRules(ruleInZKPath, null, filter, facts);
    }

    /**
     * 执行指定ZK节点路径下的所有agendaGroup指定议程组和“MAIN”议程组(使用agenda-group定义，默认是MAIN)的并且经过AgendaFilter过滤的规则
     * @Title: fireAllRules 
     * @param ruleInZKPath 规则所在ZK node的路径
     * @param agendaGroup 规则所在议程组名称，如果不定义默认：MAIN
     * @param filter 规则过滤器
     * @param facts 事实
     * @return: void
     */
    public void fireRules(String ruleInZKPath, String agendaGroup, AgendaFilter filter, Object... facts) {
        KieSession session = null;
        try {
            session = newSession(ruleInZKPath);
            // add fact
            for (Object fact : facts) {
                session.insert(fact);
            }
            //focus agenda group
            if (agendaGroup != null && !agendaGroup.isEmpty()) {
                session.getAgenda().getAgendaGroup(agendaGroup).setFocus();
            }
            // add filter
            if (filter != null) {
                session.fireAllRules(filter);
            } else {
                session.fireAllRules();
            }
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        } finally {
            if (session != null) {
                session.dispose();
            }
        }
    }

    @RequestMapping(value = "/app/drools/reload", method = RequestMethod.GET)
    public @ResponseBody ResponseEntity<String> reloadRules() {
        String msg = RELOAD_RULES_OK;
        try {
            String targetDir = env.getProperty(TARGET_DIR);
            loadRules(targetDir, getRulesFromLocalFile(targetDir));
        } catch (Exception e) {
            msg = e.getMessage();
        }
        return ResponseEntity.ok().body(msg);
    }

    @RequestMapping(value = "/app/drools/test", method = RequestMethod.GET)
    public @ResponseBody ResponseEntity<String> testRules() {
        String msg = RELOAD_RULES_OK;
        try {
            String targetDir = env.getProperty(TARGET_DIR);
            testRules(targetDir, getRulesFromLocalFile(targetDir));
        } catch (Exception e) {
            msg = e.getMessage();
        }
        return ResponseEntity.ok().body(msg);
    }

    @RequestMapping(value = "/app/drools/test2", method = RequestMethod.GET)
    public @ResponseBody ResponseEntity<String> test2() {
        String msg = "test ok";
        try {
            fireRules(ZK_PRIFEX_NODE_PATH + "/group1", "group1", null, new Object());
            fireRules(ZK_PRIFEX_NODE_PATH + "/group2", "", null, new Object());

            fireRules(ZK_PRIFEX_NODE_PATH + "/gps/zte", "gps.zte", null, new Object());
            fireRules(ZK_PRIFEX_NODE_PATH + "/gps/zte2", "gps.zte", null, new Object());

//          fireAllRules("rules", null, null, new Object());
        } catch (Exception e) {
            msg = e.getMessage();
        }
        return ResponseEntity.ok().body(msg);

    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
springboot使用zookeeper作为配置中心
龚艺洋的博客
04-17 1万+
在使用springcloud做微服务时，大家可以使用配置中心对配置做实时管理，刷新，即时生效；但是springCloud的微服务需要依赖很多组件，如果我们只是一个springboot应用可以使用配置中心管理配置吗？其实很多公司提供了这种配置管理的框架, 例如，百度的disconf，ctrip apollo，淘宝 diamond，spring-cloud/spring-cloud-config，这...
Spring Boot 读取 ZooKeeper (ZK) 属性的总结指南
最新发布
weixin_43833540的博客
03-12 532
通过以上步骤，你可以在 Spring Boot 中优雅地读取和管理 ZooKeeper 的配置属性。在任意 Spring Bean 中注入。如果需要切换不同的 ZK 源（如。
Spring Boot整合Zookeeper实现配置中心
CodersCoder的博客
06-30 5938
简介 使用背景 说到配置中心，目前市面上用的较多的配置中心都广为人知，比如百度的Disconf、Spring Cloud Config、携程的Apollo、阿里的Nacos等。由于项目组一直是使用的zookeeper作为配置中心，所以来学习使用。 实现原理 在Zookeeper建立一个根节点，比如/CONFIG，代表某个配置文件。将配置文件中的信息作为根节点的子节点存储，比如配置项timeout=3000，在Zookeeper中展现为：/CONFIG/timeout ，节点内容是3000。然后让所有使用到
Springboot 使用 Dubbo3 并以 zookeeper 为注册中心
泡泡的博客
09-29 3240
dubbo：简单来讲就是一个 RPC 调用框架，类似于 SpringCloud + OpenFeign，支持 nacos、zookeeper 等注册中心，拥有图形界面，可使用界面管理 zookeeper 的节点信息zookeeper：是一个微服务注册中心，将一个个 Java 项目注册到 zookeeper，然后使用 openfeign 或者 dubbo 就可以实现这些 Java 项目之间的互相调用。
Springboot使用Zookeeper
青春不散场的专栏
08-31 1173
zk可以作为注册中心和配置中心。
SpringBoot + Dubbo + Zookeeper + zkui-master 最简单案例源码打包
09-29
在当前的IT行业中，分布式系统已经成为企业级应用的主流架构，SpringBoot、Dubbo、Zookeeper以及zkui-master是构建这种系统的关键组件。这个压缩包包含的案例源码旨在演示如何将这些技术整合在一起，创建一个高效、...
WebSocket聊天室实现J-IM+SpringBoot+Zookeeper+Redis
06-10
J-IM 是用JAVA语言,基于t-io开发的轻量、高...前后端分离：前端Vue，后端以springboot框架实现：WebSocket服务器+zookeeper+后端服务器。已实现：群组、图片、红包等扩展功能。群聊审核、公告、禁言开关、系统广播等。
基于SpringBoot+Zookeeper+Dubbo打造分布式高并发商品秒杀系统.zip
10-15
基于SpringBoot+Zookeeper+Dubbo打造分布式高并发商品秒杀系统 基于SpringBoot+Zookeeper+Dubbo打造分布式高并发商品秒杀系统 基于SpringBoot+Zookeeper+Dubbo打造分布式高并发商品秒杀系统 基于SpringBoot+...
springBoot+dubbo+zookeeper分布式微服务
10-26
在"springBoot+zookeeper+dubbo"的项目中，SpringBoot作为基础，负责初始化应用环境和配置管理；Dubbo则作为服务治理框架，定义服务接口，实现服务的远程调用；Zookeeper作为服务注册与发现的中间件，维护服务提供者...
基于spring boot框架访问zookeeper
热门推荐
程序员欣宸的博客
04-09 4万+
通过springboot快速开发web应用，并读取单机部署的zookeeper上的数据。
springboot集成zookeeper_demo.zip
06-13
根据网上的视频教程，自己实践过后整理的代码及所需的资料，具体的部署及安装详见博客：https://blog.youkuaiyun.com/yyj108317/article/details/106731301 springbooot集成zookeeper的示例代码
借助Zookeeper实现SpringBoot动态配置刷新
qq_36744284的博客
08-17 1582
SpringBoot应用的配置文件默认是application.properties，而且必须在启动前就已经配置好，在运行过程中不允许修改。如果确实想让应用在运行过程中修改配置呢，我们可以将配置记录在Zookeeper上，借助Zookeeper的watcher机制来实现配置变更通知。 一般的属性获取示例： application.properties的配置如下： name=ljh ConfigController如下： /** * @author lipeng * @date 2021/8/14 *
springboot实现zookeeper统一配置中心
飞在江湖的专栏
07-22 3457
配置文件比如数据库连接，缓存更新时间，接口调用地址，加解密密钥，sesion超时时间，等等每个项目里面用的太多，如果项目里面都统一放在一个properties文件里面，会出现的问题，就是一旦一个地方修改了，假如有10台机器或者上百台，那么就需要重新部署这10台或者上百台的服务器，有没有更好的方法来管理配置文件？有，目前用的比较多的就是使用zookeeper，目前我还没仔细阅读过zookeeper的源码，不过实际使用已经做过测试，这里分享一下，如何在springboot项目里面使用zookee...
Spring Boot集成zookeeper快速入门Demo
HBLOG
05-10 654
Zookeeper 是一个开源的分布式协调服务，目前由 Apache 进行维护。Zookeeper 可以用于实现分布式系统中常见的发布/订阅、负载均衡、命令服务、分布式协调/通知、集群管理、Master 选举、分布式锁和分布式队列等功能。顺序一致性：从一个客户端发起的事务请求，最终都会严格按照其发起顺序被应用到 Zookeeper 中；原子性：所有事务请求的处理结果在整个集群中所有机器上都是一致的；不存在部分机器应用了该事务，而另一部分没有应用的情况；单一视图：所有客户端看到的服务端数据模型都是一致的。
SpringBoot-08-Zookeeper
weixin_46147113的博客
03-02 1904
简介 ①Dubbo Provider 暴露服务方称之为“服务提供者”。 Consumer 调用远程服务方称之为“服务消费者”。 Registry 服务注册与发现的中心目录服务称之为“服务注册中心”。 Monitor 统计服务的调用次数和调用时间的日志服务称之为“服务监控中心” ②Zookeeper ZooKeeper是一个分布式的，开放源码的分布式应用程序协 调服务。 是一个为分布式应用提供一致性服务的软件，提供的功能包括：配置维护、域名服务、分布式同步、组服务等。 Z..
进阶分布式系统架构系列（九）：Zookeeper 配置中心
民工哥的博客
08-29 460
点击下方名片，设为星标！回复“1024”获取2TB学习资源！前面介绍了 Zookeeper安装部署、常用管理命令、节点、选举机制、监听机制、集群 ZAB 协议等相关的知识点，今天我将详细的为大家介绍zookeeper 配置中心相关知识，希望大家能够从中收获多多！如有帮助，请点在看、转发支持一波！！！说到配置中心，目前市面上用的较多的配置中心都广为人知，比如百度的Disconf、Spring C...
【分布式技术】Springboot集成zookeeper
wendao76的专栏
01-07 1475
虽然Spring Cloud提供了与Eureka、Consul和ZooKeeper等服务发现工具的集成，但需要注意的是，Spring Cloud ZooKeeper并不是Spring Cloud官方维护的一个子项目，而是由社区维护的。应用启动后，它应该会自动注册到Zookeeper中，并且你可以使用Zookeeper的客户端工具或Spring Cloud提供的工具来查看注册的服务实例。在你的Spring Boot应用中，你需要创建一个配置类来定义Zookeeper客户端的Bean。
spring boot3 使用zookeeper做注册中心、配置中心
weixin_65286215的博客
07-31 1246
RefreshScope是用来动态更新demo的值的，比如我在项目启动后，如果要修改demo的值，在不重启的情况下更新项目的demo值，加上注解之后就会自动更新。对于 Zookeeper Config 来说，它会读取 Zookeeper /{root}/{spring.application.name}/ 和 /{root}/{default-context}/ 目录下的节点。我们要用zookeeper配置中心的话 ，要知道具体系统怎么读zookeeper的上面的路径。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值