spring PropertyPlaceholderConfigurer源码分析

系统管理员 2022-11-16 13:43 278阅读 0赞

## 1：写在前面 ##

在[这篇文章][Link 1]中我们分析了BeanFactoryPostProcessor,知道了，其也是spring提供给我们的一个扩展点，这个`点`是在外部配置生成BeanDefinition对象之后，在通过BeanDefinition创建spring bean之前，允许我们对BeanDefinition进行自己的定制化处理，本文要分析PropertyPlaceholderConfigure就是BeanFacotryPostProcessor的一个子类，利用其实现了`占位符${变量名}`替换的功能，这个功能是我们在工程上必用的一个功能，非常重要！！！  
另外，关于PropertyPlaceholderConfigurer的使用例子，可以参考[这里][Link 2]。

## 2：类图 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]

## 3：源码分析 ##

首先执行到代码：

org.springframework.context.support.ClassPathXmlApplicationContext#ClassPathXmlApplicationContext(java.lang.String[], boolean, org.springframework.context.ApplicationContext)
    public ClassPathXmlApplicationContext(
    		String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
    		throws BeansException { 
    
    	...snip...
    	if (refresh) { 
    		refresh();
    	}
    }

继续看`refresh();`方法，源码如下：

org.springframework.context.support.AbstractApplicationContext#refresh
    public void refresh() throws BeansException, IllegalStateException { 
    	synchronized (this.startupShutdownMonitor) { 
    		...snip...
    		try { 
    			...snip...
    			// <2021-04-07 15:13>
    			invokeBeanFactoryPostProcessors(beanFactory);
    			...snip...
    		}
    
    		catch (BeansException ex) { 
    			...snip...
    		}
    
    		finally { 
    			...snip...
    		}
    	}
    }

其中`<2021-04-07 15:13>`处代码就是注册BeanFactoryPostProcessor，最终从这里会执行到如下代码：

org.springframework.context.support.PostProcessorRegistrationDelegate#invokeBeanFactoryPostProcessors(java.util.Collection<? extends org.springframework.beans.factory.config.BeanFactoryPostProcessor>, org.springframework.beans.factory.config.ConfigurableListableBeanFactory)
    private static void invokeBeanFactoryPostProcessors(
    			Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) { 
    	// 循环遍历所有的BeanFactoryPostProcessor，调用postProcessBeanFactory方法
    	for (BeanFactoryPostProcessor postProcessor : postProcessors) { 
    		// <2021-04-07 15:26>
    		postProcessor.postProcessBeanFactory(beanFactory);
    	}
    }

我们就从`2021-04-07 15:26>`开始正式分析。

### 3.1：postProcessBeanFactory ###

该处调用的是`PropertyPlaceholderConfigurer`的父类`PropertyResourceConfigurer`，源码如下：

org.springframework.beans.factory.config.PropertyResourceConfigurer#postProcessBeanFactory
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    	try { 
    		// <2021-04-07 15:32>
    		Properties mergedProps = mergeProperties();
    
    		// <2021-04-07 15:40>
    		convertProperties(mergedProps);
    
    		// <2021-04-07 15:41>
    		processProperties(beanFactory, mergedProps);
    	}
    	catch (IOException ex) { 
    		throw new BeanInitializationException("Could not load properties", ex);
    	}
    }

`<2021-04-07 15:32>`处是获取配置文件中配置的信息，可能如下图：  
![在这里插入图片描述][20210407154104672.png_pic_center]  
`<2021-04-07 15:40>`处最终还是将原始值，作为转换后的值，不知道到底有什么用。`<2021-04-07 15:41>`就是具体应用配置文件中的值到BeanDefinition中来替换占位符了，单起一部分来看。

### 3.2：processProperties ###

这里执行的方法所在的类就是我们本文要分析的PropertyPlaceHolderConfiguer了，源码如下：

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer#processProperties
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
    			throws BeansException { 
    	// <2021-04-07 17:24>
    	StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);
    	// <2021-04-07 17:31>
    	doProcessProperties(beanFactoryToProcess, valueResolver);
    }

`<2021-04-07 17:24>`使用该类完成`${}`占位符的替换工作，具体可以参考[这里][Link 3]。`<2021-04-07 17:31>`是执行具体的替换操作，详细参考`3.3：doProcessProperties`。

### 3.3：doProcessProperties ###

源码如下：

