¿Cuál es la forma más fácil de analizar un archivo INI en Java?

Question

Estoy escribiendo un reemplazo directo para una aplicación heredada en Java. Uno de los requisitos es que los archivos ini que utilizó la aplicación anterior se deben leer tal cual en la nueva aplicación Java. El formato de estos archivos ini es el estilo de ventana común, con secciones de encabezado y pares clave = valor, usando # como el carácter para comentar.

He intentado utilizar la clase de propiedades de Java, pero por supuesto que no funcionará si hay conflictos de nombres entre diferentes encabezados.

Entonces la pregunta es, ¿cuál sería la forma más fácil de leer en este archivo INI y acceder a las claves?

Answer 1

La biblioteca que he usado es ini4j. Es liviano y analiza los archivos ini con facilidad. También se utiliza sin dependencias esotéricos a otras 10.000 archivos jar, como uno de los objetivos de diseño era utilizar sólo el API estándar de Java

Este es un ejemplo de cómo se usa la biblioteca:

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

Otra opción es Apache Commons Config también tiene una clase para cargar desde INI files. Tiene algunos runtime dependencies, pero para los archivos INI solo debería requerir colecciones Commons, lang y logging.

He usado Commons Config en proyectos con sus propiedades y configuraciones XML. Es muy fácil de usar y admite algunas funciones bastante potentes.

Answer 3

O con la API estándar de Java puede utilizar java.util.Properties:

new Properties() props = rowProperties.load(new FileInputStream(path)); 

Answer 4

Aquí es un simple pero potente ejemplo, mediante la clase Apache 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"); 
} 

Commons configuración tiene un número de runtime dependencies. Como mínimo, se requieren commons-lang y commons-logging. Dependiendo de lo que esté haciendo con él, es posible que necesite bibliotecas adicionales (consulte el enlace anterior para obtener más información).

Answer 5

Como mentioned, ini4j se puede utilizar para lograr esto. Déjame mostrar otro ejemplo.

Si tenemos un archivo INI así:

[header] 
key = value 

Lo siguiente debe mostrar value a STDOUT:

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

Comprobar the tutorials para más ejemplos.

Answer 6

Puede probar JINIFile. Es una traducción de la TIniFile de Delphi, pero para java

https://github.com/SubZane/JIniFile

Answer 7

tan simple como 80 líneas:

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 8

yo personalmente prefiero Confucious.

Es bueno, ya que no requiere ninguna dependencia externa, es pequeño, solo 16K, y carga automáticamente su archivo ini en la inicialización. P.ej.

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

Answer 9

En 19 líneas, extendiendo el java.util.Properties a analizar en varias secciones:

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("]")) 
       result.put(header.substring(1, header.length() - 1), 
         section = new Properties()); 
      else 
       section.put(key, value); 
      return null; 
     } 

    }.load(reader); 
    return result; 
}