作者：SnoWalker

来源：http://wuwenliang.net/2018/12/05/%E8%87%AA%E5%B7%B1%E5%86%99%E5%88%86%E5%B8%83%E5%BC%8F%E9%85%8D%E7%BD%AE%E4%B8%AD%E5%BF%83-%E5%8D%95%E6%9C%BA%E6%A8%A1%E5%BC%8F/

本篇我们讲讲如何实现一个分布式配置中心服务。

由于该项目实现起来较为复杂，因此分为上下两篇讲解，上篇为单机模式，下篇为分布式模式。话不多说，我们进入正文。

说说配置中心 

在编码之前，我们简单介绍一下什么是分布式配置中心，以及它是为了解决什么问题而出现的。

传统项目中，我们使用配置文件来进行可变参数的动态配置，通过改动配置文件并重启应用的方式达到“不改代码而变更程序行为”的目的。

项目规模小，服务数量少的时候，这种方式还是可堪一用的，当项目规模变大，服务数量上升的时候，停机修改配置就成为一件难以忍受的事情。试想，我们为了修改配置文件，首先要关停部分机器，修改完成还需要手动重启，如果修改有误还需要返工。这对运维而言，简直就是折磨。

因此，配置中心，或者说配置服务就应运而生了。最直接的变化就是，修改配置无需重启，配置能够动态生效，减少了运维成本和压力。

不仅如此，引入较为成熟的配置中心，能够在全局的视角，对不同业务线的不同模块的配置进行统一管理，将分散在各处的配置集中管理，从根源上规避了“配置地狱”的情况的出现。

配置中心不仅减少了开发运维的压力，对运营而言也方便了需求的快速实现及业务目标的灵活变更，它是分布式/微服务架构中的必备的基础设施。

业界较为流行的配置中心实现如下，读者可以根据自己的需要，结合官方文档及业界的最佳实践，灵活的选择适合自己的配置中心实现。

1. 项目    公司  模式

2. qconf    奇虎360   拉模式

3. apollo    携程  推模式

4. dimond    阿里巴巴    拉模式

5. ACM    阿里巴巴    推/拉模式

6. Disconf    百度  推/拉模式

定义配置实体 

按照惯例，在实现一个组件之前，需要定义业务模型，我们按照

1. 主项目->子项目->key/value

的层级模式定义配置实体如下。

