जावा संपत्ति फ़ाइलों का उपयोग कैसे करें?

Question

मेरे पास उन कॉन्फ़िगरेशन मानों की कुंजी / मान युग्मों की एक सूची है जिन्हें मैं जावा संपत्ति फ़ाइलों के रूप में संग्रहीत करना चाहता हूं, और बाद में लोड और पुनरावृति करता हूं।

प्रशन:

• क्या मुझे फ़ाइल को उसी पैकेज में संग्रहीत करने की आवश्यकता है, जिस कक्षा में उन्हें लोड किया जाएगा, या क्या कोई विशिष्ट स्थान है जहां इसे रखा जाना चाहिए?
• क्या फ़ाइल को किसी विशिष्ट एक्सटेंशन में समाप्त होने की आवश्यकता है या है .txt ठीक है?
• मैं फ़ाइल को कोड में कैसे लोड कर सकता हूं
• और मैं अंदर मूल्यों के माध्यम से कैसे पुनरावृति कर सकता हूं?

Answer 1

आप संपत्ति के लिए एक इनपुटस्ट्रीम पास कर सकते हैं, इसलिए आपकी फ़ाइल कहीं भी, और कुछ भी कह सकती है।

Properties properties = new Properties();
try {
  properties.load(new FileInputStream("path/filename"));
} catch (IOException e) {
  ...
}

निम्नानुसार:

for(String key : properties.stringPropertyNames()) {
  String value = properties.getProperty(key);
  System.out.println(key + " => " + value);
}

Comments

गुण फ़ाइल में कुंजी मौजूद नहीं होने पर क्या मान लौटाया जाता है?

— मिताक्ष गुप्ता

@MitakshGupta यदि आपके द्वारा पारित नाम वाली कोई संपत्ति फ़ाइल में या डिफ़ॉल्ट गुण सूची में नहीं मिली है, तो यह पुन: हो जाती है null। देखें जावाडोक

— drigoangelo

यह कैसे properties.load(PropertiesReader.class.getResourceAsStream("/properties.properties")); है, getResourceAsStreamबनाम के साथ तुलना करता है FileInputStream? फायदा और नुकसान?

— थूफ़िर

Answer 2

• आप फ़ाइल को कहीं भी स्टोर कर सकते हैं। यदि आप इसे अपनी जार फ़ाइल में रखना चाहते हैं, तो आप इसका उपयोग करना चाहते हैं Class.getResourceAsStream()या इसका उपयोग करना चाहते हैं ClassLoader.getResourceAsStream()। यदि यह फ़ाइल सिस्टम पर है तो यह थोड़ा आसान है।

• कोई भी विस्तार ठीक है, हालांकि। अनुभव मेरे अनुभव में अधिक सामान्य है

• यदि आप जावा 6 का उपयोग कर रहे हैं, तो ( या यदि आप जावा 6 का उपयोग कर रहे हैं, तो या तो Properties.loadपास करके , फ़ाइल का लोड करें , मैं शायद UTF-8 का उपयोग करूं और स्ट्रीम के लिए डिफ़ॉल्ट ISO-8859-1 एन्कोडिंग के बजाय। )InputStreamStreamReaderReader

• जैसे आप एक सामान्य Hashtable(जो इससे Propertiesप्राप्त होता है), जैसे कि का उपयोग कर के माध्यम से पुनरावृत्त keySet()। वैकल्पिक रूप से, आप द्वारा दिए गए गणना का उपयोग कर सकते हैं propertyNames()।

Comments

धन्यवाद जॉन, अगली बात मुझे पता है कि मैं जॉदा पर कुछ देख रहा हूं और आप इसका जवाब देंगे।

— ज्वाला

Answer 3

यदि आप गुण फ़ाइल को क्लास फू के समान पैकेज में रखते हैं, तो आप इसे आसानी से लोड कर सकते हैं

new Properties().load(Foo.class.getResourceAsStream("file.properties"))

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

यदि आप * .प्रतिरोधी एक्सटेंशन का उपयोग करते हैं, तो आप संपादक का समर्थन प्राप्त कर सकते हैं, उदाहरण के लिए ग्रहण में एक गुण फ़ाइल संपादक है।

Comments

