Spring Boot集成配置中心

Nacos不仅提供了服务的注册与发现，也提供了配置管理的功能。

本节，我们继续使用Nacos，基于其配置管理的功能，实现微服务的配置中心。

首先，我们在Nacos上，新建两个配置：

f

如上图所示：

  • Nacos提供了dataId、group两个字段，用于区分不同的配置

  • 我们在group字段填充微服务的名称，例如homs-demo

  • 我们在dataId字段填写配置的key

  • Nacos的支持简单的类型检验，例如json、数值、字符串等，但只限于前端校验，存储后多统一为字符串类型

有了配置后，我们来实现Nacos配置管理的驱动部分：

  1. public interface NacosConfigService {
  3.     Optional<String> getConfig(String serviceName, String key);
  5.     void onChange(String serviceName, String key, Consumer<Optional<String>> consumer);
  7. }
  1. package com.coder4.homs.demo.server.service.impl;
  3. import com.alibaba.nacos.api.NacosFactory;
  4. import com.alibaba.nacos.api.config.ConfigService;
  5. import com.alibaba.nacos.api.config.listener.Listener;
  6. import com.alibaba.nacos.api.exception.NacosException;
  7. import com.coder4.homs.demo.server.service.spi.NacosConfigService;
  8. import org.slf4j.Logger;
  9. import org.slf4j.LoggerFactory;
  10. import org.springframework.beans.factory.annotation.Value;
  11. import org.springframework.stereotype.Service;
  13. import javax.annotation.PostConstruct;
  14. import java.util.Optional;
  15. import java.util.concurrent.Executor;
  16. import java.util.function.Consumer;
  18. /**
  19.  * @author coder4
  20.  */
  21. @Service
  22. public class NacosConfigServiceImpl implements NacosConfigService{
  24.     private static final Logger LOG = LoggerFactory.getLogger(NacosConfigServiceImpl.class);
  26.     @Value("${nacos.server}")
  27.     private String nacosServer;
  29.     private ConfigService configService;
  31.     @PostConstruct
  32.     public void postConstruct() throws NacosException {
  33.         configService = NacosFactory
  34.                 .createConfigService(nacosServer);
  35.     }
  37.     @Override
  38.     public Optional<String> getConfig(String serviceName, String key) {
  39.         try {
  40.             return Optional.ofNullable(configService.getConfig(key, serviceName, 5000));
  41.         } catch (NacosException e) {
  42.             LOG.error("nacos get config exception for " + serviceName + " " + key, e);
  43.             return Optional.empty();
  44.         }
  45.     }
  47.     @Override
  48.     public void onChange(String serviceName, String key, Consumer<Optional<String>> consumer) {
  49.         try {
  50.             configService.addListener(key, serviceName, new Listener() {
  51.                 @Override
  52.                 public Executor getExecutor() {
  53.                     return null;
  54.                 }
  56.                 @Override
  57.                 public void receiveConfigInfo(String configInfo) {
  58.                     consumer.accept(Optional.ofNullable(configInfo));
  59.                 }
  60.             });
  61.         } catch (NacosException e) {
  62.             LOG.error("nacos add listener exception for " + serviceName + " " + key, e);
  63.             throw new RuntimeException(e);
  64.         }
  65.     }
  66. }

上述驱动部分，主要实现了两个功能：

  • 通过getConfig方法，同步拉取配置

  • 通过onChange方法，添加异步监听器，当配置发生改变时，会执行回调

配置的自动注解与更新

我们希望实现一个更加“易用”的配置中心，期望具有如下特性：

  • 通过注解的方式，自动将类中的字段”绑定”到远程Nacos配置中心对应字段上，并自动初始化。

  • 当Nacos配置更新后，本地同步进行修改。

  • 支持类型的自动转换

第一步，我们声明注解：

  1. package com.coder4.homs.demo.server.annotation;
  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. @Target({ElementType.FIELD, ElementType.PARAMETER})
  10. @Retention(RetentionPolicy.RUNTIME)
  11. @Documented
  12. public @interface HSConfig {
  14.     String name() default "";
  16.     String serviceName() default "";
  18. }