1. public class SysConfig implements Serializable {

3.    private static final long serialVersionUID = 7173154101565448135L;

5.    private Integer configId;                   // 配置id

6.    private String configKey;                   // 配置key

7.    private String configValue;                 // 配置值

8.    private String configDesc;                  // 配置描述

9.    private Integer projectId;                  // 主工程id

10.    private String projectName;                 // 主工程名

11.    private Integer moduleId;                   // 子模块id

12.    private String moduleName;                  // 子模块名

13.    private Integer configSwitch;               // 配置开关，默认为1关闭  0-开启，1-关闭

14.    private String optUser;                     // 操作人员，默认administrator

15.    private String insertTime;                  // 插入时间

16.    private String updateTime;                  // 修改时间

17.    private String md5Value;                    // md5值，用于版本控制

18.    private String configSwitchDesc;            // 配置标记描述

19.    ...省略getter setter...

这些配置在配置服务后台都是可配置的。

注意，由于是demo项目，因此本文的目的主要是从原理的角度去阐述一个配置中心是如何实现的，提供一种思路，因此未实现如：命名空间、版本隔离等高级功能。

项目类结构

1、概述

项目包结构如下

1. sheild-conf-client-core -- 配置服务核心包，实现配置服务的全部功能

2. shield-config-manage-ui -- 配置扩展包，提供一个简洁的配置管理页面，添加用户授权机制

3. shield-demo-project-single -- demo工程

简单看下管理的ui界面，基于bootstrap实现的，没有什么技术含量，由于我本身不是专攻前端的，所以就以实现功能为主要目标了，如果觉得长的太丑，欢迎吐槽（反正我也不改，逃。。。）

碍于篇幅限制，我们主要讲解sheild-conf-client-core配置核心的实现。

首先看一下类图

是不是很熟悉的感觉，“Subject”、“Observer”。。。这些类名很直接的表明了这个项目主要使用了观察者模式，相信有心的小伙伴已经猜到了，观察者模式用在这里就是为了实现配置的动态拉取变更的，核心就是被观察者感知到到变更，通知对应的观察者对象去更新配置。

很简单对吧，不急，我们继续往下走。

2、配置持有者ConfigHolder及配置获取者Config 

首先引入的类是ConfigHolder，它的作用是对配置进行集中的管理，并在项目的初始化阶段预加载所有配置。

1. @Service

2. class ConfigHolder {

4.    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigHolder.class);

6.    private static Map<String, SysConfig> config;

8.    static {

9.        config = new ConcurrentHashMap<>();

10.    }

12.    @Autowired

13.    ConfigRepository configRepository;

15.    @PostConstruct

16.    private void init() {

17.        // 初始化加载一次全量配置

18.        config = configRepository.getConfigMap();

19.        LOGGER.info("sheild-conf初始化全量配置完成");

20.    }

22.    protected static SysConfig get(String key) {

23.        return config.get(key);

24.    }

26.    public static void set(String key, SysConfig sysConfig) {

27.        config.put(key, sysConfig);

28.    }

30.    protected static void remove(String key) {

31.        config.remove(key);

32.    }

33. }

由于是全局的配置持有者，我们使用具备分段锁机制的ConcurrentHashMap作为配置的容器，并提供了对外的读取、移除、设置配置的方法。

接下来再定义一个客户端可以直接操作的配置获取者类，用于将读取配置功能暴露给业务调用者。

1. public class Config {

3.    private volatile static Config config;

5.    private Config() {}

7.    public static Config getInstance() {

8.        if (config == null) {

9.            synchronized (Config.class) {

10.                if (config == null) {

11.                    config = new Config();

12.                }

13.            }

14.        }

15.        return config;

16.    }

18.    /**

19.    * 客户端获取配置项

20.    * @param key

21.    * @return

22.    */

23.    public static String get(String key) {

24.        return getInstance().get(key, "");

25.    }

27.    /**

28.    * 客户端获取配置项，如果不存在则使用默认值

29.    * @param key

30.    * @return

31.    */

32.    public static String get(String key, String defaultValue) {

33.        return ConfigHolder.get(key).getConfigValue() == null ?

34.            defaultValue : ConfigHolder.get(key).getConfigValue();

35.    }

36. }

这里的方法 get(String key, String defaultValue) 为调用方提供了指定默认值的功能，如果读取到的配置不存在，则使用默认值，从而避免业务异常。

3、配置服务后台更新线程池加载器ConfigCommandLineRunner 

这里开始，我们就开始引入配置动态加载“魔法”的核心–观察者模式，这里先介绍一下配置服务后台更新的启动器。它的作用是在项目启动完成的同时，加载好配置的被观察者角色及其依赖的线程池。

1. @Component

2. public class ConfigCommandLineRunner implements CommandLineRunner {

4.    static ScheduledExecutorService configExec;

6.    @Override

7.    public void run(String... strings) throws Exception {

8.        // 新建线程池

9.        configExec = Executors.newScheduledThreadPool(10);

10.        // 定义配置更新被观察者

11.        ConfigSubject configSubject = new ConfigSubject(configExec, 30,

12.         0, 10, TimeUnit.SECONDS);

13.        configSubject.runExec();

14.    }

15. }

此处我们的目的是在项目加载完成前，完成对配置更新的被观察者实体的构建，这样在项目启动完成后，就可以同步开始对配置项的持续扫描操作，实现对配置变更的及时处理。

