1.不通过配置文件注入属性的情况

  • 注入普通字符串

    1. @Value("normal") 
    2. private String normal; // 注入普通字符串

  • 注入操作系统属性

    1. @Value("#{systemProperties['os.name']}") 
    2. private String systemPropertiesName; // 注入操作系统属性

  • 注入表达式结果

    1. @Value("#{ T(java.lang.Math).random() * 100.0 }") 
    2. private double randomNumber; //注入表达式结果

  • 注入其他Bean属性

    1. @Value("#{person.name}") 
    2. private String name; // 注入其他Bean属性：注入person对象的属性name

  • 注入文件资源

    1. @Value("classpath:io/mykit/spring/config/config.properties") 
    2. private Resource resourceFile; // 注入文件资源

  • 注入URL资源

    1. @Value("http://www.baidu.com")
    2. private Resource url; // 注入URL资源

    2.通过配置文件注入属性的情况

    通过@Value(“${app.name}”)语法将属性文件的值注入到bean的属性中，如下所示。

    1. @Component
    2. // 引入外部配置文件组：${app.configinject}的值来自config.properties。
    3. // 如果相同
    4. @PropertySource({"classpath:io/mykit/spring/config/config.properties",
    5.   "classpath:io/mykit/spring/config/config_${anotherfile.configinject}.properties"})
    6. public class ConfigurationFileInject{
    7.   // 这里的值来自application.properties，spring boot启动时默认加载此文件
    8.   @Value("${app.name}")
    9.   private String appName; 
    11.   // 注入第一个配置外部文件属性
    12.   @Value("${book.name}")
    13.   private String bookName; 
    15.   // 注入第二个配置外部文件属性
    16.   @Value("${book.name.placeholder}")
    17.   private String bookNamePlaceholder; 
    19.   // 注入环境变量对象，存储注入的属性值
    20.   @Autowired
    21.   private Environment env;  
    23.   public String toString(){
    24.       StringBuilder sb = new StringBuilder();
    25.       sb.append("bookName=").append(bookName).append("\r\n")
    26.       .append("bookNamePlaceholder=").append(bookNamePlaceholder).append("\r\n")
    27.       .append("appName=").append(appName).append("\r\n")
    28.       .append("env=").append(env).append("\r\n")
    29.       // 从eniroment中获取属性值
    30.       .append("env=").append(env.getProperty("book.name.placeholder")).append("\r\n");
    31.       return sb.toString();
    32.   }   
    33. }

    3.@Value中#{..}和${…}的区别

    我们这里提供一个测试属性文件：advance_value_inject.properties，大致的内容如下所示。

    1. server.name=server1,server2,server3
    2. author.name=binghe

    测试类AdvanceValueInject：引入advance_value_inject.properties文件，作为属性的注入

    1. @Component
    2. @PropertySource({"classpath:io/mykit/spring/config/advance_value_inject.properties"})
    3. public class AdvanceValueInject {
    4. ...
    5. }

    ${…}的用法

    {}里面的内容必须符合SpEL表达式， 通过@Value(“${spelDefault.value}”)可以获取属性文件中对应的值，但是如果属性文件中没有这个属性，则会报错。可以通过赋予默认值解决这个问题，如下所示。

    1. @Value("${author.name:binghe}")

    上述代码的含义表示向bean的属性中注入配置文件中的author.name属性的值，如果配置文件中没有author.name属性，则向bean的属性中注入默认值binghe。例如下面的代码片段。

    1. @Value("${author.name:binghe}")
    2. private String name;

    #{…}的用法

    ```java // SpEL：调用字符串Hello World的concat方法 @Value(“#{‘Hello World’.concat(‘!’)}”) private String helloWorld;

// SpEL: 调用字符串的getBytes方法，然后调用length属性 @Value(“#{‘Hello World’.bytes.length}”) private String helloWorldbytes;

  1. <a name="jHDKm"></a>
  2. ### ${…}和#{…}混合使用
  3. ${...}和#{...}可以混合使用，如下文代码执行顺序：通过${server.name}从属性文件中获取值并进行替换，然后就变成了 执行SpEL表达式{‘server1,server2,server3’.split(‘,’)}。
  4. ```java
  5. // SpEL: 传入一个字符串，根据","切分后插入列表中， #{}和${}配置使用(注意单引号，注意不能反过来${}在外面，#{}在里面)
  6. @Value("#{'${server.name}'.split(',')}")
  7. private List<String> servers;

在上文中#{}在外面，${}在里面可以执行成功，那么反过来是否可以呢？也就是说能否让${}在外面，#{}在里面，如下代码所示。

// SpEL: 注意不能反过来${}在外面，#{}在里面，这个会执行失败
@Value("${#{'HelloWorld'.concat('_')}}")
private List<String> servers2;

