YAML का उपयोग करके स्प्रिंग @PropertySource

Question

स्प्रिंग बूट हमें YAML समकक्षों के साथ हमारे application.properties फ़ाइलों को बदलने की अनुमति देता है। हालांकि मैं अपने परीक्षणों के साथ एक रोड़ा मारा लगता है। अगर मैं अपना TestConfiguration(एक साधारण जावा कॉन्फिगरेशन) एनोटेट करता हूं , तो यह एक प्रॉपर्टी फाइल की उम्मीद कर रहा है।

उदाहरण के लिए यह काम नहीं करता है: @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}"

मैं अपने परीक्षणों में युकल अच्छाई का लाभ कैसे उठा सकता हूं?

Comments

परिभाषित करें "काम नहीं करता है।" अपवाद / त्रुटि / चेतावनी क्या है?

— इमर्सन फरुगिया

स्प्रिंग बूट YAML फ़ाइल को समतल करता है इसलिए यह डॉट नोटेशन के साथ एक संपत्ति फ़ाइल के रूप में प्रकट होता है। यह समतल नहीं हो रहा है।

— चेकेट

और सिर्फ पुष्टि करने के लिए, यह गैर-परीक्षण कोड में काम करता है?

— इमर्सन फरुगिया

हाँ। यहां एक डॉक समझाने वाली परियोजनाएं हैं। spring.io/spring-boot/docs/spring-boot-actuator/… और पेज को डाउन करने के एक तरीके के बारे में कहा जाता है कि 'ध्यान दें कि YAML ऑब्जेक्ट को अवधि विभाजकों द्वारा चपटा हुआ है।'

— चेक

स्पिंगबूट ने कहा कि यह प्रॉपर्टी सोर्स के साथ YAML को लोड नहीं कर सकता: 24.6.4 YAML की कमियां YAML फाइलें @PropertySource एनोटेशन के जरिए लोड नहीं की जा सकतीं। तो उस मामले में जब आपको उस तरह से मूल्यों को लोड करने की आवश्यकता होती है, तो आपको एक गुण फ़ाइल का उपयोग करने की आवश्यकता होती है।

— लेक्स प्रो

Answer 1

स्प्रिंग-बूट में इसके लिए एक सहायक है, बस जोड़ें

@ContextConfiguration(initializers = ConfigFileApplicationContextInitializer.class)

अपने परीक्षण वर्गों या एक सार परीक्षण सुपरक्लास के शीर्ष पर।

संपादित करें: मैंने यह उत्तर पांच साल पहले लिखा था। यह स्प्रिंग बूट के हाल के संस्करणों के साथ काम नहीं करता है। अब मैं यही करता हूं (कृपया यदि आवश्यक हो तो कोटलिन को जावा में अनुवाद करें):

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

शीर्ष पर जोड़ा जाता है, फिर

    @Configuration
    open class TestConfig {

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

संदर्भ के लिए।

Comments

प्रॉपर्टीजपॉल्सहोल्डरहोल्डरफिंगर को न भूलें

— कल्पेश सोनी

@KalpeshSoni वास्तव में, विन्यासकर्ता के बिना, यह काम नहीं करेगा।

— ओला सुंदर

मुझे इनिशियलाइज़र को @SpringJunitConfig में जोड़ना था@SpringJUnitConfig(value = {...}, initializers = {ConfigFileApplicationContextInitializer.class})

— टॉमस एफ

@Jan Galinski आप मेरे जवाब की कोशिश कर सकते हैं, यह प्रयोग करने में आसान है, और यह मेरे उत्पादों को अच्छी तरह से काम करता है। stackoverflow.com/questions/21271468/…

— Forest10

Answer 2

जैसा कि उल्लेख किया गया था कि @PropertySourceयमल फ़ाइल लोड नहीं होती है। वर्कअराउंड के रूप में फ़ाइल को अपने आप लोड करें और लोड किए गए गुणों को जोड़ें 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
  }
}

Comments

वास्तव में यह सबसे अच्छा उत्तर होना चाहिए, धन्यवाद यह काम किया!

— एडेलिन

Mateusz, मैंने YamlFileApplicationContextInitializerकक्षा के साथ उत्तर पोस्ट किया है जहां प्रति परीक्षण मामले में YAML स्थान परिभाषित किया गया है। यदि आपको लगता है कि यह दिलचस्प है, तो बेझिझक इसे अपने उत्तर में मिला दें और मैं इसे हटा दूंगा। बस मुझे अपने जवाब में एक टिप्पणी में बताएं।