这里解释一下为何实现CommandLineRunner接口：CommandLineRunner是springboot为开发者提供的在项目构建时，进行预先加载数据的接口，当我们的项目启动完成，通过CommandLineRunner预加载的资源也就同步准备完毕，我们的业务类就可以对该资源进行业务操作。是一个很方便易用的接口。

4、被观察者接口Observable

1. interface Observable {

2.    // 增加一个观察者

3.    void addObserver(Observer observer);

4.    // 删除一个观察者

5.    void deleteObserver(Observer observer);

6.    // 通知观察者

7.    void notifyObservers(Observer observer, List<Object> context);

8. }

这里定义了一个被观察者接口，我们主要用到了notifyObservers，当实际的配置更新被观察者实体检测到配置变更，会调用该方法通知对应的观察者实体进行配置更新后的业务操作。

5、观察者接口Observer

1. interface Observer {

3.    // 接收到通知发起更新操作

4.    void update(List<Object> context);

5. }

此处定义的观察者接口Observer定义了具体的观察者实现类在接收到被观察者传递的更新配置通知后做更新操作的接口update(List context);

不同的实现类在收到通知后会采用不同的配置项更新策略，本项目中我们主要实现了两种配置更新策略：

1. ConfigDirectUpdateObserver--配置的key不存在，对配置的value进行直接设置。

2. ConfigMD5UpdateObserver--   配置项发生变更，计算出的MD5与原先的不相等，

3.                            更新key对应的配置项value

6、配置新增观察者实现–ConfigDirectUpdateObserver–直接修改更新配置

1. public class ConfigDirectUpdateObserver implements Observer {

3.    private static final Logger LOGGER = LoggerFactory

4.            .getLogger(ConfigDirectUpdateObserver.class);

6.    @Override

7.    public void update(List<Object> context) {

8.        ConfigHolder.set((String)context.get(0),

9.                                (SysConfig)context.get(1));

10.        LOGGER.debug("通知配置观察者ConfigDirectUpdateObserver更新key={}的配置完成",

11.                                (String)context.get(0));

12.    }

13. }

很简单对吧，这个类实现了接口Observer，作用为：当接收到被观察者通知的时候，直接将配置上下文通过ConfigHolder.set(key,value)方法更新到内存中。

该类的调用场景为：当内存中的配置容器中不存在该项配置（即后台新增配置）。更新配置到配置容器中。

7、观察者修改观察者实现–ConfigMD5UpdateObserver

1. public class ConfigMD5UpdateObserver implements Observer  {

3.    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigDirectUpdateObserver.class);

5.    @Override

6.    public void update(List<Object> context) {

7.        ConfigHolder.getConfig().remove(context.get(0));

8.        ConfigHolder.getConfig().put((String)context.get(0),

9.            (SysConfig)context.get(1));

10.        LOGGER.debug("通知配置观察者ConfigMD5UpdateObserver根据MD5更新key={}的配置完成",

11.            context.get(0));

12.    }

13. }

本类同样实现了接口Observer，它的作用是检测一旦被观察者检测到某项配置的内存内MD5值与数据库中最新的配置的MD5值不同，就会通知ConfigMD5UpdateObserver观察者进行更新操作。

而更新操作也比较粗暴，就是将key对应的配置项删除后重新添加最新的配置。这样对外的效果就是key未改变，而配置内容已经更新。

8、接口IConfigPullHandler，定义对配置项的更新策略

1. interface IConfigPullHandler {

2.    void runExec();

3. }

扩展接口，在核心工程中用于被观察者调度线程池进行定时任务。在ConfigCommandLineRunner中用到，在项目加载完成时启动被观察者进行配置项的定时扫描作业。

9、重要：配置被观察者ConfigSubject–自动更新魔法的主角 

