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

Question

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

Preguntas:

• ¿Es necesario para almacenar el archivo en el mismo paquete que la clase que cargarlos, o hay un lugar específico donde debe ser colocado?
• ¿El archivo debe terminar en una extensión específica o es .txt OK?
• ¿Cómo puedo cargar el archivo en el código
• Y cómo puedo repetir los valores en el interior?

Answer 1

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

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

Iterar como:

for(String key : properties.stringPropertyNames()) { 
    String value = properties.getProperty(key); 
    System.out.println(key + " => " + value); 
} 

Answer 2

Esta carga el archivo de propiedades:

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

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

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

Answer 3

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

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

Como tal, cualquier extensión de archivo puede ser utilizado para 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().

Answer 4

• Usted puede almacenar el archivo de 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á muy bien, aunque .properties es más común en mi experiencia

• carga el archivo utilizando Properties.load, pasando en un InputStream o una StreamReader Si está utilizando Java 6. (Si está utilizando Java 6, probablemente use UTF-8 y un Reader en lugar de la codificación ISO-8859-1 por defecto para una corriente.)

• Iterar a través de él como desee iterar a través de una normal de Hashtable (que Properties se deriva de), por ejemplo usando keySet(). Alternativamente, puede usar la enumeración devuelta por propertyNames().

Answer 5

En orden:

1. Puede almacenar el archivo casi en cualquier lugar.
2. ninguna extensión es necesaria.
3. Montecristo tiene illustrated cómo cargar esto. Eso debería funcionar bien.
4. propertyNames() le da una enumeración para recorrer.

Answer 6

Hay muchas maneras de crear y leer archivos properties:

1. almacenar el archivo en el mismo paquete.
2. Recomendar .properties extensión sin embargo usted puede elegir su propio.
3. Utilice estas clases ubicadas en java.util paquete =>Properties, ListResourceBundle, ResourceBundle clases.
4. leer las propiedades, el uso iterador o empadronador o métodos directos de Properties o java.lang.System clase.

ResourceBundle clase:

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

Properties clase:

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

Answer 7

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

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

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

Si usa la extensión * .properties puede obtener soporte para el editor, p. Eclipse tiene un editor de archivos de propiedades.

Answer 8

Aquí es otra forma de repetir las propiedades:

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

Answer 9

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

Answer 10

que he escrito en este marco de la propiedad para el año pasado. Proporcionará varias formas de cargar propiedades y las tendrá fuertemente tipadas también.

Tenga una mirada en http://sourceforge.net/projects/jhpropertiestyp/

JHPropertiesTyped dará el desarrollador propiedades inflexible. Fácil de integrar en proyectos existentes. Manejado por una serie grande para los tipos de propiedad. Da la capacidad de propiedades de inicialización de una línea a través de implementaciones de IO de propiedad. Le da al desarrollador la capacidad de crear tipos de propiedad propios y propiedades io. Demo web también está disponible, capturas de pantalla que 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 es una disposición en la página web del proyecto.

Answer 11

Properties se ha convertido en el legado. Preferences clase 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.

diferencia de las propiedades que se basan cadena pares de valores clave, la clase Preferences tiene varios métodos utilizados para obtener y poner los datos primitivos en la tienda Preferencias de datos. Podemos utilizar sólo los siguientes tipos de datos:

1. cadena
2. booleano
3. doble
4. flotador
5. int
6. largo
7. matriz de bytes

Para cargar el archivo de propiedades, o usted puede proporcionar la ruta absoluta O use 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'> 
<preferences EXTERNAL_XML_VERSION="1.0"> 
<root type="user"> 
<map /> 
<node name="com"> 
    <map /> 
    <node name="mypack"> 
    <map /> 
    <node name="test"> 
     <map> 
     <entry key="property1" value="80" /> 
     <entry key="property2" value="Red" /> 
     </map> 
    </node> 
    </node> 
</node> 
</root> 
</preferences> 

un vistazo a este article en la parte interna de la tienda preferencias

Answer 12

1) Es bueno tener su archivo de propiedades en la ruta de clase, pero se puede colocar en cualquier lugar en proyecto

A continuación se muestra cómo se carga archivo de propiedades de ruta de clases 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.propiedades

Answer 13

Lectura de un archivo de propiedades y carga su contenido a Properties

String filename = "sample.properties"; 
Properties properties = new Properties(); 

input = this.getClass().getClassLoader().getResourceAsStream(filename); 
properties.load(input); 

La siguiente es la forma más eficiente para repetir un Properties

for (Entry<Object, Object> entry : properties.entrySet()) { 

     System.out.println(entry.getKey() + " => " + entry.getValue()); 
    } 

Answer 14

En Java 8 para obtener todas sus propiedades

public static Map<String, String> readPropertiesFile(String location) throws Exception { 

    Map<String, String> 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; 
}