百度分布式配置管理平台——Disconf入门

最新推荐文章于 2024-09-03 08:23:18 发布

龍弟-idea

最新推荐文章于 2024-09-03 08:23:18 发布

阅读量3.3k

点赞数 12

分类专栏： # 微服务架构文章标签： java 分布式 zookeeper

本文链接：https://blog.csdn.net/weixin_48838340/article/details/123232266

版权

微服务架构专栏收录该内容

4 篇文章 0 订阅

订阅专栏

一、简介

二、Disconf与Diamond横向对比

一、简介

Distributed Configuration Management Platform(分布式配置管理平台)

专注于各种「分布式系统配置管理」的「通用组件」和「通用平台」, 提供统一的「配置管理服务」，是一套完整的基于zookeeper的分布式配置统一解决方案。

二、Disconf与Diamond横向对比

disconf是来自百度的分布式配置管理平台,包括百度、滴滴出行、银联、网易、拉勾网、苏宁易购、顺丰科技 等知名互联网公司正在使用!Diamond则是淘宝开源的一种分布式配置管理服务的实现。

三、主要目标

部署极其简单：同一个上线包，无须改动配置，即可在多个环境中(RD/QA/PRODUCTION) 上线
部署动态化：更改配置，无需重新打包或重启，即可实时生效
统一管理：提供web平台，统一管理多个环境(RD/QA/PRODUCTION)、多个产品的所有配置
支持微服务架构

四、功能特点

支持配置（配置项+配置文件）的分布式化管理
- 配置发布统一化
- 配置发布、更新统一化（云端存储、发布）:配置存储在云端系统，用户统一在平台上进行发布、更新配置。
- 配置更新自动化：用户在平台更新配置，使用该配置的系统会自动发现该情况，并应用新配置。特殊地，如果用户为此配置定义了回调函数类，则此函数类会被自动调用。
配置异构系统管理
- 异构包部署统一化：这里的异构系统是指一个系统部署多个实例时，由于配置不同，从而需要多个部署包（jar或war）的情况（下同）。使用Disconf后，异构系统的部署只需要一个部署包，不同实例的配置会自动分配。特别地，在业界大量使用部署虚拟化（如JPAAS系统，SAE，BAE）的情况下，同一个系统使用同一个部署包的情景会越来越多，Disconf可以很自然地与他天然契合。异构主备自动切换：如果一个异构系统存在主备机，主机发生挂机时，备机可以自动获取主机配置从而变成主机。
- 异构主备机Context共享工具：异构系统下，主备机切换时可能需要共享Context。可以使用Context共享工具来共享主备的Context。
注解式编程，极简的使用方式：我们追求的是极简的、用户编程体验良好的编程方式。通过简单的标注+极简单的代码撰写，即可完成复杂的配置分布式化。
需要Spring编程环境
上手简单，基于注解或者xml配置方式

五、模块架构图

每个模块的简单介绍如下：

Disconf-core
        分布式通知模块：支持配置更新的实时化通知
        路径管理模块：统一管理内部配置路径URL
Disconf-client（客户端）
        配置仓库容器模块：统一管理用户实例中本地配置文件和配置项的内存数据存储
        配置reload模块：监控本地配置文件的变动，并自动reload到指定bean
        扫描模块：支持扫描所有disconf注解的类和域
        下载模块：restful风格的下载配置文件和配置项
        watch模块：监控远程配置文件和配置项的变化
        主备分配模块：主备竞争结束后，统一管理主备分配与主备监控控制
        主备竞争模块：支持分布式环境下的主备竞争
Disconf-web（管理端）
        配置存储模块：管理所有配置的存储和读取
        配置管理模块：支持配置的上传、下载、更新
        通知模块：当配置更新后，实时通知使用这些配置的所有实例
        配置自检监控模块：自动定时校验实例本地配置与中心配置是否一致
        权限控制：web的简单权限控制
Disconf-tools
        context共享模块：提供多实例间context的共享。

六、使用说明

1、使用disconf，只需要在pom中引入依赖

<dependency>
    <groupId>com.baidu.disconf</groupId>
    <artifactId>disconf-client</artifactId>
    <version>2.6.36</version>
</dependency>

2.在客户端应用的classpath下新增disconf.properties文件

注：所有disconf.properties配置文件中的参数，所有配置均可以通过命令行 -Dname=value 参数传入。启动参数方式进行覆盖

# 是否使用远程配置文件
# true(默认)会从远程获取配置 false则直接获取本地配置
enable.remote.conf=true
 
#
# 配置服务器的 HOST,用逗号分隔  127.0.0.1:8000,127.0.0.1:8000
#
conf_server_host=127.0.0.1:8080
 
# 版本, 请采用 X_X_X_X 格式 
version=1_0_0_0
 
# APP 请采用 产品线_服务名 格式 
app=disconf_demo
 