आप ऐसा कर सकते हैं - लेकिन मैं एक ही पैकेज में संपत्तियों की फाइलों को पसंद नहीं करता। आप अपने आवेदन में सभी स्थानों पर फैली संपत्तियों की फाइलों के साथ अंत करते हैं। मैं बहुत सारे ऐप के रूट में सभी प्रॉपर्टीज़ फ़ाइलों को स्टोर करता हूँ, और उन्हें "class.getResourceAsStream (" \ file.properties ")" या कुछ अन्य ज्ञात स्थान पर लोड करता हूँ।

— नैट

नैट, यह सच है। हालाँकि, कुछ परिदृश्यों में परिनियोजित स्थान ज्ञात नहीं है (उदाहरण के लिए आपके विशेष घटक की प्रत्येक चीज़ को कुछ संग्रह में बंडल किया जाता है)। ऐसे मामलों में यह कहना काफी सुविधाजनक हो सकता है कि 'यह उस वर्ग के साथ है, जहाँ भी वह वर्ग समाप्त होता है'। इसके अलावा, सभी फाइलों को फैलाने से बचने के लिए, सभी संपत्ति फ़ाइलों के लिए एक एकल कॉन्फ़िगरेशन पैकेज का उपयोग किया जा सकता है।

— फेबियन स्टिग

फैबियन, उन दोनों मामलों में मेरी टिप्पणी के साथ काम करते हैं - यह क्लासपैथ पर आधारित है - फाइलसिस्टम नहीं।

— नैट

काम करने के लिए नैट का उदाहरण प्राप्त करने की कोशिश करने वाले किसी भी व्यक्ति के लिए बैकस्लैश को एक फॉरवर्ड स्लैश से बदलना चाहिए। तो इस मामले में: 'class.getResourceAsStream ("/ file.properties")'

— hash_collision

Answer 4

propertiesफ़ाइलें बनाने और पढ़ने के कई तरीके हैं :

1. फ़ाइल को उसी पैकेज में संग्रहीत करें।
2. सिफारिश .propertiesविस्तार की करें हालांकि आप अपना खुद का चयन कर सकते हैं।
3. उपयोग में स्थित कक्षाओं शोध करे java.utilपैकेज => Properties, ListResourceBundle,ResourceBundle कक्षाएं।
4. गुण पढ़ने के लिए, iterator या प्रगणक या के प्रत्यक्ष तरीकों का उपयोग Propertiesया java.lang.Systemवर्ग।

ResourceBundle वर्ग:

 ResourceBundle rb = ResourceBundle.getBundle("prop"); // prop.properties
 System.out.println(rb.getString("key"));

Properties वर्ग:

Properties ps = new Properties();
ps.Load(new java.io.FileInputStream("my.properties"));

Comments

हाय AVD, हमें .propertiesकेवल एक्सटेंशन की आवश्यकता क्यों है ? क्या गलत है '.txt' का ज़िक्र? कृपया मेरी सहायता करें।

— आतिश शिंपी

@atishshimpi गुण प्रकार के साथ काम करते हुए आवश्यक नहीं है, लेकिन यह ResourceBundle के लिए अनिवार्य है - डॉक्टर पढ़ docs.oracle.com/javase/8/docs/api/java/util/ResourceBundle.html

— adatapost

Answer 5

यह गुण फ़ाइल लोड करता है:

Properties prop = new Properties();
InputStream stream = ...; //the stream to the file
try {
  prop.load(stream);
} finally {
  stream.close();
}

मैं एक निर्देशिका में .properties फ़ाइल डालने के लिए उपयोग करता हूं, जहां मेरे पास सभी कॉन्फ़िगरेशन फ़ाइलें हैं, मैं इसे उस वर्ग के साथ एक साथ नहीं रखता हूं जो इसे एक्सेस करता है, लेकिन यहां कोई प्रतिबंध नहीं है।

नाम के लिए ... मैं उपयोग करता हूं। सत्यनिष्ठा के लिए। मैं नहीं चाहता कि आप इसे नाम दें।

Comments

हालाँकि, गुणों की फ़ाइलों के कुछ "एक्सटेंशन" .properties एक्सटेंशन मान लेते हैं - उदाहरण के लिए संसाधन Bundle I18N में उपयोग किया जाता है।

— नैट

Answer 6

उदाहरण:

Properties pro = new Properties();
FileInputStream in = new FileInputStream("D:/prop/prop.properties");
pro.load(in);
String temp1[];
String temp2[];
// getting values from property file
String username = pro.getProperty("usernamev3");//key value in prop file 
String password = pro.getProperty("passwordv3");//eg. username="zub"
String delimiter = ",";                         //password="abc"
temp1=username.split(delimiter);
temp2=password.split(delimiter);

Comments

क्या होगा यदि आपके पास 3 प्रॉपर्टीज़ फाइलें हैं?

— एंजेलिना

Answer 7

गुण विरासत बन गए हैं। गुण के लिए प्राथमिकता वर्ग पसंद किया जाता है।

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

उन गुणों के विपरीत, जो स्ट्रिंग आधारित कुंजी-मूल्य जोड़े हैं, Preferencesवर्ग में प्रेफरेंस डेटा स्टोर में आदिम डेटा प्राप्त करने और डालने के लिए कई तरीके हैं। हम केवल निम्न प्रकार के डेटा का उपयोग कर सकते हैं:

1. तार
2. बूलियन
3. दोहरा
4. नाव
5. पूर्णांक
6. लंबा
7. बाइट सरणी

गुण फ़ाइल लोड करने के लिए, या तो आप निरपेक्ष पथ प्रदान कर सकते हैं या उपयोग कर सकते हैं getResourceAsStream()यदि गुण फ़ाइल आपके classpath में मौजूद है।

package com.mypack.test;

import java.io.*;
import java.util.*;
import java.util.prefs.Preferences;

public class PreferencesExample {

    public static void main(String args[]) throws FileNotFoundException {
        Preferences ps = Preferences.userNodeForPackage(PreferencesExample.class);
        // Load file object
        File fileObj = new File("d:\\data.xml");
        try {
            FileInputStream fis = new FileInputStream(fileObj);
            ps.importPreferences(fis);
            System.out.println("Prefereces:"+ps);
            System.out.println("Get property1:"+ps.getInt("property1",10));

        } catch (Exception err) {
            err.printStackTrace();
        }
    }
}

xml फ़ाइल:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE preferences SYSTEM 'http://java.sun.com/dtd/preferences.dtd'>
<preferences EXTERNAL_XML_VERSION="1.0">
<root type="user">
<map />
<node name="com">
  <map />
  <node name="mypack">
    <map />
    <node name="test">
      <map>
        <entry key="property1" value="80" />
        <entry key="property2" value="Red" />
      </map>
    </node>
  </node>
</node>
</root>
</preferences>

वरीयताओं की दुकान के आंतरिक पर इस लेख पर एक नज़र है

Answer 8

क्रम में:

1. आप फ़ाइल को कहीं भी रख सकते हैं।
2. कोई विस्तार आवश्यक नहीं है।
3. मोंटेक्रिस्टो ने इसे लोड करने के तरीके का वर्णन किया है । यह ठीक काम करना चाहिए।
4. propertyNames () के माध्यम से पुनरावृति करने के लिए आपको एक संसेचन देता है।

Comments

2. no extension is necessary, क्या आप कृपया मुझे इस कथन के लिए कोई संदर्भ प्रदान कर सकते हैं। मुझे उस पर भ्रम है।

— आतिश शिंपी

ध्यान दें कि आप संपत्तियों को इनपुट स्ट्रीम के माध्यम से लोड कर सकते हैं। इस तरह के गुणों के बारे में कोई जानकारी नहीं है कि इनपुटस्ट्रीम कहाँ से आया है (एक फ़ाइल? एक सॉकेट?) और परिणामस्वरूप नामकरण मानक लागू नहीं कर सकता है

— ब्रायन एग्न्यू

Answer 9

डिफ़ॉल्ट रूप से, जावा इसे आपके एप्लिकेशन की कार्यशील निर्देशिका में खोलता है (यह व्यवहार वास्तव में उपयोग किए गए ओएस पर निर्भर करता है)। फ़ाइल लोड करने के लिए, यह करें:

Properties props = new java.util.Properties();
FileInputStream fis new FileInputStream("myfile.txt");
props.load(fis)

जैसे, संपत्ति फ़ाइल के लिए किसी भी फ़ाइल एक्सटेंशन का उपयोग किया जा सकता है। इसके अतिरिक्त, फ़ाइल को कहीं भी संग्रहीत किया जा सकता है, जब तक आप एक का उपयोग कर सकते हैं FileInputStream।

