Spring @PropertySource โดยใช้ YAML

Spring Boot ช่วยให้เราสามารถแทนที่ไฟล์ application.properties ของเราด้วย YAML ที่เทียบเท่า อย่างไรก็ตามดูเหมือนว่าฉันจะประสบปัญหากับการทดสอบของฉัน ถ้าฉันใส่คำอธิบายประกอบTestConfiguration(การกำหนดค่า Java แบบง่าย) ของฉันจะต้องมีไฟล์คุณสมบัติ

ตัวอย่างเช่นนี้ใช้ไม่ได้: @PropertySource(value = "classpath:application-test.yml")

หากมีสิ่งนี้ในไฟล์ YAML ของฉัน:

db:
  url: jdbc:oracle:thin:@pathToMyDb
  username: someUser
  password: fakePassword

และฉันจะใช้ประโยชน์จากคุณค่าเหล่านั้นด้วยสิ่งนี้:

@Value("${db.username}") String username

อย่างไรก็ตามฉันลงเอยด้วยข้อผิดพลาดดังนี้:

Could not resolve placeholder 'db.username' in string value "${db.username}"

ฉันจะใช้ประโยชน์จากความดีของ YAML ในการทดสอบของฉันได้อย่างไร

Spring-boot มีตัวช่วยสำหรับสิ่งนี้เพียงแค่เพิ่ม

@ContextConfiguration(initializers = ConfigFileApplicationContextInitializer.class)

ที่ด้านบนสุดของชั้นเรียนทดสอบของคุณหรือซูเปอร์คลาสทดสอบนามธรรม

แก้ไข: ฉันเขียนคำตอบนี้เมื่อห้าปีที่แล้ว ใช้ไม่ได้กับ Spring Boot เวอร์ชันล่าสุด นี่คือสิ่งที่ฉันทำตอนนี้ (โปรดแปล Kotlin เป็น Java หากจำเป็น):

@TestPropertySource(locations=["classpath:application.yml"])
@ContextConfiguration(
        initializers=[ConfigFileApplicationContextInitializer::class]
)

จะถูกเพิ่มไปที่ด้านบนแล้ว

    @Configuration
    open class TestConfig {

        @Bean
        open fun propertiesResolver(): PropertySourcesPlaceholderConfigurer {
            return PropertySourcesPlaceholderConfigurer()
        }
    }

กับบริบท

ตามที่กล่าวไว้@PropertySourceไม่โหลดไฟล์ yaml วิธีแก้ปัญหาให้โหลดไฟล์ด้วยตัวคุณเองและเพิ่มคุณสมบัติที่โหลดลงในEnvironmentไฟล์.

การดำเนินการApplicationContextInitializer:

public class YamlFileApplicationContextInitializer implements ApplicationContextInitializer<ConfigurableApplicationContext> {
  @Override
  public void initialize(ConfigurableApplicationContext applicationContext) {
    try {
        Resource resource = applicationContext.getResource("classpath:file.yml");
        YamlPropertySourceLoader sourceLoader = new YamlPropertySourceLoader();
        PropertySource<?> yamlTestProperties = sourceLoader.load("yamlTestProperties", resource, null);
        applicationContext.getEnvironment().getPropertySources().addFirst(yamlTestProperties);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
  }
}

เพิ่มตัวเริ่มต้นของคุณในการทดสอบของคุณ:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(classes = Application.class, initializers = YamlFileApplicationContextInitializer.class)
public class SimpleTest {
  @Test
  public test(){
    // test your properties
  }
}

@PropertySourceสามารถกำหนดค่าโดยfactoryอาร์กิวเมนต์ คุณสามารถทำสิ่งต่างๆเช่น:

@PropertySource(value = "classpath:application-test.yml", factory = YamlPropertyLoaderFactory.class)

ตัวYamlPropertyLoaderFactoryโหลดคุณสมบัติที่กำหนดเองของคุณอยู่ที่ไหน:

public class YamlPropertyLoaderFactory extends DefaultPropertySourceFactory {
    @Override
    public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
        if (resource == null){
            return super.createPropertySource(name, resource);
        }

        return new YamlPropertySourceLoader().load(resource.getResource().getFilename(), resource.getResource(), null);
    }
}

แรงบันดาลใจจากhttps://stackoverflow.com/a/45882447/4527110

@PropertySourceรองรับเฉพาะไฟล์คุณสมบัติ (เป็นข้อ จำกัด จาก Spring ไม่ใช่ Boot เอง) รู้สึกอิสระที่จะเปิดออกตั๋วคุณลักษณะคำขอใน JIRA