这里，我们隆重推出配置的核心类–ConfigSubject，它是配置服务实现配置自动更新的主角，核心思路就是：ConfigSubject会在通过线程池定时调度，扫描当前应用对应的所有配置项，对其中新增的及修改的配置发送通知给我们之前定义的ConfigDirectUpdateObserver及ConfigMD5UpdateObserver这两个配置更新观察者角色，从而实现配置的动态更新。

国际惯例我们还是先show一下code。

1. @Component

2. public class ConfigSubject implements Observable, IConfigPullHandler {

4.    private static final Logger LOGGER = LoggerFactory.getLogger(ConfigSubject.class);

6.    // 待注册的观察者列表

7.    private List<Observer> observerList = new CopyOnWriteArrayList<>();

9.    private ScheduledExecutorService configExec;           // 配置定时调度线程池

10.    private long initialDelay;               // 定时任务初始化延迟时间长度

11.    private long delay;                      // 一次执行终止和下一次执行开始之间的延迟

12.    private TimeUnit unit;                   // 使用毫秒

13.    private int poolSize;

这里我们定义了观察者列表，用于在业务中实际发起通知。同时定义了一系列的参数，用于对线程池进行调度。

1. public ConfigSubject() {}

3. public ConfigSubject(ScheduledExecutorService configExec,

4.                     int poolSize,

5.                     long initialDelay,

6.                     long delay,

7.                     TimeUnit unit) {

8.    this.configExec = configExec;

9.    this.poolSize = poolSize;

10.    this.delay = delay;

11.    this.initialDelay = initialDelay;

12.    this.unit = unit;

13. }

这里不多解释，提供一个带参构造，对外部暴露配置参数，这个构造方法我主要用在了配置管理模块中，通过网页前端传递参数，从而实现对扫描频率，线程池等的动态配置。

1. /**

2. * 执行更新操作，发现变更后通知观察者

3. */

4. @Override

5. public void runExec() {

6.    // 初始化后开始执行更新操作

7.    configExec.scheduleAtFixedRate(

8.            new Runnable() {

9.                @Override

10.                public void run() {

11.                    doWork();

12.                }

13.            }, initialDelay, delay, unit);

14. }

该方法是实现了IConfigPullHandler接口的runExec()，让调用者能够自主选择何时开始对配置项进行定时拉取操作。

1. /**

2. * <p>一共有三种情况</p>

3. * <p>1. 本地有远程没有，基于本地迭代

4. *      需要同步远程，本地优先</p>

5. * <p>2. 远程有本地没有，基于远程迭代

6. *      直接同步本地</p>

7. * <p>3. 本地和远程都有，基于远程迭代

8. *      比较MD5进行更新操作</p>

9. * <p>当然，存在一种情况，某个配置项不再需要使用，即修改了代码逻辑

10. * 删除了该配置<br/>

11. * 此时，如果加载应用，根据逻辑还是会获取到不需要的配置项，这时只需要

12. * 重启应用，<br/>并在远程删除配置项。如果是集群，可以增加同步配置的时间，保证一致性

13. * <br/>当然，我们允许应用中存在一定的配置冗余<p/>

14. */

15. public void doWork() {

16.    LOGGER.debug("开始定时获取全量配置定时任务");

17.    ConfigRepository configRepository = (ConfigRepository)SpringConfigTool.getBean("configRepository");

18.    Map<String, SysConfig> remoteConfigMap = configRepository.getConfigMap();

19.    LOGGER.debug("获取到应用的全量配置数量为:" + remoteConfigMap.size() + ",本地缓存中的配置数量为:"

20.            + ConfigHolder.getConfig().size());

21.    StringBuffer stringBuffer = new StringBuffer();

22.    // 根据数据库中迭代本地

23.    for (String remoteKey : remoteConfigMap.keySet()) {

24.        SysConfig localConfig = ConfigHolder.getConfig().get(remoteKey);

25.        if (ConfigHolder.getConfig().get(remoteKey) == null) {

26.            // 本地不存在配置项，新增配置

27.            notifyIfLocalConfigNotExist(remoteConfigMap, stringBuffer, remoteKey);

28.        } else if (!getMd5Value(localConfig.getProjectName(),

29.                localConfig.getConfigKey(),

30.                localConfig.getConfigValue(),

31.                remoteConfigMap.get(remoteKey)).equals(remoteConfigMap.get(remoteKey).getMd5Value())) {

32.            // 相同key对应的配置项MD5比对不相同，更新配置项

33.            notifyObserverIfConfigInvalid(remoteConfigMap, stringBuffer, remoteKey);

34.        }

35.    }

36.    LOGGER.debug("应用配置文件更新完毕, 发生变更的配置项列表为:{}", stringBuffer.toString());

37. }

这段代码是核心逻辑，我在注释中写的已经很清楚了，主要就是定时拉取数据库中的远程配置列表并迭代，与本地的配置列表进行对比，根据比较的结果做进一步的操作。这里再简单讲解一下，这里主要枚举了所有可能出现的情况：

1. 本地有配置而远程（此处特指数据库）没有，则基于本地的配置列表进行迭代，并同步到远程。 

2. 远程有（数据库中新增）而本地没有，基于远程迭代，直接同步本地。这种情况就要通知ConfigDirectUpdateObserver观察者对新增的配置项进行新增操作，更新到内存中的配置容器中。 

3. 本地和远程都有，但是计算出来的配置的MD5值不同，则基于远程迭代并比较MD5，对比较结果不同的配置，根据配置的key更新本地的配置项。这种情况就是调用ConfigMD5UpdateObserver进行配置的更新。 

4. 暂时还未实现配置删除后本地同步删除的功能，这个思路也很简单，新增一个观察者，当被观察者检测到拉取的配置列表比本地的少，则通知新增的观察者将本地多出来的配置项进行删除操作。

1. /**

2. * 本地不存在配置项，通知ConfigDirectUpdateObserver新增配置

3. * @param remoteConfigMap

4. * @param stringBuffer

5. * @param remoteKey

6. */

7. private void notifyIfLocalConfigNotExist(Map<String, SysConfig> remoteConfigMap, StringBuffer stringBuffer, String remoteKey) {

8.    LOGGER.debug("key={}为新增配置，直接更新本地配置", remoteKey);

9.    List<Object> configList = new CopyOnWriteArrayList<>();

10.    configList.add(remoteKey);

11.    configList.add(remoteConfigMap.get(remoteKey));

12.    // 定义配置更新观察者--根据key修改对应的value

13.    Observer configObserver = new ConfigDirectUpdateObserver();

14.    this.notifyObservers(configObserver, configList);

15.    stringBuffer.append(",key=" + remoteKey + ",");

16. }

本段代码就是检测本地不存在配置值，通知ConfigDirectUpdateObserver新增配置

1. /**

2. * 相同key对应的配置项MD5比对不相同，通知ConfigMD5UpdateObserver更新配置项

3. * @param remoteConfigMap

4. * @param stringBuffer

5. * @param remoteKey

6. */

7. private void notifyObserverIfConfigInvalid(Map<String, SysConfig> remoteConfigMap, StringBuffer stringBuffer, String remoteKey) {

8.    LOGGER.debug("key={}配置项为更新的配置项，直接更新本地配置", remoteKey);

9.    List<Object> configList = new CopyOnWriteArrayList<>();

10.    configList.add(remoteKey);

11.    configList.add(remoteConfigMap.get(remoteKey));

12.    Observer configObserver = new ConfigMD5UpdateObserver();

13.    this.notifyObservers(configObserver, configList);

14.    stringBuffer.append(",key=" + remoteKey + ",");

15. }

这代代码逻辑为比较出同一个key对应的配置项的MD5比对不相同，则通知ConfigMD5UpdateObserver更新配置项。

1. /**

2. * 计算本地配置MD5 哈希值

3. * @param projectName

4. * @param configKey

5. * @param configValue

6. * @return

7. */

8. private static String getMd5Value(String projectName, String configKey, String configValue, SysConfig sysConfig) {

9.    String md5Value = DigestUtils.md5Hex(projectName + configKey + configValue);

10.    LOGGER.debug("configKey={}对应的本地MD5为--{}, 远程MD5为--{}", configKey, md5Value, sysConfig.getMd5Value());

11.    return md5Value;

12. }

getMd5Value方法为计算配置项的MD5策略，策略为对projectName+configKey+configValue拼接的结果做MD5，这样保证一个工程中的某个配置项的MD5一定是唯一的。

1. @Override

2. public void addObserver(Observer observer) {

3.    this.observerList.add(observer);

4. }

6. @Override

7. public void deleteObserver(Observer observer) {

8.    this.observerList.remove(observer);

9. }

11. @Override

12. public void notifyObservers(Observer observer, List<Object> context) {

13.    observer.update(context);

14. }

15. }

