Spring中@Value标签的使用详解

1.@Value标签

由于Spring对通过IOC的方式对对象进行统一管理，所以对任何对象而言，其生成方法均由Spring管理。传统的方法是通过XML配置每一个Bean，并对这个Bean的所有Field进行声明式配置。

以一个简单的学校的例子为示范。假设有两种角色，老师和班长。

package org.kingszelda.version3.controller;

/**
 * Created by shining.cui on 2017/7/30.
 */
public class Teacher {

    /**
     * 姓名
     */
    private String name = "王老师";

    /**
     * 教授科目
     */
    private String major = "数学";

    /**
     * 教授课程班级的班长
     */
    private ClassMonitor classMonitor = new ClassMonitor();

    /**
     * 老师会上课
     */
    public void teachLesson() {

    }

    /**
     * 老师要收作业，然而老师并不亲自收，而是交给班长收
     */
    public void collectHomework() {
        classMonitor.collectHomework();
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getMajor() {
        return major;
    }

    public void setMajor(String major) {
        this.major = major;
    }

    public ClassMonitor getClassMonitor() {
        return classMonitor;
    }

    public void setClassMonitor(ClassMonitor classMonitor) {
        this.classMonitor = classMonitor;
    }
}

老师有自己的名字和教授的科目两个属性，这属于老师的静态属性。老师有很多“功能“，比如上课和收作业。上课属于老师可以自己完成的功能，而收作业则需要班长帮忙。所以老师为了完成自己的工作是不能独立存在的，需要依赖班长。

/**
 * Created by shining.cui on 2017/7/30.
 */
public class ClassMonitor {

    public void collectHomework(){
        System.out.println("开始收作业了！");
        System.out.println("收作业完毕");
    }
}

这里我们假设班长只有一个功能，就是收作业。

上面的例子很好的说明了对象之间相互依赖共同合作的方法，即互相依赖。这些功能交给spring之后管理起来就方便多了，以xml的方式为例，需要如下配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <bean id="classMonitor" class="org.kingszelda.version3.controller.ClassMonitor"/>
    <bean id="teacher" class="org.kingszelda.version3.controller.Teacher">
        <property name="name" value="王老师"/>
        <property name="major" value="数学"/>
        <property name="classMonitor" ref="classMonitor"/>
    </bean>
</beans>

通过这种配置的方式之后，实体之间的依赖关系变得一清二楚。比如Teacher的名字，科目，所依赖的班长是哪个，只看配置文件就可以一目了然。但是，当实体变多了之后，可想而知，这个xml配置文件将庞大的不可想象，就更不要提可读性了。

于是Spring从3.0开始推出了基于注解的形式，来简化配置。

package org.kingszelda.version3.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Created by shining.cui on 2017/7/30.
 */
@Service
public class Teacher {

    /**
     * 姓名
     */
    @Value("王老师")
    private String name;

    /**
     * 教授科目
     */
    @Value("数学")
    private String major;

    /**
     * 教授课程班级的班长
     */
    @Resource
    private ClassMonitor classMonitor;

    /**
     * 老师会上课
     */
    public void teachLesson() {

    }

    /**
     * 老师要收作业，然而老师并不亲自收，而是交给班长收
     */
    public void collectHomework() {
        classMonitor.collectHomework();
    }
}

通过注解的形式已经减少了大量的get、set方法，通过@Resource注入了依赖的班长，并且通过@Value注入了老师的姓名和科目。

问题来了，当姓名与科目如何做到可配置，而不是写死的呢？对应xml与注解都有其对应的方式。

首先声明一个config.perproties文件:

name=张老师
major=数学

xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:property-placeholder location="classpath:config.properties"/>
    <bean id="classMonitor" class="org.kingszelda.version3.controller.ClassMonitor"/>
    <bean id="teacher" class="org.kingszelda.version3.controller.Teacher">
        <property name="name" value="${name}"/>
        <property name="major" value="${major}"/>
        <property name="classMonitor" ref="classMonitor"/>
    </bean>
</beans>

注解：

package org.kingszelda.version3.controller;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * Created by shining.cui on 2017/7/30.
 */
@Service
public class Teacher {

