手写分布式配置中心（二）实现分布式配置中心的简单版本

已于 2024-03-04 20:33:36 修改
阅读量694 收藏 8
点赞数 7
文章标签： 分布式
于 2024-03-04 15:58:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjc000/article/details/136451860
版权
本文详细描述了一种使用SpringBoot构建的配置中心服务端，包括控制器、服务和DAO层的接口设计，以及客户端如何通过HTTP调用获取配置。后续将探讨配置自动刷新功能的实现。
摘要由CSDN通过智能技术生成

这一篇文章比较简单，就是一个增删改查的服务端和一个获取配置的客户端，旨在搭建一个简单的配置中心架构，代码在 https://gitee.com/summer-cat001/config-center

服务端

服务端选择用springboot 2.7.14搭建，设计了4个接口/config/insert、/config/update、/config/delete、/config/get。

Controller层

Controller层做了请求参数的校验，和对服务层的转发

@RestController
@RequestMapping("/config")
public class ConfigController {

    @Autowired
    private ConfigService configService;

    @PostMapping("/insert")
    public Result<Void> insertConfig(@RequestBody ConfigVO configVO) {
        Result<ConfigBO> result = checkOpConfig(configVO);
        if (result.failed()) {
            return Result.resultToFail(result);
        }
        return configService.insertConfig(result.getData());
    }

    @PostMapping("/update")
    public Result<Void> updateConfig(@RequestBody ConfigVO configVO) {
        Result<ConfigBO> result = checkOpConfig(configVO);
        if (result.failed()) {
            return Result.resultToFail(result);
        }
        ConfigBO configBO = result.getData();

        long id = configVO.getId();
        if (id <= 0) {
            return Result.fail("配置id错误");
        }
        configBO.setId(id);
        return configService.updateConfig(configBO);
    }

    @PostMapping("/delete")
    public Result<Void> delConfig(@RequestBody ConfigVO configVO) {
        long id = configVO.getId();
        if (id <= 0) {
            return Result.fail("配置id错误");
        }
        return configService.delConfig(id, 0L);
    }

    @GetMapping("/get")
    public Result<List<ConfigVO>> getAllValidConfig() {
        Result<List<ConfigBO>> result = configService.getAllValidConfig();
        if (result.failed()) {
            return Result.resultToFail(result);
        }
        return Result.success(result.getData().stream().map(configBO -> {
            ConfigVO configVO = new ConfigVO();
            configVO.setId(configBO.getId());
            configVO.setName(configBO.getName());
            configVO.setConfigData(configBO.getConfigData());
            configVO.setCreateTime(DateUtil.date2str1(configBO.getCreateTime()));
            return configVO;
        }).collect(Collectors.toList()));
    }

    private Result<ConfigBO> checkOpConfig(ConfigVO configVO) {
        String name = configVO.getName();
        if (name == null || (name = name.trim()).length() == 0) {
            return Result.fail("配置名不能为空");
        }
        JSONObject configData = configVO.getConfigData();
        if (configData == null) {
            return Result.fail("配置内容不能为空");
        }
        ConfigBO configBO = new ConfigBO();
        configBO.setName(name);
        configBO.setConfigData(configData);
        return Result.success(configBO);
    }
}

Service层

Service层做了数据的转换和对dao层的调用，对于这个配置中心数据的存储，我做了两个模式，1是单机模式，2是集群模式。简单的来说就是一个存在数据库中，一个存在本地。根据配置文件中的config.center.mode来指定使用哪种模式

@Service
public class ConfigServiceImpl implements ConfigService {

    private ConfigDAO configDAO;

    @Autowired
    private LocalConfigDAO localConfigDAO;

    @Value("${config.center.mode:0}")
    private int configCenterMode;

    @PostConstruct
    public void init() {
        ConfigCenterModeEnum configCenterModeEnum = ConfigCenterModeEnum.getEnum(configCenterMode);
        if (configCenterModeEnum == null) {
            throw new IllegalArgumentException("配置config.center.mode错误");
        }
        if (configCenterModeEnum == ConfigCenterModeEnum.STANDALONE) {
            this.configDAO = localConfigDAO;
        }
    }

