Comment utiliser les fichiers de propriétés Java?

• vous can conservez le fichier où vous voulez. Si vous voulez le conserver dans votre fichier jar, vous devrez utiliser Class.getResourceAsStream() ou ClassLoader.getResourceAsStream() pour y accéder. Si c'est sur le système de fichiers, c'est légèrement plus facile.

• toute extension est bien, bien que .propriétés est plus fréquente dans mon expérience

• chargez le fichier en utilisant Properties.load , en passant dans un InputStream ou un StreamReader si vous utilisez Java 6. (Si vous êtes en utilisant Java 6, j'utiliserais probablement UTF-8 et un Reader au lieu de l'encodage ISO-8859-1 par défaut pour un flux.)

• Itérer dessus comme vous le feriez itérer normale Hashtable (qui Properties dérive de), par exemple à l'aide de keySet() . Vous pouvez également utiliser le dénombrement retourné par propertyNames() .

si vous mettez le fichier de propriétés dans le même paquet Que class Foo, vous pouvez facilement le charger avec

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

étant donné que Properties extends Hashtable vous pouvez itérer sur les valeurs de la même manière que vous le feriez dans un Hashtable.

si vous utilisez le *.extension de propriétés Vous pouvez obtenir le soutien d'éditeur, par exemple Eclipse a un éditeur de fichiers de propriétés.

il y a plusieurs façons de créer et de lire properties fichiers:

1. conservez le fichier dans le même paquet.
2. Recommander .properties extension cependant, vous pouvez choisir votre propre.
3. utiliser les classes situées sur le colis java.util => Properties , ListResourceBundle , ResourceBundle les cours.
4. pour lire les propriétés, utiliser iterator ou enumerator ou les méthodes directes de Properties ou java.lang.System de la classe.

ResourceBundle classe:

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

Properties classe:

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

cette charge le fichier de propriétés:

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

j'utilise pour mettre le .fichier de propriétés dans un répertoire où j'ai tous les fichiers de configuration, Je ne le mets pas avec la classe qui y accède, mais il n'y a pas de restrictions ici.

pour le nom... J'utilise .propriétés pour la verbosité, Je ne pense pas que vous devriez le nommer .propriétés si vous ne souhaitez pas.

exemple:

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

dans l'ordre:

1. vous pouvez stocker le fichier à peu près n'importe où.
2. aucune extension n'est nécessaire.
3. Montecristo a illustré comment charger ceci. Qui devrait fonctionner correctement.
4. propertyNames () vous donne une énumération pour itérer à travers.

par défaut, Java l'ouvre dans le répertoire de travail de votre application (ce comportement dépend en fait du système D'exploitation utilisé). Pour charger un fichier, faites:

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

comme tel, n'importe quelle extension de fichier peut être utilisée pour le fichier de propriété. En outre, le fichier peut également être stocké n'importe où, tant que vous pouvez utiliser un FileInputStream .

sur une note connexe si vous utilisez un framework moderne, le framework peut fournir des moyens supplémentaires d'ouvrir un fichier de propriété. Pour exemple, Spring fournir un ClassPathResource pour charger un fichier de propriété en utilisant un nom de paquet à l'intérieur d'un fichier JAR.

quant à l'itération à travers les propriétés, une fois les propriétés chargées, elles sont stockées dans l'objet java.util.Properties , qui offre la méthode propertyNames() .

propriétés est devenu héritage. Préférences la classe est préféré Propriétés.

un noeud dans une collection hiérarchique de données de préférence. Cette classe permet aux applications de stocker et de récupérer les préférences de l'utilisateur et du système et les données de configuration. Ces données sont stockées de manière constante dans un support de stockage dépendant de l'implémentation. Les implémentations typiques incluent des fichiers plats, des registres spécifiques à OS, des serveurs de répertoires et SQL les bases de données. L'utilisateur de cette classe n'a pas besoin de se préoccuper des détails du backing store.

Contrairement aux propriétés qui sont des paires de valeurs clés basées sur des chaînes de caractères, la classe Preferences a plusieurs méthodes utilisées pour obtenir et mettre des données primitives dans les préférences data store. Nous ne pouvons utiliser que les types de données suivants:

1. Chaîne
2. boolean
3. double
4. float
5. int
6. long
7. tableau d'octets

pour charger le fichier de propriétés, soit vous pouvez fournir absolute path ou utiliser getResourceAsStream() si le fichier de propriétés est présent dans votre 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();
        }
    }
}

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

Avoir un oeil à cette article sur le fonctionnement interne des préférences magasin

lecture d'un fichier de propriétés et chargement de son contenu en Properties

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

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

ce qui suit est le moyen efficace pour itérer sur un Properties

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

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

1) Il est bon d'avoir votre dossier de biens dans classpath, mais vous pouvez le placer n'importe où dans le projet.

vous trouverez ci-dessous la façon de charger un fichier de propriétés à partir de classpath et de lire toutes les propriétés.

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) les fichiers de propriétés ont l'extension as .propriétés

Dans Java 8 pour obtenir toutes vos propriétés

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

Voici une autre façon d'itérer sur les propriétés:

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

j'ai écrit sur ce cadre de propriété pour la dernière année. Il fournira de multiples façons de charger des propriétés, et les ont fortement typé.

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

JHPropertiesTyped donnera au développeur des propriétés fortement typées. Facile à intégrer dans les projets existants. Manipulé par une grande série pour les types de propriétés. Donne la capacité d'une ligne initialiser les propriétés via les implémentations de la propriété IO. Donne au développeur la capacité de créer ses propres types de propriétés et io propriétés. La démo Web est également disponible, screenshots montré ci-dessus. Vous disposez également d'une implémentation standard pour une interface web pour gérer les propriétés, si vous choisissez de l'utiliser.

documentation complète, tutoriel, javadoc, faq etc est disponible sur la page Web du projet.