    /**
     * 姓名
     */
    @Value("${name}")
    private String name;

    /**
     * 教授科目
     */
    @Value("${major}")
    private String major;

    /**
     * 教授课程班级的班长
     */
    @Resource
    private ClassMonitor classMonitor;

    /**
     * 老师会上课
     */
    public void teachLesson() {

    }

    /**
     * 老师要收作业，然而老师并不亲自收，而是交给班长收
     */
    public void collectHomework() {
        classMonitor.collectHomework();
    }

}

我们看到，不论是通过xml配置，还是通过注解@Value的方式，姓名与科目都在生成Teacher对象是被赋值进去了。

2.@Value是如何起作用的

Spirng在生命周期里关于Bean的处理大概可以分为下面几步：

1. 加载Bean定义（从xml或者从@Import等）
2. 处理BeanFactoryPostProcessor
3. 实例化Bean
4. 处理Bean的property注入
5. 处理BeanPostProcessor

而当我们在声明了<context:property-placeholder location="classpath:config.properties"/>标签之后，即声明了一个配置型bean交给Spring容器进行管理，即PropertyPlaceholderConfigurer类。我们先看一下这个类的继承结构。

蓝色的是功能性结构，实现了解析文件，处理文件的功能，黄色的是Spring的钩子功能，声明了功能性模块被调用的时机。这里PrepertyPlaceholderConfigurer实现了BeanFactoryPostProcesser接口，并实现了postProcessBeanFactory()方法即当Spring容器的BeanFactory被构造成功之后会调用这个方法。这里要注意，ApplicationContext也是BeanFactory的派生类。这时，我们先看父类的PropertyResourceConfigurer方法postProcessBeanFactory。因为这个类继承了Spring的BeanFactoryPostProcesser接口，所以这个方法一定是操作BeanFactory的。

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        try {
　　　　　　　//1.获取当前容器配置的所有Properties文件，可能由多个文件merge而来
            Properties mergedProps = mergeProperties();

            //2.如果需要的话，将Properties文件的内容进行转化，因为默认的Preperties都是String的key-value形式。
            //Spring提供的默认方式是不转化，保持String,String的key-value
            convertProperties(mergedProps);

            //3.由子类继承，对容器与Properties进行操作，即value注入。
            processProperties(beanFactory, mergedProps);
        }
        catch (IOException ex) {
            throw new BeanInitializationException("Could not load properties", ex);
        }
    }

这里最重要的第一步就是获得Properties文件即mergeProperties方法，这是解析资源文件最基本的方法，所以这个方法一定存在于当前功能的最基类中，即PropertiesLoaderSupport。由于xml中是这样配置的:

<context:property-placeholder location="classpath:config.properties"/>

这里声明了一个PropertyPlaceholderConfigurer对象，显然是调用了setLocation方法，而这个方法同样存在于该功能模块的最基本父类PropertiesLoaderSupport中。

public abstract class PropertiesLoaderSupport {
       //……省略

    private Resource[] locations;

       //……省略

        public void setLocation(Resource location) {
        this.locations = new Resource[] {location};
    }

       //注意：晚声明的文件内容将覆盖早声明的文件内容，所以请自己保证文件之间内容不要重叠，否则以最后一个文件为准
        public void setLocations(Resource... locations) {
        this.locations = locations;
    }
       //……省略
}

mergeProperties方法中进行了配置化管理，针对某些标志位进行额外的操作，这里不做过多说明，其最重要的功能是调用了下面方法：

    protected void loadProperties(Properties props) throws IOException {
        if (this.locations != null) {
　　　　　　　//1.遍历声明的Resource文件地址
            for (Resource location : this.locations) {
                if (logger.isInfoEnabled()) {
                    logger.info("Loading properties file from " + location);
                }
                try {
　　　　　　　　　　　　//2.获得Resource文件流，并加载内容到Properties对象中
                    PropertiesLoaderUtils.fillProperties(
                            props, new EncodedResource(location, this.fileEncoding), this.propertiesPersister);
                }
                catch (IOException ex) {
                    if (this.ignoreResourceNotFound) {
                        if (logger.isWarnEnabled()) {
                            logger.warn("Could not load properties from " + location + ": " + ex.getMessage());
                        }
                    }
                    else {
                        throw ex;
                    }
                }
            }
        }
    }