— मीकल फोकसा

हां, यह सबसे अच्छा जवाब है

— रिचर्ड एचएम

Answer 3

@PropertySourcefactoryतर्क द्वारा कॉन्फ़िगर किया जा सकता है। तो आप कुछ ऐसा कर सकते हैं:

@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 से प्रेरित

Comments

यह अंतर्निहित yaml parse IllegalStateExceptionतब फेंकता है जब फ़ाइल उचित के बजाय मौजूद नहीं होती है FileNotFoundException- इसलिए इस कार्य को करने के लिए @PropertySource(..., ignoreResourceNotFound = true), आपको इस मामले को पकड़ने और संभालने की आवश्यकता होगी: try { return new YamlPropertySourceLoader().load(resource.getResource().getFilename(), resource.getResource(), null); } catch (IllegalStateException e) { throw (IOException) e.getCause(); }

— Christian Opitz

यदि आपको किसी विशिष्ट प्रोफ़ाइल के लिए गुण प्राप्त करने की आवश्यकता है, तो YamlPropertySourceLoader.load () में तीसरा पैरामीटर प्रोफ़ाइल नाम है। YamlPropertySourceLoader.load () एकल संपत्ति स्रोत के बजाय एक सूची वापस करने के लिए बदल गया है। यहाँ अधिक जानकारी stackoverflow.com/a/53697551/10668441

— 15

यह अब तक का सबसे साफ दृष्टिकोण है।

— मिशाल फोकसा

मेरे लिए, इसके बदले में थोड़ा संशोधन आवश्यक था:CompositePropertySource propertySource = new CompositePropertySource(name); new YamlPropertySourceLoader().load(resource.getResource().getFilename(), resource.getResource()).stream().forEach(propertySource::addPropertySource); return propertySource;

— xorcus

Answer 4

@PropertySourceकेवल गुण फ़ाइलों का समर्थन करता है (यह स्प्रिंग से सीमा है, बूट नहीं है)। JIRA में सुविधा अनुरोध टिकट खोलने के लिए स्वतंत्र महसूस करें ।

Comments

मुझे उम्मीद है कि याम्ल श्रोता को फिर से उपयोग करने या यामाल में एक पर्यावरण को मैन्युअल रूप से लोड करने का एक तरीका था जिसे परीक्षण कॉन्फ़िगरेशन में पारित किया जा सकता है।

— चेकनेट्स

मुझे लगता है कि आप एक लिख सकते हैं ApplicationContextInitializerऔर इसे परीक्षण कॉन्फ़िगरेशन में जोड़ सकते हैं (बस एक YamlPropertySourceLoaderबढ़ाने के लिए Environment) का उपयोग करें । अगर मैं @PropertySourceइस व्यवहार का मूल रूप से समर्थन करूंगा तो व्यक्तिगत रूप से इसे पसंद करूंगा ।

— डेव सीर

क्या अभी भी यही मामला है? क्या '@PropertySource' YAML का समर्थन नहीं करता है?

— domi

stackoverflow.com/questions/21271468/… इस का उपयोग कर हल कर सकते हैं

— @PropertySource

मैं चौंक गया कि मैंने इस 6 साल पुरानी पोस्ट के साथ अपनी समस्या को हल किया।

— जिन क्वोन

Answer 5

एक अन्य विकल्प spring.config.locationथ्रू सेट करना है @TestPropertySource:

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

Comments

मैंने निम्न पंक्ति द्वारा इनपुट को पैरामीट्रिक किया है: @TestPropertySource(properties = {"spring.config.location=classpath:application-${test.env}.yml" }) IMO तुम्हारा सबसे अच्छा उत्तर है।

— लेवेंटुन्वर

महान विचार और परीक्षणों के लिए बहुत न्यूनतर, बहुत बहुत धन्यवाद! बस जोड़ने के लिए, एक कई विन्यास फाइल शामिल कर सकता है, प्रति:@TestPropertySource(properties = {"spring.config.location=classpath:application-config.yml,classpath:test-config.yml,..." })

— stx