    @Override
    public Result<Void> insertConfig(ConfigBO configBO) {
        List<ConfigDO> configList = configDAO.getAllValidConfig();
        if (configList.stream().anyMatch(c -> c.getName().equals(configBO.getName()))) {
            return Result.fail("配置名重复");
        }
        ConfigDO configDO = new ConfigDO();
        configDO.setName(configBO.getName());
        configDO.setConfigData(configBO.getConfigData().toJSONString());
        configDAO.insertConfigDO(configDO);
        return Result.success(null);
    }

    @Override
    public Result<Void> updateConfig(ConfigBO configBO) {
        ConfigDO configDO = new ConfigDO();
        configDO.setId(configBO.getId());
        configDO.setName(configBO.getName());
        configDO.setConfigData(configBO.getConfigData().toJSONString());
        configDAO.updateConfig(configDO);
        return Result.success(null);
    }

    @Override
    public Result<Void> delConfig(long id, long updateUid) {
        configDAO.delConfig(id, updateUid);
        return Result.success(null);
    }

    @Override
    public Result<List<ConfigBO>> getAllValidConfig() {
        List<ConfigDO> configList = configDAO.getAllValidConfig();
        return Result.success(configList.stream().map(configDO -> {
            ConfigBO configBO = new ConfigBO();
            configBO.setId(configDO.getId());
            configBO.setName(configDO.getName());
            configBO.setCreateTime(configDO.getCreateTime());
            configBO.setConfigData(JSON.parseObject(configDO.getConfigData()));
            return configBO;
        }).collect(Collectors.toList()));
    }
}

DAO层

DAO层提供了一个接口com.config.center.dao.ConfigDAO。单机和集群模式分别实现这个接口，例如单机模式是com.config.center.dao.impl.LocalConfigDAO实现类（集群模式就是访问数据库，大家估计都用吐了，这个就不多介绍了）。
单机模式就是将配置文件存储到本地的一个路径中，这个路径根据配置文件的config.center.standalone.path配置来指定，保存的是以配置id为文件名.conf为后缀的文件。其中id是从1开始自增，增加配置接口用了锁，所以id不会重复

@Slf4j
@Repository
public class LocalConfigDAO implements ConfigDAO {

    private final Lock insertLock = new ReentrantLock();

    @Value("${config.center.standalone.path}")
    private String standalonePath;

    @Override
    public long insertConfigDO(ConfigDO configDO) {
        insertLock.lock();
        try {
            long id = 1;
            List<ConfigDO> configList = getAllConfig();
            if (!configList.isEmpty()) {
                id = configList.get(configList.size() - 1).getId() + 1;
            }
            configDO.setId(id);
            Optional.of(configDO).filter(c -> c.getCreateTime() == null).ifPresent(c -> c.setCreateTime(LocalDateTime.now()));

            String configPathStr = standalonePath + "/config";
            Files.createDirectories(Paths.get(configPathStr));
            Path path = Paths.get(configPathStr + "/" + id + ".conf");
            Files.write(path, JSON.toJSONString(configDO).getBytes(StandardCharsets.UTF_8), StandardOpenOption.CREATE_NEW);
            return id;
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            insertLock.unlock();
        }
    }

    @Override
    public void updateConfig(ConfigDO configDO) {
        ConfigDO dbConfigDO = getConfig(configDO.getId());
        Optional.ofNullable(dbConfigDO).map(c -> {
            c.setName(configDO.getName());
            c.setUpdateTime(LocalDateTime.now());
            c.setUpdateUid(configDO.getUpdateUid());
            c.setConfigData(configDO.getConfigData());
            return c;
        }).ifPresent(this::updateConfigDO);
    }

    @Override
    public void delConfig(long id, long updateUid) {
        ConfigDO dbConfigDO = getConfig(id);
        Optional.ofNullable(dbConfigDO).map(c -> {
            c.setDeleted(true);
            c.setUpdateTime(LocalDateTime.now());
            c.setUpdateUid(updateUid);
            return c;
        }).ifPresent(this::updateConfigDO);
    }