10、其他辅助类 

能读到这里的一定都是真爱，那么我们一鼓作气，把剩下的类也过一次吧。

首先是SpringConfigTool，这个类多次出现在我的博客中，眼尖的读者应该能发现。作用为为非Spring容器加载的类提供获取Spring容器中bean的能力。实现跨容器的交互。

1. @Component

2. public class SpringConfigTool implements ApplicationContextAware {

3.    @Autowired

4.    private static ApplicationContext context;

5.    private static volatile SpringConfigTool stools = null;

6.    public synchronized static SpringConfigTool init() {

7.        if (stools == null) {

8.            synchronized (SpringConfigTool.class) {

9.                if (stools == null) {

10.                    stools = new SpringConfigTool();

11.                    stools.setApplicationContext(context);

12.                }

13.            }

14.        }

15.        return stools;

16.    }

17.    public void setApplicationContext(ApplicationContext applicationContext)

18.            throws BeansException {

19.        context = applicationContext;

20.    }

21.    public static Object getBean(String beanName) {

22.        return context.getBean(beanName);

23.    }

24. }

然后是ConfigRepository，这个类通过JDBCTemplate从数据库中加载某个项目对应的所有生效的配置。

1. @Repository

2. class ConfigRepository {

4.    private static final Logger LOGGER = LoggerFactory.getLogger

5.    (ConfigRepository.class);

7.    @Autowired

8.    JdbcTemplate jdbcTemplate;

10.    protected Map<String, SysConfig> getConfigMap() {

11.        String sql = SQL.SQL_GET_ALL_CONFIGS;

12.        LOGGER.debug("开始获取全量配置信息");

13.        final List<SysConfig> sysConfigs = new CopyOnWriteArrayList<>();

14.        jdbcTemplate.query(sql, new RowCallbackHandler() {

15.            @Override

16.            public void processRow(ResultSet rs) throws SQLException {

17.                SysConfig sysConfig = new SysConfig();

18.                sysConfig.setConfigId(rs.getInt("configId"))

19.                        .setConfigKey(rs.getString("configKey"))

20.                        .setConfigValue(rs.getString("configValue"))

21.                        .setConfigDesc(rs.getString("configDesc"))

22.                        .setOptUser(rs.getString("optUser"))

23.                        .setInsertTime(rs.getString("insertTime"))

24.                        .setUpdateTime(rs.getString("updateTime"));

25.                sysConfigs.add(sysConfig);

26.            }

27.        });

28.        // 迭代设置Map，生成MD5

29.        Map<String, SysConfig> sysConfigMap = new ConcurrentHashMap<>();

30.        for (SysConfig sysConfig : sysConfigs) {

31.            String md5Source = sysConfig.getProjectName() + sysConfig.getConfigKey()

32.                    + sysConfig.getConfigValue();

33.            sysConfig.setMd5Value(DigestUtils.md5Hex(md5Source));

34.            sysConfigMap.put(sysConfig.getConfigKey(), sysConfig);

35.        }

36.        LOGGER.debug("获取全量配置信息--{}", sysConfigs.toString());

37.        return sysConfigMap;

38.    }

39. }