यह अब तक का सबसे अच्छा जवाब है! ध्यान दें कि आपको @SpringBootTestएनोटेशन की आवश्यकता है

— मिस्त्री

यह जादुई काम करता है!

— user1079877

Answer 6

स्प्रिंग बूट 1.4 से, आप @SpringBootTestस्प्रिंग बूट समर्थन का उपयोग करके अपने एकीकरण परीक्षणों को बूटस्ट्रैप करके इसे और अधिक आसानी से प्राप्त करने के लिए (और अपने एकीकरण परीक्षण सेटअप को सामान्य बनाने के लिए) नए एनोटेशन का उपयोग कर सकते हैं ।

स्प्रिंग ब्लॉग पर विवरण ।

जहां तक ​​मैं बता सकता हूं, इसका मतलब है कि आपको अपने उत्पादन कोड की तरह ही स्प्रिंग बूट के बाहरी विन्यास की अच्छाई के सभी लाभ मिलते हैं , जिसमें क्लासपाथ से स्वचालित रूप से YAML कॉन्फ़िगरेशन लेना शामिल है।

डिफ़ॉल्ट रूप से, यह एनोटेशन होगा

... @Configurationकिसी भी आंतरिक-वर्ग से लोड करने का पहला प्रयास , और यदि वह विफल रहता है, तो यह आपके प्राथमिक @SpringBootApplicationवर्ग की खोज करेगा ।

लेकिन यदि आवश्यक हो तो आप अन्य विन्यास कक्षाओं को निर्दिष्ट कर सकते हैं।

इस विशेष मामले के लिए, आप के @SpringBootTestसाथ संयोजन कर सकते हैं @ActiveProfiles( "test" )और स्प्रिंग आपके YAML कॉन्फ़िगरेशन को उठाएगा, बशर्ते यह सामान्य बूट नामकरण मानकों (अर्थात 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

Comments

:) @ActiveProfiles का उपयोग करना एकमात्र विकल्प है जिसने काम किया है। धन्यवाद!

— zcourts

Answer 7

याम्ल गुण लोड करने के लिए दृष्टिकोण, दो तरीकों से किया जा सकता है:

ए। आप कॉन्फ़िगरेशन को एक मानक स्थान में - application.ymlक्लासपाथ रूट में रख सकते हैं - आम तौर पर src/main/resourcesऔर इस याम्ल संपत्ति को स्वचालित रूप से स्प्रिंग बूट द्वारा लोड किया जाना चाहिए जो आपके द्वारा उल्लिखित पथ नाम के साथ लोड होना चाहिए।

ख। दूसरा दृष्टिकोण थोड़ा अधिक व्यापक है, मूल रूप से इस तरह से अपने गुणों को रखने के लिए एक वर्ग को परिभाषित करें:

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

तो अनिवार्य रूप से यह कह रहा है कि yaml फ़ाइल को लोड करें और "db" के मूल तत्व के आधार पर DbProperties वर्ग को आबाद करें।

अब इसे किसी भी वर्ग में उपयोग करने के लिए आपको यह करना होगा:

@EnableConfigurationProperties(DbProperties.class)
public class PropertiesUsingService {

    @Autowired private DbProperties dbProperties;

}

इनमें से किसी भी दृष्टिकोण से आपको स्प्रिंग-बूट का उपयोग करके सफाई से काम करना चाहिए।

Comments

सुनिश्चित करें कि आपके क्लासपैथ में साँप है और ऊपर काम करना चाहिए।

— होसेरुडे

इन दिनों (हालाँकि उस समय यह प्रश्न नहीं पूछा गया था), snakeyamlद्वारा एक सकरात्मक निर्भरता के रूप में खींचा जाता है spring-boot-starter, इसलिए इसे अपने pom.xmlया अपने साथ जोड़ने की कोई आवश्यकता नहीं होनी चाहिए build.gradle, जब तक कि आपके पास एक अलग संस्करण का उपयोग करने के लिए गहरी जड़ें न हों। :)

— स्टीव

यह अब है locations, नहीं path, और ConfigFileApplicationContextInitializerभी आवश्यक है।

— ऑरेंजडॉग

Answer 8

मुझे @ActiveProfiles("test")src / test / Resources के लिए एप्लिकेशन-टेस्ट.yml फ़ाइल का उपयोग करके और जोड़कर एक वर्कअराउंड मिला ।

