गुण फ़ाइल से मान कैसे पढ़ें?

Question

मैं वसंत का उपयोग कर रहा हूं। मुझे गुण फ़ाइल से मान पढ़ने की आवश्यकता है। यह आंतरिक गुण फ़ाइल है बाहरी गुण फ़ाइल नहीं। गुण फ़ाइल नीचे दी गई हो सकती है।

some.properties ---file name. values are below.

abc = abc
def = dsd
ghi = weds
jil = sdd

मुझे उन मूल्यों को पारंपरिक तरीके से नहीं फ़ाइल से पढ़ने की आवश्यकता है। उसकी प्राप्ति कैसे हो? क्या वसंत 3.0 के साथ कोई नवीनतम दृष्टिकोण है?

Comments

यह एक गुण फ़ाइल की तरह नहीं दिखता है ।

— रघुराम

यदि यह जावा अर्थ में एक गुण फ़ाइल है - हाँ। अन्यथा यह एक कस्टम फ़ाइल प्रारूप है जिसे अलग-अलग व्यवहार करने की आवश्यकता है (और यदि आपके पास कुंजी नहीं है तो आप बस स्प्रिंग में संपत्ति मान के रूप में लाइनों का उपयोग नहीं कर सकते हैं)।

— हॉक इंगमार श्मिट

"पारंपरिक तरीके से नहीं" - इसका क्या मतलब है?

— हौके इंगमार श्मिट

मेरा मतलब है कि एनोटेशन का उपयोग .. xml कॉन्फ़िगरेशन द्वारा नहीं ...

— user1016403

Answer 1

अपने संदर्भ में प्रॉपर्टीधारक को कॉन्फ़िगर करें:

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

फिर आप अपनी फलियों में गुणों को देखें:

@Component
class MyClass {
  @Value("${my.property.name}")
  private String[] myValues;
}

संपादित करें: उत्परिवर्ती अल्पविराम से अलग मूल्यों के साथ संपत्ति को पार्स करने के लिए कोड अपडेट किया गया:

my.property.name=aaa,bbb,ccc

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

<bean id="myProperties"
      class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="locations">
    <list>
      <value>classpath*:my.properties</value>
    </list>
  </property>
</bean>

और बीन:

@Component
class MyClass {
  @Resource(name="myProperties")
  private Properties myProperties;

  @PostConstruct
  public void init() {
    // do whatever you need with properties
  }
}

Comments

हाय mrembisz, आपके उत्तर के लिए धन्यवाद। बाहरी गुण फ़ाइल से मान पढ़ने के लिए मैंने पहले से ही उचित प्लेसहोल्डर कॉन्फ़िगर किया है। लेकिन मेरे पास संसाधन फ़ोल्डर के अंदर एक गुण फ़ाइल है। मुझे पढ़ने और इंजेक्शन लगाने की आवश्यकता है। मुझे सूची में सभी मानों को इंजेक्ट करने की आवश्यकता है। धन्यवाद!

— user1016403

जैसा कि @ ईथन द्वारा सुझाव दिया गया है। अपडेट के लिए धन्यवाद, मूल संपादन को स्वीकार नहीं किया जा सकता है, पहले ही बहुत देर हो चुकी थी।

— मर्मबिज़

उस स्थिति के लिए जहां आप अल्पविराम से अलग किए गए मानों के साथ काम कर रहे हैं, शायद इस बात पर विचार करें कि EL का उपयोग करके यहां क्या प्रस्तावित किया जा रहा है: stackoverflow.com/questions/12576156/…

— arcseldon

हम कैसे उपयोग करते हैं aaa? क्या यह @Value(${aaa}) private String aaa;तब हम कर सकते हैं System.out.println(aaa)???????

@ user75782131 अधिक सटीक @Value("${aaa}"), उद्धरणों को ध्यान में रखें। और हां, आप इसे कंस्ट्रक्टर में नहीं छोड़ सकते, क्योंकि वैल्यूज़ इंजेक्ट होने से पहले कंस्ट्रक्टर को निष्पादित किया जाता है।