思路也很简单，查找到某个项目的所有生效的配置项，并迭代取出每个配置的ProjectName，ConfigKey，ConfigValue计算MD5重新设置回Map并返回给调用者，效率不太好，其实更好的实现应该是查询出来的时候就带了MD5,这个问题有很多解决方法，留给聪明的你解决吧。

最后是查询SQL，这里为了方便，定义了一个静态类SQL.java

1. class SQL {

2.    /**

3.    * 查询所有可用的配置

4.    */

5.    static String SQL_GET_ALL_CONFIGS = "SELECT\n" +

6.            "  t.CONFIG_ID configId,\n" +

7.            "  t.CONFIG_KEY configKey,\n" +

8.            "  t.CONFIG_VALUE configValue,\n" +

9.            "  t.CONFIG_DESC configDesc,\n" +

10.            "  t.CONFIG_SWITCH configSwitch,\n" +

11.            "  t.OPT_USER optUser,\n" +

12.            "  t.PROJECT_NAME projectName,\n" +

13.            "  DATE_FORMAT(t.INSERT_TIME,'%Y-%m-%d %H:%i:%s') insertTime,\n" +

14.            "  DATE_FORMAT(t.UPDATE_TIME,'%Y-%m-%d %H:%i:%s') updateTime\n" +

15.            " FROM\n" +

16.            "  sys_config t\n" +

17.            "  where t.CONFIG_SWITCH=0";

18. }