อีกทางเลือกหนึ่งคือการตั้งค่าspring.config.locationผ่าน@TestPropertySource:

@TestPropertySource(properties = { "spring.config.location = classpath:<path-to-your-yml-file>" }

จาก Spring Boot 1.4 คุณสามารถใช้ไฟล์ @SpringBootTestคำอธิบายประกอบเพื่อให้บรรลุสิ่งนี้ได้ง่ายขึ้น (และเพื่อลดความซับซ้อนของการตั้งค่าการทดสอบการรวมของคุณโดยทั่วไป) โดยการบูตการทดสอบการรวมของคุณโดยใช้การสนับสนุน Spring Boot

รายละเอียดเกี่ยวกับบล็อกฤดูใบไม้ผลิ

เท่าที่ฉันสามารถบอกได้นั่นหมายความว่าคุณจะได้รับประโยชน์ทั้งหมดจากการกำหนดค่าภายนอกของ Spring Boot เช่นเดียวกับในรหัสการผลิตของคุณรวมถึงการรับการกำหนดค่า YAML จาก classpath โดยอัตโนมัติ

ตามค่าเริ่มต้นคำอธิบายประกอบนี้จะ

... ขั้นแรกให้ลองโหลด@Configurationจากคลาสภายในใด ๆ และหากล้มเหลวมันจะค้นหา@SpringBootApplicationคลาสหลักของคุณ

แต่คุณสามารถระบุคลาสคอนฟิกูเรชันอื่น ๆ ได้หากต้องการ

สำหรับกรณีนี้คุณสามารถใช้ร่วม@SpringBootTestกับ@ActiveProfiles( "test" )Spring จะรับการกำหนดค่า YAML ของคุณหากเป็นไปตามมาตรฐานการตั้งชื่อ Boot ปกติ (เช่นapplication-test.yml)

@RunWith( SpringRunner.class )
@SpringBootTest
@ActiveProfiles( "test" )
public class SpringBootITest {

    @Value("${db.username}")
    private String username;

    @Autowired
    private MyBean myBean;

    ...

}

หมายเหตุ: SpringRunner.classเป็นชื่อใหม่สำหรับSpringJUnit4ClassRunner.class

วิธีการโหลดคุณสมบัติของมันแกว IMHO สามารถทำได้สองวิธี:

ก. คุณสามารถวางการกำหนดค่าในตำแหน่งมาตรฐาน - application.ymlในรูท classpath - โดยทั่วไปsrc/main/resourcesและคุณสมบัติ yaml นี้ควรโหลดโดยอัตโนมัติโดย Spring boot พร้อมกับชื่อพา ธ ที่แบนที่คุณได้กล่าวถึง

ข. แนวทางที่สองนั้นกว้างขวางกว่าเล็กน้อยโดยทั่วไปกำหนดคลาสเพื่อเก็บคุณสมบัติของคุณด้วยวิธีนี้:

@ConfigurationProperties(path="classpath:/appprops.yml", name="db")
public class DbProperties {
    private String url;
    private String username;
    private String password;
...
}

โดยพื้นฐานแล้วนี่คือการบอกว่าให้โหลดไฟล์ yaml และเติมข้อมูลคลาส DbProperties ตามอิลิเมนต์รูทของ "db"

ตอนนี้เพื่อใช้ในชั้นเรียนใด ๆ คุณจะต้องทำสิ่งนี้:

@EnableConfigurationProperties(DbProperties.class)
public class PropertiesUsingService {

    @Autowired private DbProperties dbProperties;

}

วิธีใดวิธีหนึ่งเหล่านี้ควรได้ผลสำหรับคุณโดยใช้ Spring-boot

ฉันพบวิธีแก้ปัญหาโดยใช้@ActiveProfiles("test")และเพิ่มไฟล์ application-test.yml ไปที่ src / test / resources

มันลงเอยเช่นนี้:

@SpringApplicationConfiguration(classes = Application.class, initializers = ConfigFileApplicationContextInitializer.class)
@ActiveProfiles("test")
public abstract class AbstractIntegrationTest extends AbstractTransactionalJUnit4SpringContextTests {

}

ไฟล์ application-test.yml มีคุณสมบัติที่ฉันต้องการแทนที่จาก application.yml (ซึ่งสามารถพบได้ใน src / main / resources)

เป็นเพราะคุณไม่ได้กำหนดค่า snakeyml สปริงบูตมาพร้อมกับคุณสมบัติ @EnableAutoConfiguration มีการกำหนดค่า snakeyml ด้วยเมื่อคุณเรียกคำอธิบายประกอบนี้ ..

นี่คือวิธีของฉัน:

@Configuration
@EnableAutoConfiguration
public class AppContextTest {
}

นี่คือการทดสอบของฉัน:

@RunWith(SpringJUnit4ClassRunner.class)
@SpringApplicationConfiguration(
        classes = {
                AppContextTest.class,
                JaxbConfiguration.class,
        }
)

public class JaxbTest {
//tests are ommited
}

ฉันต้องการอ่านคุณสมบัติบางอย่างในโค้ดของฉันและสิ่งนี้ใช้ได้กับ spring-boot 1.3.0 RelEASE

@Autowired
private ConfigurableListableBeanFactory beanFactory;

// access a properties.yml file like properties
@Bean
public PropertySource properties() {
    PropertySourcesPlaceholderConfigurer propertySourcesPlaceholderConfigurer = new PropertySourcesPlaceholderConfigurer();
    YamlPropertiesFactoryBean yaml = new YamlPropertiesFactoryBean();
    yaml.setResources(new ClassPathResource("properties.yml"));
    propertySourcesPlaceholderConfigurer.setProperties(yaml.getObject());
    // properties need to be processed by beanfactory to be accessible after
    propertySourcesPlaceholderConfigurer.postProcessBeanFactory(beanFactory);
    return propertySourcesPlaceholderConfigurer.getAppliedPropertySources().get(PropertySourcesPlaceholderConfigurer.LOCAL_PROPERTIES_PROPERTY_SOURCE_NAME);
}

การโหลดไฟล์ yml ที่กำหนดเองด้วยการกำหนดค่าโปรไฟล์หลายรายการใน Spring Boot

1) เพิ่มคุณสมบัติ bean ด้วย SpringBootApplication เริ่มต้นดังนี้

@SpringBootApplication
@ComponentScan({"com.example.as.*"})
public class TestApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }

    @Bean
    @Profile("dev")
    public PropertySourcesPlaceholderConfigurer propertiesStage() {
        return properties("dev");
    }

    @Bean
    @Profile("stage")
    public PropertySourcesPlaceholderConfigurer propertiesDev() {
        return properties("stage");
    }

    @Bean
    @Profile("default")
    public PropertySourcesPlaceholderConfigurer propertiesDefault() {
        return properties("default");

    }
   /**
    * Update custom specific yml file with profile configuration.
    * @param profile
    * @return
    */
    public static PropertySourcesPlaceholderConfigurer properties(String profile) {
       PropertySourcesPlaceholderConfigurer propertyConfig = null;
       YamlPropertiesFactoryBean yaml  = null;

       propertyConfig  = new PropertySourcesPlaceholderConfigurer();
       yaml = new YamlPropertiesFactoryBean();
       yaml.setDocumentMatchers(new SpringProfileDocumentMatcher(profile));// load profile filter.
       yaml.setResources(new ClassPathResource("env_config/test-service-config.yml"));
       propertyConfig.setProperties(yaml.getObject());
       return propertyConfig;
    }
}

2) กำหนดค่าวัตถุ Java pojo ดังต่อไปนี้

@Component
@JsonIgnoreProperties(ignoreUnknown = true)
@JsonInclude(Include.NON_NULL)
@ConfigurationProperties(prefix = "test-service")
public class TestConfig {

    @JsonProperty("id") 
    private  String id;

    @JsonProperty("name")
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

}

3) สร้าง yml ที่กำหนดเอง (และวางไว้ใต้รีซอร์สพา ธ ดังนี้ชื่อไฟล์ YML: test-service-config.yml

เช่น Config ในไฟล์ yml

test-service: 
    id: default_id
    name: Default application config
---
spring:
  profiles: dev

test-service: 
  id: dev_id
  name: dev application config

--- 
spring:
  profiles: stage

test-service: 
  id: stage_id
  name: stage application config

ฉันอยู่ในสถานการณ์เฉพาะที่ฉันไม่สามารถโหลดคลาส @ConfigurationProperties เนื่องจากการตั้งชื่อคุณสมบัติไฟล์แบบกำหนดเอง ในตอนท้ายสิ่งเดียวที่ใช้ได้คือ (ขอบคุณ @Mateusz Balbus):

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.List;

import org.apache.commons.io.IOUtils;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.bind.Bindable;
import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.env.YamlPropertySourceLoader;
import org.springframework.boot.test.context.TestConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.env.ConfigurableEnvironment;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.Resource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes = {MyTest.ContextConfiguration.class})
public class MyTest {

