SpringBoot中如何加载远程配置

Java
403
0
0
2022-12-09
Mybatis 中经典的 9 种设计模式
上一篇
MyBatis 架构与原理
下一篇
标签   SpringBoot

本文章将通过结合consul config来讲解在springboot中如何加载远程配置：通过consul config加载consul server中存储的配置。

我们先来说下在spring中常规的加载配置文件的方式。

加载配置文件方式

对于一个工程来说，我们一般都会需要有各种配置，在spring工程里面，一般都是yml或者properties文件，如下所示：

server: 
  port: 9991 # 端口
 
spring: 
  application: 
    name: ts-service1 # 应用名称 
  profiles: 
    active: dev # 指定环境，默认加载 default 环境 
  cloud: 
    consul: 
      # Consul 服务器地址 
      host: 51.6.196.200 
      port: 8500 
      # 配置中心相关配置 
      config: 
        # 是否启用配置中心，默认值 true 开启 
        enabled: true 
        # 设置配置的基本文件夹，默认值 config 可以理解为配置文件所在的最外层文件夹 
        prefix: config 
        # 设置应用的文件夹名称，默认值 application 一般建议设置为微服务应用名称 
        default-context: tsService 
        # 配置环境分隔符，默认值 "," 和 default-context 配置项搭配 
        # 例如应用 orderService 分别有环境 default、dev、test、prod 
        # 只需在 config 文件夹下创建 orderService、orderService-dev、orderService-test、orderService-prod 文件夹即可 
        profile-separator: '-' 
        # 指定配置格式为 yaml 
        format: YAML 
        # Consul 的 Key/Values 中的 Key，Value 对应整个配置文件 
        data-key: redisConfig 
        # 以上配置可以理解为：加载 config/orderService/ 文件夹下 Key 为 orderServiceConfig 的 Value 对应的配置信息 
        watch: 
          # 是否开启自动刷新，默认值 true 开启 
          enabled: true 
          # 刷新频率，单位：毫秒，默认值 1000 
          delay: 1000 
      # 服务发现相关配置 
      discovery: 
        register: true                                # 是否需要注册 
        instance-id: ${spring.application.name}-01    # 注册实例 id（必须唯一） 
        service-name: ${spring.application.name}      # 服务名称 
        port: ${server.port}                          # 服务端口 
        prefer-ip-address: true                       # 是否使用 ip 地址注册 
        ip-address: ${spring.cloud.client.ip-address} # 服务请求 ip

那么对于读取这些配置文件中的值，一般有如下几种方式

  • 1、使用 @Value("${property}") 读取比较简单的配置信息。
  • 2、通过@ConfigurationProperties读取并通过@Component与 bean 绑定
  • 3、通过@ConfigurationProperties读取并在使用的地方使用@EnableConfigurationProperties注册需要的配置 bean
  • 4、通过@PropertySource读取指定 properties 文件

注：spring加载配置文件有个默认的加载顺序的，根据存放的路径来决定。

拉取远程配置

我们知道，上面说的那些一般要求配置都必须是本地，而且格式只能是 properties(或者 yaml)。那么，如果我们有远程配置，如何把他引入进来来呢。主要有以下三步：

  • 1、编写PropertySource：编写一个类继承EnumerablePropertySource，然后实现它的抽象方法即可。
  • 2、编写PropertySourceLocator：PropertySourceLocator 其实就是用来定位我们前面的PropertySource，需要重写的方法只有一个，就是返回一个PropertySource对象。
  • 3、配置PropertySourceLocator生效

下面就以consul为例，剖析下它是怎么做的

consul的配置示例如下：