# 环境
env=rd
 
# debug
debug=true
 
# 忽略哪些分布式配置，用逗号分隔
ignore=
 
# 获取远程配置 重试次数，默认是3次
conf_server_url_retry_times=1
# 获取远程配置 重试时休眠时间，默认是5秒
conf_server_url_retry_sleep_seconds=1

3、在applicationContext.xml添加Disconf启动支持(disconf初始化流程)

关于disconf-client的初始化，联想到Spring IoC流程，我们先不看代码，可以猜想一下其大致流程，disconf-client首先需要从disconf服务端获取配置，然后等到IoC流程中创建好对应的bean之后，将对应的配置值设置到bean中，这样基本上就完成了初始化流程，其实disconf的初始化实现就是这样的。

disconf-client的初始化开始于BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry（Spring IoC初始化时，对于BeanDefinitionRegistryPostProcessor的实现类，会调用其postProcessBeanDefinitionRegistry方法），disconf的DisconfMgrBean类就是BeanDefinitionRegistryPostProcessor的实现类，DisconfMgrBean类的bean配置在哪里呢？其实就是disconf.xml中的配置，该配置是必须的，示例如下：

<aop:aspectj-autoproxy proxy-target-class="true">
<!-- 使用disconf必须添加以下配置 -->
<bean id="disconfMgrBean" class="com.baidu.disconf.client.DisconfMgrBean"
      destroy-method="destroy">
    <property name="scanPackage" value="com.yfy.test"/>
</bean>
<bean id="disconfMgrBean2" class="com.baidu.disconf.client.DisconfMgrBeanSecond"
      init-method="init" destroy-method="destroy">
</bean>

scanPackage是扫描标注了disconf注解类所在包路径

DisconfMgrBean 的 postProcessBeanDefinitionRegistry 方法主要做的3件事就是扫描（firstScan）、注册DisconfAspectJ 和 bean属性注入。

    /**
     * 第一次扫描<br/>
     * 在Spring内部的Bean定义初始化后执行，这样是最高优先级的
     */
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {

        // 为了做兼容
        DisconfCenterHostFilesStore.getInstance().addJustHostFileSet(fileList);

        List<String> scanPackList = StringUtil.parseStringToStringList(scanPackage, SCAN_SPLIT_TOKEN);
        // unique
        Set<String> hs = new HashSet<String>();
        hs.addAll(scanPackList);
        scanPackList.clear();
        scanPackList.addAll(hs);

        // 进行扫描
        DisconfMgr.getInstance().setApplicationContext(applicationContext);
        DisconfMgr.getInstance().firstScan(scanPackList);

        // register java bean
        registerAspect(registry);
    }

进行包扫描是使用Reflections来完成的，获取路径下（比如xxx/target/classes）某个包下符合条件（比如com.yfy.test）的资源（reflections），然后从reflections获取某些符合条件的资源列表，如下

 /**
     * 扫描基本信息
     */
    private ScanStaticModel scanBasicInfo(List<String> packNameList) {

        ScanStaticModel scanModel = new ScanStaticModel();

        //
        // 扫描对象
        //
        Reflections reflections = getReflection(packNameList);
        scanModel.setReflections(reflections);

        //
        // 获取DisconfFile class
        //
        Set<Class<?>> classdata = reflections.getTypesAnnotatedWith(DisconfFile.class);
        scanModel.setDisconfFileClassSet(classdata);

        //
        // 获取DisconfFileItem method
        //
        Set<Method> af1 = reflections.getMethodsAnnotatedWith(DisconfFileItem.class);
        scanModel.setDisconfFileItemMethodSet(af1);

        //
        // 获取DisconfItem method
        //
        af1 = reflections.getMethodsAnnotatedWith(DisconfItem.class);
        scanModel.setDisconfItemMethodSet(af1);

        //
        // 获取DisconfActiveBackupService
        //
        classdata = reflections.getTypesAnnotatedWith(DisconfActiveBackupService.class);
        scanModel.setDisconfActiveBackupServiceClassSet(classdata);

        //
        // 获取DisconfUpdateService
        //
        classdata = reflections.getTypesAnnotatedWith(DisconfUpdateService.class);
        scanModel.setDisconfUpdateService(classdata);

        // update pipeline
        Set<Class<? extends IDisconfUpdatePipeline>> iDisconfUpdatePipeline = reflections.getSubTypesOf
                (IDisconfUpdatePipeline
                        .class);
        if (iDisconfUpdatePipeline != null && iDisconfUpdatePipeline.size() != 0) {
            scanModel.setiDisconfUpdatePipeline((Class<IDisconfUpdatePipeline>) iDisconfUpdatePipeline
                    .toArray()[0]);
        }

        return scanModel;
    }

