¿Cómo usar los archivos de propiedades de Java?

Tengo una lista de pares clave / valor de valores de configuración que quiero almacenar como archivos de propiedades Java, y luego cargar e iterar.

Preguntas:

  • ¿Debo guardar el archivo en el mismo paquete que la clase que los cargará, o hay alguna ubicación específica donde debería colocarse?
  • ¿El archivo debe terminar en una extensión específica o está .txt OK?
  • ¿Cómo puedo cargar el archivo en el código?
  • ¿Y cómo puedo repetir los valores en el interior?

Puede pasar un InputStream a la propiedad, por lo que su archivo puede estar prácticamente en cualquier lugar, y puede llamar a cualquier cosa.

 Properties properties = new Properties(); try { properties.load(new FileInputStream("path/filename")); } catch (IOException e) { ... } 

Iteramos como:

 for(String key : properties.stringPropertyNames()) { String value = properties.getProperty(key); System.out.println(key + " => " + value); } 
  • Puede almacenar el archivo en cualquier lugar que desee. Si desea mantenerlo en su archivo jar, querrá usar Class.getResourceAsStream() o ClassLoader.getResourceAsStream() para acceder a él. Si está en el sistema de archivos, es un poco más fácil.

  • Cualquier extensión está bien, aunque .properties es más común en mi experiencia

  • Cargue el archivo usando Properties.load , pasando un InputStream o un StreamReader si está usando Java 6. (Si está usando Java 6, probablemente use UTF-8 y un Reader lugar del predeterminado ISO-8859- 1 encoding para una transmisión).

  • Itere a través de él como lo haría a través de una Hashtable normal (de la que se derivan las Properties ), por ejemplo, usando keySet() . Alternativamente, puede usar la enumeración devuelta por propertyNames() .

Si coloca el archivo de propiedades en el mismo paquete que la clase Foo, puede cargarlo fácilmente con

 new Properties().load(Foo.class.getResourceAsStream("file.properties")) 

Dado que Properties extends Hashtable puede iterar sobre los valores de la misma manera que lo haría en una Hashtable.

Si usa la extensión * .properties, puede obtener compatibilidad con el editor, por ejemplo, Eclipse tiene un editor de archivos de propiedades.

Hay muchas maneras de crear y leer archivos de properties :

  1. Almacene el archivo en el mismo paquete.
  2. Recomienda la extensión .properties sin embargo, puede elegir la suya propia.
  3. Utilice estas clases ubicadas en java.util package => Properties , ListResourceBundle , ResourceBundle classes.
  4. Para leer propiedades, use el iterador o el enumerador o los métodos directos de las Properties o la clase java.lang.System .

Clase ResourceBundle :

  ResourceBundle rb = ResourceBundle.getBundle("prop"); // prop.properties System.out.println(rb.getString("key")); 

Clase de Properties :

 Properties ps = new Properties(); ps.Load(new java.io.FileInputStream("my.properties")); 

Esto carga el archivo de propiedades:

 Properties prop = new Properties(); InputStream stream = ...; //the stream to the file try { prop.load(stream); } finally { stream.close(); } 

Utilizo para poner el archivo .properties en un directorio donde tengo todos los archivos de configuración, no lo pongo junto con la clase que accede a él, pero aquí no hay restricciones.

Para el nombre … Utilizo .properties para verbosity sake, no creo que deba nombrarlo .properties si no lo desea.

Ejemplo:

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

En orden:

  1. Puede almacenar el archivo prácticamente en cualquier lugar.
  2. ninguna extensión es necesaria.
  3. Montecristo ha ilustrado cómo cargar esto. Eso debería funcionar bien.
  4. propertyNames () te da una enumeración para iterar.

Por defecto, Java lo abre en el directorio de trabajo de su aplicación (este comportamiento en realidad depende del SO utilizado). Para cargar un archivo, hazlo:

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

Como tal, cualquier extensión de archivo se puede usar para el archivo de propiedades. Además, el archivo también se puede almacenar en cualquier lugar, siempre que pueda usar un FileInputStream .

En una nota relacionada si utiliza un marco moderno, el marco puede proporcionar formas adicionales de abrir un archivo de propiedades. Por ejemplo, Spring proporciona un ClassPathResource para cargar un archivo de propiedad usando un nombre de paquete desde dentro de un archivo JAR.

En cuanto a la iteración a través de las propiedades, una vez que se cargan las propiedades, se almacenan en el objeto java.util.Properties , que ofrece el método propertyNames() .

Las propiedades se han convertido en legado. La clase de preferencias es preferible a las Propiedades.

Un nodo en una colección jerárquica de datos de preferencia. Esta clase permite a las aplicaciones almacenar y recuperar preferencias de usuario y sistema y datos de configuración. Esta información se almacena de forma persistente en una tienda de respaldo dependiente de la implementación. Las implementaciones típicas incluyen archivos planos, registros específicos del sistema operativo, servidores de directorio y bases de datos SQL. El usuario de esta clase no necesita preocuparse por los detalles de la tienda de respaldo.

A diferencia de las propiedades que son pares clave-valor basados ​​en cadenas, la clase Preferences tiene varios métodos utilizados para obtener y colocar datos primitivos en el almacén de datos de preferencias. Solo podemos usar los siguientes tipos de datos:

  1. Cuerda
  2. booleano
  3. doble
  4. flotador
  5. En t
  6. largo
  7. matriz de bytes

Para cargar el archivo de propiedades, puede proporcionar la ruta absoluta O usar getResourceAsStream() si el archivo de propiedades está presente en su classpath.

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

archivo xml:

 < ?xml version="1.0" encoding="UTF-8"?> < !DOCTYPE preferences SYSTEM 'http://java.sun.com/dtd/preferences.dtd'>                  

Echa un vistazo a este artículo en la tienda de interiores de preferencias

Leer un archivo de propiedades y cargar sus contenidos en Properties

 String filename = "sample.properties"; Properties properties = new Properties(); input = this.getClass().getClassLoader().getResourceAsStream(filename); properties.load(input); 

La siguiente es la forma eficiente de iterar sobre un Properties

  for (Entry entry : properties.entrySet()) { System.out.println(entry.getKey() + " => " + entry.getValue()); } 

1) Es bueno tener su archivo de propiedad en classpath pero puede ubicarlo en cualquier lugar del proyecto.

A continuación se muestra cómo cargar el archivo de propiedades de classpath y leer todas las propiedades.

 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) Los archivos de propiedades tienen la extensión como .properties

En Java 8 para obtener todas sus propiedades

 public static Map readPropertiesFile(String location) throws Exception { Map 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; } 

Aquí hay otra forma de iterar sobre las propiedades:

 Enumeration eProps = properties.propertyNames(); while (eProps.hasMoreElements()) { String key = (String) eProps.nextElement(); String value = properties.getProperty(key); System.out.println(key + " => " + value); } 

He escrito sobre este marco de propiedad para el último año. Proporcionará múltiples formas de cargar propiedades, y las tendrá fuertemente tipadas también.

Eche un vistazo a http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped le dará al desarrollador propiedades fuertemente tipadas. Fácil de integrar en proyectos existentes. Manejado por una gran serie de tipos de propiedad. Da la capacidad de propiedades de inicialización de una línea a través de implementaciones IO de propiedad. Le da al desarrollador la capacidad de crear tipos de propiedad propios y propiedad io. La demostración web también está disponible, las capturas de pantalla se muestran arriba. También tiene una implementación estándar para un front-end web para administrar propiedades, si elige usarla.

Documentación completa, tutorial, javadoc, preguntas frecuentes, etc. está disponible en la página web del proyecto.