org.springframework.beans.factory.config.PlaceholderConfigurerSupport#doProcessProperties
    protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
    			StringValueResolver valueResolver) { 
    	// 通过字符串解析对象，创建bean定义的访问者对象BeanDefinitionVisitor
    	BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);
    	// 获取所有的bean名称
    	String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
    	for (String curName : beanNames) { 
    		// 注意此时为了能够处理BeanDefinition,配置的PropertyPlaceholderConfiguer已经初始化完毕了
    		// 满足以下条件则为true
    		// 1：当前bean名称不等于PropertyPlaceholderConfigurer的bean名称
    		// 2：PropertyPlaceholderConfiguer所在的bean工厂和当前需要处理的bean工厂是同一个工厂容器
    		if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) { 
    			// 通过当前bean名称获取对应的db
    			BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);
    			try { 
    				// <2021-04-07 18:00>
    				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.
    	beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);
    }

`<2021-04-07 18:00>`处是`核心代码`，执行配置文件中占位符的替换操作，详细参考`3.4：visitBeanDefinition`。

### 3.4：visitBeanDefinition ###

源码如下：

org.springframework.beans.factory.config.BeanDefinitionVisitor#visitBeanDefinition
    public void visitBeanDefinition(BeanDefinition beanDefinition) { 
    	// 替换parent属性，如果有parent且存在${}占位符的话
    	visitParentName(beanDefinition);
    	// 替换class属性，如果有class且存在${}占位符的话
    	visitBeanClassName(beanDefinition);
    	// 替换facotry-bean属性，如果有factory-bean且存在${}占位符的话
    	visitFactoryBeanName(beanDefinition);
    	// 替换facotry-method属性，如果有factory-method且存在${}占位符的话
    	visitFactoryMethodName(beanDefinition);
    	// 替换scope属性，如果有scope且存在${}占位符的话
    	visitScope(beanDefinition);
    	// 如果是配置了<property>标签，这里在工程上会重点使用！！！
    	if (beanDefinition.hasPropertyValues()) { 
    		// <2021-04-07 18:13>
    		visitPropertyValues(beanDefinition.getPropertyValues());
    	}
    	// 如果配置了<constructor-arg>，进行相关占位符的替换，如果需要的话
    	if (beanDefinition.hasConstructorArgumentValues()) { 
    		// 获取配置的构造函数参数值
    		ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
    		// 处理通过index配置的构造函数参数
    		visitIndexedArgumentValues(cas.getIndexedArgumentValues());
    		// 处理通过name配置的构造函数参数
    		visitGenericArgumentValues(cas.getGenericArgumentValues());
    	}
    }

`<2021-04-07 18:13>`处是处理属性的占位符，源码如下：

org.springframework.beans.factory.config.BeanDefinitionVisitor#visitPropertyValues
    protected void visitPropertyValues(MutablePropertyValues pvs) { 
    	// 获取所有的pv
    	PropertyValue[] pvArray = pvs.getPropertyValues();
    	for (PropertyValue pv : pvArray) { 
    		// 解析原始值，替换占位符为实际值
    		// <2021-04-07 18:28>
    		Object newVal = resolveValue(pv.getValue());
    		// 如果是处理后不相等，则说明替换了占位符，才处理
    		if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) { 
    			// 设置替换了占位符后的值
    			pvs.add(pv.getName(), newVal);
    		}
    	}
    }

`<2021-04-07 18:28>`处就是执行具体的替换，源码如下：

org.springframework.beans.factory.config.BeanDefinitionVisitor#resolveValue
    protected Object resolveValue(@Nullable Object value) { 
    	...snip...
    	else if (value instanceof String) { 
    		// <2021-04-07 18:31>
    		return resolveStringValue((String) value);
    	}
    	return value;
    }

`<2021-04-07 18:31>`处源码如下：

org.springframework.beans.factory.config.BeanDefinitionVisitor#resolveStringValue
    protected String resolveStringValue(String strVal) { 
    	if (this.valueResolver == null) { 
    		throw new IllegalStateException("No StringValueResolver specified - pass a resolver " +
    				"object into the constructor or override the 'resolveStringValue' method");
    	}
    	// <2021-04-07 18:33>
    	String resolvedValue = this.valueResolver.resolveStringValue(strVal);
    	// Return original String if not modified.
    	return (strVal.equals(resolvedValue) ? strVal : resolvedValue);
    }

重点看`<2021-04-07 18:33>`处代码，源码如下：