获取到资源信息（比如DisconfFile 和DisconfFileItem ）之后，读取DisConfFile类及其对应的DisconfFileItem信息，将它们放到disconfFileItemMap中，最后将这些信息存储到仓库DisconfCenterStore。这部分逻辑在ScanMgrImpl.firstScan方法中。

    /**
     * 扫描并存储(静态)
     *
     * @throws Exception
     */
    public void firstScan(List<String> packageNameList) throws Exception {

        LOGGER.debug("start to scan package: " + packageNameList.toString());

        // 获取扫描对象并分析整合
        scanModel = scanStaticStrategy.scan(packageNameList);

        // 增加非注解的配置
        scanModel.setJustHostFiles(DisconfCenterHostFilesStore.getInstance().getJustHostFiles());

        // 放进仓库
        for (StaticScannerMgr scannerMgr : staticScannerMgrList) {

            // 扫描进入仓库
            scannerMgr.scanData2Store(scanModel);

            // 忽略哪些KEY
            scannerMgr.exclude(DisClientConfig.getInstance().getIgnoreDisconfKeySet());
        }
    }

扫描入库之后，就该获取数据/注入/Watch了。

    public static DisconfCoreMgr getDisconfCoreMgr(Registry registry) throws Exception {

        FetcherMgr fetcherMgr = FetcherFactory.getFetcherMgr();

        //
        // 不开启disconf，则不要watch了
        //
        WatchMgr watchMgr = null;
        if (DisClientConfig.getInstance().ENABLE_DISCONF) {
            // Watch 模块
            watchMgr = WatchFactory.getWatchMgr(fetcherMgr);
        }

        return new DisconfCoreMgrImpl(watchMgr, fetcherMgr, registry);
    }

扫描按顺序做了以下几个事情：

1.初始化Disconf-client自己的配置模块。 2.初始化Scan模块。 3.初始化Core模块，并极联初始化Watch，Fetcher，Restful模块。 4.扫描用户类，整合分布式配置注解相关的静态类信息至配置仓库里。 5.执行Core模块，从disconf-web平台上下载配置数据：配置文件下载到本地，配置项直接下载。 6.配置文件和配置项的数据会注入到配置仓库里。 7.使用watch模块为所有配置关联ZK上的结点,如果节点不存在，客户端会自己创建节点
流程图为：

4. disconf第二次扫描

    /**
     * 第二次扫描, 动态扫描, for annotation config
     */
    protected synchronized void secondScan() {

        // 该函数必须第一次运行后才能运行
        if (!isFirstInit) {
            LOGGER.info("should run First Scan before Second Scan.");
            return;
        }

        // 第二次扫描也只能做一次
        if (isSecondInit) {
            LOGGER.info("should not run twice.");
            return;
        }

        LOGGER.info("******************************* DISCONF START SECOND SCAN *******************************");

        try {

            // 扫描回调函数
            if (scanMgr != null) {
                scanMgr.secondScan();
            }

            // 注入数据至配置实体中
            // 获取数据/注入/Watch
            if (disconfCoreMgr != null) {
                disconfCoreMgr.inject2DisconfInstance();
            }

        } catch (Exception e) {
            LOGGER.error(e.toString(), e);
        }

        isSecondInit = true;

        //
        // 不开启 则不要打印变量map
        //
        if (DisClientConfig.getInstance().ENABLE_DISCONF) {

            //
            String data = DisconfStoreProcessorFactory.getDisconfStoreFileProcessor()
                    .confToString();
            if (!StringUtils.isEmpty(data)) {
                LOGGER.info("Conf File Map: {}", data);
            }

            //
            data = DisconfStoreProcessorFactory.getDisconfStoreItemProcessor()
                    .confToString();
            if (!StringUtils.isEmpty(data)) {
                LOGGER.info("Conf Item Map: {}", data);
            }
        }
        LOGGER.info("******************************* DISCONF END *******************************");
    }

5.配置动态更新机制

disconf的配置动态更新借助于zk的watch机制（watch机制是zk 3大重要内容之一，其余两个是zk协议和node存储模型）实现的，初始化流程会对配置文件注册watch，这样当配置文件更新时，会通知到discnof-client，然后disconf-client再从disconf-web中获取最新的配置并更新到本地，这样就完成了配置动态更新。

如果disconf-web更新配置文件时，zk-client收到事件通知时，会调用本地回调函数，业务逻辑会回调至此

/**
 * 当配置更新时，系统会自动 调用此回调函数<br/>
 * 这个函数是系统调用的，当有配置更新时，便会进行回调
 *
 * @author liaoqiqi
 * @version 2014-5-16
 */
public class DisconfSysUpdateCallback implements IDisconfSysUpdate {