spring: 
  application: 
    name: ts-service1 # 应用名称 
  profiles: 
    active: dev # 指定环境，默认加载 default 环境 
  cloud: 
    consul: 
      # Consul 服务器地址 
      host: 51.6.196.200 
      port: 8500 
      # 配置中心相关配置 
      config: 
        # 是否启用配置中心，默认值 true 开启 
        enabled: true 
        # 设置配置的基本文件夹，默认值 config 可以理解为配置文件所在的最外层文件夹 
        prefix: config 
        # 设置应用的文件夹名称，默认值 application 一般建议设置为微服务应用名称 
        default-context: tsService 
        # 配置环境分隔符，默认值 "," 和 default-context 配置项搭配 
        # 例如应用 orderService 分别有环境 default、dev、test、prod 
        # 只需在 config 文件夹下创建 orderService、orderService-dev、orderService-test、orderService-prod 文件夹即可 
        profile-separator: '-' 
        # 指定配置格式为 yaml 
        format: YAML 
        # Consul 的 Key/Values 中的 Key，Value 对应整个配置文件 
        data-key: redisConfig 
        # 以上配置可以理解为：加载 config/orderService/ 文件夹下 Key 为 orderServiceConfig 的 Value 对应的配置信息 
        watch: 
          # 是否开启自动刷新，默认值 true 开启 
          enabled: true 
          # 刷新频率，单位：毫秒，默认值 1000 
          delay: 1000

一般对于配置文件，都有一个对应的配置属性类，consul也不例外：

@ConfigurationProperties("spring.cloud.consul.config")
@Validated
public class ConsulConfigProperties {
 
  private boolean enabled = true;
 
  private String prefix = "config";
 
  @NotEmpty 
  private String defaultContext = "application";
 
  @NotEmpty 
  private String profileSeparator = ",";
 
  @NotNull 
  private Format format = Format.KEY_VALUE;
 
  /**
   * If format is Format.PROPERTIES or Format.YAML then the following field is used as
   * key to look up consul for configuration.
   */ 
  @NotEmpty 
  private String dataKey = "data";
 
  @Value("${consul.token:${CONSUL_TOKEN:${spring.cloud.consul.token:${SPRING_CLOUD_CONSUL_TOKEN:}}}}") 
  private String aclToken;
 
  private Watch watch = new Watch();
 
  ...
}

上面代码对应的就是yml文件中spring.consul.config下面的这一部分的配置。

1、编写PropertySource

consul config下面有这样一个类：ConsulPropertySource，看下它的继承关系：

public class ConsulPropertySource extends EnumerablePropertySource<ConsulClient> {
  private final Map<String, Object> properties = new LinkedHashMap<>();
}

可以看到，它使用了一个map来说存储配置数据。

主要看下以下三个方法：

@Override
public Object getProperty(String name) {
  return this.properties.get(name);
}
 
@Override
public String[] getPropertyNames() {
  Set<String> strings = this.properties.keySet();
  return strings.toArray(new String[strings.size()]);
}

这两个方法就是需要继承实现的父类方法，主要就是获取配置信息，那这些配置信息是哪里来的呢？下面看第三个方法：

public void init() {
  if (!this.context.endsWith("/")) {
    this.context = this.context + "/";
  }
 
  Response<List<GetValue>> response = this.source.getKVValues(this.context,
      this.configProperties.getAclToken(), QueryParams.DEFAULT);
 
  this.initialIndex = response.getConsulIndex();
 
  final List<GetValue> values = response.getValue();
  ConsulConfigProperties.Format format = this.configProperties.getFormat();
  switch (format) {
  case KEY_VALUE:
    parsePropertiesInKeyValueFormat(values);
    break;
  case PROPERTIES:
  case YAML:
    parsePropertiesWithNonKeyValueFormat(values, format);
  }
}

这里的this.context可以理解为consul中key-value存储里面的key。this.source就是ConsulClient。

上面代码的逻辑就是：

  • 通过consulclient向consul server发起请求，查询前缀key为this.context的value信息
  • 根据consul配置文件（也就是工程里面的yml或者properties文件）里面配置的format配置来决定解析该response
  • 如果format是key-value，则表示consule server中该this.context对应的value是一个key-value格式的值，按照key-value进行解析放入this.properties中
  • 如果format是yml或者properties，则表示consule server中该this.context对应的value是一个yml或者properties格式的值，按照相应的格式进行解析放入this.properties中

