Spring Boot整合配置中心

上一小节中，我们探讨了如何利用gerrit搭建配置中心的版本仓库。

现在，我们探讨如何在Spring Boot的框架中整合配置中心。

开发lmsia-cfg4j库，实现配置项的自动注入

与之前的Cache等功能类似，我们在多个微服务中，轻松地使用配置中心，所以将相关功能提取但独立的项目中。你可以在这里查看lmsia-cfg4j的源代码。

如前文描述，我们使用cfg4j来辅助实现配置中心的功能。

cfg4j提供了默认的”Binding”方式，来绑定配置项到类中，但使用起来较为繁琐。

许多Spring的功能都是通过注解来实现的，非常方便。我们的配置项也可以用注解来实现，首先定义一个注解接口:

  1. package com.coder4.lmsia.cfg4j;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Retention;
  6. import java.lang.annotation.RetentionPolicy;
  7. import java.lang.annotation.Target;
  9. /**
  10.  * @author coder4
  11.  */
  12. @Target({ElementType.FIELD, ElementType.PARAMETER})
  13. @Retention(RetentionPolicy.RUNTIME)
  14. @Documented
  15. public @interface Cfg4jValue {
  17.     String value() default "";
  18. }

如上所示，之后希望可以使用类似”@Cfg4jValue”的方式，将配置项注解到对应字段中。

有了注解接口，如何实现自动注解呢，传统的方式需要使用动态代理来完成，在这里我们采用Spring提供的BeanPostProcessor来完成：

  1. package com.coder4.lmsia.cfg4j;
  3. import org.cfg4j.provider.ConfigurationProvider;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.aop.support.AopUtils;
  7. import org.springframework.beans.BeansException;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.beans.factory.config.BeanPostProcessor;
  10. import org.springframework.core.Ordered;
  11. import org.springframework.util.ReflectionUtils;
  13. import java.lang.reflect.Field;
  14. import java.util.NoSuchElementException;
  16. /**
  17.  * @author coder4
  18.  */
  19. public class Cfg4jValueProcessor implements BeanPostProcessor, Ordered {
  21.     private Logger LOG = LoggerFactory.getLogger(getClass());
  23.     @Autowired
  24.     private ConfigurationProvider configurationProvider;
  26.     // 初始化前注入
  27.     @Override
  28.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  30.         final Class targetClass = AopUtils.getTargetClass(bean);
  31.         ReflectionUtils.doWithFields(targetClass, field -> process(bean, targetClass, field), field -> {
  32.             return field.isAnnotationPresent(Cfg4jValue.class);
  33.         });
  34.         return bean;
  35.     }
  37.     private void process(final Object bean, Class<?> targetClass, final Field field) {
  38.         // Get injected field name
  39.         Cfg4jValue valueAnnotation = field.getDeclaredAnnotation(Cfg4jValue.class);
  40.         String fieldName = getPropName(valueAnnotation, field.getName());
  41.         // inject for some support type
  42.         fieldSetWithSupport(bean, field, fieldName);
  43.     }
  45.     private void fieldSetWithSupport(Object bean, Field field, String key) {
  46.         Class type = field.getType();
  47.         field.setAccessible(true);
  48.         try {
  49.             if (int.class == type || Integer.class == type) {
  50.                 field.set(bean, configurationProvider.getProperty(key, Integer.class));
  51.             } else if (boolean.class == type || Boolean.class == type) {
  52.                 field.set(bean, configurationProvider.getProperty(key, Boolean.class));
  53.             } else if (String.class == type) {
  54.                 field.set(bean, configurationProvider.getProperty(key, String.class));
  55.             } else if (long.class == type || Long.class == type) {
  56.                 field.set(bean, configurationProvider.getProperty(key, Long.class));
  57.             } else {
  58.                 LOG.error("not support cfj4j value inject type");
  59.                 throw new RuntimeException("not supported cfg4jValue type");
  60.             }
  61.         } catch (IllegalAccessException e) {
  62.             LOG.error("exception during field set", e);
  63.             throw new RuntimeException(e);
  64.         } catch (NoSuchElementException e) {
  65.             LOG.error("config missing key, please check");
  66.             throw new RuntimeException(e);
  67.         }
  68.     }
  70.     public static String getPropName(Cfg4jValue annotation, String defaultName) {
  71.         String key = annotation.value();
  72.         if (key == null || key.isEmpty()) {
  73.             key = defaultName;
  74.         }
  75.         return key;
  76.     }
  78.     @Override
  79.     public Object postProcessAfterInitialization(Object bean, String beanName) throws
  80.             BeansException {
  81.         return bean;
  82.     }
  84.     @Override
  85.     public int getOrder() {
  86.         return HIGHEST_PRECEDENCE;
  87.     }
  88. }

如上所示，Cfg4jValueProcessor完成了以下功能:

  • 自动查找所有@Cfg4jValue的注解
  • 对有上述注解的字段，根据字段名从Cfg4j的数据源(ConfigurationProvider)中读取配置项
  • 若有配置项，完成类型转换并注入到对应字段中。这里目前只支持int, long, string这三种类型。

ConfigurationProvider是cfg4j的数据源，如前文所述，我们希望它自动从gerrit来读取。

