Bagaimana cara menggunakan file properti Java?

Saya memiliki daftar pasangan kunci / nilai nilai konfigurasi yang ingin saya simpan sebagai file properti Java, dan kemudian memuat dan mengulanginya.

Pertanyaan:

• Apakah saya perlu menyimpan file dalam paket yang sama dengan kelas yang akan memuatnya, atau adakah lokasi spesifik di mana ia harus ditempatkan?
• Apakah file harus diakhiri dengan ekstensi tertentu atau tidak .txtapa - apa?
• Bagaimana saya dapat memuat file dalam kode
• Dan bagaimana saya bisa mengulanginya melalui nilai-nilai di dalamnya?

Anda dapat mengirimkan InputStream ke Properti, sehingga file Anda dapat berada di mana saja, dan memanggil apa saja.

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

Iterate sebagai:

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

• Anda dapat menyimpan file di mana saja Anda suka. Jika Anda ingin menyimpannya di file jar Anda, Anda akan ingin menggunakan Class.getResourceAsStream()atau ClassLoader.getResourceAsStream()mengaksesnya. Jika ada di sistem file itu sedikit lebih mudah.

• Ekstensi apa pun baik-baik saja, meskipun .properties lebih umum dalam pengalaman saya

• Memuat file menggunakan Properties.load, lewat di sebuah InputStreamatau StreamReaderjika Anda menggunakan Java 6. (Jika Anda sedang menggunakan Java 6, aku mungkin menggunakan UTF-8 dan Readerbukan default ISO-8859-1 encoding untuk sungai. )

• Iterasi melalui itu karena Anda akan beralih melalui normal Hashtable(yang Propertiesberasal dari), misalnya menggunakan keySet(). Atau, Anda dapat menggunakan enumerasi yang dikembalikan oleh propertyNames().

Jika Anda meletakkan file properti dalam paket yang sama dengan kelas Foo, Anda dapat dengan mudah memuatnya

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

Mengingat bahwa Properties memperluas Hashtable, Anda dapat mengulangi nilai-nilai dengan cara yang sama seperti yang Anda lakukan dalam Hashtable.

Jika Anda menggunakan ekstensi * .properties Anda bisa mendapatkan dukungan editor, misalnya Eclipse memiliki editor file properti.

Ada banyak cara untuk membuat dan membaca propertiesfile:

1. Simpan file dalam paket yang sama.
2. Rekomendasikan .propertiesekstensi namun Anda dapat memilih sendiri.
3. Gunakan tesis kelas yang terletak di java.utilpaket => Properties, ListResourceBundle, ResourceBundlekelas.
4. Untuk membaca properti, gunakan iterator atau enumerator atau metode langsung Propertiesatau java.lang.Systemkelas.

ResourceBundle kelas:

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

Properties kelas:

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

Ini memuat file properti:

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

Saya gunakan untuk meletakkan file .properties di direktori di mana saya memiliki semua file konfigurasi, saya tidak meletakkannya bersama-sama dengan kelas yang mengaksesnya, tetapi tidak ada batasan di sini.

Untuk nama ... Saya menggunakan .properties demi kata kerja, saya tidak berpikir Anda harus memberi nama .properties jika Anda tidak mau.

Contoh:

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

Properti telah menjadi warisan. Preferensi kelas lebih disukai ke Properties.

Sebuah simpul dalam kumpulan data preferensi hirarkis. Kelas ini memungkinkan aplikasi untuk menyimpan dan mengambil preferensi pengguna dan sistem dan data konfigurasi. Data ini disimpan secara terus-menerus di toko dukungan yang bergantung pada implementasi. Implementasi yang umum termasuk file datar, registrasi khusus OS, server direktori dan database SQL. Pengguna kelas ini tidak perlu khawatir dengan detail dari toko dukungan.

Tidak seperti properti yang merupakan pasangan nilai kunci berbasis String, Preferenceskelas ini memiliki beberapa metode yang digunakan untuk mendapatkan dan menempatkan data primitif di penyimpanan data Preferensi. Kami hanya dapat menggunakan tipe data berikut:

1. Tali
2. boolean
3. dua kali lipat
4. mengapung
5. int
6. panjang
7. array byte

Untuk memuat file properti, Anda bisa memberikan path absolut atau gunakan getResourceAsStream()jika file properti ada di classpath Anda.

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

file 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>

Lihat artikel ini di internal toko preferensi

Dalam urutan:

1. Anda dapat menyimpan file cukup banyak di mana saja.
2. tidak perlu ekstensi.
3. Montecristo telah menggambarkan cara memuat ini. Itu seharusnya bekerja dengan baik.
4. propertyNames () memberi Anda enumerasi untuk beralih melalui.

Secara default, Java membukanya di direktori kerja aplikasi Anda (perilaku ini sebenarnya tergantung pada OS yang digunakan). Untuk memuat file, lakukan:

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

Dengan demikian, ekstensi file apa pun dapat digunakan untuk file properti. Selain itu, file tersebut juga dapat disimpan di mana saja, selama Anda dapat menggunakan file FileInputStream.

Pada catatan terkait jika Anda menggunakan kerangka kerja modern, kerangka kerja dapat memberikan cara tambahan untuk membuka file properti. Misalnya, Spring menyediakan a ClassPathResourceuntuk memuat file properti menggunakan nama paket dari dalam file JAR.

Adapun iterasi melalui properti, setelah properti dimuat mereka disimpan dalam java.util.Propertiesobjek, yang menawarkan propertyNames()metode ini.

Membaca file properti dan memuat isinya ke Properties

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

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

Berikut ini adalah cara yang efisien untuk beralih ke a Properties

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

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

Di Java 8 untuk mendapatkan semua properti Anda

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

1) Ada baiknya memiliki file properti Anda di classpath tetapi Anda dapat menempatkannya di mana saja dalam proyek.

Di bawah ini adalah cara Anda memuat file properti dari classpath dan membaca semua properti.

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) File properti memiliki ekstensi sebagai .properties

Berikut ini cara lain untuk beralih dari properti:

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

Saya telah menulis tentang kerangka kerja properti ini selama setahun terakhir. Ini akan memberikan beberapa cara untuk memuat properti, dan meminta mereka mengetik dengan kuat juga.

Lihat http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped akan memberi pengembang properti yang sangat diketik. Mudah diintegrasikan dalam proyek yang ada. Ditangani oleh seri besar untuk tipe properti. Memberikan kemampuan untuk menginisialisasi satu baris properti melalui implementasi IO properti. Memberi pengembang kemampuan untuk membuat jenis properti dan properti milik sendiri. Demo web juga tersedia, tangkapan layar ditunjukkan di atas. Juga memiliki implementasi standar untuk ujung depan web untuk mengelola properti, jika Anda memilih untuk menggunakannya.

Dokumentasi lengkap, tutorial, javadoc, faq dll tersedia di halaman web proyek.

Kelas statis siap di sini

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

Di sini sampel:

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

Anda dapat memuat file properti dengan cara berikut:

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

Dan kemudian Anda dapat beralih di atas peta menggunakan ekspresi lambda seperti:

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

menurut pendapat saya cara lain sudah usang ketika kita bisa melakukannya dengan sangat sederhana seperti di bawah ini:

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

    @Autowired
    private Environment env;

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

}

itu sangat sederhana tetapi saya pikir itu cara terbaik !! Nikmati