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

leer datos de un properties java

Question

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

Preguntas:

• ¿Necesito almacenar el archivo en el mismo paquete que la clase que los cargará, o hay alguna ubicación específica donde se debe colocar?
• ¿Es necesario que el archivo termine en una extensión específica o está bien .txt ?
• ¿Cómo puedo cargar el archivo en el código?
• ¿Y cómo puedo iterar a través de los valores en el interior?

Answer 1

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 desde 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

Answer 2

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

Answer 3

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

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

Como tal, cualquier extensión de archivo se puede utilizar para el archivo de propiedades. Además, el archivo también se puede almacenar en cualquier lugar, siempre que pueda usar 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 propiedades usando un nombre de paquete desde dentro de un archivo JAR.

En cuanto a iterar 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

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 5

En Java 8 para obtener todas tus 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;
}

Answer 6

En orden:

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

Answer 7

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 colocar el archivo .properties en un directorio donde tengo todos los archivos de configuración, no lo coloco junto con la clase que lo accede, pero aquí no hay restricciones.

Para el nombre ... uso .properties por verbosidad, no creo que debas nombrarlo .properties si no quieres.

Answer 8

Hay muchas formas de crear y leer archivos de properties :

1. Almacena el archivo en el mismo paquete.
2. Recomendamos la extensión .properties sin embargo puedes elegir la tuya propia.
3. Use estas clases ubicadas en java.util package => Properties , ListResourceBundle , ResourceBundle .
4. Para leer las 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"));

Answer 9

He escrito en este marco de propiedad para el último año. Proporcionará múltiples formas de cargar propiedades y las tendrá muy escritas 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 serie grande para tipos de propiedad. Ofrece la posibilidad de inicializar propiedades de una línea a través de implementaciones de IO de propiedades. Le da al desarrollador la capacidad de crear tipos de propiedad propios y io''s de propiedad. 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.

La documentación completa, tutorial, javadoc, preguntas frecuentes, etc. están disponibles en la página web del proyecto.

Answer 10

Leyendo un archivo de propiedades y cargando su contenido en Properties

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

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

La siguiente es la manera eficiente de iterar sobre las Properties

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

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

Answer 11

Propiedades se ha convertido en legado. Se prefiere la clase de preferencias a las propiedades.

Un nodo en una colección jerárquica de datos de preferencia. Esta clase permite que las aplicaciones almacenen y recuperen los datos de configuración y preferencias del usuario y del sistema. Estos datos se almacenan de forma persistente en un almacén 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 de clave-valor basados ​​en String, la clase de Preferences tiene varios métodos utilizados para obtener y poner datos primitivos en el almacén de datos de Preferencias. Podemos usar solo 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 una 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''>
<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>

Echa un vistazo a este article en el interior de la tienda de preferencias.

Answer 12

Puede pasar un InputStream a la propiedad, por lo que su archivo puede estar prácticamente en cualquier lugar, y se puede llamar a 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 13

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 Propiedades extiende Hashtable, puede iterar sobre los valores de la misma manera que lo haría en un Hashtable.

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

Answer 14

• 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 usaría UTF-8 y un Reader lugar del ISO-8859 predeterminado) 1 codificación para un flujo.)

• Iterar a través de él como iterarías a través de un Hashtable normal (de qué Properties derivan), por ejemplo, usando keySet() . Alternativamente, puede usar la enumeración devuelta por propertyNames() .