注：consul config还提供了另外一个propertySource的实现：

public class ConsulFilesPropertySource extends ConsulPropertySource {
  public void init(GetValue value) {
    if (this.getContext().endsWith(".yml") || this.getContext().endsWith(".yaml")) {
      parseValue(value, YAML);
    }
    else if (this.getContext().endsWith(".properties")) {
      parseValue(value, PROPERTIES);
    }
    else {
      throw new IllegalStateException(
          "Unknown files extension for context " + this.getContext());
    }
  }
 
}

该类继承自上面说的那个类，实现了init方法：主要就是用于直接将获取到的value根据需要解析成yml或者properties格式的数据。

2、编写PropertySourceLocator

consul config的实现类如下：

@Order(0)
public class ConsulPropertySourceLocator implements PropertySourceLocator {}

如上面所说，我们主要关注下locate方法：

@Override
@Retryable(interceptor = "consulRetryInterceptor")
public PropertySource<?> locate(Environment environment) {
  if (environment instanceof ConfigurableEnvironment) {
    ConfigurableEnvironment env = (ConfigurableEnvironment) environment;
 
    String appName = this.properties.getName();
 
    if (appName == null) {
      appName = env.getProperty("spring.application.name");
    }
 
    List<String> profiles = Arrays.asList(env.getActiveProfiles());
 
    String prefix = this.properties.getPrefix();
 
    List<String> suffixes = new ArrayList<>();
    if (this.properties.getFormat() != FILES) {
      suffixes.add("/");
    }
    else {
      suffixes.add(".yml");
      suffixes.add(".yaml");
      suffixes.add(".properties");
    }
 
    String defaultContext = getContext(prefix,
        this.properties.getDefaultContext());
 
    for (String suffix : suffixes) {
      this.contexts.add(defaultContext + suffix);
    }
    for (String suffix : suffixes) {
      addProfiles(this.contexts, defaultContext, profiles, suffix);
    }
 
    String baseContext = getContext(prefix, appName);
 
    for (String suffix : suffixes) {
      this.contexts.add(baseContext + suffix);
    }
    for (String suffix : suffixes) {
      addProfiles(this.contexts, baseContext, profiles, suffix);
    }
 
    Collections.reverse(this.contexts);
 
    CompositePropertySource composite = new CompositePropertySource("consul");
 
    for (String propertySourceContext : this.contexts) {
      try {
        ConsulPropertySource propertySource = null;
        if (this.properties.getFormat() == FILES) {
          Response<GetValue> response = this.consul.getKVValue(
              propertySourceContext, this.properties.getAclToken());
          addIndex(propertySourceContext, response.getConsulIndex());
          if (response.getValue() != null) {
            ConsulFilesPropertySource filesPropertySource = new ConsulFilesPropertySource(
                propertySourceContext, this.consul, this.properties);
            filesPropertySource.init(response.getValue());
            propertySource = filesPropertySource;
          }
        }
        else {
          propertySource = create(propertySourceContext, this.contextIndex);
        }
        if (propertySource != null) {
          composite.addPropertySource(propertySource);
        }
      }
      catch (Exception e) {
        if (this.properties.isFailFast()) {
          log.error(
              "Fail fast is set and there was an error reading configuration from consul.");
          ReflectionUtils.rethrowRuntimeException(e);
        }
        else {
          log.warn("Unable to load consul config from "
              + propertySourceContext, e);
        }
      }
    }
 
    return composite;
  }
  return null;
}

上面代码的逻辑就是：

  • 通过上面配置文件中prefix和default-context、prefix和application.name通过分隔符组合成consule中的key
  • 对每一个key，创建ConsulPropertySource实例并初始化（上一节我们已经分析过了），将该实例保存下来

3、配置启动加载

consul config实现这样一个类：