上述关键字段的用途是：

  • name，远程fdc指定的配置名称，可选，若未填写则使用注解应用的原始字段名。

  • serviceName，远程fdc指定的服务名称，可选，若未填写则使用当前本地服务名。

接着，我们借助BeanPostProcessor，来对打了HSConfig注解的字段，进行值注入。

  1. package com.coder4.homs.demo.server.processor;
  3. import com.alibaba.nacos.common.utils.StringUtils;
  4. import com.coder4.homs.demo.server.HsReflectionUtils;
  5. import com.coder4.homs.demo.server.annotation.HSConfig;
  6. import com.coder4.homs.demo.server.service.spi.NacosConfigService;
  7. import org.slf4j.Logger;
  8. import org.slf4j.LoggerFactory;
  9. import org.springframework.aop.support.AopUtils;
  10. import org.springframework.beans.BeansException;
  11. import org.springframework.beans.factory.config.BeanPostProcessor;
  12. import org.springframework.core.Ordered;
  13. import org.springframework.data.util.ReflectionUtils.AnnotationFieldFilter;
  14. import org.springframework.util.ReflectionUtils;
  15. import org.springframework.util.ReflectionUtils.FieldFilter;
  17. import java.lang.reflect.Field;
  18. import java.util.Optional;
  20. /**
  21.  * @author coder4
  22.  */
  23. public class HsConfigFieldProcessor implements BeanPostProcessor, Ordered {
  25.     private static final Logger LOG = LoggerFactory.getLogger(HsConfigFieldProcessor.class);
  27.     private static final FieldFilter HS_CONFIG_FIELD_FILTER = new AnnotationFieldFilter(HSConfig.class);
  29.     private NacosConfigService nacosConfigService;
  31.     private String serviceName;
  33.     public HsConfigFieldProcessor(NacosConfigService service, String serviceName) {
  34.         this.nacosConfigService = service;
  35.         this.serviceName = serviceName;
  36.     }
  38.     @Override
  39.     public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
  40.         Class targetClass = AopUtils.getTargetClass(bean);
  41.         ReflectionUtils.doWithFields(
  42.                 targetClass, field -> processField(bean, field), HS_CONFIG_FIELD_FILTER);
  43.         return bean;
  44.     }
  46.     private void processField(Object bean, Field field) {
  47.         HSConfig valueAnnotation = field.getDeclaredAnnotation(HSConfig.class);
  48.         // 优先注解，其次本地代码
  49.         String key = StringUtils.defaultIfEmpty(valueAnnotation.name(), field.getName());
  50.         String serviceName = StringUtils.defaultIfEmpty(valueAnnotation.serviceName(), this.serviceName);
  51.         Optional<String> valueOp = nacosConfigService.getConfig(serviceName, key);
  52.         try {
  53.             if (!valueOp.isPresent()) {
  54.                 LOG.error("nacos config for serviceName = {} key = {} is empty", serviceName, key);
  55.             }
  56.             HsReflectionUtils.setField(bean, field, valueOp.get());
  58.             // Future Change
  59.             nacosConfigService.onChange(serviceName, key, valueOp2 -> {
  60.                 try {
  61.                     HsReflectionUtils.setField(bean, field, valueOp2.get());
  62.                 } catch (IllegalAccessException e) {
  63.                     LOG.error("nacos config for serviceName = {} key = {} exception", e);
  64.                 }
  65.             });
  66.         } catch (IllegalAccessException e) {
  67.             LOG.error("setField for " + field.getName() + " exception", e);
  68.             throw new RuntimeException(e.getMessage());
  69.         }
  70.     }
  72.     @Override
  73.     public int getOrder() {
  74.         return LOWEST_PRECEDENCE;
  75.     }
  76. }

上述代码比较复杂，我们逐步讲解：

  • 构造函数传入nacosConfigService用于操作nacos配置管理接口

  • 构造函数传入的serviceName做为默认的服务名

  • postProcessBeforeInitialization方法，会在Bean构造前执行，通过ReflectionUtils来过滤所有打了@HsConfig注解的字段，逐一处理，流程如下：

    • 首先获取要绑定的服务名、字段名，遵循注解优于本地的顺序

    • 调用nacosServer拉取当前配置，并通过HsReflectionUtils工具的反射的注入到字段中。

    • 添加回调，以便未来更新时，及时修改本地变量。

HsReflectionUtils中涉及类型的自动转换，代码如下：

  1. package com.coder4.homs.demo.server.utils;
  3. import com.fasterxml.jackson.core.JsonProcessingException;
  4. import com.fasterxml.jackson.databind.ObjectMapper;
  6. import java.lang.reflect.Field;
  8. /**
  9.  * @author coder4
  10.  */
  11. public class HsReflectionUtils {
  13.     private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
  15.     public static void setField(Object bean, Field field, String valueStr) throws IllegalAccessException {
  16.         field.setAccessible(true);
  17.         Class fieldType = field.getType();
  18.         if (fieldType == Integer.TYPE || fieldType == Integer.class) {
  19.             field.set(bean, Integer.parseInt(valueStr));
  20.         } else if (fieldType == Long.TYPE || fieldType == Long.class) {
  21.             field.set(bean, Long.parseLong(valueStr));
  22.         } else if (fieldType == Short.TYPE || fieldType == Short.class) {
  23.             field.set(bean, Short.parseShort(valueStr));
  24.         } else if (fieldType == Double.TYPE || fieldType == Double.class) {
  25.             field.set(bean, Double.parseDouble(valueStr));
  26.         } else if (fieldType == Float.TYPE || fieldType == Float.class) {
  27.             field.set(bean, Float.parseFloat(valueStr));
  28.         } else if (fieldType == Byte.TYPE || fieldType == Byte.class) {
  29.             field.set(bean, Byte.parseByte(valueStr));
  30.         } else if (fieldType == Boolean.TYPE || fieldType == Boolean.class) {
  31.             field.set(bean, Boolean.parseBoolean(valueStr));
  32.         } else if (fieldType == Character.TYPE || fieldType == Character.class) {
  33.             if (valueStr == null || valueStr.isEmpty()) {
  34.                 throw new IllegalArgumentException("can't parse char because value string is empty");
  35.             }
  36.             field.set(bean, valueStr.charAt(0));
  37.         } else if (fieldType.isEnum()) {
  38.             field.set(bean, Enum.valueOf(fieldType, valueStr));
  39.         } else {
  40.             try {
  41.                 field.set(bean, OBJECT_MAPPER.readValue(valueStr, fieldType));
  42.             } catch (JsonProcessingException e) {
  43.                 throw new IllegalArgumentException("can't parse json because exception");
  44.             }
  45.         }
  46.     }
  48. }

上述代码中，针对field的类型逐一判断，针对八大基本类型，直接parse，针对复杂类型，使用json反序列化的方式注入。

自动配置的使用

有了上述的基础后，我们还需要添加自动配置类，让其生效：

  1. package com.coder4.homs.demo.server.configuration;
  3. import com.coder4.homs.demo.constant.HomsDemoConstant;
  4. import com.coder4.homs.demo.server.processor.HsConfigFieldProcessor;
  5. import com.coder4.homs.demo.server.service.spi.NacosConfigService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.Configuration;
  11. /**
  12.  * @author coder4
  13.  */
  14. @Configuration
  15. public class HsConfigProcessorConfiguration {
  17.     @Bean
  18.     @ConditionalOnMissingBean(HsConfigFieldProcessor.class)
  19.     public HsConfigFieldProcessor fieldProcessor(@Autowired NacosConfigService configService) {
  20.         return new HsConfigFieldProcessor(configService, HomsDemoConstant.SERVICE_NAME);
  21.     }
  23. }

使用时非常简单：

  1. @Service
  2. public class HomsDemoConfig {
  4.     @HSConfig
  5.     private int num;
  7.     @HSConfig(name = "mapConfig")
  8.     private Map<String, String> map;
  10.     @PostConstruct
  11.     public void postConstruct() {
  12.         System.out.println(num);
  13.         System.out.println(map);
  14.     }
  16. }

只需要添加HSConfig注解，即可完成远程配置的自动注入、绑定、更新。