如果可能的话，我会尝试在没有Spring Context的情况下编写这些测试。如果您在没有spring的测试中创建这个类，那么您可以完全控制它的字段。

要设置@value字段，您可以使用Springs ReflectionTestUtils -它有一个方法setField来设置私有字段。

@see JavaDoc: ReflectionTestUtils.setField(java.lang)Object, java . lang。管柱,java . lang . Object)

如果您愿意，您仍然可以在Spring Context中运行测试，并在Spring配置类中设置所需的属性。如果您使用JUnit，请使用SpringJUnit4ClassRunner并为您的测试定义专用配置类，如下所示:

被测类:

@Component
public SomeClass {

    @Autowired
    private SomeDependency someDependency;

    @Value("${someProperty}")
    private String someProperty;
}

测试类:

@RunWith(SpringJUnit4ClassRunner.class) 
@ContextConfiguration(classes = SomeClassTestsConfig.class)
public class SomeClassTests {

    @Autowired
    private SomeClass someClass;

    @Autowired
    private SomeDependency someDependency;

    @Before
    public void setup() {
       Mockito.reset(someDependency);

    @Test
    public void someTest() { ... }
}

和这个测试的配置类:

@Configuration
public class SomeClassTestsConfig {

    @Bean
    public static PropertySourcesPlaceholderConfigurer properties() throws Exception {
        final PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
        Properties properties = new Properties();

        properties.setProperty("someProperty", "testValue");

        pspc.setProperties(properties);
        return pspc;
    }
    @Bean
    public SomeClass getSomeClass() {
        return new SomeClass();
    }

    @Bean
    public SomeDependency getSomeDependency() {
        // Mockito used here for mocking dependency
        return Mockito.mock(SomeDependency.class);
    }
}

话虽如此，我不推荐这种方法，我只是在这里添加它作为参考。在我看来，更好的方法是使用Mockito runner。在这种情况下，您根本不需要在Spring中运行测试，这更加清晰和简单。

不要滥用反射获取/设置的私有字段

在这里的几个答案中使用反射是我们可以避免的。 它在这里带来的价值很小，但它呈现出多个缺点:

we detect reflection issues only at runtime (ex: fields not existing any longer) We want encapsulation but not a opaque class that hides dependencies that should be visible and make the class more opaque and less testable. it encourages bad design. Today you declare a @Value String field. Tomorrow you can declare 5 or 10 of them in that class and you may not even be straight aware that you decrease the design of the class. With a more visible approach to set these fields (such as constructor) , you will think twice before adding all these fields and you will probably encapsulate them into another class and use @ConfigurationProperties.

使你的类在单一和集成中都可测试

为了能够为spring组件类编写简单的单元测试(即没有运行的spring容器)和集成测试，您必须使这个类在使用或不使用spring时都可用。 在单元测试中运行不需要的容器是一种糟糕的做法，会降低本地构建的速度:您不希望出现这种情况。 我添加这个答案是因为这里的答案似乎没有显示出这种区别，所以它们系统地依赖于运行的容器。

所以我认为你应该移动这个属性定义为类的内部:

@Component
public class Foo{   
    @Value("${property.value}") private String property;
    //...
}

注入一个将由Spring注入的构造函数参数:

@Component
public class Foo{   
    private String property;
     
    public Foo(@Value("${property.value}") String property){
       this.property = property;
    }

    //...         
}

单元测试示例

你可以在没有Spring的情况下实例化Foo，并通过构造函数为属性注入任何值:

public class FooTest{

   Foo foo = new Foo("dummyValue");

   @Test
   public void doThat(){
      ...
   }
}

集成测试示例

多亏了@SpringBootTest的properties属性，你可以用这种简单的方式在SpringBoot的上下文中注入属性:

@SpringBootTest(properties="property.value=dummyValue")
public class FooTest{
    
   @Autowired
   Foo foo;
     
   @Test
   public void doThat(){
       ...
   }    
}

您可以使用替代的@TestPropertySource，但它添加了一个额外的注释:

@SpringBootTest
@TestPropertySource(properties="property.value=dummyValue")
public class FooTest{ ...}

使用Spring(没有Spring Boot)，它应该更复杂一点，但由于我很长时间没有使用Spring，所以我不喜欢说愚蠢的事情。

旁注:如果要设置许多@Value字段，将它们提取到带有@ConfigurationProperties注释的类中更相关，因为我们不希望构造函数带有太多参数。

@ExtendWith(SpringExtension.class)    // @RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(initializers = ConfigDataApplicationContextInitializer.class)

希望这能有所帮助。关键是ConfigDataApplicationContextInitializer获取所有道具数据

这是一个相当老的问题，我不确定当时是否有这个选项，但这就是为什么我总是喜欢通过构造函数而不是通过值来实现DependencyInjection的原因。

我可以想象你的类可能是这样的:

class ExampleClass{

   @Autowired
   private Dog dog;

   @Value("${this.property.value}") 
   private String thisProperty;

   ...other stuff...
}

您可以更改为:

class ExampleClass{

   private Dog dog;
   private String thisProperty;

   //optionally @Autowire
   public ExampleClass(final Dog dog, @Value("${this.property.value}") final String thisProperty){
      this.dog = dog;
      this.thisProperty = thisProperty;
   }

   ...other stuff...
}

有了这个实现，spring将知道要自动注入什么，但是对于单元测试，您可以做任何您需要的事情。例如，自动装配spring的每个依赖项，并通过构造函数手动注入它们来创建“ExampleClass”实例，或者只使用spring与测试属性文件，或者根本不使用spring并自己创建所有对象。

这似乎是可行的，尽管仍然有点啰嗦(我想要更短的东西):

@BeforeClass
public static void beforeClass() {
    System.setProperty("some.property", "<value>");
}

// Optionally:
@AfterClass
public static void afterClass() {
    System.clearProperty("some.property");
}