答案是不能。因为Spring执行${}时机要早于#{}，当Spring执行外层的${}时，内部的#{}为空，所以会执行失败！

@Value注解用法小结：

{…} 用于执行SpEl表达式，并将内容赋值给属性。
${…} 主要用于加载外部属性文件中的值。
#{…} 和${…} 可以混合使用，但是必须#{}外面，${}在里面。

4. @Value注解案例

这里，我们还是以一个小案例的形式来说明。

首先，我们来创建一个Person类作为测试的bean组件，如下所示。

package io.mykit.spring.plugins.register.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import java.io.Serializable;
/**
 * @author binghe
 * @version 1.0.0
 * @description 测试实体类
 */
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {
    private static final long serialVersionUID = 7387479910468805194L;
    private String name;
    private Integer age;
}

接下来，创建一个新的配置类PropertyValueConfig，用来配置Spring的bean组件，我们在PropertyValueConfig类中将Person类的对象注册到IOC容器中，如下所示。

package io.mykit.spring.plugins.register.config;
import io.mykit.spring.plugins.register.bean.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/**
 * @author binghe
 * @version 1.0.0
 * @description 测试属性赋值
 */
@Configuration
public class PropertyValueConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}

我们再来创建一个测试类PropertyValueTest，在PropertyValueTest类中创建测试方法testPropertyValue01()，并在testPropertyValue01()方法中通过PropertyValueConfig类创建AnnotationConfigApplicationContext对象，打印出目前IOC容器中存在的bean名称，如下所示。

package io.mykit.spring.test;
import io.mykit.spring.plugins.register.config.PropertyValueConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.Arrays;
/**
 * @author binghe
 * @version 1.0.0
 * @description 测试bean的生命周期
 */
public class PropertyValueTest {
    @Test
    public void testPropertyValue01(){
        //创建IOC容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PropertyValueConfig.class);
        String[] names = context.getBeanDefinitionNames();
        Arrays.stream(names).forEach(System.out::println);
    }
}

此时，我们运行PropertyValueTest类的testPropertyValue01()方法，输出的结果信息如下所示。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
propertyValueConfig
person

从输出的结果信息中，可以看出，IOC容器中除了Spring框架注册的bean之外，还包含我们自己向IOC容器中注册的bean组件：propertyValueConfig和person。

接下来，我们改造下PropertyValueTest类的testPropertyValue01()方法，输出Person对象的信息，如下所示。

package io.mykit.spring.test;
import io.mykit.spring.plugins.register.bean.Person;
import io.mykit.spring.plugins.register.config.PropertyValueConfig;
import org.junit.Test;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.Arrays;
/**
 * @author binghe
 * @version 1.0.0
 * @description 测试bean的生命周期
 */
public class PropertyValueTest {
    @Test
    public void testPropertyValue01(){
        //创建IOC容器
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(PropertyValueConfig.class);
        String[] names = context.getBeanDefinitionNames();
        Arrays.stream(names).forEach(System.out::println);

        System.out.println("================================");
        Person person = (Person) context.getBean("person");
        System.out.println(person);
    }
}

接下来，再次运行PropertyValueTest类的testPropertyValue01()方法，输出的结果信息如下所示。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
propertyValueConfig
person
================================
Person(name=null, age=null)

可以看到，向IOC容器中注册的Person对象的name属性为null，age属性为null。那如何向Person对象的name属性和age属性赋值呢？此时，Spring中的@Value注解就派上了用场。

如果我们通过XML文件为bean的属性赋值，则可以通过如下配置的方式实现。

<bean id = "person" class="io.mykit.spring.plugins.register.bean.Person">
    <property name="name" value="binghe"></property>
    <property name="age" value="18"></property>
</bean>

如果使用注解该如何实现呢？

我们可以在Person类的属性上使用@Value注解为属性赋值，如下所示。

package io.mykit.spring.plugins.register.bean;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.beans.factory.annotation.Value;
import java.io.Serializable;
/**
 * @author binghe
 * @version 1.0.0
 * @description 测试实体类
 */
@Data
@ToString
@NoArgsConstructor
@AllArgsConstructor
public class Person implements Serializable {
    private static final long serialVersionUID = 7387479910468805194L;
    @Value("binghe")
    private String name;
    @Value("#{20-2}")
    private Integer age;
}

此时，我们再次运行PropertyValueTest类的testPropertyValue01()方法，输出的结果信息如下所示。

org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.event.internalEventListenerProcessor
org.springframework.context.event.internalEventListenerFactory
propertyValueConfig
person
================================
Person(name=binghe, age=18)

可以看到，使用@Value注解已经向Person对象的name属性中注入了binghe，向age属性中注入了18。