Jak korzystać z plików właściwości Java?

• Możesz przechowywać plik w dowolnym miejscu. Jeśli chcesz zachować go w pliku jar, użyj Class.getResourceAsStream() lub ClassLoader.getResourceAsStream(), Aby uzyskać do niego dostęp. Jeśli jest w systemie plików, jest to nieco łatwiejsze.

• Chociaż każde rozszerzenie jest w porządku .właściwości jest bardziej powszechne w moim doświadczeniu

• Wczytaj plik używając Properties.load, przekazując InputStream lub StreamReader, Jeśli używasz Java 6. (Jeśli używasz Javy 6, prawdopodobnie użyłbym UTF-8 i Reader zamiast domyślnego kodowania ISO-8859-1 dla strumienia.)

• Iteracja przez nią tak, jak przez normalną Hashtable (z której Properties wynika), np. za pomocą keySet(). Alternatywnie można użyć wyliczenia zwracanego przez propertyNames().

Jeśli umieścisz Plik Właściwości w tym samym pakiecie co Klasa Foo, możesz go łatwo załadować za pomocą

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

Biorąc pod uwagę, że właściwości rozszerzają tabelę Hashtable, możesz iterować wartości w taki sam sposób, jak w tabeli Hashtable.

Jeśli używasz *.rozszerzenie właściwości można uzyskać wsparcie edytora, np. Eclipse posiada edytor właściwości.

Istnieje wiele sposobów tworzenia i odczytywania plików properties:

1. przechowuj plik w tym samym pakiecie.
2. Poleć rozszerzenie .properties jednak możesz wybrać własne.
3. użyj tych klas znajdujących się w java.util pakiecie => Properties, ListResourceBundle, ResourceBundle klasy.
4. aby odczytać właściwości, użyj iteratora lub enumeratora lub bezpośrednich metod klasy Properties lub java.lang.System.

ResourceBundle Klasa:

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

Properties Klasa:

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

To wczytuje Plik Właściwości:

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

Używam, aby umieścić .Plik Właściwości w katalogu, w którym mam wszystkie pliki konfiguracyjne, nie umieszczam go razem z klasą, która ma do niego dostęp, ale nie ma tutaj żadnych ograniczeń.

Na imię... Używam .właściwości ze względu na gadatliwość, myślę, że nie powinieneś tego nazywać .właściwości, jeśli nie chcesz.

Przykład:

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

W kolejności:

1. Plik można przechowywać praktycznie wszędzie.
2. nie jest konieczne rozszerzenie.
3. Montecristo ma zilustrowane Jak to załadować. To powinno zadziałać.
4. propertyNames () daje wyliczenie do iteracji.

Domyślnie Java otwiera go w katalogu roboczym aplikacji (to zachowanie zależy od używanego systemu operacyjnego). Aby załadować plik, wykonaj:

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

Jako takie, każde rozszerzenie pliku może być używane dla pliku właściwości. Dodatkowo plik może być przechowywany w dowolnym miejscu, o ile można użyć FileInputStream.

Jeśli używasz nowoczesnego frameworka, framework może dostarczyć dodatkowych sposobów otwarcia pliku właściwości. Na przykład, Spring dostarcza ClassPathResource do załadowania pliku właściwości używanie nazwy pakietu z pliku JAR.

Jeśli chodzi o iterację poprzez właściwości, po załadowaniu właściwości są one przechowywane w obiekcie java.util.Properties, który oferuje metodę propertyNames().

Właściwości stały się dziedzictwem. Preferencje klasa jest preferowana do Właściwości.

Węzeł w hierarchicznym zbiorze danych preferencji. Klasa ta pozwala aplikacjom na przechowywanie i pobieranie preferencji użytkownika i systemu oraz danych konfiguracyjnych. Dane te są przechowywane w magazynie zapasowym zależnym od implementacji. Typowe implementacje obejmują pliki płaskie, rejestry specyficzne dla systemu operacyjnego, serwery katalogów i bazy danych SQL. Użytkownik tej klasy nie musi być / align = "left" /

W przeciwieństwie do właściwości, które są parami klucz-wartość, klasa Preferences ma kilka metod używanych do pobierania i umieszczania prymitywnych danych w magazynie danych preferencji. Możemy używać tylko następujących typów danych:

1. String
2. boolean
3. double
4. float
5. int
6. long
7. tablica bajtów

Aby załadować plik właściwości, możesz podać ścieżkę bezwzględną lub użyj getResourceAsStream(), Jeśli plik właściwości jest obecny w twojej ścieżce 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();
        }
    }
}

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

Odczyt pliku właściwości i załadowanie jego zawartości do Properties

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

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

Poniżej znajduje się efektywny sposób iteracji Properties

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

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

1) dobrze jest mieć Plik Właściwości w classpath, ale można go umieścić w dowolnym miejscu w projekcie.

Poniżej znajduje się sposób wczytywania pliku właściwości z classpath i odczytywania wszystkich właściwości.

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) pliki właściwości mają rozszerzenie as .właściwości

W Java 8 aby uzyskać wszystkie swoje właściwości

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

Oto inny sposób iteracji nad właściwościami:

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

Pisałem o tej ramie własności przez ostatni rok. Zapewni wiele sposobów ładowania właściwości i będzie je również mocno wpisywać.

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

JHPropertiesTyped da deweloperowi mocno wpisane właściwości. Łatwa integracja z istniejącymi projektami. Obsługiwane przez dużą serię dla typów nieruchomości. Daje możliwość jednokierunkowej inicjalizacji właściwości poprzez właściwość IO wdrożenia. Daje deweloperowi możliwość tworzenia własnych typów nieruchomości i właściwości io. Dostępne jest również demo internetowe, zrzuty ekranu pokazane powyżej. Mają również standardową implementację front-end sieci Web do zarządzania właściwościami, jeśli zdecydujesz się go używać.

Pełna dokumentacja, tutorial, javadoc, faq itp. jest dostępna na stronie projektu.