    @TestConfiguration
    public static class ContextConfiguration {

        @Autowired
        ApplicationContext applicationContext;

        @Bean
        public ConfigurationPropertiesBean myConfigurationPropertiesBean() throws IOException {
            Resource resource = applicationContext.getResource("classpath:my-properties-file.yml");

            YamlPropertySourceLoader sourceLoader = new YamlPropertySourceLoader();
            List<PropertySource<?>> loadedSources = sourceLoader.load("yamlTestProperties", resource);
            PropertySource<?> yamlTestProperties = loadedSources.get(0);
            ConfigurableEnvironment configurableEnvironment = (ConfigurableEnvironment)applicationContext.getEnvironment();
            configurableEnvironment.getPropertySources().addFirst(yamlTestProperties);

            Binder binder = Binder.get(applicationContext.getEnvironment());
            ConfigurationPropertiesBean configurationPropertiesBean = binder.bind("my-properties-file-prefix", Bindable.of(ConfigurationPropertiesBean.class)).get();
            return configurationPropertiesBean;
        }

    }

    @Autowired
    ConfigurationPropertiesBean configurationPropertiesBean;

    @Test
    public void test() {

        configurationPropertiesBean.getMyProperty();

    }

}

<dependency>
  <groupId>com.github.yingzhuo</groupId>
  <artifactId>spring-boot-stater-env</artifactId>
  <version>0.0.3</version>
</dependency>

ยินดีต้อนรับสู่การใช้ห้องสมุดของฉัน ตอนนี้รองรับ yaml , toml , hoconแล้ว

ที่มา: github.com

นี่ไม่ใช่คำตอบสำหรับคำถามเดิม แต่เป็นทางเลือกอื่นสำหรับความจำเป็นในการกำหนดค่าที่แตกต่างกันในการทดสอบ ...

แทนคุณ@PropertySourceสามารถใช้-Dspring.config.additional-location=classpath:application-tests.yml.

โปรดทราบว่าคำต่อท้ายtestsไม่ได้หมายถึงโปรไฟล์ ...

ในไฟล์ YAML หนึ่งไฟล์สามารถระบุได้หลายโปรไฟล์ซึ่งสามารถสืบทอดต่อกันได้อ่านเพิ่มเติมที่นี่ - คุณสมบัติการแก้ไขสำหรับโปรไฟล์ Spring หลายโปรไฟล์ (การกำหนดค่า yaml)

จากนั้นคุณสามารถระบุในการทดสอบของคุณที่โปรไฟล์ที่ใช้งาน (ใช้@ActiveProfiles("profile1,profile2")) เป็นprofile1,profile2ที่profile2ก็จะแทนที่ (บางคนก็ไม่ต้องแทนที่ทั้งหมด) profile1คุณสมบัติจาก

ฉันได้ลองคำถามทั้งหมดในรายการแล้ว แต่คำถามทั้งหมดไม่ได้ผลสำหรับงานของฉัน: ใช้ไฟล์ yaml เฉพาะสำหรับการทดสอบหน่วย ในกรณีของฉันมันใช้งานได้ดังนี้:

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(initializers = {ConfigFileApplicationContextInitializer.class})
@TestPropertySource(properties = {"spring.config.location=file:../path/to/specific/config/application.yml"})
public class SomeTest {


    @Value("${my.property.value:#{null}}")
    private String value;

    @Test
    public void test() {
        System.out.println("value = " + value);
    }

}

ไม่จำเป็นต้องเพิ่มเช่น YamlPropertyLoaderFactory หรือ YamlFileApplicationContextInitializer คุณควรเปลี่ยนความคิดของคุณ เช่นเดียวกับโครงการสปริงทั่วไป คุณรู้ว่าไม่ได้ใช้ Java config เพียง * .xml

ทำตามขั้นตอนเหล่านี้:

เพียงเพิ่ม applicationContext.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-2.5.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"
       default-autowire="byName">

    <context:property-placeholder location="classpath*:*.yml"/>
</beans>

จากนั้นเพิ่ม

@ImportResource({"classpath:applicationContext.xml"})

ไปยังApplicationMainClassไฟล์.

ซึ่งสามารถช่วยสแกน application-test.yml ของคุณ

db:
  url: jdbc:oracle:thin:@pathToMyDb
  username: someUser
  password: fakePassword