    @Override
    public ConfigDO getConfig(long id) {
        List<ConfigDO> configList = getAllConfig();
        return configList.stream().filter(c -> c.getId() == id).findFirst().orElse(null);
    }

    @Override
    public List<ConfigDO> getAllValidConfig() {
        return getAllConfig().stream().filter(c -> !c.isDeleted()).collect(Collectors.toList());
    }

    @Override
    public List<ConfigDO> getAllConfig() {
        File[] files;
        File folder = new File(standalonePath + "/config");
        if (!folder.exists() || (files = folder.listFiles()) == null) {
            return new ArrayList<>();
        }
        return Arrays.stream(files).map(File::getAbsolutePath)
                .filter(p -> p.endsWith(".conf")).map(this::buildConfigDO)
                .filter(Objects::nonNull).sorted(Comparator.comparing(ConfigDO::getId)).collect(Collectors.toList());
    }

    private synchronized ConfigDO buildConfigDO(String path) {
        try {
            byte[] bytes = Files.readAllBytes(Paths.get(path));
            String json = new String(bytes, StandardCharsets.UTF_8);
            return JSON.parseObject(json, ConfigDO.class);
        } catch (Exception e) {
            log.error("buildConfigDO error,path:{}", path, e);
            return null;
        }
    }

    private synchronized void updateConfigDO(ConfigDO configDO) {
        Path path = Paths.get(standalonePath + "/config/" + configDO.getId() + ".conf");
        if (Files.exists(path)) {
            try {
                Files.write(path, JSON.toJSONString(configDO).getBytes(StandardCharsets.UTF_8), StandardOpenOption.WRITE);
            } catch (IOException e) {
                log.error("updateConfigDO error configDO:{}", configDO, e);
            }
        }
    }
}

效果

到这里就已经完成了服务端的构建了，简单吧，下面看看效果

新增配置

获取所有有效配置

修改配置

删除配置

客户端

客户端就更简单了，就是在启动时通过http调用上面的/config/get接口获取配置，并且赋值给对象的成员变量，之后直接使用这个成员变量即可

public class ConfigCenterClient {

    /**
     * 服务端地址
     */
    private String url;

    public List<ConfigVO> getAllValidConfig() {
        HttpRespBO httpRespBO = HttpUtil.httpGet(url + "/config/get");
        if (!httpRespBO.success()) {
            throw new IllegalArgumentException("获取配置失败：code:" + httpRespBO.getCode() + ",msg:" + httpRespBO.getMessage());
        }
        if (httpRespBO.getBody() == null) {
            throw new IllegalArgumentException("获取配置失败 body is null：code:" + httpRespBO.getCode() + ",msg:" + httpRespBO.getMessage());
        }
        Result<?> result = JSON.parseObject(new String(httpRespBO.getBody(), StandardCharsets.UTF_8), Result.class);
        if (result.failed()) {
            throw new IllegalArgumentException("获取配置失败 result:" + result);
        }
        return JSON.parseArray(JSON.toJSONString(result.getData()), ConfigVO.class);
    }

    public void setUrl(String url) {
        this.url = url;
    }

}
public class ClientTest {

    private String userName;

    private String userAge;

    private List<Object> education;

    public ClientTest() {
        ConfigCenterClient configCenterClient = new ConfigCenterClient();
        configCenterClient.setUrl("http://localhost:8088");
        List<ConfigVO> configList = configCenterClient.getAllValidConfig();
        configList.stream().map(ConfigVO::getConfigData).map(c -> c.getJSONObject("user")).findFirst().ifPresent(user -> {
            this.userName = user.getString("name");
            this.userAge = user.getString("age");
            this.education = user.getJSONArray("education");
        });
    }

    public String toString() {
        return "姓名:" + userName + ",年龄:" + userAge + ",教育经历:" + education;
    }

    public static void main(String[] args) {
        ClientTest clientTest = new ClientTest();
        System.out.println(clientTest);
    }
}

