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 les charger et les parcourir.

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ù il devrait être placé?
• Le fichier doit-il se terminer par une extension spécifique ou est-il .txtcorrect?
• Comment puis-je charger le fichier dans le code
• Et comment puis-je parcourir les valeurs à l'intérieur?

Vous pouvez passer un InputStream à la propriété, de sorte que votre fichier peut ê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) {
  ...
}

Répéter comme:

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

• Vous pouvez stocker le fichier où vous le souhaitez. Si vous souhaitez le conserver dans votre fichier jar, vous devrez l'utiliser Class.getResourceAsStream()ou ClassLoader.getResourceAsStream()y accéder. Si c'est sur le système de fichiers c'est un peu plus facile.

• Toute extension est correcte, bien que .properties soit plus courant dans mon expérience

• Chargez le fichier en utilisant Properties.load, en passant dans un InputStreamou StreamReadersi vous utilisez Java 6. (Si vous êtes utilisez Java 6, je serais probablement utiliser UTF-8 et au Readerlieu de la valeur par défaut ISO-8859-1 pour un flux. )

• Parcourez-le comme vous le feriez à travers une normale Hashtable(qui Propertiesdérive de), par exemple en utilisant keySet(). Vous pouvez également utiliser l'énumération renvoyée par propertyNames().

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 Propriétés étend la table de hachage, vous pouvez parcourir les valeurs de la même manière que vous le feriez dans une table de hachage.

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

Il existe de nombreuses façons de créer et de lire des propertiesfichiers:

1. Stockez le fichier dans le même package.
2. Recommander l' .propertiesextension mais vous pouvez choisir la vôtre.
3. Utiliser les classes de thèses situées au java.utilpackage => Properties, ListResourceBundle, ResourceBundleclasses.
4. Pour lire les propriétés, utilisez l'itérateur ou l'énumérateur ou les méthodes directes de Propertiesou la java.lang.Systemclasse.

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

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'utilise pour mettre le fichier .properties 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 .properties pour la verbosité, je ne pense pas que vous devriez le nommer .properties si vous ne voulez 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);

Les propriétés sont devenues un héritage. La classe Préférences 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 les préférences utilisateur et système et les données de configuration. Ces données sont stockées de manière persistante dans un magasin de sauvegarde dépendant de l'implémentation. Les implémentations typiques incluent les fichiers plats, les registres spécifiques au système d'exploitation, les serveurs d'annuaire 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 sauvegarde.

Contrairement aux propriétés qui sont des paires clé-valeur basées sur des chaînes, la Preferencesclasse a plusieurs méthodes utilisées pour obtenir et 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. flotte
5. int
6. longue
7. tableau d'octets

Pour charger le fichier de propriétés, vous pouvez fournir un chemin absolu ou 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 œil à cet article sur les internes du magasin de préférences

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.

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, procédez comme suit:

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

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

Sur une note connexe, si vous utilisez un cadre moderne, le cadre peut fournir des moyens supplémentaires d'ouvrir un fichier de propriétés. Par exemple, Spring fournit un ClassPathResourcepour charger un fichier de propriétés à l'aide d'un nom de package à l'intérieur d'un fichier JAR.

Quant à parcourir les propriétés, une fois les propriétés chargées, elles sont stockées dans l' java.util.Propertiesobjet qui propose la propertyNames()méthode.

Lire un fichier de propriétés et charger son contenu dans 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 d'itérer sur un Properties

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

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

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

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

Voici comment charger le fichier de propriétés à partir du chemin de classe 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 .properties

Voici une autre façon d'itérer 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 l'année dernière. Il fournira plusieurs façons de charger les propriétés et les aura également fortement tapées.

Jetez un œil à http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped donnera au développeur des propriétés fortement typées. Facile à intégrer dans les projets existants. Géré par une grande série de types de propriétés. Donne la possibilité d'initialiser une ligne de propriétés via des implémentations d'E / S de propriété. Donne au développeur la possibilité de créer ses propres types de propriété et io de propriété. Une démo Web est également disponible, captures d'écran illustrées ci-dessus. Ayez également une implémentation standard pour un frontal 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.

Voici la 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 exemple:

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

Vous pouvez charger le fichier de propriétés de la manière suivante:

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

Et puis vous pouvez parcourir la carte en utilisant une expression lambda comme:

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

à mon avis, d'autres moyens sont déconseillés lorsque nous pouvons le faire très simplement comme ci-dessous:

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

    @Autowired
    private Environment env;

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

}

c'est tellement simple mais je pense que c'est la meilleure façon !! Prendre plaisir