— मर्मबिसज

Answer 2

इसे प्राप्त करने के विभिन्न तरीके हैं। नीचे वसंत में कुछ आमतौर पर उपयोग किए जाने वाले तरीके दिए गए हैं-

1. प्रॉपर्टीजहोल्डरकॉन्फिगर का उपयोग करना

2. संपत्ति स्रोत का उपयोग करना

3. ResourceBundleMessageSource का उपयोग करना

4. PropertiesFactoryBean का उपयोग करना

   और बहुत सारे........................

मान लें ds.typeकि आपकी संपत्ति फ़ाइल में कुंजी है।

---

का उपयोग करते हुए PropertyPlaceholderConfigurer

रजिस्टर PropertyPlaceholderConfigurerबीन-

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

या

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="locations" value="classpath:path/filename.properties" ></property>
</bean>

या

@Configuration
public class SampleConfig {
 @Bean
 public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
  return new PropertySourcesPlaceholderConfigurer();
  //set locations as well.
 }
}

पंजीकरण करने के बाद PropertySourcesPlaceholderConfigurer, आप मूल्य का उपयोग कर सकते हैं-

@Value("${ds.type}")private String attr; 

---

का उपयोग करते हुए PropertySource

नवीनतम वसंत संस्करण में आप रजिस्टर करने के लिए की जरूरत नहीं है PropertyPlaceHolderConfigurerके साथ @PropertySource, मैं एक अच्छा पाया लिंक संस्करण संगतता- को समझने के लिए

@PropertySource("classpath:path/filename.properties")
@Component
public class BeanTester {
    @Autowired Environment environment; 
    public void execute() {
        String attr = this.environment.getProperty("ds.type");
    }
}

---

का उपयोग करते हुए ResourceBundleMessageSource

बीन पंजीकृत करें-

<bean id="messageSource" class="org.springframework.context.support.ResourceBundleMessageSource">
  <property name="basenames">
    <list>
      <value>classpath:path/filename.properties</value>
    </list>
  </property>
</bean>

पहुँच मान-

((ApplicationContext)context).getMessage("ds.type", null, null);

या

@Component
public class BeanTester {
    @Autowired MessageSource messageSource; 
    public void execute() {
        String attr = this.messageSource.getMessage("ds.type", null, null);
    }
}

---

का उपयोग करते हुए PropertiesFactoryBean

बीन पंजीकृत करें-

<bean id="properties"
      class="org.springframework.beans.factory.config.PropertiesFactoryBean">
  <property name="locations">
    <list>
      <value>classpath:path/filename.properties</value>
    </list>
  </property>
</bean>

वायर गुण आपके वर्ग में

@Component
public class BeanTester {
    @Autowired Properties properties; 
    public void execute() {
        String attr = properties.getProperty("ds.type");
    }
}

Comments

प्रॉपर्टी सोर्सप्लसहोल्डरकॉन्फिगर का उपयोग करने के लिए आपको सामान्य रूप से एक स्थान या संसाधन सेट करना होगा अन्यथा आप एक गुण फ़ाइल तक नहीं पहुंच सकते। आप ClassPathResource generalProperties = new ClassPathResource ("general.properties") का उपयोग कर सकते हैं;

— M46

Answer 3

विन्यास वर्ग में

@Configuration
@PropertySource("classpath:/com/myco/app.properties")
public class AppConfig {
   @Autowired
   Environment env;

   @Bean
   public TestBean testBean() {
       TestBean testBean = new TestBean();
       testBean.setName(env.getProperty("testbean.name"));
       return testBean;
   }
}

Comments

इस उदाहरण में, क्या आप app.propertiesउत्पादन v। परीक्षण में एक अलग प्रयोग करेंगे ? दूसरे शब्दों में, app.propertiesउत्पादन मूल्यों के साथ बदलने के लिए आपकी तैनाती प्रक्रिया का हिस्सा होगा ?