    /**
     *
     */
    @Override
    public void reload(DisconfCoreProcessor disconfCoreMgr, DisConfigTypeEnum disConfigTypeEnum, String keyName)
        throws Exception {

        // 更新配置数据仓库 && 调用用户的回调函数列表
        disconfCoreMgr.updateOneConfAndCallback(keyName);
    }
}

DisconfFileCoreProcessorImpl.updateOneConfAndCallback()

    /**
     * 更新消息: 某个配置文件 + 回调
     */
    @Override
    public void updateOneConfAndCallback(String key) throws Exception {
 
        // 更新 配置
        updateOneConf(key);
 
        // 回调
        DisconfCoreProcessUtils.callOneConf(disconfStoreProcessor, key);
        callUpdatePipeline(key);
    }

更新配置时，首先更新仓库中值，然后更新bean属性值，配置更新回调是用户自定义的回调方法，也就是@DisconfUpdateService修饰的类。配置更新时流程是：

开发人员在前端更新配置 -> disconf-web保存数据并更新zookeeper -> zookeeper通知disconf-client -> disconf-client 从 disconf-web下载对应配置 -> 更新仓库和bean属性 -> 调用回调 -> 更新配置完成。

配置数据的获取

@Aspect
public class DisconfAspectJ {
 
    protected static final Logger LOGGER = LoggerFactory.getLogger(DisconfAspectJ.class);
 
    @Pointcut(value = "execution(public * *(..))")
    public void anyPublicMethod() {
    }
 
    /**
     * 获取配置文件数据, 只有开启disconf远程才会进行切面
     *
     * @throws Throwable
     */
    @Around("anyPublicMethod() && @annotation(disconfFileItem)")
    public Object decideAccess(ProceedingJoinPoint pjp, DisconfFileItem disconfFileItem) throws Throwable {
 
        if (DisClientConfig.getInstance().ENABLE_DISCONF) {
 
            MethodSignature ms = (MethodSignature) pjp.getSignature();
            Method method = ms.getMethod();
 
            //
            // 文件名
            //
            Class<?> cls = method.getDeclaringClass();
            DisconfFile disconfFile = cls.getAnnotation(DisconfFile.class);
 
            //
            // Field名
            //
            Field field = MethodUtils.getFieldFromMethod(method, cls.getDeclaredFields(), DisConfigTypeEnum.FILE);
            if (field != null) {
 
                //
                // 请求仓库配置数据
                //
                DisconfStoreProcessor disconfStoreProcessor =
                        DisconfStoreProcessorFactory.getDisconfStoreFileProcessor();
                Object ret = disconfStoreProcessor.getConfig(disconfFile.filename(), disconfFileItem.name());
                if (ret != null) {
                    LOGGER.debug("using disconf store value: " + disconfFile.filename() + " ("
                            + disconfFileItem.name() +
                            " , " + ret + ")");
                    return ret;
                }
            }
        }
 
        Object rtnOb;
 
        try {
            // 返回原值
            rtnOb = pjp.proceed();
        } catch (Throwable t) {
            LOGGER.info(t.getMessage());
            throw t;
        }
 
        return rtnOb;
    }

6.注解介绍

@Component
@Scope("singleton")
@DisconfFile(filename = "instance-redis.properties")
public class InstanceJedisConfig {
	private String host;
	private int port;
    
    @DisconfFileItem(name = "redis.host", associateField = "host")
    public String getHost() {
        return host;
    }
    
    @DisconfFileItem(name = "redis.port", associateField = "port")
    public int getPort() {
    	return port;
    }
}

@DisconfFile

作用于类，表示这个类是instance-redis.properties文件的配置类。

@DisconfFileItem

作用于成员变量，表示这个成员变量对应于配置文件中的哪个配置项。

标记associateField是可选的，它表示此get方法相关连的域的名字，如果此标记未填，则系统会自动分析get方法，猜测其相对应于域名。强烈建议添加associateField标记，这样就可以避免Eclipse生成的Get/Set方法不符合 Java规范的问题。

@DisconfItem

private String instantMessage;
@DisconfItem(key="instant.message")
public String getInstantMessage() {
return instantMessage;
}

表示instantMessage成员变量对应于instant.message配置项。

@DisconfUpdateService

定义一个Spring的组件类，实现IDisconfUpdate接口，加上@DisconfUpdateService注解，里面加上需要监听的配置类或者配置项的key，那么当配置文件或配置项发生变化时，就会回调该类的reload方法。

比如es的连接，数据库的连接修改之后，我们需要重新初始化重连，就需要实现reload方法

@Service
@Scope("singleton")
@DisconfFile(filename = "paopaoSliveLevel.properties")
@DisconfUpdateService(classes = {PaoPaoLevelConfig.class})
public class PaoPaoLevelConfig implements IDisconfUpdate {
    
    @Override
    public void reload() throws Exception {
        init();
    }
}

@DisconfActiveBackupService

标识需要进行主备切换的服务,需要指定它影响的配置数