संबंधित नोट पर यदि आप एक आधुनिक ढांचे का उपयोग करते हैं, तो ढांचा संपत्ति फ़ाइल खोलने के अतिरिक्त तरीके प्रदान कर सकता है। उदाहरण के लिए, स्प्रिंग ClassPathResourceएक JAR फ़ाइल के अंदर से पैकेज नाम का उपयोग करके एक संपत्ति फ़ाइल लोड करने के लिए प्रदान करता है।

गुणों के माध्यम से पुनरावृत्ति के लिए, एक बार गुण लोड होने के बाद वे java.util.Propertiesऑब्जेक्ट में संग्रहीत होते हैं , जो propertyNames()विधि प्रदान करते हैं ।

Answer 10

किसी गुण फ़ाइल को पढ़ना और उसकी सामग्री लोड करना Properties

String filename = "sample.properties";
Properties properties = new Properties();

input = this.getClass().getClassLoader().getResourceAsStream(filename);
properties.load(input);

निम्नलिखित एक पर पुनरावृति करने के लिए कुशल तरीका है Properties

    for (Entry<Object, Object> entry : properties.entrySet()) {

        System.out.println(entry.getKey() + " => " + entry.getValue());
    }

Answer 11

में जावा 8 अपने सभी गुण प्राप्त करने के

public static Map<String, String> readPropertiesFile(String location) throws Exception {

    Map<String, String> properties = new HashMap<>();

    Properties props = new Properties();
    props.load(new FileInputStream(new File(location)));

    props.forEach((key, value) -> {
        properties.put(key.toString(), value.toString());
    });

    return properties;
}

Answer 12

1) अपनी संपत्ति की फाइल क्लासपाथ में रखना अच्छा है लेकिन आप इसे प्रोजेक्ट में कहीं भी रख सकते हैं।

नीचे बताया गया है कि आप क्लासपैथ से संपत्ति फ़ाइल को कैसे लोड करते हैं और सभी गुणों को पढ़ते हैं।

Properties prop = new Properties();
InputStream input = null;

