Quel est le moyen le plus simple d'analyser un fichier INI en Java ?

Question

Je suis en train d'écrire un remplacement immédiat d'une ancienne application en Java. L'une des exigences est que les fichiers ini que l'ancienne application utilisait doivent être lus tels quels dans la nouvelle application Java. Le format de ces fichiers ini est le style commun de Windows, avec des sections d'en-tête et des paires clé=valeur, en utilisant # comme caractère de commentaire.

J'ai essayé d'utiliser la classe Properties de Java, mais bien sûr, cela ne fonctionnera pas s'il y a des conflits de noms entre les différents en-têtes.

La question est donc la suivante : quel serait le moyen le plus simple de lire ce fichier INI et d'accéder aux clés ?

Answer 1

La bibliothèque que j'ai utilisée est ini4j . Il est léger et analyse les fichiers ini avec facilité. Il n'utilise pas non plus de dépendances ésotériques vers 10 000 autres fichiers jar, car l'un des objectifs de la conception était d'utiliser uniquement l'API Java standard.

Voici un exemple de l'utilisation de la bibliothèque :

Ini ini = new Ini(new File(filename));
java.util.prefs.Preferences prefs = new IniPreferences(ini);
System.out.println("grumpy/homePage: " + prefs.node("grumpy").get("homePage", null));

Answer 2

Comme mentionné , ini4j peut être utilisé pour y parvenir. Permettez-moi de vous montrer un autre exemple.

Si nous avons un fichier INI comme celui-ci :

[header]
key = value

Le texte suivant devrait s'afficher value vers STDOUT :

Ini ini = new Ini(new File("/path/to/file"));
System.out.println(ini.get("header", "key"));

Vérifiez les didacticiels pour d'autres exemples.

Answer 3

Aussi simple que 80 lignes :

package windows.prefs;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class IniFile {

   private Pattern  _section  = Pattern.compile( "\\s*\\[([^]]*)\\]\\s*" );
   private Pattern  _keyValue = Pattern.compile( "\\s*([^=]*)=(.*)" );
   private Map< String,
      Map< String,
         String >>  _entries  = new HashMap<>();

   public IniFile( String path ) throws IOException {
      load( path );
   }

   public void load( String path ) throws IOException {
      try( BufferedReader br = new BufferedReader( new FileReader( path ))) {
         String line;
         String section = null;
         while(( line = br.readLine()) != null ) {
            Matcher m = _section.matcher( line );
            if( m.matches()) {
               section = m.group( 1 ).trim();
            }
            else if( section != null ) {
               m = _keyValue.matcher( line );
               if( m.matches()) {
                  String key   = m.group( 1 ).trim();
                  String value = m.group( 2 ).trim();
                  Map< String, String > kv = _entries.get( section );
                  if( kv == null ) {
                     _entries.put( section, kv = new HashMap<>());   
                  }
                  kv.put( key, value );
               }
            }
         }
      }
   }

   public String getString( String section, String key, String defaultvalue ) {
      Map< String, String > kv = _entries.get( section );
      if( kv == null ) {
         return defaultvalue;
      }
      return kv.get( key );
   }

   public int getInt( String section, String key, int defaultvalue ) {
      Map< String, String > kv = _entries.get( section );
      if( kv == null ) {
         return defaultvalue;
      }
      return Integer.parseInt( kv.get( key ));
   }

   public float getFloat( String section, String key, float defaultvalue ) {
      Map< String, String > kv = _entries.get( section );
      if( kv == null ) {
         return defaultvalue;
      }
      return Float.parseFloat( kv.get( key ));
   }

   public double getDouble( String section, String key, double defaultvalue ) {
      Map< String, String > kv = _entries.get( section );
      if( kv == null ) {
         return defaultvalue;
      }
      return Double.parseDouble( kv.get( key ));
   }
}

Answer 4

Voici un exemple simple, mais puissant, utilisant la classe apache Configuration hiérarchique de l'INIC :

HierarchicalINIConfiguration iniConfObj = new HierarchicalINIConfiguration(iniFile); 

// Get Section names in ini file     
Set setOfSections = iniConfObj.getSections();
Iterator sectionNames = setOfSections.iterator();

while(sectionNames.hasNext()){

 String sectionName = sectionNames.next().toString();

 SubnodeConfiguration sObj = iniObj.getSection(sectionName);
 Iterator it1 =   sObj.getKeys();

    while (it1.hasNext()) {
    // Get element
    Object key = it1.next();
    System.out.print("Key " + key.toString() +  " Value " +  
                     sObj.getString(key.toString()) + "\n");
}

La configuration commune comporte un certain nombre de dépendances d'exécution . Au minimum, commons-lang et commons-logging sont nécessaires. Selon l'utilisation que vous en faites, vous pouvez avoir besoin de bibliothèques supplémentaires (voir le lien précédent pour plus de détails).

Answer 5

Ou avec les API standard de Java, vous pouvez utiliser java.util.Properties: