• 欢迎来到我的技术站,如果对网站内容感兴趣或者帮助到你,请为文章点赞、评论、分享,谢谢!

spring中@Value实现原理解析(一)——获取环境变量

spring 奔跑的蜗牛 1个月前 (10-24) 71次浏览 0个评论
文章目录[隐藏]

在平常的开发中,@Value注解其实是使用频率很高的,在我锁经理的项目中主要有两种使用场景:

  • 从上下文环境中读取配置属性值
  • 通过该注解将配置值解析为常用集合。解析为常用集合,主要需要使用到spring SpEL表达式的使用。

而今天这篇文章的重点,我们则主要来学习下@Value在spring中是如何实现的,留下记录,便于后面自己学习。

基础用法

在开始学习@Value注解之前,还是通过一个简单的demo, 可以知道我们目标是什么。具体源码如下:

@Slf4j
@Service
public class ValueAnnotationService {

    @Value("${annotation.value}")
    private String annotationValue;

    @PostConstruct
    public void init() {
        log.info("value: {}", annotationValue);
    }
}

这个例子很简单,就是通过@Value注解实现成员变量的注入。

@Value注解

在开始学习之前,我们还是看下Value注解的文档,看看该注解的使用场景。

package org.springframework.beans.factory.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Annotation at the field or method/constructor parameter level
 * that indicates a default value expression for the affected argument.
 *
 * <p>Typically used for expression-driven dependency injection. Also supported
 * for dynamic resolution of handler method parameters, e.g. in Spring MVC.
 *
 * <p>A common use case is to assign default field values using
 * {@code #{systemProperties.myProp}} style expressions.
 *
 * <p>Note that actual processing of the {@code @Value} annotation is performed
 * by a {@link org.springframework.beans.factory.config.BeanPostProcessor
 * BeanPostProcessor} which in turn means that you <em>cannot</em> use
 * {@code @Value} within
 * {@link org.springframework.beans.factory.config.BeanPostProcessor
 * BeanPostProcessor} or
 * {@link org.springframework.beans.factory.config.BeanFactoryPostProcessor BeanFactoryPostProcessor}
 * types. Please consult the javadoc for the {@link AutowiredAnnotationBeanPostProcessor}
 * class (which, by default, checks for the presence of this annotation).
 *
 * @author Juergen Hoeller
 * @since 3.0
 * @see AutowiredAnnotationBeanPostProcessor
 * @see Autowired
 * @see org.springframework.beans.factory.config.BeanExpressionResolver
 * @see org.springframework.beans.factory.support.AutowireCandidateResolver#getSuggestedValue
 */
@Target({ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Value {

    /**
     * The actual value expression: for example {@code #{systemProperties.myProp}}.
     */
    String value();

}

 

通过以上文档,我们可以看出几点:

  • @Value注解的用法,主要能够作用成员变量,方法或者构造函数的入参的注入
  • @Value注解能够包含SpEL表达式,做简单的运算操作
  • @Value注解的处理是通过BeanProcessor进行处理,不能与BeanProcessor或者BeanFactoryProcessor一起使用
  • @Value的默认解析是通过AutowiredAnnotationBeanPostProcessor进行处理

通过文档,我们了解了@Value注解需要注意的几点,以及在Spring Bean声明周期的过程中,如何处理@Value的注解。因此我们接下来就以AutowiredAnnotationBeanPostProcessor作为入口,调试如何对注解进行处理的。

执行原理

在以上的例子中,我们主要学习如何通过@Value进行成员属性的值注入。因此该部分处于Spring Bean声明周期的属性设置部分poplulateBean()方法的调用。由于从上面我们已知最终是通过AutowiredAnnotationBeanPostProcessor进行处理,因此我们直接查看该类的postProcessProperties(PropertyValues pvs, Object bean, String beanName)方法:

AutowiredAnnotationBeanPostProcessor#postProcessProperties()

该方法处于bean声明周期中的属性设置阶段,因此查看源码:

@Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        // 获取当前bean所关联的注入元数据信息
        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;
    }
private InjectionMetadata findAutowiringMetadata(String beanName, Class<?> clazz, @Nullable PropertyValues pvs) {
        // Fall back to class name as cache key, for backwards compatibility with custom callers.
        String cacheKey = (StringUtils.hasLength(beanName) ? beanName : clazz.getName());
        // Quick check on the concurrent map first, with minimal locking.
        InjectionMetadata metadata = this.injectionMetadataCache.get(cacheKey);
        // 判断当前的元数据是否需要刷新, 主要判断元数据与目标class是否不一致
        if (InjectionMetadata.needsRefresh(metadata, clazz)) {
            synchronized (this.injectionMetadataCache) {
                metadata = this.injectionMetadataCache.get(cacheKey);
                if (InjectionMetadata.needsRefresh(metadata, clazz)) {
                    if (metadata != null) {
                        metadata.clear(pvs);
                    }
                    metadata = buildAutowiringMetadata(clazz);
                    this.injectionMetadataCache.put(cacheKey, metadata);
                }
            }
        }
        return metadata;
    }

InjectionMetadata#inject()

当需要元数据注入时,最终将会通过InjectionMetadata进行属性的注入, 直接看下源码:

public void inject(Object target, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
        // 该处获取当前bean需要检查的元素列表
        Collection<InjectedElement> checkedElements = this.checkedElements;
        // 当checkedElements为Null时,则执行injectedElements列表
        Collection<InjectedElement> elementsToIterate =
                (checkedElements != null ? checkedElements : this.injectedElements);
        // 判断是否需要有元素需要注入
        if (!elementsToIterate.isEmpty()) {
            // 遍历需要注入的元素
            for (InjectedElement element : elementsToIterate) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Processing injected element of bean '" + beanName + "': " + element);
                }
                // 执行元素的注入
                element.inject(target, beanName, pvs);
            }
        }
    }