try {

    String filename = "path to property file";
    input = getClass().getClassLoader().getResourceAsStream(filename);
    if (input == null) {
        System.out.println("Sorry, unable to find " + filename);
        return;
    }

    prop.load(input);

    Enumeration<?> e = prop.propertyNames();
    while (e.hasMoreElements()) {
        String key = (String) e.nextElement();
        String value = prop.getProperty(key);
        System.out.println("Key : " + key + ", Value : " + value);
    }

} catch (IOException ex) {
    ex.printStackTrace();
} finally {
    if (input != null) {
        try {
            input.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2) संपत्ति फ़ाइलों में .properties के रूप में विस्तार है

Answer 13

यहाँ गुणों पर पुनरावृति करने का एक और तरीका है:

Enumeration eProps = properties.propertyNames();
while (eProps.hasMoreElements()) { 
    String key = (String) eProps.nextElement(); 
    String value = properties.getProperty(key); 
    System.out.println(key + " => " + value); 
}

Comments

मुझे पूरी तरह खेद है। मैंने जेड के जवाब में कोड की समीक्षा की और यह काफी अच्छी तरह से काम करता है ... मुझे नहीं पता कि मैंने फिर क्या सोचा ... वास्तव में उसका समाधान मेरे मुकाबले अच्छा है, मुझे लगता है ...

— dertoni

Answer 14

मैंने पिछले साल के लिए इस संपत्ति ढांचे पर लिखा है। यह संपत्तियों को लोड करने के कई तरीके प्रदान करेगा, और उन्हें दृढ़ता से टाइप भी करेगा।

Http://sourceforge.net/projects/jhpropertiestyp/ पर एक नज़र डालें

JHPropertiesTyped डेवलपर को जोरदार टाइप की गई प्रॉपर्टी देगा। मौजूदा परियोजनाओं में एकीकृत करना आसान है। संपत्ति प्रकारों के लिए एक बड़ी श्रृंखला द्वारा नियंत्रित किया जाता है। संपत्ति IO कार्यान्वयन के माध्यम से गुणों को एक-पंक्ति इनिशियलाइज़ करने की क्षमता देता है। डेवलपर को खुद की संपत्ति प्रकार और संपत्ति io's बनाने की क्षमता देता है। वेब डेमो भी उपलब्ध है, ऊपर दिखाए गए स्क्रीनशॉट। यदि आप इसका उपयोग करना चाहते हैं, तो संपत्तियों के प्रबंधन के लिए वेब फ्रंट एंड के लिए एक मानक कार्यान्वयन भी है।

पूरा प्रलेखन, ट्यूटोरियल, जावाडॉक, फेक आदि परियोजना वेबपेज पर उपलब्ध है।

Answer 15

यहाँ तैयार स्थिर वर्ग

import java.io.*;
import java.util.Properties;
public class Settings {
    public static String Get(String name,String defVal){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            FileReader reader = new FileReader(configFile);
            Properties props = new Properties();
            props.load(reader);
            reader.close();
            return props.getProperty(name);
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
            return defVal;
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
            return defVal;
        } catch (Exception ex){
            logger.error(ex);
            return defVal;
        }
    }
    public static Integer Get(String name,Integer defVal){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            FileReader reader = new FileReader(configFile);
            Properties props = new Properties();
            props.load(reader);
            reader.close();
            return Integer.valueOf(props.getProperty(name));
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
            return defVal;
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
            return defVal;
        } catch (Exception ex){
            logger.error(ex);
            return defVal;
        }
    }
    public static Boolean Get(String name,Boolean defVal){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            FileReader reader = new FileReader(configFile);
            Properties props = new Properties();
            props.load(reader);
            reader.close();
            return Boolean.valueOf(props.getProperty(name));
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
            return defVal;
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
            return defVal;
        } catch (Exception ex){
            logger.error(ex);
            return defVal;
        }
    }
    public static void Set(String name, String value){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            Properties props = new Properties();
            FileReader reader = new FileReader(configFile);
            props.load(reader);
            props.setProperty(name, value.toString());
            FileWriter writer = new FileWriter(configFile);
            props.store(writer, Variables.SETTINGS_COMMENT);
            writer.close();
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
        } catch (Exception ex){
            logger.error(ex);
        }
    }
    public static void Set(String name, Integer value){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            Properties props = new Properties();
            FileReader reader = new FileReader(configFile);
            props.load(reader);
            props.setProperty(name, value.toString());
            FileWriter writer = new FileWriter(configFile);
            props.store(writer,Variables.SETTINGS_COMMENT);
            writer.close();
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
        } catch (Exception ex){
            logger.error(ex);
        }
    }
    public static void Set(String name, Boolean value){
        File configFile = new File(Variables.SETTINGS_FILE);
        try {
            Properties props = new Properties();
            FileReader reader = new FileReader(configFile);
            props.load(reader);
            props.setProperty(name, value.toString());
            FileWriter writer = new FileWriter(configFile);
            props.store(writer,Variables.SETTINGS_COMMENT);
            writer.close();
        } catch (FileNotFoundException ex) {
            // file does not exist
            logger.error(ex);
        } catch (IOException ex) {
            // I/O error
            logger.error(ex);
        } catch (Exception ex){
            logger.error(ex);
        }
    }
}

यहाँ नमूना:

Settings.Set("valueName1","value");
String val1=Settings.Get("valueName1","value");
Settings.Set("valueName2",true);
Boolean val2=Settings.Get("valueName2",true);
Settings.Set("valueName3",100);
Integer val3=Settings.Get("valueName3",100);

Answer 16

आप निम्न तरीके से मुकदमा करने वाली संपत्ति फ़ाइल लोड कर सकते हैं:

InputStream is = new Test().getClass().getClassLoader().getResourceAsStream("app.properties");
        Properties props =  new Properties();
        props.load(is);

और फिर आप एक लंबोदर अभिव्यक्ति का उपयोग करके मानचित्र पर पुनरावृति कर सकते हैं जैसे:

props.stringPropertyNames().forEach(key -> {
            System.out.println("Key is :"+key + " and Value is :"+props.getProperty(key));
        });

Answer 17

मेरी राय में अन्य तरीके तब हटाए जाते हैं जब हम इसे नीचे की तरह बहुत सरल कर सकते हैं:

@PropertySource("classpath:application.properties")
public class SomeClass{

    @Autowired
    private Environment env;

    public void readProperty() {
        env.getProperty("language");
    }

}

यह बहुत आसान है, लेकिन मुझे लगता है कि सबसे अच्छा तरीका है !! का आनंद लें