Was ist der einfachste Weg, eine INI-Datei in Java zu analysieren?

Ich schreibe einen Drop-In-Ersatz für eine Legacy-Anwendung in Java. Eine der Anforderungen ist, dass die INI-Dateien, die die ältere Anwendung verwendet, unverändert in die neue Java-Anwendung eingelesen werden müssen. Das Format dieser INI-Dateien ist der übliche Windows-Stil mit Kopfzeilenabschnitten und Schlüssel-Wert-Paaren, wobei # als Zeichen für das Kommentieren verwendet wird.

Ich habe versucht, die Properties-Klasse aus Java zu verwenden, aber das funktioniert natürlich nicht, wenn zwischen verschiedenen Headern Namenskonflikte auftreten.

Die Frage ist also, wie Sie diese INI-Datei am einfachsten einlesen und auf die Schlüssel zugreifen können.

Die Bibliothek, die ich benutzt habe, ist ini4j . Es ist leicht und analysiert die INI-Dateien mit Leichtigkeit. Außerdem werden keine esoterischen Abhängigkeiten zu 10.000 anderen JAR-Dateien verwendet, da eines der Entwurfsziele darin bestand, nur die Standard-Java-API zu verwenden

Dies ist ein Beispiel für die Verwendung der Bibliothek:

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

Wie bereits erwähnt , kann ini4j verwendet werden, um dies zu erreichen. Lassen Sie mich ein weiteres Beispiel zeigen.

Wenn wir eine INI-Datei wie diese haben:

[header]
key = value

Für valueSTDOUT sollte Folgendes angezeigt werden:

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

Weitere Beispiele finden Sie in den Tutorials .

So einfach wie 80 Zeilen:

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

Hier ist ein einfaches, aber leistungsstarkes Beispiel mit der Apache-Klasse HierarchicalINIConfiguration :

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

Die Commons-Konfiguration weist eine Reihe von Laufzeitabhängigkeiten auf . Zumindest sind commons-lang und commons-logging erforderlich. Je nachdem, was Sie damit machen, benötigen Sie möglicherweise zusätzliche Bibliotheken (Details siehe vorherigen Link).

Oder mit der Standard-Java-API können Sie java.util.Properties verwenden :

Properties props = new Properties();
try (FileInputStream in = new FileInputStream(path)) {
    props.load(in);
}

In 18 Zeilen wird das java.util.PropertiesParsen in mehrere Abschnitte erweitert:

public static Map<String, Properties> parseINI(Reader reader) throws IOException {
    Map<String, Properties> result = new HashMap();
    new Properties() {

        private Properties section;

        @Override
        public Object put(Object key, Object value) {
            String header = (((String) key) + " " + value).trim();
            if (header.startsWith("[") && header.endsWith("]"))
                return result.put(header.substring(1, header.length() - 1), 
                        section = new Properties());
            else
                return section.put(key, value);
        }

    }.load(reader);
    return result;
}

Eine weitere Option ist, dass Apache Commons Config auch eine Klasse zum Laden aus INI-Dateien hat . Es gibt einige Laufzeitabhängigkeiten , aber für INI-Dateien sollten nur Commons-Sammlungen, lang und Protokollierung erforderlich sein.

Ich habe Commons Config für Projekte mit ihren Eigenschaften und XML-Konfigurationen verwendet. Es ist sehr einfach zu bedienen und unterstützt einige ziemlich mächtige Funktionen.

Sie könnten JINIFile versuchen. Ist eine Übersetzung des TIniFile aus Delphi, aber für Java

https://github.com/SubZane/JIniFile

Ich persönlich bevorzuge Konfuzious .

Es ist schön, da es keine externen Abhängigkeiten erfordert, es ist winzig - nur 16 KB, und lädt Ihre INI-Datei bei der Initialisierung automatisch. Z.B

Configurable config = Configuration.getInstance();  
String host = config.getStringValue("host");   
int port = config.getIntValue("port"); 
new Connection(host, port);

Die Lösung von hoat4 ist sehr elegant und einfach. Es funktioniert für alle vernünftigen INI-Dateien. Ich habe jedoch viele gesehen, die nicht maskierte Leerzeichen im Schlüssel haben .
Um dies zu lösen, habe ich eine Kopie von heruntergeladen und geändert java.util.Properties. Obwohl dies ein wenig unorthodox und kurzfristig ist, waren die eigentlichen Mods nur ein paar Zeilen und recht einfach. Ich werde der JDK-Community einen Vorschlag unterbreiten, um die Änderungen aufzunehmen.

Durch Hinzufügen einer internen Klassenvariablen:

private boolean _spaceCharOn = false;

Ich steuere die Verarbeitung im Zusammenhang mit dem Scannen nach dem Schlüssel / Wert-Trennungspunkt. Ich habe den Suchcode für Leerzeichen durch eine kleine private Methode ersetzt, die abhängig vom Status der obigen Variablen einen Booleschen Wert zurückgibt.

private boolean isSpaceSeparator(char c) {
    if (_spaceCharOn) {
        return (c == ' ' || c == '\t' || c == '\f');
    } else {
        return (c == '\t' || c == '\f');
    }
}

Diese Methode wird an zwei Stellen innerhalb der privaten Methode verwendet load0(...).
Es gibt auch eine öffentliche Methode zum Einschalten. Es ist jedoch besser, die Originalversion von zu verwenden, Propertieswenn das Leerzeichen für Ihre Anwendung kein Problem darstellt.

Bei Interesse bin ich bereit, den Code in meine IniFile.javaDatei aufzunehmen. Es funktioniert mit beiden Versionen von Properties.

Durch die Antwort von @Aerospace wurde mir klar, dass es für INI-Dateien legitim ist, Abschnitte ohne Schlüsselwerte zu haben. In diesem Fall sollte das Hinzufügen zur Top-Level-Map erfolgen, bevor Schlüsselwerte gefunden werden, z. B. (für Java 8 minimal aktualisiert):

            Path location = ...;
            try (BufferedReader br = new BufferedReader(new FileReader(location.toFile()))) {
                String line;
                String section = null;
                while ((line = br.readLine()) != null) {
                    Matcher m = this.section.matcher(line);
                    if (m.matches()) {
                        section = m.group(1).trim();
                        entries.computeIfAbsent(section, k -> new HashMap<>());
                    } else if (section != null) {
                        m = keyValue.matcher(line);
                        if (m.matches()) {
                            String key = m.group(1).trim();
                            String value = m.group(2).trim();
                            entries.get(section).put(key, value);
                        }
                    }
                }
            } catch (IOException ex) {
                System.err.println("Failed to read and parse INI file '" + location + "', " + ex.getMessage());
                ex.printStackTrace(System.err);
            }

So einfach ist das .....

//import java.io.FileInputStream;
//import java.io.FileInputStream;

Properties prop = new Properties();
//c:\\myapp\\config.ini is the location of the ini file
//ini file should look like host=localhost
prop.load(new FileInputStream("c:\\myapp\\config.ini"));
String host = prop.getProperty("host");