这样整个配置中心的简单版本就完成了，不过这样只是在new对象的时候设置了配置的值，但是如果配置中心的配置发生变化后，客户端是无法感知的，为了解决这个问题需要加入配置自动刷新功能，这个我们在下一篇文章中介绍。

@summer@
关注
Etcd - 分布式配置中心
GY的的专栏
07-15 1万+
Etcd 简介 Etcd 是一种分布式 kv 存储设施, 他具有一定的一致性,高性能,高可用的方案. 类似的 zookeeper, 但没有 zookeeper 那么重型,功能也没有覆盖那么多. 简单直接的应用就是配置中心 架构设计总览 clients 为多个需要 配置的服务, 中间层为 多个 grpc-proxy 做均衡负载, 以免一个 proxy 挂了之后 导致单点问题. grpc...
MQ大牛成长课-从0到1手写分布式消息队列中间件
最新发布
06-18
### 分布式消息队列中间件基础概念及应用 #### 一、MQ（Message Queue）概念解析 **MQ**，即**消息队列**，属于一种重要的**分布式中间件**，其核心作用在于管理和传递消息。它作为一种软件系统，遵循**FIFO...
easyconfig配置中心，自己搭建的配置中心
06-20
easyconfig配置中心，自己搭建的配置中心，是一个轻量级的配置中心，简单易懂，配置方便亢捷，易查看，集成简答，受到广大中少年妇女朋友的喜爱。 搭建文档地址：https://blog.csdn.net/monkeyblog/article/details/93048140
手写分布式配置中心
u011381576的博客
04-15 994
一.引言 随着微服务架构的兴起，分布式配置中心越来越必不可少。目前比较流行的有携程的Apollo，阿里的disconf,淘宝的diamond。 二.原理 其实实现原理可以简单的概括如下：客户端先集成框架，在启动的时候已经将客户端的ip和端口发送到了注册中心（比如zookeeper），再设置具体某个值得时候，发送给服务器端，服务器端接收到请求后，依次通知之前注册的机器。这样随便...
硬核！8个类手写一个配置中心！
Java知音
02-11 405
配置中心是我们平常使用微服务架构时重要的一个模块，常用的配置中心组件也比较多，从早期的Spring Cloud Config，到Disconf、Apollo、Nacos等，它们支持的功能、...
手写分布式配置中心（一）背景/需求
cjc000的博客
03-04 404
从本质上来说配置中心就是一个服务中存储了配置文件，这个配置文件的数据可以放到数据库中也可以存储到别的地方，客户端可以通过相关接口从这个服务中新增、修改、删除、获取配置文件，和获取配置的实时推送，下面我会从下面几点来一步步的揭开配置中心的神秘面纱。开源的配置中心有很多，比如，360的QConf、淘宝的DIamond、百度的Disconf、携程的Apollo、Apache Commons Configuration、Owner、Cfg4J、Spring Cloud Config等。
手写分布式配置中心（六）整合springboot（自动刷新）
cjc000的博客
03-08 788
对于springboot配置自动刷新，原理也很简单，就是在启动过程中用一个BeanPostProcessor去收集需要自动刷新的字段，然后在springboot启动后开启轮询任务即可。不过需要对之前的代码再次做修改，因为springboot的配置注入@value("${}")，允许多个${}和嵌套，所以不能确定简单的确定用到了那个配置，本文为了简单就把所有的配置都认为需要动态刷新，实际用的时候可以在application.yml中配置需要动态刷新的配置id列表。代码在。
二、ZooKeeper 手写分布式配置
huanghuitan的博客
08-25 186
文章目录一、ZooKeeper 分布式配置实现1. 需求2. 代码实现 一、ZooKeeper 分布式配置实现 ZooKeeper Java Example : https://zookeeper.apache.org/doc/current/javaExample.html 1. 需求 用ZK实现一个配置中心，当节点中的数据变更的时候，应用程序同步最新的配置数据。 2. 代码实现 添加配置类 Configuration @Getter @Setter @AllArgsConstructor publi
手写配置中心，实现无需重启应用实现 Bean 属性动态刷新
11-13
本项目"SPeed-Cooperos 手写配置中心"旨在实现这一功能，使得Bean属性的动态刷新成为可能，从而避免了因频繁重启服务而带来的业务中断。 首先，我们需要理解的是Spring框架中的`@RefreshScope`注解。这个注解可以...
简单的分布式配置中心
infi
11-03 1840
               目前已有的分布式配置中心方案，有淘宝的diamond和百度的disconf。但由于公司需要的配置中心的需求比较简单，而且使用的数据库是MongoDB，而不像disconf需要mysql，于是就手写了一个简单的分布式配置中心。   1. 总体设计原则      公用配置不应该分散存在于各应用中，而是应该抽出来，统一存储到一个公用的位置(数据库或zookeeper)...