因为InjectedElement 是一个抽象的类,并没有 具体的实现,因此在AutowiredAnnotationBeanPostProcessor中对InjectedElement 有具体的实现类型为AutowiredInjectedElement的实现类型,用于实现对属性类型的注入操作。

AutowiredAnnotationBeanPostProcessor.AutowiredFieldElement#inject()

执行元素的注入,则是通过该类来实现,具体看下该源码:

@Override
        protected void inject(Object bean, @Nullable String beanName, @Nullable PropertyValues pvs) throws Throwable {
            // 当前成员变量
            Field field = (Field) this.member;
            Object value;
            // 判断是否开启了缓存,如果开启缓存,则从缓存中尝试解析元素
            if (this.cached) {
                value = resolvedCachedArgument(beanName, this.cachedFieldValue);
            }
            else {
                // 创建依赖描述
                DependencyDescriptor desc = new DependencyDescriptor(field, this.required);
                // 关联目标class对象
                desc.setContainingClass(bean.getClass());
                // 自动注入bean名称列表
                Set<String> autowiredBeanNames = new LinkedHashSet<>(1);
                Assert.state(beanFactory != null, "No BeanFactory available");
                // 从BeanFactory中获取类型转换器, 默认转换器为: SimpleTypeConverter
                TypeConverter typeConverter = beanFactory.getTypeConverter();
                try {
                    // 通过beanFactory解析依赖
                    value = beanFactory.resolveDependency(desc, beanName, autowiredBeanNames, typeConverter);
                }
                catch (BeansException ex) {
                    throw new UnsatisfiedDependencyException(null, beanName, new InjectionPoint(field), ex);
                }
                synchronized (this) {
                    // 未开启缓存
                    if (!this.cached) {
                        // 值不为空, 并且必须存在时
                        if (value != null || this.required) {
                            // 解析后的值
                            this.cachedFieldValue = desc;
                            // 注册依赖bean独享
                            registerDependentBeans(beanName, autowiredBeanNames);
                            if (autowiredBeanNames.size() == 1) {
                                String autowiredBeanName = autowiredBeanNames.iterator().next();
                                if (beanFactory.containsBean(autowiredBeanName) &&
                                        beanFactory.isTypeMatch(autowiredBeanName, field.getType())) {
                                    this.cachedFieldValue = new ShortcutDependencyDescriptor(
                                            desc, autowiredBeanName, field.getType());
                                }
                            }
                        }
                        else {
                            this.cachedFieldValue = null;
                        }
                        // 更新当前缓存的值为true
                        this.cached = true;
                    }
                }
            }
            if (value != null) {
                // 通过反射能够访问private
                ReflectionUtils.makeAccessible(field);
                // 为field设置元素值
                field.set(bean, value);
            }
        }