— केविन मेरेडिथ

@KevinMeredith हाँ, आप कर सकते हैं, प्रोफ़ाइल एनोटेशन stackoverflow.com/questions/12691812/…

— mokshino

@KevinMeredith हम तैनाती के बाहर एक फ़ोल्डर का उपयोग करते हैं: जैसे c: \ apps \ sys_name \ conf \ app.properties। परिनियोजन प्रक्रिया सरल हो जाती है और त्रुटि-कम होती है।

— jpfreire

Answer 4

यहाँ एक अतिरिक्त उत्तर है जो मेरे लिए यह समझने में भी बहुत मददगार था कि यह कैसे काम करता है: http://www.javacodegeeks.com/2013/07/spring-bean-and-propertyplaceholderconfigurer.html

किसी भी BeanFactoryPostProcessor बीन्स को एक स्थिर , संशोधक के साथ घोषित किया जाना है

@Configuration
@PropertySource("classpath:root/test.props")
public class SampleConfig {
 @Value("${test.prop}")
 private String attr;
 @Bean
 public SampleService sampleService() {
  return new SampleService(attr);
 }

 @Bean
 public static PropertySourcesPlaceholderConfigurer placeHolderConfigurer() {
  return new PropertySourcesPlaceholderConfigurer();
 }
}

Comments

PropertySourcesPlaceholderConfigurerबीन को स्पष्ट रूप से पंजीकृत करने की आवश्यकता नहीं है@PropertySource

@ dubey -Harcourtians जो स्प्रिंग (कोर) संस्करण का उपयोग करते हैं? यदि आप स्प्रिंग बूट का उपयोग कर रहे हैं तो आपको @PropertySourceपूरी तरह से आवश्यकता भी नहीं है ।

— माइकल टेकोर्ट

Answer 5

यदि आपको @Value का उपयोग किए बिना किसी गुण फ़ाइल को मैन्युअल रूप से पढ़ने की आवश्यकता है।

लोकेश गुप्ता द्वारा लिखित अच्छे ब्लॉग के लिए धन्यवाद: ब्लॉग

package utils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.util.ResourceUtils;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import java.io.File;


public class Utils {

    private static final Logger LOGGER = LoggerFactory.getLogger(Utils.class.getName());

    public static Properties fetchProperties(){
        Properties properties = new Properties();
        try {
            File file = ResourceUtils.getFile("classpath:application.properties");
            InputStream in = new FileInputStream(file);
            properties.load(in);
        } catch (IOException e) {
            LOGGER.error(e.getMessage());
        }
        return properties;
    }
}

Comments

धन्यवाद, यह मेरे मामले के लिए काम करता है। मुझे स्थिर फ़ंक्शन से गुणों को पढ़ने की आवश्यकता है।

— त्रियुगी गुयेन

Answer 6

आपको अपने आवेदन के संदर्भ में एक प्रॉपर्टीहोल्डरकॉन्फिगर बीन लगाने की जरूरत है और इसके स्थान की संपत्ति निर्धारित करें।

यहां देखें विवरण: http://www.zparacha.com/how-to-read-properties-file-in-spring/

इस काम के लिए आपको अपनी संपत्ति फ़ाइल को थोड़ा संशोधित करना पड़ सकता है।

आशा करता हूँ की ये काम करेगा।

Answer 7

एक अन्य तरीका है एक उपयोग कर रहा है ResourceBundle । मूल रूप से आपको '.properties' के बिना इसके नाम का उपयोग करके बंडल मिलता है

private static final ResourceBundle resource = ResourceBundle.getBundle("config");

और आप इसका उपयोग करके किसी भी मूल्य की वसूली करते हैं:

private final String prop = resource.getString("propName");

Answer 8

 [project structure]: http://i.stack.imgur.com/RAGX3.jpg