org.springframework.beans.factory.config.PropertyPlaceholderConfigurer.PlaceholderResolvingStringValueResolver#resolveStringValue
    public String resolveStringValue(String strVal) throws BeansException { 
    	// <2021-04-07 18:34>
    	String resolved = this.helper.replacePlaceholders(strVal, this.resolver);
    	if (trimValues) { 
    		resolved = resolved.trim();
    	}
    	return (resolved.equals(nullValue) ? null : resolved);
    }

继续看`<2021-04-07 18:34>`处代码，源码如下：

org.springframework.util.PropertyPlaceholderHelper#replacePlaceholders(java.lang.String, org.springframework.util.PropertyPlaceholderHelper.PlaceholderResolver)
    public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) { 
    	Assert.notNull(value, "'value' must not be null");
    	// <2021-04-07 18:35>
    	return parseStringValue(value, placeholderResolver, null);
    }

继续看`<2021-04-07 18:35>`处代码，这里就是真正执行替换的地方了，是`核心`,源码如下：

org.springframework.util.PropertyPlaceholderHelper#parseStringValue
    protected String parseStringValue(
    			String value, PlaceholderResolver placeholderResolver, @Nullable Set<String> visitedPlaceholders) { 
    	// this.placeholderPrefix这里为${，获取存在该前缀的第一个位置
    	int startIndex = value.indexOf(this.placeholderPrefix);
    	// 如果是不存在，说明不存在占位符，直接返回
    	if (startIndex == -1) { 
    		return value;
    	}
    	
    	StringBuilder result = new StringBuilder(value);
    	while (startIndex != -1) { 
    		// 获取后缀}的位置
    		int endIndex = findPlaceholderEndIndex(result, startIndex);
    		// 存在后缀}
    		if (endIndex != -1) { 
    			// 获取${ 和 }中间的内容，如果是${my.name}，则该值就是my.name
    			String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
    			String originalPlaceholder = placeholder;
    			// 初始化记录已经访问替换的占位符set集合
    			if (visitedPlaceholders == null) { 
    				visitedPlaceholders = new HashSet<>(4);
    			}
    			// 如果是已经处理过，则抛出异常
    			if (!visitedPlaceholders.add(originalPlaceholder)) { 
    				throw new IllegalArgumentException(
    						"Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
    			}
    			// 处理占位符中包含占位符的情况
    			placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
    			// 从配置文件中获取占位符真正的值
    			String propVal = placeholderResolver.resolvePlaceholder(placeholder);
    			// 存在默认值的情况
    			if (propVal == null && this.valueSeparator != null) { 
    				// 获取：的位置
    				int separatorIndex = placeholder.indexOf(this.valueSeparator);
    				// 如果存在：
    				if (separatoIndex != -1) { 
    					// 获取真实的占位符,如${my.name:张三}这里就是my.name
    					String actualPlaceholder = placeholder.substring(0, separatorIndex);
    					// 获取默认值，如${my.name:张三}这里就是张三
    					String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
    					// 获取真实占位符的值
    					propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
    					// 如果是配置文件中没有，则使用默认值
    					if (propVal == null) { 
    						propVal = defaultValue;
    					}
    				}
    			}
    			// 如果是获取到了占位符的值
    			if (propVal != null) { 
    				propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
    				// 替换为真实值，如${my.name},如果propVal为张三的歌，则result变为张三的歌
    				result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
    				if (logger.isTraceEnabled()) { 
    					logger.trace("Resolved placeholder '" + placeholder + "'");
    				}
    				startIndex = result.indexOf(this.placeholderPrefix, startIndex + propVal.length());
    			}
    			else if (this.ignoreUnresolvablePlaceholders) { 
    				// Proceed with unprocessed value.
    				startIndex = result.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
    			}
    			else { 
    				throw new IllegalArgumentException("Could not resolve placeholder '" +
    						placeholder + "'" + " in value \"" + value + "\"");
    			}
    			visitedPlaceholders.remove(originalPlaceholder);
    		}
    		else { 
    			startIndex = -1;
    		}
    	}
    	// 返回替换后的结果值
    	return result.toString();
    }

[Link 1]: https://blog.csdn.net/wang0907/article/details/115440135
[Link 2]: https://blog.csdn.net/wang0907/article/details/115443697
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmcwOTA3_size_16_color_FFFFFF_t_70]: /images/20221022/d4d6c49bc27e4a6d9ce84304869bf107.png
[20210407154104672.png_pic_center]: /images/20221022/3627754d93294dc8bc980a85f4b3bfcc.png
[Link 3]: https://blog.csdn.net/wang0907/article/details/115488263