web-dev-qa-db-fra.com

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

J'ai une liste de paires clé/valeur de valeurs de configuration que je souhaite stocker en tant que fichiers de propriétés Java, puis chargées et itérées ultérieurement.

Des questions:

  • Dois-je stocker le fichier dans le même package que la classe qui les chargera ou existe-t-il un emplacement spécifique où le placer?
  • Le fichier doit-il se terminer par une extension spécifique ou .txt est-il OK?
  • Comment puis-je charger le fichier dans le code
  • Et comment puis-je parcourir les valeurs à l'intérieur?
javaproperties
214
Click Upvote

Vous pouvez passer un InputStream à la propriété afin que votre fichier puisse être à peu près n'importe où et appelé n'importe quoi.

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

Itérer comme:

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

  • Vous pouvez stocker le fichier où bon vous semble. Si vous souhaitez 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 un peu plus facile.

  • Toute extension convient, bien que .properties soit plus courante dans mon expérience

  • Chargez le fichier en utilisant Properties.load en passant 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 du codage ISO-8859-1 par défaut pour un flux.)

  • Parcourez-le comme vous le feriez avec une Hashtable normale (dont Properties dérive), par ex. en utilisant keySet(). Vous pouvez également utiliser l'énumération renvoyée par propertyNames().

78
Jon Skeet

Si vous placez le fichier de propriétés dans le même package que la classe Foo, vous pouvez facilement le charger avec

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

Étant donné que Properties étend Hashtable, vous pouvez parcourir les valeurs de la même manière que dans une Hashtable.

Si vous utilisez l’extension * .properties, vous pouvez obtenir l’aide de l’éditeur, par exemple. Eclipse a un éditeur de fichier de propriétés.

26
Fabian Steeg

Il existe plusieurs façons de créer et de lire des fichiers properties:

  1. Stockez le fichier dans le même package.
  2. Recommander l’extension .properties mais vous pouvez choisir la vôtre.
  3. Utilisez ces classes situées dans Java.util package => Properties, ListResourceBundle, ResourceBundle classes.
  4. Pour lire les propriétés, utilisez l'itérateur ou l'énumérateur ou les méthodes directes de la classe Properties ou Java.lang.System.

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"));
11
adatapost

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

Cela 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'avais l'habitude de placer le fichier .properties dans un répertoire contenant 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 .properties pour des raisons de verbosité, je ne pense pas que vous devriez le nommer .properties si vous ne voulez pas.

5
Alberto Zaccagni

Lecture d’un fichier de propriétés et chargement de son contenu dans Properties

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

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

Voici le moyen efficace d'itérer sur un Properties

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

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

Les propriétés sont devenues un héritage. Préférences La classe est préférée aux propriétés.

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

Contrairement aux propriétés qui sont des paires clé-valeur basées sur une chaîne, la classe Preferences dispose de plusieurs méthodes permettant d’obtenir et de placer des données primitives dans le magasin de données Préférences. Nous ne pouvons utiliser que les types de données suivants:

  1. Chaîne
  2. booléen
  3. double
  4. float
  5. int
  6. longue
  7. tableau d'octets

Pour charger le fichier de propriétés, vous pouvez soit fournir un chemin absolu, soit utiliser getResourceAsStream() si le fichier de propriétés est présent dans votre chemin de classe.

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>

Jetez un coup d'œil à ceci article sur les composants internes du magasin de préférences

3
Ravindra babu

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)

En tant que telle, toute extension de fichier peut être utilisée pour un fichier de propriétés. En outre, le fichier peut également être stocké n’importe où, à condition que vous puissiez utiliser un FileInputStream.

Sur une note connexe, si vous utilisez un cadre moderne, celui-ci peut fournir des moyens supplémentaires d’ouvrir un fichier de propriétés. Par exemple, Spring fournit un ClassPathResource pour charger un fichier de propriétés à l'aide d'un nom de package contenu dans un fichier JAR.

En ce qui concerne l'itération à travers les propriétés, une fois que les propriétés sont chargées, elles sont stockées dans l'objet Java.util.Properties, qui propose la méthode propertyNames().

3
Thierry-Dimitri Roy

En 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 cela. Cela devrait bien fonctionner.
  4. propertyNames () vous donne une énumération à parcourir.
3
Brian Agnew

1) Il est bon d’avoir votre fichier de propriété dans classpath mais vous pouvez le placer n’importe où dans le projet.

Vous trouverez ci-dessous comment charger le fichier de propriétés à partir de classpath et 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 en tant que .properties

2
Jitender Chahar

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;
}
2
Radouane ROUFID

J'ai écrit sur ce cadre de propriété pour la dernière année. Il fournira de multiples façons de charger les propriétés et de les avoir également fortement typées.

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

JHPropertiesTyped donnera au développeur des propriétés fortement typées. Facile à intégrer dans des projets existants. Géré par une grande série pour les types de propriété. Permet d'initialiser des propriétés sur une ligne via les implémentations de la propriété IO. Donne au développeur la possibilité de créer ses propres types de propriétés et leurs propriétés io. La démo Web est également disponible, les captures d'écran ci-dessus. Ayez également une implémentation standard pour un serveur Web pour gérer les propriétés, si vous choisissez de l’utiliser.

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

1
FrederikH

Voici un autre moyen de parcourir 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); 
}
1
dertoni

Ici classe statique prête

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

Voici un échantillon:

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