-------------------------------
    package beans;

        import java.util.Properties;
        import java.util.Set;

        public class PropertiesBeans {

            private Properties properties;

            public void setProperties(Properties properties) {
                this.properties = properties;
            }

            public void getProperty(){
                Set keys = properties.keySet();
                for (Object key : keys) {
                    System.out.println(key+" : "+properties.getProperty(key.toString()));
                }
            }

        }
    ----------------------------

        package beans;

        import org.springframework.context.ApplicationContext;
        import org.springframework.context.support.ClassPathXmlApplicationContext;

        public class Test {

            public static void main(String[] args) {
                // TODO Auto-generated method stub
                ApplicationContext ap = new ClassPathXmlApplicationContext("resource/spring.xml");
                PropertiesBeans p = (PropertiesBeans)ap.getBean("p");
                p.getProperty();
            }

        }
    ----------------------------

 - driver.properties

    Driver = com.mysql.jdbc.Driver
    url = jdbc:mysql://localhost:3306/test
    username = root
    password = root
    ----------------------------



     <beans xmlns="http://www.springframework.org/schema/beans"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xmlns:util="http://www.springframework.org/schema/util"
               xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">

            <bean id="p" class="beans.PropertiesBeans">
                <property name="properties">
                    <util:properties location="classpath:resource/driver.properties"/>
                </property>
            </bean>

        </beans>

Comments

कुछ स्पष्टीकरण जोड़ने

— HaveNoDisplayName

कोर कंटेनर का उपयोग करके आप रिसोर्स प्रॉपर्टीज़ फ़ाइल के बाहर नहीं पहुँच सकते हैं, इसलिए आपको ApplicationContext जैसे j2ee कंटेनर का उपयोग करने की आवश्यकता है, और आपको सेम लेवल वेलिडेशन जैसे xmlns, xmlns: use, xsi: schemaLocation, xsns: xsi

— Sangram Badi

Answer 9

मैं इस लिंक को पढ़ने की सलाह दूंगा https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html स्प्रिंगबूट डॉक्स से बाहरी कॉन्फिगर को इंजेक्ट करने के बारे में। उन्होंने केवल एक प्रॉपर्टी फ़ाइल से पुनर्प्राप्त करने के बारे में बात नहीं की, बल्कि YAML और यहां तक ​​कि JSON फाइलें भी। मुझे यह मददगार लगा। मैं आपसे भी करने की उम्मीद करता हूं।

Answer 10

मैं एक उपयोगिता वर्ग चाहता था, जो वसंत द्वारा प्रबंधित नहीं है, इसलिए कोई भी स्प्रिंग एनोटेशन जैसे कि आदि नहीं है @Component, @Configurationलेकिन मैं चाहता था कि कक्षा इससे पढ़ेंapplication.properties

मैंने इसे स्प्रिंग कॉनटेक्स्ट के बारे में जानने के लिए कक्षा में काम कर पाने में कामयाब रहा, इसलिए इसके बारे में पता है Environment, और इसलिए यह environment.getProperty()उम्मीद के मुताबिक काम करता है।

स्पष्ट होने के लिए, मेरे पास है:

application.properties

mypath=somestring

Utils.java

import org.springframework.core.env.Environment;

// No spring annotations here
public class Utils {
    public String execute(String cmd) {
        // Making the class Spring context aware
        ApplicationContextProvider appContext = new ApplicationContextProvider();
        Environment env = appContext.getApplicationContext().getEnvironment();

        // env.getProperty() works!!!
        System.out.println(env.getProperty("mypath")) 
    }
}

ApplicationContextProvider.java (देखें वसंत वर्तमान ApplicationContext मिलता है )

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContextProvider implements ApplicationContextAware {
    private static ApplicationContext CONTEXT;

    public ApplicationContext getApplicationContext() {
        return CONTEXT;
    }

    public void setApplicationContext(ApplicationContext context) throws BeansException {
        CONTEXT = context;
    }

    public static Object getBean(String beanName) {
        return CONTEXT.getBean(beanName);
    }
}