spring-cloud-config 源码解析
spring-cloud-config 源码解析：
本文主要针对 spring-cloud-dependencies Hoxton.SR4版本, spring-cloud-config-server/client的 2.2.2.RELEASE 版本进行源码的解析。
对于未接触过 Config 的小伙伴可以参考 https://www.cnblogs.com/wuzhenzhao/p/10670580.html 进行一些基础知识的了解。
本文主要从以下几个点来分析：
- @Value 的源码解析
- Environment的初始化
- SpringBoot 配置的加载过程
- Config Client 配置加载过程
- Config Server获取配置过程
- 实现自定义配置中心 PropertySourceLocator (基于拓展org.springframework.cloud.bootstrap.BootstrapConfiguration)
@Value 的源码解析
在 spring-cloud-config 配置中心的使用中，我们通常只需要使用 @Value 注解，就能完成属性的注入。而 @Value 基于 Environment 的机制。我们先来看一下 @Value的注入过程
以如下代码为例：
@Value("${wuzz.name}") private String name;
@Value 发生于 依赖注入的阶段，对于依赖注入不熟悉的朋友可以先参考：https://www.cnblogs.com/wuzhenzhao/p/10882050.html
在注入的流程中有个至关重要的方法：AbstractAutowireCapableBeanFactory#populateBean
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { //........ PropertyDescriptor[] filteredPds = null; if (hasInstAwareBpps) { if (pvs == null) { pvs = mbd.getPropertyValues(); } for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // @Value 的注入入口，基于 AutowiredAnnotationBeanPostProcessor PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { if (filteredPds == null) { filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); } pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvsToUse == null) { return; } } pvs = pvsToUse; } } } //....... }
基于 AutowiredAnnotationBeanPostProcessor#postProcessProperties ，这个东西有点类似于类的后置处理器。
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 扫描注解元数据
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
try { // 注入
metadata.inject(bean, beanName, pvs);
}
catch (BeanCreationException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Injection of autowired dependencies failed", ex);
}
return pvs;
}
调用重载的方法 inject，这里有很多的实现，基于目前我们注入是一个 属性，调用到 AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject ，最终会进入 DefaultListableBeanFactory#doResolveDependency
@Nullable
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
Class<?> type = descriptor.getDependencyType();
// 获取 @Value 的表达式
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
//处理表达式的值，其实就是从 Eviromengt里面去获取
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
try {
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
// A custom TypeConverter which does not support TypeDescriptor resolution...
// 转换类型，进行实际注入
return (descriptor.getField() != null ?
converter.convertIfNecessary(value, type, descriptor.getField()) :
converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
}
}
// ........
}
finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
DefaultListableBeanFactory#doResolveDependency 作用是处理 bean中的依赖。由此可见，处理 @Value 注解的时机是在getBean方法中，即SpringApplication#run的最后一步，实例化 bean。当获取 @Value 注解中的表达式之后，进入了 resolveEmbeddedValue 方法，来替换表达式的值：
public String resolveEmbeddedValue(@Nullable String value) { if (value == null) { return null; } String result = value; // 遍历 StringValueResolver for (StringValueResolver resolver : this.embeddedValueResolvers) { result = resolver.resolveStringValue(result); if (result == null) { return null; } } return result; }
通过代码逻辑我们看到，对于属性的解析已经委托给了StringValueResolver 对应的实现类，接下来我们就要分析一下这个 StringValueResolver 是如何初始化的。
StringValueResolver 的初始化 依赖于 PropertySourcesPlaceholderConfigurer ，来看一下该类类图：
很明显 ，该类实现了 BeanFactoryPostProcessor ，必然会执行 postProcessBeanFactory 方法。
@Override public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { if (this.propertySources == null) { this.propertySources = new MutablePropertySources(); if (this.environment != null) { this.propertySources.addLast( new PropertySource<Environment>(ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME, this.environment) { @Override @Nullable public String getProperty(String key) { return this.source.getProperty(key); } } ); } try { PropertySource<?> localPropertySource = new PropertiesPropertySource(LOCAL_PROPERTIES_PROPERTY_SOURCE_NAME, mergeProperties()); if (this.localOverride) { this.propertySources.addFirst(localPropertySource); } else { this.propertySources.addLast(localPropertySource); } } catch (IOException ex) { throw new BeanInitializationException("Could not load properties", ex); } } // 创建替换 ${...} 表达式的处理器 processProperties(beanFactory, new PropertySourcesPropertyResolver(this.propertySources)); this.appliedPropertySources = this.propertySources; }
然后进入 processProperties ：
protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, final ConfigurablePropertyResolver propertyResolver) throws BeansException { // 设置占位符的前缀："{" propertyResolver.setPlaceholderPrefix(this.placeholderPrefix); // 设置占位符的后缀："}" propertyResolver.setPlaceholderSuffix(this.placeholderSuffix); // 设置默认值分隔符：":" propertyResolver.setValueSeparator(this.valueSeparator); // 生成处理 ${...} 表达式的处理器 StringValueResolver valueResolver = strVal -> { String resolved = (this.ignoreUnresolvablePlaceholders ? propertyResolver.resolvePlaceholders(strVal) : propertyResolver.resolveRequiredPlaceholders(strVal)); if (this.trimValues) { resolved = resolved.trim(); } return (resolved.equals(this.nullValue) ? null : resolved); }; // 将处理器放入 Spring 容器 doProcessProperties(beanFactoryToProcess, valueResolver); } protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess, StringValueResolver valueResolver) { BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver); String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames(); for (String curName : beanNames) { // Check that we're not parsing our own bean definition, // to avoid failing on unresolvable placeholders in properties file locations. if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) { BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName); try { visitor.visitBeanDefinition(bd); } catch (Exception ex) { throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage(), ex); } } } // New in Spring 2.5: resolve placeholders in alias target names and aliases as well. beanFactoryToProcess.resolveAliases(valueResolver); // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes. // 将 StringValueResolver 存入 BeanFactory 中 beanFactoryToProcess.addEmbeddedValueResolver(valueResolver); } @Override public void addEmbeddedValueResolver(StringValueResolver valueResolver) { Assert.notNull(valueResolver, "StringValueResolver must not be null"); this.embeddedValueResolvers.add(valueResolver); }
回到 AbstractBeanFactory#resolveEmbeddedValue。这个时候我们能知道 embeddedValueResolvers 里面就一个实现，即 PropertySourcesPlaceholderConfigurer#processProperties 方法内构造的匿名内部类：
StringValueResolver valueResolver = strVal -> { // 默认是 false 走后面的逻辑 String resolved = (this.ignoreUnresolvablePlaceholders ? propertyResolver.resolvePlaceholders(strVal) : propertyResolver.resolveRequiredPlaceholders(strVal)); if (this.trimValues) { resolved = resolved.trim(); } return (resolved.equals(this.nullValue) ? null : resolved); };
然后这里会走propertyResolver.resolveRequiredPlaceholders(strVal)) ,而这里的 propertyResolver 即 PropertySourcesPropertyResolver，在 PropertySourcesPlaceholderConfigurer#postProcessBeanFactory 创建出来的。
由于其为重写该方法，所以进入其父类 AbstractPropertyResolver#resolveRequiredPlaceholders：
@Override public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException { if (this.strictHelper == null) { this.strictHelper = createPlaceholderHelper(false); } return doResolvePlaceholders(text, this.strictHelper); } private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) { return helper.replacePlaceholders(text, this::getPropertyAsRawString); }
然后来到了很关键的一步 this::getPropertyAsRawString ：
@Override @Nullable protected String getPropertyAsRawString(String key) { return getProperty(key, String.class, false); } @Nullable protected <T> T getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders) { if (this.propertySources != null) { for (PropertySource<?> propertySource : this.propertySources) { if (logger.isTraceEnabled()) { logger.trace("Searching for key '" + key + "' in PropertySource '" + propertySource.getName() + "'"); } Object value = propertySource.getProperty(key); if (value != null) { if (resolveNestedPlaceholders && value instanceof String) { value = resolveNestedPlaceholders((String) value); } logKeyFound(key, propertySource, value); return convertValueIfNecessary(value, targetValueType); } } } if (logger.isTraceEnabled()) { logger.trace("Could not find key '" + key + "' in any property source"); } return null; }
这里的 propertySources 也是 PropertySourcesPlaceholderConfigurer#postProcessBeanFactory 创建出来的：
if (this.environment != null) { this.propertySources.addLast( new PropertySource<Environment>(ENVIRONMENT_PROPERTIES_PROPERTY_SOURCE_NAME, this.environment) { @Override @Nullable public String getProperty(String key) { return this.source.getProperty(key); } } ); }
通过 Debug 可以看到相关信息
然后就会来到 PropertySourcesPlaceholderConfigurer#postProcessBeanFactory 匿名内部类中的 getProperty：
获取到了一个 StandardServletEnvironment,然后通过该 Environment 类型进行获取配置源，这个时候又会进到 PropertySourcesPropertyResolver#getProperty，但是这个时候所看到的 propertySources 属性则如下图所示
这就是所有的本环境下的配置源，然后遍历这些配置源进行属性的读取。因为我们这里是直接通过application.properties 配置的 ，所以在 ConfigurationPropertySourcesPropertySource#getProperty 获取到配置。
然后回到 DefaultListableBeanFactory#doResolveDependency 会通过 converter.convertIfNecessary 将获取到的值进行注入到对应的Bean 里面，完成 @Value 的注入操作. 流程图如下：
Environment的初始化
上面的 @Value 代码的注入流程我们大致是了解了，但是这一过程有个 StandardServletEnvironment 是怎么初始化的 ，也就是spring boot需要解析的外部资源文件的路径是如何初始化的。在spring boot的启动流程中，有一个 prepareEnvironment 方法，这个方法就是用来准备Environment这个对象的。
springApplication.run -> prepareEnvironment
private ConfigurableEnvironment prepareEnvironment(SpringApplicationRunListeners listeners, ApplicationArguments applicationArguments) { // Create and configure the environment // 根据上下文，创建一个合适的Environment对象 ConfigurableEnvironment environment = getOrCreateEnvironment(); //配置Environment的propertySource、以及profile configureEnvironment(environment, applicationArguments.getSourceArgs()); ConfigurationPropertySources.attach(environment); // 通知监听器，加载配置文件 listeners.environmentPrepared(environment); bindToSpringApplication(environment); if (!this.isCustomEnvironment) { environment = new EnvironmentConverter(getClassLoader()).convertEnvironmentIfNecessary(environment, deduceEnvironmentClass()); } ConfigurationPropertySources.attach(environment); return environment; }
getOrCreateEnvironment 这个方法，就是根据当前的webApplication类型匹配对应的environment，当前默认的应该就是StandardServletEnvironment ，如果是spring webflflux，则是StandardReactiveWebEnvironment .
private ConfigurableEnvironment getOrCreateEnvironment() {
if (this.environment != null) {
return this.environment;
}
switch (this.webApplicationType) {
case SERVLET:
return new StandardServletEnvironment();
case REACTIVE:
return new StandardReactiveWebEnvironment();
default:
return new StandardEnvironment();
}
}
StandardServletEnvironment 是整个spring boot应用运行环境的实现类，后面所有的关于环境相关的配置操作都是基于这个类，它的类图如下
StandardServletEnvironment 的初始化过程，会做一些事情，就是配置一些基本的属性来源。StandardServletEnvironment 会初始化父类 AbstractEnvironment ，在这个类的构造方法中，会调用一个自定义配置文件的方法
public AbstractEnvironment() { customizePropertySources(this.propertySources); }
customizePropertySources 这个方法被 StandardServletEnvironment 重写了，所以会调用StandardServletEnvironment 中的 customizePropertySources 方法。相信大家不难看出，这里是将几个不同的配置源封装成 StubPropertySource 添加到MutablePropertySources 中，调用 addLast 是表示一直往最后的位置添加。
- SERVLET_CONFIG_PROPERTY_SOURCE_NAME：servlet的配置信息，也就是在中配置的
- SERVLET_CONTEXT_PROPERTY_SOURCE_NAME： 这个是servlet初始化的上下文，也就是以前我们在web.xml中配置的 context-param 。
- JNDI_PROPERTY_SOURCE_NAME： 加载jndi.properties配置信息。
- SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME： 系统变量，通过System.setProperty设置的变量，默认可以看到 java.version 、 os.name 等。
- SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME： 系统环境变量，也就是我们配置JAVA_HOME的地方。
private final List<PropertySource<?>> propertySourceList = new CopyOnWriteArrayList<>();
接着，我们来看一下它怎么用的，找到 AbstractEnvironment 这个类，在这里定义了 MutablePropertySources。并且把这个MutablePropertySources作为参数传递给了 ConfigurablePropertyResolver 配置解析器中，而这个配置解析器是一个 PropertySourcesPropertyResolver 实例。
private final MutablePropertySources propertySources = new MutablePropertySources();
private final ConfigurablePropertyResolver propertyResolver = new PropertySourcesPropertyResolver(this.propertySources);
我们来看一下这个类关系图， AbstractEnvironment 实现了文件解析器ConfigurablePropertyResolver ，而在上面这段代码中我们把 MutablePropertySources 传递到PropertySourcesPropertyResolver 中。这样就可以让 AbstractEnvironment 具备文件解析的功能，只是这个功能，委托给了PropertySourcesPropertyResolver来实现。 这跟我们上面的分析是一致的.
通过上面的代码，spring构造了一个 StandardServletEnvironment 对象并且初始化了一些需要解析的propertySource。我们继续来看 configureEnvironment 这个方法，这个方法有两个作用
- addConversionService 添加类型转化的服务，我们知道properties文件中配置的属性都是String类型的，而转化为Java对象之后要根据合适的类型进行转化，而 ConversionService 是一套通用的转化方案，这里把这个转化服务设置到当前的Environment，很显然，就是为Environment配置解析时提供一个类型转化的解决方案。这块大家有空可以去研究一下，也是一个值的学习的设计。
- configurePropertySources 配置Environment中的propertysources，在上面五个属性来源的基础上又加了两个configureProfiles ：这个方法就比较容易理解，就是配置当前激活的profifiles，将当前的activeProfifiles设置到enviroment中。这样就能够使得我们完成不同环境下配置的获取问题。
- 设置 defaultProperties 属性来源
- 设置commandLineProperties来源，如果设置了命令行参数，则会加载SimpleCommandLinePropertySource 作为propertySource
这个defaultProperties是什么呢？给大家演示一个东西，就是说我们可以设置一个默认的属性，如果设置过，则需要加载。否则就不需要。
public static void main(String[] args) { // SpringApplication.run(ConfigClientApp.class,args); // log.info("服务启动成功"); SpringApplication springApplication=new SpringApplication(ConfigClientApp.class); Map<String, Object> pro = new HashMap<>(); pro.put("key", "value"); springApplication.setDefaultProperties(pro); springApplication.run(args); }
上述工作完成之后，就是发布一个environmentPrepared环境准备就绪的通知，具体的时间监听过程的代码就不再分析了，我们直接进入到 ConfigFileApplicationListener 这个监听器，这个监听器就是用来处理项目配置的。
SpringBoot 配置的加载过程
ConfigFileApplicationListener.onApplicationEvent 收到事件之后，会执行如下代码onApplicationEnvironmentPreparedEvent
private void onApplicationEnvironmentPreparedEvent(ApplicationEnvironmentPreparedEvent event) { List<EnvironmentPostProcessor> postProcessors = loadPostProcessors(); // 把自己加进去了，意味着会执行 this.postProcessEnvironment postProcessors.add(this); AnnotationAwareOrderComparator.sort(postProcessors); for (EnvironmentPostProcessor postProcessor : postProcessors) { postProcessor.postProcessEnvironment(event.getEnvironment(), event.getSpringApplication()); } }
最终执行到 ConfigFileApplicationListener.addPropertySources 方法中，这个方法做两个事情
- 添加一个RandomValuePropertySource到Environment的MutablePropertySources中
- 加载spring boot中的配置信息，比如application.yml或者application.properties
这块的代码就不继续深入分析了，小伙伴自己感兴趣的深入去看看。load 所做的事情如下：
- 获取默认的配置文件路径，有4种。private static final String DEFAULT_SEARCH_LOCATIONS = "classpath:/,classpath:/config/,file:./,file:./config/*/,file:./config/";
- 遍历所有的路径，拼装配置文件名称。
- 再遍历解析器，选择yml或者properties解析，将解析结果添加到集合MutablePropertySources当中。
至此，springBoot中的资源文件加载完毕，解析顺序从上到下，所以前面的配置文件会覆盖后面的配置文件。可以看到 application.properties 的优先级最低，系统变量和环境变量的优先级相对较高。
结合上面 @Value 的流程，是不是就串起来了呢？ 显示SpringBoot 启动的时候将加载相关配置到 Environment ，然后注入的时候去这个里面拿.
基于springboot得拓展 是 org.springframework.boot.env.EnvironmentPostProcessor 接口，需要实现该类，然后在 META-INF/spring.factories 指定该类实现即可。
Config Client 配置加载过程
- 如何将配置加载到 Environment
- 配置变更时，如何控制 Bean 是否需要 create,重新触发一次 Bean 的初始化，才能将 @Value 注解指定的字段从 Environment 中重新注入。
- 配置变更时，如何控制新的配置会更新到 Environment 中，才能保证配置变更时可注入最新的值。
- PropertySourceLocator：抽象出这个接口，就是让用户可定制化的将一些配置加载到Environment。这部分的配置获取遵循了 Spring Cloud Config 的理念，即希望能从外部储存介质中来 loacte。
- RefreshScope: Spring Cloud 定义这个注解，是扩展了 Spring 原有的 Scope 类型。用来标识当前这个 Bean 是一个refresh 类型的 Scope。其主要作用就是可以控制 Bean 的整个生命周期。
- ContextRefresher：抽象出这个 Class，是让用户自己按需来刷新上下文(比如当有配置刷新时，希望可以刷新上下文，将最新的配置更新到 Environment，重新创建 Bean 时，就可以从Environment 中注入最新的配置)。
从前面的代码分析过程中我们知道，Environment中所有外部化配置，针对不同类型的配置都会有与之对应的PropertySource，比如（SystemEnvironmentPropertySource、CommandLinePropertySource）。以及PropertySourcesPropertyResolver来进行解析。那Config Client在启动的时候，必然也会需要从远程服务器上获取配置加载到Environment中，这样才能使得应用程序通过@value进行属性的注入，而且我们一定可以猜测到的是，这块的工作一定又和spring中某个机制有关系。
在spring boot项目启动时，有一个prepareContext的方法，它会回调所有实现了ApplicationContextInitializer 的实例，来做一些初始化工作。
public ConfigurableApplicationContext run(String... args) { //省略代码... prepareContext(context, environment, listeners,applicationArguments, printedBanner); //省略代码 return context; } protected void applyInitializers(ConfigurableApplicationContext context) { for (ApplicationContextInitializer initializer : getInitializers()) { Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(initializer.getClass(), ApplicationContextInitializer.class); Assert.isInstanceOf(requiredType, context, "Unable to call initializer."); initializer.initialize(context); } }
PropertySourceBootstrapConfiguration 实现了 ApplicationContextInitializer 接口，其目的就是在应用程序上下文初始化的时候做一些额外的操作.根据默认的 AnnotationAwareOrderComparator 排序规则对propertySourceLocators数组进行排序获取运行的环境上下文ConfifigurableEnvironment 遍历propertySourceLocators时 ，调用 locate 方法，传入获取的上下文environment，将source添加到PropertySource的链表中，设置source是否为空的标识标量empty。source不为空的情况，才会设置到environment中，返回Environment的可变形式，可进行的操作如addFirst、addLast，移除propertySources中的bootstrapProperties，根据config server覆写的规则，设置propertySources，处理多个active profiles的配置信息 。
public void initialize(ConfigurableApplicationContext applicationContext) { List<PropertySource<?>> composite = new ArrayList<>(); //对propertySourceLocators数组进行排序，根据默认的AnnotationAwareOrderComparator AnnotationAwareOrderComparator.sort(this.propertySourceLocators); boolean empty = true; //获取运行的环境上下文 ConfigurableEnvironment environment = applicationContext.getEnvironment(); for (PropertySourceLocator locator : this.propertySourceLocators) { //回调所有实现PropertySourceLocator接口实例的locate方法， Collection<PropertySource<?>> source = locator.locateCollection(environment); if (source == null || source.size() == 0) { continue; } List<PropertySource<?>> sourceList = new ArrayList<>(); for (PropertySource<?> p : source) { sourceList.add(new BootstrapPropertySource<>(p)); } logger.info("Located property source: " + sourceList); composite.addAll(sourceList);//将source添加到数组 empty = false;//表示propertysource不为空 } //只有propertysource不为空的情况，才会设置到environment中 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); } }
PropertySourceLoader.locateCollection，这个方法会调用子类的locate方法，来获得一个PropertySource，然后将PropertySource集合返回。接着它会调用 ConfigServicePropertySourceLocator 的locate方法。
ConfigServicePropertySourceLocator.locate ：这个就是Confifig Client的关键实现了，它会通过RestTemplate调用一个远程地址获得配置信息，getRemoteEnvironment 。然后把这个配置PropertySources，然后将这个信息包装成一个OriginTrackedMapPropertySource，设置到 Composite 中。
Config Server获取配置过程
服务器端去远程仓库加载配置的流程就比较简单了，核心接口是： EnvironmentRepository ，提供了配置读取的功能。我们先从请求入口开始看
EnvironmentController ：Spring Cloud Config Server提供了EnvironmentController，这样通过在浏览器访问即可从git中获取配置信息
在这个controller中，提供了很多的映射，最终会调用的是 getEnvironment 。
public Environment getEnvironment(String name, String profiles, String label, boolean includeOrigin) { name = Environment.normalize(name); label = Environment.normalize(label); Environment environment = this.repository.findOne(name, profiles, label, includeOrigin); if (!this.acceptEmpty && (environment == null || environment.getPropertySources().isEmpty())) { throw new EnvironmentNotFoundException("Profile Not found"); } return environment; }
this.repository.findOne ，调用某个repository存储组件来获得环境配置信息进行返回。repository是一个 EnvironmentRepository 对象，它有很多实现，其中就包含RedisEnvironmentRepository 、 JdbcEnvironmentRepository 等。默认实现是MultipleJGitEnvironmentRepository ，表示多个不同地址的git数据源。
MultipleJGitEnvironmentRepository.findOne ：MultipleJGitEnvironmentRepository 代理遍历每个 JGitEnvironmentRepository，JGitEnvironmentRepository 下使用 NativeEnvironmentRepository 代理读取本地文件。
public Environment findOne(String application, String profile, String label, boolean includeOrigin) {
for (PatternMatchingJGitEnvironmentRepository repository : this.repos.values()) { if (repository.matches(application, profile, label)) { for (JGitEnvironmentRepository candidate : getRepositories(repository, application, profile, label)) { try { if (label == null) { label = candidate.getDefaultLabel(); } Environment source = candidate.findOne(application, profile, label, includeOrigin); if (source != null) { return source; } } catch (Exception e) { if (this.logger.isDebugEnabled()) { this.logger.debug( "Cannot load configuration from " + candidate.getUri() + ", cause: (" + e.getClass().getSimpleName() + ") " + e.getMessage(), e); } continue; } } } } JGitEnvironmentRepository candidate = getRepository(this, application, profile, label); if (label == null) { label = candidate.getDefaultLabel(); } if (candidate == this) { return super.findOne(application, profile, label, includeOrigin); } return candidate.findOne(application, profile, label, includeOrigin); }
AbstractScmEnvironmentRepository.findOne ：调用抽象类的findOne方法，主要有两个核心逻辑
- 调用getLocations从GIT远程仓库同步到本地
- 使用 NativeEnvironmentRepository 委托来读取本地文件内容
@Override public synchronized Environment findOne(String application, String profile, String label, boolean includeOrigin) { NativeEnvironmentRepository delegate = new NativeEnvironmentRepository(getEnvironment(), new NativeEnvironmentProperties()); Locations locations = getLocations(application, profile, label); delegate.setSearchLocations(locations.getLocations()); Environment result = delegate.findOne(application, profile, "", includeOrigin); result.setVersion(locations.getVersion()); result.setLabel(label); return this.cleaner.clean(result, getWorkingDirectory().toURI().toString(),getUri()); }
然后调用 getLocations 如下：
@Override public synchronized Locations getLocations(String application, String profile, String label) { if (label == null) { label = this.defaultLabel; } String version = refresh(label); return new Locations(application, profile, label, version, getSearchLocations(getWorkingDirectory(), application, profile, label)); } // 调用 Git 相关API 进行获取相关配置 public String refresh(String label) { Git git = null; try { git = createGitClient(); if (shouldPull(git)) { FetchResult fetchStatus = fetch(git, label); if (this.deleteUntrackedBranches && fetchStatus != null) { deleteUntrackedLocalBranches(fetchStatus.getTrackingRefUpdates(), git); } // checkout after fetch so we can get any new branches, tags, ect. checkout(git, label); tryMerge(git, label); } else { // nothing to update so just checkout and merge. // Merge because remote branch could have been updated before checkout(git, label); tryMerge(git, label); } // always return what is currently HEAD as the version return git.getRepository().findRef("HEAD").getObjectId().getName(); } // ........ }
总体来说，spring-cloud-config 的相关代码流程并不复杂，主要是我们需要熟悉 @Value 的原理 、Environment 的原理。这样看起来就很轻松了。
实现自定义配置中心 PropertySourceLocator (基于拓展org.springframework.cloud.bootstrap.BootstrapConfiguration)
看过了 Spring-Cloud-Config 相关源码，我们怎么基于同样的机制来实现我们的配置中心呢？ 只需要以下几个步骤，以JSON 为例：
- 编写类JsonPropertySourceLocator实现 org.springframework.cloud.bootstrap.config.PropertySourceLocator 接口，实现 locate 方法
- 编写类继承 org.springframework.core.env.EnumerablePropertySource
- 新建 resource/META-INF/spring.factories 文件拓展 org.springframework.cloud.bootstrap.BootstrapConfiguration
- 新建配置源文件 json
1.编写类JsonPropertySourceLocator实现 org.springframework.cloud.bootstrap.config.PropertySourceLocator 接口，实现 locate 方法
@Component public class JsonPropertySourceLocator implements PropertySourceLocator{ private final static String DEFAULT_LOCATION="classpath:gupao.json"; private final ResourceLoader resourceLoader=new DefaultResourceLoader(getClass().getClassLoader()); @Override public PropertySource<?> locate(Environment environment) { WuzzDefineJsonPropertySource jsonPropertySource= new WuzzDefineJsonPropertySource("jsonPropertyConfig",mapPropertySource()); return jsonPropertySource; } private Map<String,Object> mapPropertySource(){ //访问远程配置？http接口。 Resource resource=this.resourceLoader.getResource(DEFAULT_LOCATION); if(resource==null){ return null; } Map<String,Object> result=new HashMap<>(); JsonParser jsonParser= JsonParserFactory.getJsonParser(); Map<String,Object> fileMap=jsonParser.parseMap(readFile(resource)); processorMap("",result,fileMap); return result; } private void processorMap(String prefix,Map<String,Object> result,Map<String,Object> fileMap){ if(prefix.length()>0){ prefix+="."; } for (Map.Entry<String,Object> entrySet:fileMap.entrySet()){ if(entrySet.getValue() instanceof Map){ processorMap(prefix+entrySet.getKey(),result,(Map<String,Object>)entrySet.getValue()); }else{ result.put(prefix+entrySet.getKey(),entrySet.getValue()); } } } /** * JSON格式 * @param resource * @return */ private String readFile(Resource resource){ FileInputStream fileInputStream=null; try{ fileInputStream=new FileInputStream(resource.getFile()); byte[] readByte=new byte[(int)resource.getFile().length()]; //TODO 错误演示 fileInputStream.read(readByte); return new String(readByte,"UTF-8"); }catch (Exception e){ e.printStackTrace(); }finally { if(fileInputStream!=null){ try { fileInputStream.close(); } catch (IOException e) { e.printStackTrace(); } } } return null; } }
2.编写类继承 org.springframework.core.env.EnumerablePropertySource
public class WuzzDefineJsonPropertySource extends EnumerablePropertySource<Map<String, Object>> { public WuzzDefineJsonPropertySource(String name, Map<String, Object> source) { super(name, source); } @Override public String[] getPropertyNames() { return StringUtils.toStringArray(this.source.keySet()); } @Override public Object getProperty(String name) { return this.source.get(name); } }
3.新建 resource/META-INF/spring.factories 文件拓展 org.springframework.cloud.bootstrap.BootstrapConfiguration
org.springframework.cloud.bootstrap.BootstrapConfiguration=\
com.wuzz.demo.sourceloader.JsonPropertySourceLocator
4.新建配置源文件 json
{ "custom":{ "property":{ "hello": "hello Wuzz" } } }
5.测试类
@Value("${custom.property.hello}")
private String config;
@GetMapping("/config")
public String config(){
return config;
}
启动的时候可以断点进去看看是否被加载：
访问配置好的路径 ：
更多的信息请参考官网。