14章MQ大牛成长课-从0到1手写分布式消息队列中间件
06-14
一、什么是RabbitMq MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。应用程序通过读写出入...在分布式的系统中，RabbitMQ也被用在很多其他的方面，比如分布式事务的支持、RPC的调用等。
分布式配置中心
步北宸的博客
03-17 370
分布式配置中心 在分布式系统中，由于服务数量巨多，为了方便服务配置文件统一管理，实时更新，所以需要分布式配置中心组件。在 Spring Cloud 中，有分布式配置中心组件 Spring Cloud Config ，它支持配置服务放在配置服务的内存中（即本地），也支持放在远程 Git 仓库中。在 Spring Cloud Config 组件中，分两个角色，一是 Config Server，二是 ...
基于Zookeeper手写配置中心
qq_33816292的博客
08-21 629
基于Zookeeper手写配置中心
手写springcloud|配置中心 客户端
谢文峰的博客
11-03 461
手写springcloud|配置中心 客户端 文章目录手写springcloud|配置中心 客户端github示例代码前言实现步骤第一步：在`config-client`客户端应用中如何获取`config-server`服务端的第二步：如何将参数加载到spring配置中第三步：如何实时刷新配置手写代码ConfigController类测试感谢 github示例代码 github对应代码仓库地址：...
手写springcloud|配置中心 服务端
谢文峰的博客
11-02 535
手写springcloud|配置中心 服务端 文章目录手写springcloud|配置中心 服务端github示例代码前言使用场景核心概念Spring Environment配置源的顺序第一：spring上下文层级2.1 The Bootstrap Application Context第二：配置文件加载的相对顺序24.Externalized Configuration源码分析GIT 实现JDB...
Nacos-手写配置中心基本原理
Wzill
06-23 1698
在系统开发过程中，开发者通常会将一些需要变更的参数、变量等从代码中分离出来独立管理，以独立的配置文件的形式存在。目的是让静态的系统工件或者交付物（如 WAR，JAR 包等）更好地和实际的物理运行环境进行适配。
2024-5-6-从0到1手写配置中心Config之实现配置中心客户端
子夜的博客
05-24 448
在demo工程中，使用了@Value的方式和@ConfigurationProperties配置的方式。新建一个web工程，在启动类中使用注解@EnableMidnightConfig启动配置中心客户端。配置中心的客户端只是一个jar包，不是web项目，不能自动扫描注解包，需要手动注册bean。启动工程，查看日志，两种配置方式都是dev500，说明配置中心起作用了。程序启动时，debug可以看到，配置中心的值加载到env的最前面了。工程中默认的配置值midnight.a=a100。
手写分布式配置中心（三）增加实时刷新功能（短轮询）
cjc000的博客
03-05 569
要实现配置自动实时刷新，需要改造之前的代码。
基于SpringBoot手撸配置中心
雨后是冰雹
01-23 934
基于SpringBoot手撸配置中心一、配置中心二、手写配置中心2.1 创建一个SpringBoot项目2.2 配置文件读取2.3 通过Environment装载配置2.4 缓存需要刷新配置文件的类2.5 配置发生变更，通过事件刷新服务配置2.5.1 定义配置变更Event2.5.2 定义配置变更Listener2.5.3 监听到配置中心变更后，主动发送RefreshEnvEvent2.6 配置文件及spring.factories2.7 测试 一、配置中心 什么是配置中心？ 在微服务架构中，当系统从一个单
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值