@Configuration(proxyBeanMethods = false)
@ConditionalOnConsulEnabled
public class ConsulConfigBootstrapConfiguration {
 
  @Configuration(proxyBeanMethods = false)
  @EnableConfigurationProperties 
  @Import(ConsulAutoConfiguration.class)
  @ConditionalOnProperty(name = "spring.cloud.consul.config.enabled",
      matchIfMissing = true)
  protected static class ConsulPropertySourceConfiguration {
 
    @Autowired
    private ConsulClient consul;
 
    @Bean 
    @ConditionalOnMissingBean
    public ConsulConfigProperties consulConfigProperties() {
      return new ConsulConfigProperties();
    }
 
    @Bean
    public ConsulPropertySourceLocator consulPropertySourceLocator(
        ConsulConfigProperties consulConfigProperties) {
      return new ConsulPropertySourceLocator(this.consul, consulConfigProperties);
    }
 
  }
 
}

然后在 META-INF/spring.factories中配置如下：

# Auto Configuration
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.cloud.consul.config.ConsulConfigAutoConfiguration
# Bootstrap Configuration
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
org.springframework.cloud.consul.config.ConsulConfigBootstrapConfiguration

就是给Spring Boot说，这个是一个启动配置类，spring boot在启动的时候会自动加载。

放入environment

上面讲解了对应接口的实现，那么consul的这些实现类是在哪里调用的呢？

过程是这样的：spring boot工程在启动的时候，会执行BootStrapConfiguration的initize方法，PropertySourceBootstrapConfiguration的该方法如下：

@Override
public void initialize(ConfigurableApplicationContext applicationContext) {
  List<PropertySource<?>> composite = new ArrayList<>();
  AnnotationAwareOrderComparator.sort(this.propertySourceLocators);
  boolean empty = true;
  ConfigurableEnvironment environment = applicationContext.getEnvironment();
  for (PropertySourceLocator locator : this.propertySourceLocators) {
    Collection<PropertySource<?>> source = locator.locateCollection(environment);
    if (source == null || source.size() == 0) {
      continue;
    }
    List<PropertySource<?>> sourceList = new ArrayList<>();
    for (PropertySource<?> p : source) {
      if (p instanceof EnumerablePropertySource) {
        EnumerablePropertySource<?> enumerable = (EnumerablePropertySource<?>) p;
        sourceList.add(new BootstrapPropertySource<>(enumerable));
      }
      else {
        sourceList.add(new SimpleBootstrapPropertySource(p));
      }
    }
    logger.info("Located property source: " + sourceList);
    composite.addAll(sourceList);
    empty = false;
  }
  if (!empty) {
    MutablePropertySources propertySources = environment.getPropertySources();
    String logConfig = environment.resolvePlaceholders("${logging.config:}");
    LogFile logFile = LogFile.get(environment);
    for (PropertySource<?> p : environment.getPropertySources()) {
      if (p.getName().startsWith(BOOTSTRAP_PROPERTY_SOURCE_NAME)) {
        propertySources.remove(p.getName());
      }
    }
    insertPropertySources(propertySources, composite);
    reinitializeLoggingSystem(environment, logConfig, logFile);
    setLogLevels(applicationContext, environment);
    handleIncludedProfiles(environment);
  }
}

可以看到，这里代码中，调用了每个PropertySourceLocator的实例方法locateCollection，该方法里面调用了locate方法，也就是回到了上一节所说的内容了。最后将所有的source放入了environment中： insertPropertySources(propertySources, composite);

读取propertySource

通过上面的方式加载了远程配置之后，我们在其他地方就可以任意读取了，方式如下：

//可以获取整个系统所有的配置：通过这个可以获取到更新之前的数据
ConfigurableEnvironment environment = (ConfigurableEnvironment)context.getEnvironment();
PropertySources sources = environment.getPropertySources();
Mybatis 中经典的 9 种设计模式
上一篇
MyBatis 架构与原理
下一篇