private void registerDependentBeans(@Nullable String beanName, Set<String> autowiredBeanNames) {
        if (beanName != null) {
            for (String autowiredBeanName : autowiredBeanNames) {
                // 判断依赖bean是否存在, 如果存在,则注册bean与依赖bean之间的关系
                if (this.beanFactory != null && this.beanFactory.containsBean(autowiredBeanName)) {
                    this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
                }
                if (logger.isTraceEnabled()) {
                    logger.trace("Autowiring by type from bean name '" + beanName +
                            "' to bean named '" + autowiredBeanName + "'");
                }
            }
        }
    }

该类型中,最主要是创建DependencyDescriptor对象,并将最终获取到的值value进行缓存,能够有效提升启动时的速度。同时类也通过beanFactory维护了bean与bean之间的依赖关系。

DefaultListableBeanFactory#resolveDependency()

public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

        // 通过descriptor进行参数名称发现,通过源码可以得知,
        // 他主要是判断是否包含了methodParameter参数,当存在方法参数时,此时将会通过ParameterNameDiscovery进行处理
        // 当前我们给的实例中,只是方法成员变量,因此该方法不会有作用
        descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());

        // 判断依赖的类型是否为Optional对象
        if (Optional.class == descriptor.getDependencyType()) {
            return createOptionalDependency(descriptor, requestingBeanName);
        }
        // 判断依赖的类型是否为ObjectFactory或者ObjectProvider对象,
        // 这两个类型主要是为了实现懒加载而存在的
        else if (ObjectFactory.class == descriptor.getDependencyType() ||
                ObjectProvider.class == descriptor.getDependencyType()) {
            return new DependencyObjectProvider(descriptor, requestingBeanName);
        }
        else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
            return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName);
        }
        else {
            // 该方法通过判断是否在属性上加上了@Lazy注解,如果当前的属性被Lazy锁注解时,将通过
            // 代理机制,返回代理对象
            Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary(descriptor, requestingBeanName);

            // 当返回为空值,则表示当前的value并不是@Lazy加载,则需要解析依赖
            if (result == null) {
                // 执行依赖解析
                result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter);
            }
            return result;
        }
    }
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName,
            @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException {

        // 该处属于上下文中的内容,通过ThreadLocal的方式绑定当前正在inject的DependencyDescriptor对象
        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) {
                // 当value的是string类型时
                if (value instanceof String) {
                    // 解析内嵌的value值
                    String strVal = resolveEmbeddedValue((String) value);
                    // 获取当前beanName所关联的BeanDefinition数据
                    BeanDefinition bd = (beanName != null && containsBean(beanName) ?
                            getMergedBeanDefinition(beanName) : null);
                    // 该处主要对注入的值进行解析, 其中包含了spel的解析操作
                    value = evaluateBeanDefinitionString(strVal, bd);
                }
                // 获取类型转换器
                TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
                try {
                    // 将value转换为需要的类型
                    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()));
                }
            }
            
            // 后续则不为value需要解析的内容
            .....
        }
        finally {
            ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
        }
    }