简单的说就是获取所有状态为可用（config_switch=0）的所有配置项。你可能已经想到了，是的，我们可以在配置页面去设置配置的启用和禁用状态，如下图。

使用效果 

辛苦了大半天，我们终于讲完了项目的代码层的实现。聪明的你也一定能看出来，我们就是利用了经典的设计模式–观察者模式，实现了配置的动态扫描和更新的解耦，从而能够灵活的选择不同的策略对配置进行更新/新增等操作。这或许就是设计模式的魅力所在吧。

如下是使用该核心进行配置调用的步骤。

1、建立数据库并导入deploy/sql中的SysConfig.sql脚本建立配置表 

2、构建项目sheild-conf-client-single，执行下方命令

1. mvn clean install -DskipTests

3、参考shield-demo-project-single进行开发。在pom中添加下方依赖

1. <dependency>

2.        <artifactId>shield-config-client-core</artifactId>

3.        <groupId>com.hispeed.development</groupId>

4.        <version>1.1.0</version>

5. </dependency>

4、对于springboot项目在启动类添加注解 @ComponentScan(basePackages = {“com.sheild”})，如下

1. @SpringBootApplication

2. @ComponentScan(basePackages = {

   "com.sheild"})

3. public class App {

4.        public static void main(String[] args) {

5.                SpringApplication.run(App.class, args);

6.        }

7.        ......

5、java 在需要调用配置的地方，使用 Config.get(“key”) 方法获取需要的配置，参数即为配置的key

项目已经传到github，项目地址为https://github.com/TaXueWWL/sheild-conf-single 感兴趣的小伙伴可以down下来玩玩，有意见欢迎给我提PR，我会保持持续性的更新。也请小伙伴们动动手指给我点个star，你的支持是我前进的不懈动力~

小结 

到这里，我们就完成了一个单机模式的配置中心的原理讲解及代码实现，这里我想到一句话：“计算机领域的一切问题都能通过新增一个中间层解决”。

我们这里提到的配置中心其实就是介于变化和不变之间的中间层，有了这个中间层的存在，我们的代码就更加具有扩展性和容错性。

推荐社区开源项目：

·END·

 近期热文：

关注我

点击“阅读原文”，看本号其他精彩内容