यह इस तरह लग रहा था:

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

}

फ़ाइल Application-test.yml में वे गुण होते हैं, जिन्हें मैं application.yml (जो src / main / resource में पाया जा सकता है) से ओवरराइड करना चाहता हूँ।

Comments

यह वही है जो मैं भी उपयोग करने की कोशिश कर रहा था। किसी कारण से यह काम नहीं करता है (स्प्रिंग बूट 1.3.3) जब मैं उपयोग @Value("${my.property}")करता हूं लेकिन अगर मैं उपयोग करता हूं तो यह ठीक काम करता है environment.getProperty("my.property")।

— मार्टिन-जी

Answer 9

यह इसलिए है क्योंकि आपने स्नेकमेल को कॉन्फ़िगर नहीं किया है। स्प्रिंग बूट @EnableAutoConfiguration सुविधा के साथ आते हैं। वहाँ सांप विन्यास भी है जब यू इस एनोटेशन कॉल ..

यह मेरा तरीका है:

@Configuration
@EnableAutoConfiguration
public class AppContextTest {
}

यहाँ मेरा परीक्षण है:

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

public class JaxbTest {
//tests are ommited
}

Answer 10

मुझे अपने कोड में कुछ गुणों को पढ़ने की आवश्यकता थी और यह स्प्रिंग-बूट 1.3.0 के साथ काम करता है। कृपया

@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);
}

Answer 11

स्प्रिंग बूट में कई प्रोफाइल कॉन्फिग के साथ कस्टम yml फ़ाइल लोड कर रहा है।

1) 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) जावा पूजो ऑब्जेक्ट को निम्नानुसार कॉन्फ़िगर करें

@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 फ़ाइल नाम: परीक्षण-सेवा-config.yml

उदाहरण के लिए 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

Answer 12

मैं एक विशेष स्थिति में था जहाँ मैं कस्टम फ़ाइल प्रॉपर्टी नामकरण के कारण @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();

    }

}

Answer 13

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

मेरे पुस्तकालय का उपयोग करने के लिए आपका स्वागत है। अब yaml , toml , hocon समर्थित है।

स्रोत: github.com

Answer 14

यह मूल प्रश्न का उत्तर नहीं है, लेकिन एक परीक्षण में एक अलग कॉन्फ़िगरेशन की आवश्यकता के लिए एक वैकल्पिक समाधान है ...

इसके बजाय @PropertySourceआप उपयोग कर सकते हैं -Dspring.config.additional-location=classpath:application-tests.yml।

जानिए, उस प्रत्यय का testsमतलब प्रोफाइल नहीं ...

उस एक YAML फ़ाइल में एक से अधिक प्रोफ़ाइल निर्दिष्ट की जा सकती हैं, जो एक दूसरे से विरासत में मिल सकती हैं, यहाँ अधिक पढ़ें - कई स्प्रिंग प्रोफाइल (yaml कॉन्फ़िगरेशन) के लिए संपत्ति का समाधान

फिर, आप अपने परीक्षण में निर्दिष्ट कर सकते हैं, कि सक्रिय प्रोफ़ाइल (उपयोग @ActiveProfiles("profile1,profile2")) वे हैं profile1,profile2जहां profile2बस ओवरराइड करेंगे (कुछ, एक को सभी को ओवरराइड करने की आवश्यकता नहीं है) से गुण profile1।

Answer 15

मैंने सभी सूचीबद्ध प्रश्नों की कोशिश की है, लेकिन उनमें से सभी मेरे काम के लिए काम नहीं करते हैं: कुछ यूनिट परीक्षण के लिए विशिष्ट याम्ल फ़ाइल का उपयोग करना। मेरे मामले में, यह इस तरह काम करता है:

@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);
    }

}

Answer 16

YamlPropertyLoaderFactory या YamlFileApplicationContextInitializer की तरह जोड़ने की आवश्यकता नहीं है। आपको अपना विचार परिवर्तित करना चाहिए। आम वसंत परियोजना की तरह। तुम्हें पता है, जावा विन्यास का उपयोग नहीं। बस * .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।

यह आपके एप्लिकेशन-टेस्ट को स्कैन करने में मदद कर सकता है

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

Comments

यह सवाल याम्ल (जो IMHO एक अच्छा विन्यास विधि है) से संबंधित था

— एल्डेबरन-एमएस