En Java, l'accès aux données stockées dans des fichiers .properties s'articule généralement autour de deux approches majeures : l'utilisation de la classe java.util.Properties via un flux d'entrée (InputStream), et l'utilisation de la classe java.util.ResourceBundle. Le choix de la méthode dépend principalement de l'emplacement du fichier et du contexte d'exécution.

1. Chargement via FileInputStream (Chemin absolu ou relatif au projet)

Cette méthode utilise un flux binaire satndard pour lire le fichier à partir du système de fichiers.

public String loadByFileStream(String path) {
   Properties config = new Properties();
   try (FileInputStream fis = new FileInputStream(path)) {
       config.load(fis);
       return config.getProperty("db.user");
   } catch (IOException e) {
       e.printStackTrace();
   }
   return null;
}

2. Utilisation de Class.getResourceAsStream()

Cette approche rehcerche le fichier par rapport à l'emplacement de la classe spécifiée. Si le chemin commence par un "/", il est résolu depuis la racine du classpath.

public String loadViaClassContext() {
   Properties config = new Properties();
   try (InputStream is = ConfigLoader.class.getResourceAsStream("/config/settings.properties")) {
       config.load(is);
       return config.getProperty("db.user");
   } catch (IOException e) {
       e.printStackTrace();
   }
   return null;
}

3. Utilisation de ClassLoader.getResourceAsStream()

Contrairement à la méthode précédente, le ClassLoader charge toujours les ressources relativement à la racine du classpath. Il ne faut pas utiliser de "/" initial.

public String loadViaClassLoader() {
   Properties config = new Properties();
   InputStream is = this.getClass().getClassLoader().getResourceAsStream("config/settings.properties");
   try {
       if (is != null) {
           config.load(is);
           return config.getProperty("db.user");
       }
   } catch (IOException e) {
       e.printStackTrace();
   }
   return null;
}

4. Utilisation de ClassLoader.getSystemResourceAsStream()

Il s'agit d'une méthode statique qui utilise le chargeur de classes du système pour lcoaliser la ressource.

public String loadBySystemLoader() {
   Properties config = new Properties();
   try (InputStream is = ClassLoader.getSystemResourceAsStream("config/settings.properties")) {
       if (is != null) {
           config.load(is);
           return config.getProperty("db.user");
       }
   } catch (IOException e) {
       e.printStackTrace();
   }
   return null;
}

5. Chargement via ResourceBundle.getBundle()

Cette méthode est optimisée pour l'internationalisation (i18n). Elle ne nécessite pas l'extension .properties et utilise des points comme séparateurs de paquets.

public String loadByResourceBundle() {
   // Charge le fichier config/settings.properties
   ResourceBundle bundle = ResourceBundle.getBundle("config.settings");
   return bundle.getString("db.password");
}

6. Utilisation de PropertyResourceBundle

Cette classe est une implémentation spécifique de ResourceBundle qui permet de créer un bundle à partir d'un flux d'octets.

public String loadByPropertyBundle(String path) {
   try (FileInputStream fis = new FileInputStream(path)) {
       ResourceBundle bundle = new PropertyResourceBundle(fis);
       return bundle.getString("db.alias");
   } catch (IOException e) {
       e.printStackTrace();
   }
   return null;
}

Exemple de fichier de configuration (settings.properties)

db.user=admin
db.alias=main_auth
db.password=secret123

Comparatif des syntaxes de chemins