回想PropertyResourceConfigurer主流程中的三个方法，第一步已经执行完毕，加载了配置的properties文件，第二步是spring自己的默认实现，将非空的key对应的value放入Properties中，第三步则该由子类各自实现了，将BeanFactory与Properties进行统一操作。这时候我们看我们直接声明的派生类PropertyPlaceholderConfigurer。

    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
            throws BeansException {
　　　　　//1.声明一个支持value为String类型的Resolver
        StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);
        //2.将key-value注入到BeanFactory的某些bean中
        doProcessProperties(beanFactoryToProcess, valueResolver);
    }

接下来就是真正的value注入环节了

protected void doProcessProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
            StringValueResolver valueResolver) {
　　　　 //1.将key-value内容声明为BeanDefinitionVisitor对象，用来根据BeanDefinition修改即将生成的对应的Bean内容
        BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);

        String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
        for (String curName : beanNames) {
　　　　　　  //2.只有同一个容器内的才可以进行value注入，同时应该避免掉操作本身，避免进入循环递归
            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);
                }
            }
        }

        //3.处理一些拥有别名的类
        beanFactoryToProcess.resolveAliases(valueResolver);

        //4.New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes.(这一步有些不懂，以后再修正)

  　　   beanFactoryToProcess.addEmbeddedValueResolver(valueResolver); }

在上述代码中，第2步已经修改了原始的BeanDefinition，我们一路跟进去看，原来核心的替换功能在PropertyPlaceholderHelper中：

protected String parseStringValue(
            String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {
　　　　　//1.对每一个key进行处理
        StringBuilder result = new StringBuilder(strVal);
　　　　　//2.首先考虑有占位符的情况,默认是${}
        int startIndex = strVal.indexOf(this.placeholderPrefix);
        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.add(originalPlaceholder)) {
                    throw new IllegalArgumentException(
                            "Circular placeholder reference '" + originalPlaceholder + "' in property definitions");
                }
                //3.如果有占位符，则去掉占位符递归调用本方法，即key=${abc},处理成key=abc的形式试图获取value
                placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);
                //4.真正的从key-value集合中获得key对应的value
                String propVal = placeholderResolver.resolvePlaceholder(placeholder);
　　　　　　　　　 //5.如果没有找到，则试图按照${key:default}的形式解析
                if (propVal == null && this.valueSeparator != null) {
                    int separatorIndex = placeholder.indexOf(this.valueSeparator);
                    if (separatorIndex != -1) {
                        //6.获得：之前的内容，即真正的key
                        String actualPlaceholder = placeholder.substring(0, separatorIndex);
                        //7.获得:之后的内容，即默认值
                        String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
　　　　　　　　　　　　　　 //8.再次尝试从key-value集合中获得内容，因为如果真的是key-value的形式，按照全名是肯定找不到的
                        propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
                        //9.如果找到了就按照配置的走，如果没有找到则附上默认值
                        if (propVal == null) {
                            propVal = defaultValue;
                        }
                    }
                }
                if (propVal != null) {
                    //10.如果找到了这个value，则再次递归调用自己，避免value也是占位符的情况
                    propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
                    //11.将获得的结果替换掉
                    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 string value \"" + strVal + "\"");
                }
                visitedPlaceholders.remove(originalPlaceholder);
            }
            else {
                startIndex = -1;
            }
        }

        return result.toString();
    }

3.总结

Spring管理bean的方式大大减少了编程人员的编码复杂度，这个复杂度并没有消失，而是转嫁到Spring容器中。我们可以通过xml或者@value注解的方式注入field属性，这对多环境profiles的应用是非常关键的，掌握了Spring的这条注入路径之后，对于帮助理解Spring或者查找一些值注入的问题都非常有帮助。