为此，实现一个自动配置如下:

  1. package com.coder4.lmsia.cfg4j.configuration;
  3. import com.coder4.lmsia.cfg4j.Cfg4jValueProcessor;
  4. import org.cfg4j.provider.ConfigurationProvider;
  5. import org.cfg4j.provider.ConfigurationProviderBuilder;
  6. import org.cfg4j.source.ConfigurationSource;
  7. import org.cfg4j.source.context.environment.Environment;
  8. import org.cfg4j.source.context.environment.ImmutableEnvironment;
  9. import org.cfg4j.source.context.filesprovider.ConfigFilesProvider;
  10. import org.cfg4j.source.git.GitConfigurationSourceBuilder;
  11. import org.cfg4j.source.reload.ReloadStrategy;
  12. import org.cfg4j.source.reload.strategy.PeriodicalReloadStrategy;
  13. import org.springframework.beans.factory.annotation.Autowired;
  14. import org.springframework.beans.factory.annotation.Value;
  15. import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
  16. import org.springframework.boot.context.properties.ConfigurationProperties;
  17. import org.springframework.context.annotation.Bean;
  18. import org.springframework.context.annotation.Configuration;
  19. import org.springframework.stereotype.Service;
  21. import java.nio.file.Paths;
  22. import java.util.Arrays;
  23. import java.util.concurrent.TimeUnit;
  25. /**
  26.  * @author coder4
  27.  */
  28. @Configuration
  29. @ConditionalOnProperty("msName")
  30. public class Cfg4jGitConfiguration {
  32.     @Value("${msName}")
  33.     private String msName;
  35.     // May Change this
  36.     private static String CONFIG_GIT_HOST = "10.1.64.72";
  38.     // May Change this
  39.     private static String CONFIG_GIT_REPO = "http://" + CONFIG_GIT_HOST + ":9002/lmsia-config.git";
  41.     // May Change this
  42.     private static String branch = "master";
  44.     private static int RELOAD_SECS = 60;
  46.     @Bean
  47.     public ConfigurationProvider configurationProvider() {
  48.         ConfigFilesProvider configFilesProvider = () -> Arrays.asList(Paths.get(msName + "/config.properties"));
  49.         ConfigurationSource source = new GitConfigurationSourceBuilder()
  50.                 .withRepositoryURI(CONFIG_GIT_REPO)
  51.                 .withConfigFilesProvider(configFilesProvider)
  52.                 .build();
  54.         Environment environment = new ImmutableEnvironment(branch);
  56.         ReloadStrategy reloadStrategy = new PeriodicalReloadStrategy(RELOAD_SECS, TimeUnit.SECONDS);
  58.         return new ConfigurationProviderBuilder()
  59.                 .withConfigurationSource(source)
  60.                 .withEnvironment(environment)
  61.                 .withReloadStrategy(reloadStrategy)
  62.                 .build();
  63.     }
  65.     @Bean
  66.     public Cfg4jValueProcessor createCfg4jValueProcessor() {
  67.         return new Cfg4jValueProcessor();
  68.     }
  70. }

上述完成了如下功能:

  • 从Git仓库拉去lmsia-config项目（即前文用于微服务配置的仓库）
  • 定义缓存时间为60秒
  • 配置文件具体路径为/项目名/config.properties(与前一节的目录结构相对应)
  • 顺便配置刚才编写的Cfg4jValueProcessor，让配置可以自动注入到对应的地方上。

当然，为了让上述自动注解生效，不要忘记配置spring.factories

  1. org.springframework.boot.autoconfigure.EnableAutoConfiguration=com.coder4.lmsia.cfg4j.configuration.Cfg4jGitConfiguration

至于项目名，可以通过微服务自身的application.yaml指定，若不制定将不会启动这个自动配置

使用

有了lmsia-cfg4j后，如何在微服务中自动注入配置项目呢？

首先我们需要准备好配置，例如lmsia-config/lmsia-abc的config.properties中定义

  1. key=value
  2. enable=false

接着，在微服务的application.yaml中定义项目名称

  1. msName: lmsia-abc

最后一步，在代码中，使用注解：

  1. package com.coder4.lmsia.abc.server.configuration;
  3. import com.coder4.lmsia.cfg4j.Cfg4jValue;
  4. import lombok.Data;
  5. import org.springframework.stereotype.Service;
  7. /**
  8.  * @author coder4
  9.  */
  10. @Service
  11. @Data
  12. public class TestConfig {
  14.     @Cfg4jValue
  15.     private String key;
  17.     @Cfg4jValue
  18.     private boolean enable;
  20. }

如上所示，是不是非常简单！

你可以启动自己的微服务项目，测试上述配置项是否被如期的注入进来。

在lmsia-cfg4j中，有默认60秒的缓存，你也可以修改lmsia-abc的配置，等待60秒，再观察新的配置是否生效。

拓展与思考

  1. 我们介绍的的配置中心架构中，实际采用的是拉默认来获取最新配置。当微服务及其副本数量众多的时候，可能会对gerrit服务器造成巨大压力。有什么好的方法可以改进这一点么?
  2. 如果需要结合profile实现测试、线上环境使用不同的配置，lmsia-cfg4j项目要如何进行修改呢？