public String resolveEmbeddedValue(@Nullable String value) {
        if (value == null) {
            return null;
        }
        String result = value;
        // 获取内嵌的值解析器,并解析string的值
        for (StringValueResolver resolver : this.embeddedValueResolvers) {
            result = resolver.resolveStringValue(result);
            if (result == null) {
                return null;
            }
        }
        return result;
    }

最终在解析时,会将解析的方式传递到AbstractPropertyResolver#resolveRequiredPlaceholders()方法。

AbstractPropertyResolver#resolveRequiredPlaceholders()

public String resolveRequiredPlaceholders(String text) throws IllegalArgumentException {
        // 当scriptHelper不存在时,则创建
        if (this.strictHelper == null) {
            this.strictHelper = createPlaceholderHelper(false);
        }
        // 执行占位符解析
        return doResolvePlaceholders(text, this.strictHelper);
    }
private String doResolvePlaceholders(String text, PropertyPlaceholderHelper helper) {
        // 调用helper中的占位符解析方法
        return helper.replacePlaceholders(text, this::getPropertyAsRawString);
    }

PropertiesPlaceholderHelper#replacePlacehoders()

方法为解析占位符的地方,具体源码如下:

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) {
            // 获取结束}的位置
            int endIndex = findPlaceholderEndIndex(result, startIndex);
            if (endIndex != -1) {
                // 获取占位符的具体值
                String placeholder = result.substring(startIndex + this.placeholderPrefix.length(), endIndex);
                String originalPlaceholder = placeholder;
                if (visitedPlaceholders == null) {
                    visitedPlaceholders = new HashSet<>(4);
                }
                if (!visitedPlaceholders.add(originalPlaceholder)) {
                    throw new IllegalArgumentException(
                            "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
                }
                // Recursive invocation, parsing placeholders contained in the placeholder key.
                // 解析站位付的值, 该处为一个递归调用,可以循环解析${${value}}这种格式
                placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
                // Now obtain the value for the fully resolved key...
                
                // 从上下文环境env中获取value的值
                String propVal = placeholderResolver.resolvePlaceholder(placeholder);
                if (propVal == null && this.valueSeparator != null) {
                    // 判断站位符中是否包含了:默认值的设置
                    int separatorIndex = placeholder.indexOf(this.valueSeparator);
                    if (separatorIndex != -1) {
                        // 以:分割,重新获取占位符
                        String actualPlaceholder = placeholder.substring(0, separatorIndex);
                        // 获取默认值
                        String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
                        // 重新获取占位符实际的值
                        propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
                        // 当获取失败时,以默认值替换
                        if (propVal == null) {
                            propVal = defaultValue;
                        }
                    }
                }
                // 属性值存在
                if (propVal != null) {
                    // Recursive invocation, parsing placeholders contained in the
                    // previously resolved placeholder value.
                    // 该处也是一个递归调用,主要为了解决值中依然包含占位符,同样也需要解析
                    propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
                    // 将实际的值,替换现有占位符数据
                    result.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
                    if (logger.isTraceEnabled()) {
                        logger.trace("Resolved placeholder '" + placeholder + "'");
                    }
                    // 当value中包含了多个占位符时,此时则需要循环的解决占位符问题
                    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();
    }
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) {
            // 获取已加载的所有的property源数据列表
            for (PropertySource<?> propertySource : this.propertySources) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Searching for key '" + key + "' in PropertySource '" +
                            propertySource.getName() + "'");
                }
                // 从元数据中获取value
                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;
    }

到此,@Value的简单应用解析过程就到此结束。这篇文章主要介绍了最简单使用方式,如何从环境中获取并注入需要的key-value值,希望对您的理解有帮助。

 

 


Compiler编程笔记 , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权
转载请注明原文链接:spring中@Value实现原理解析(一)——获取环境变量
喜欢 (14)
[阳光路上]
分享 (0)
发表我的评论
取消评论
表情 贴图 加粗 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址