细节知多少 - spring @Value注解解析
@Value是开发过程中使用比较频繁的注解之一，它的作用是将配置文件中key对应的值赋值给它标注的属性。对于常见的知识点，我们应该了解它功能实现的本质。对我们自己的技术提升很有帮助。
原理
在spring中是由 AutowiredAnnotationBeanPostProcessor 解析处理@Value注解。 AutowiredAnnotationBeanPostProcessor 是一个 BeanPostProcessor ，所以每个类的实例化都过经过 AutowiredAnnotationBeanPostProcessor 类。当 post-processor 处理bean时，会解析bean Class的所有属性，在解析时会判断属性上是否标有 @Value 注解，有就解析这个 @Value 的属性值，将解析后结果放入 AutowiredFieldElement 类型 InjectionMetaData.checkedElements 中，当给属性赋值时会使用 checkedElements ，从而得到 @Value 注解的 Filed 属性，调用 AutowiredFieldElement.inject() 方法进行解析，解析时会使用 DefaultListableBeanFactory (用于解析${})和 TypeConverter (用于类型转换)，从而得到 age 属性的值，最后调用 field.set(bean, value) ，从而获取的值赋给 bean的field 。
整个过程就是这样，有点抽象吧，下面我们一起debug源码，更清晰简明的了解@Value的原理。
debug源码是我觉得掌握其原理最好的方式
准备
int age
@RestController
@Slf4j
public class MyController {
@Value("${user.age:11}")
private int age;
public int getAge(){
log.info("age:{}", age)
return age;
}
}
复制代码
一起debug解开神秘
入口
核心：存。将class的标注@Value的所有信息转存InjectionMetadata.InjectedElement集合中
@Value 同@ Autowired 一样，是由 AutowiredAnnotationBeanPostProcessor 解析处理，处理 @Value 的入口为 AutowiredAnnotationBeanPostProcessor.buildAutowiringMetadata(Class clazz) 。看代码内部
AutowiredAnnotationBeanPostProcessor class
private InjectionMetadata buildAutowiringMetadata(final Class<?> clazz) {
List<InjectionMetadata.InjectedElement> elements = new ArrayList<>();
Class<?> targetClass = clazz;
do {
final List<InjectionMetadata.InjectedElement> currElements = new ArrayList<>();
// 解析targetClass的所有属性
ReflectionUtils.doWithLocalFields(targetClass, field -> {
AnnotationAttributes ann = findAutowiredAnnotation(field);
if (ann != null) {
// 由此可知，static修改的属性无法使用@Value注解赋值
if (Modifier.isStatic(field.getModifiers())) {
return;
}
boolean required = determineRequiredStatus(ann);
currElements.add(new AutowiredFieldElement(field, required));
}
});
ReflectionUtils.doWithLocalMethods(targetClass, method -> {
Method bridgedMethod = BridgeMethodResolver.findBridgedMethod(method);
AnnotationAttributes ann = findAutowiredAnnotation(bridgedMethod);
if (ann != null && method.equals(ClassUtils.getMostSpecificMethod(method, clazz))) {
// 由此可知，static修改的方法无法使用@Value注解赋值
if (Modifier.isStatic(method.getModifiers())) {
return;
}
boolean required = determineRequiredStatus(ann);
PropertyDescriptor pd = BeanUtils.findPropertyForMethod(bridgedMethod, clazz);
currElements.add(new AutowiredMethodElement(method, required, pd));
}
});
elements.addAll(0, currElements);
targetClass = targetClass.getSuperclass();
}
while (targetClass != null && targetClass != Object.class);
return new InjectionMetadata(clazz, elements);
}
复制代码
这个方法用于遍历和解析clazz的所有filed和method，解析其上的 @Value 、 @Autowired 、 @Inject 注解，然后放入类型为 InjectionMetadata.InjectedElement 的 elements 中， elements 再放入 metadata(=new InjectionMetadata(clazz, elements)) 中。再将 metadata 放入缓存 injectionMetadataCache 中，后面会从缓存中取值
下面，我们重点看属性的解析过程，代码如下
AutowiredAnnotationBeanPostProcessor class
private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
if (ao.getAnnotations().length > 0) { // autowiring annotations have to be local
for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
if (attributes != null) {
return attributes;
}
}
}
return null;
}
复制代码
autowiredAnnotationTypes 包含了 @Value 、 @Autowired 、 @Inject 。如果属性解析到了响应注解，就将注解的信息返回给上层。解析注解过程这里不详细说了
解析
核心：用。使用InjectionMetadata.InjectedElement，解析并赋值给clazz的属性，即赋值MyController.age
上面的逻辑主要为解析@Value的信息存入 InjectionMetadata.InjectedElement 集合，下面的逻辑为使用 InjectionMetadata.InjectedElement ，解析出真正的值，从而赋值给属性。下面看看怎么解析并赋值的
首先，我们通过获取 InjectionMetadata.InjectedElement 对象数据，其实是从 injectionMetadataCache 缓存中获取的。获取的地点代码如下
AutowiredAnnotationBeanPostProcessor class
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
// 获取，从injectionMetadataCache缓存获取
InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);
// 使用
metadata.inject(bean, beanName, pvs);
return pvs;
}
复制代码
我们重点看使用部分，即 metadata.inject(bean, beanName, pvs) ，看方法名就知道，要注入属性值。看代码内部
InjectionMetadata class
public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) {
if (!checkedElements.isEmpty()) {
for (InjectedElement element : checkedElements) {
element.inject(target, beanName, pvs);
}
}
}
复制代码
方法逻辑很简单，遍历集合分别调用 inject() 方法。看其内部代码逻辑
InjectionMetadata.InjectedElement class
protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) {
Field field = (Field) this.member;
Object value;
if (this.cached) {
value = resolvedCachedArgument(beanName, this.cachedFieldValue);
}
else {
DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
desc.setContainingClass(bean.getClass());
Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
// 获取类型转换器
TypeConverter typeConverter = beanFactory.getTypeConverter();
// 核心逻辑：解析field注解
value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
// ··· 值缓存起来 略
}
if (value != null) {
ReflectionUtils.makeAccessible(field);
field.set(bean, value);
}
}
复制代码
方法的核心为使用 DependencyDescriptor 包装field，使用 beanFactory 解析 DependencyDescriptor 从而得到属性值。下面看其 beanFactory.resolveDependency() 内部代码。(注： beanFactory 是通过 BeanFactoryAware 注入的，我们可学习这种用法)
DefaultListableBeanFactory class
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
// 处理Optional类型的field，与@Value无关，暂略
if (Optional.class == descriptor.getDependencyType()) {
return createOptionalDependency(descriptor, requestingBeanName);
}
// 处理ObjectFactory和ObjectProvider类型的field，与@Value无关，暂略
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
return new DependencyObjectProvider(descriptor, requestingBeanName);
}else {
// 核心: 真正解析field的方法
result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
return result;
}
}
复制代码
从方法的入参可以看到，这个类型转换器 TypeConverter 已经传进来了，需要类型转换时就使用 TypeConverter 它进行转换， TypeConverter 是从 BeanFactory.getTypeConverter() 获取来的。
doResolveDependency()解析@Value注解的大管家，它不负责具体解析，但它说明了解析的整个流程 。看 doResolveDependency() 方法代码逻辑
DefaultListableBeanFactory class
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) {
InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// field属性的类型
Class<?> type = descriptor.getDependencyType();
// 1. 获取(不只是)@Value注解的value方法的值 如此例中value方法值为: ${test.age:11} (1)
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
// 如果value是String类型，走这里。此例value为: ${test.age:11}字符串
if (value instanceof String) {
// 2. 开始解析value的值
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 {
// 3. 开始解析value的值
return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
...
}
}
... 省略解析@Autowired注解的逻辑
}finally {
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
复制代码
此方法为解析 @Value 注解属性值的核心方法了。逻辑分为四步：
- 获取(不只是)
@Value注解的value方法的值。通过descriptor解析出注解的value方法的值 - 开始解析value的值
- 如果值为String类型，会特殊的解析这个值，特殊解析的意思是如果值为
${test.age:11}，会解析出值为:"11"，这个解析过程使用的是PropertySourcesPlaceholderConfigurer.processProperties()方法
说的有点抽象，举个例子。如下，定义了一个@Value注解的变量
@Value("${user.age:11}")
private int age;
第一步：通过descriptor得到${user.age:11}
第二步：拆解${user.age:11}，得到user.age:11，获取值，没有获取到，以:或${}为标准再拆解，最后得到值
第三步：此时得到的值是String类型的，需要转换成目标变量声明的类型，此处类型为int
复制代码
one step
首先详细了解下第一步。获取 @Value的value() 方法的值
QualifierAnnotationAutowireCandidateResolver class
public Object getSuggestedValue(DependencyDescriptor descriptor) {
Object value = findValue(descriptor.getAnnotations());
if (value == null) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
value = findValue(methodParam.getMethodAnnotations());
}
}
return value;
}
protected Object findValue(Annotation[] annotationsToSearch) {
if (annotationsToSearch.length > 0) { // qualifier annotations have to be local
AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
if (attr != null) {
return extractValue(attr);
}
}
return null;
}
复制代码
以上两个方法主要是解析 @Value 注解，再通过 AnnotatedElementUtils.getMergedAnnotationAttributes() 方法得到注解的属性集合，从而获取到 value() 方法的值
two step
解析传入的${key:defaultValue}形式的字符串，从而得到key的实际的值。
public String resolveEmbeddedValue(@Nullable String value) {
String result = value;
for (StringValueResolver resolver : this.embeddedValueResolvers) {
result = resolver.resolveStringValue(result);
return result;
}
}
复制代码
核心方法为 resolver.resolveStringValue(result) 方法，resolver实际为 StringValueResolver类型的lambda表达式 ，这个表示式定义在了 PropertySourcesPlaceHolderConfigurer.processProperties() 方法中，这里debug是需要注意下，如果你不了解lambda，可能会比较朦胧。代码如下
PropertySourcesPlaceHolderConfigurer class
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);
};
doProcessProperties(beanFactoryToProcess, valueResolver);
}
复制代码
lambda会扰乱你的调用栈展示，下面截图展示真实调用栈的信息
上面代码中 processProperties 方法会调用 PropertySourcesPropertyResolver.resolveRequiredPlaceholders() 方法来解析入参，而它又会调用 PropertySourcesPropertyResolver.getPropertyAsRawString() 和 PropertyPlaceholderHelper.replacePlaceholders() 。代码如下
AbstractPropertyResoler class
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);
}
复制代码
PropertySourcesPropertyResolver.getPropertyAsRawString()方法逻辑
PropertySourcesPropertyResolver.getPropertyAsRawString() 负责获取key的值，因为 PropertySourcesPropertyResolver.持有propertySources变量 ，这个变量与 Environment的propertySources 变量是同步的，所以 propertySource.getProperty(key) 可以获取到配置文件中的值，代码如下
PropertySourcesPropertyResolver class
protected String getPropertyAsRawString(String key) {
return getProperty(key, String.class, false);
}
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);
}
}
}
return null;
}
复制代码
可以看到，最后 propertySource.getProperty(key) 获取值返回。
PropertyPlaceholderHelper.replacePlaceholders()方法逻辑
PropertyPlaceholderHelper.replacePlaceholders() 负责解析 ${key: defaultValue} ，将它拆解以获取key，再用 propertySource.getProperty(key) 获取值。而具体的拆解逻辑在 parseStringValue() 方法中，代码如下
public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
Assert.notNull(value, "'value' must not be null");
return parseStringValue(value, placeholderResolver, null);
}
protected String parseStringValue(
String value, PlaceholderResolver placeholderResolver, @Nullable Set<String> visitedPlaceholders) {
int startIndex = value.indexOf(this.placeholderPrefix);
if (startIndex == -1) {
return value;
}
StringBuilder result = new StringBuilder(value);
while (startIndex != -1) {
... 略 具体拆解${xx:yy},不展示了，自己来看吧，否则代码太多影响了要主要的逻辑
// 递归调用
placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
// 获取placeholder实际为key，最终调用propertySource.getProperty(key)获取值
String propVal = placeholderResolver.resolvePlaceholder(placeholder);
... 略 同上
}
return result.toString();
}
复制代码
可以看到这个key一个拆解一层得到一个新key，尝试调用 placeholderResolver.resolvePlaceholder(新key) 获取值，如果没有获取到，再拆解一层得到一个新key，再调用 placeholderResolver.resolvePlaceholder(新key) 获取值的循环过程，直到获取到获取不能拆解为止的过程(因为key的形式可以是 {yy:zz}})。此时得到的值时String类型的。并不是我们赋值变量的类型，所以接下来进行类型转换。
Three step
将String类型的值转换成目标变量声明的类型。
我们回到 DefaultListableBeanFactory.doResolveDependency() 方法，此时代码来到了 converter.convertIfNecessary 方法处，即类型转换。看方法代码
TypeConverterSupport class
public <T> T convertIfNecessary(@Nullable Object value, @Nullable Class<T> requiredType,
@Nullable TypeDescriptor typeDescriptor) throws TypeMismatchException {
return this.typeConverterDelegate.convertIfNecessary(null, null, value, requiredType, typeDescriptor);
}
TypeConverterDelegate class
public <T> T convertIfNecessary(@Nullable String propertyName, @Nullable Object oldValue, @Nullable Object newValue,
@Nullable Class<T> requiredType, @Nullable TypeDescriptor typeDescriptor) {
// conversionService包含着所有的转换器，如下图
ConversionService conversionService = this.propertyEditorRegistry.getConversionService();
TypeDescriptor sourceTypeDesc = TypeDescriptor.forObject(newValue);
if (conversionService.canConvert(sourceTypeDesc, typeDescriptor)) {
return (T) conversionService.convert(newValue, sourceTypeDesc, typeDescriptor);
}
}
复制代码
方法首先找到能转换(string -> int)的转换器，然后开始转换。怎么找到能转换的转换器这里不说了，自己跟下吧。开始转换的核心是确定对应的 xxxtoyyyConverter , xxxtoyyyConverter 内部调用的是本质的工具类。如String转int，工具类为: NumberUtils.parseNumber(source, this.targetType) ，这个工具类方法比较熟悉和亲切吧，所以spring很多功能最终都是调用最本质的java工具类。 xxxtoyyyConverter 是一大堆的，如下图
以上就是将 @Value 修饰的变量赋值的整个过程了，从解析注解的 value() 方法的值key，再到解析key为新key，再到配置文件获取key(新key)的值，最后对获取的值进行类型转换，最最后通过 field.set(bean, value) 赋值给目标变量
下面将整个解析过程的调用栈罗列下
整体调用栈
AbstractAutowireCapableBeanFactory.createBean() -AbstractAutowireCapableBeanFactory.doCreateBean() --AbstractAutowireCapableBeanFactory.applyMergedBeanDefinitionPostProcessors() ---AutowiredAnnotationBeanPostProcessor.postProcessMergedBeanDefinition() ----AutowiredAnnotationBeanPostProcessor.findAutowiringMetadata() -----AutowiredAnnotationBeanPostProcessor.buildAutowiringMetadata() ========以上是存逻辑，以下是用逻辑======== --AbstractAutowireCapableBeanFactory.populateBean() ---AutowiredAnnotationBeanPostProcessor.postProcessProperties() ----AutowiredAnnotationBeanPostProcessor.findAutowiringMetadata() -----InjectionMetadata.inject() ------(InjectionMetadata.InjectedElement)AutowiredFieldElement.inject() -------DefaultListableBeanFactory.resolveDependency() --------DefaultListableBeanFactory.doResolveDependency() ---核心 ---------AbstractBeanFactory.resolveEmbeddedValue() ----------StringValueResolver lambda子类.resolveStringValue() -----------PropertySourcesPropertyResolver.resolveRequiredPlaceholders() ------------AbstractPropertyResolver.getPropertyAsRawString() -------------PropertyPlaceholderHelper.replacePlaceholders() --------------PropertySource.getProperty() -----------PropertyPlaceholderHelper.parseStringValue() 递归 ------------AbstractPropertyResolver.resolvePlaceholder() -------------PropertySource.getProperty() ---------SimpleTypeConverter.convertIfNecessary() ----------TypeConverterDelegate.convertIfNecessarT() -----------ConversionService.canConvert() -----------ConversionService.convert() 复制代码
原味地址： 细节知多少 - spring @Value注解解析
正文到此结束
- 本文标签： tar Service ArrayList CTO BeanUtils db http UI IO lambda parse rmi final https Property CEO Lua list tab src 配置 cache 缓存 遍历 开发 struct BeanDefinition 代码 本质 递归 value 源码 build cat ORM Qualifier 解析 REST ip ACE IDE bug tag key java 同步 find bean equals App 管家 strace 数据 id HashSet 实例 spring provider
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
Loading...
![[HBLOG]公众号](https://www.liuhaihua.cn/img/qrcode_gzh.jpg)
