Seguro que muchos ya conocéis qué son y cómo funcionan los ficheros .properties en Java, pero para aquellos que no estén muy familiarizados con este tipo de ficheros de configuración, haremos una pequeña introducción a continuación.
¿Qué son los ficheros .properties para Java?
Los ficheros .properties son archivos que nos permiten almacenar variables de configuración de nuestra aplicación.
En la práctica, no deja de ser un fichero de texto donde almacenar por cada línea, un par clave valor, indicando el nombre de la variable y su valor.
Por ejemplo, podemos almacenar en este tipo de ficheros nuestras variables de configuración para conectar contra base de datos, de esta forma, una vez que el desarrollo pase a un entorno de producción, éste será fácilmente reconfigurable.
Ejemplo:
# DataBase Server dataBaseServer=localhost # DataBase Catalog dataBaseCatalog=mydatabase # DataBase User dataBaseUser=myuser # DataBase Password dataBasePassword=mypswd
NOTA: Las almohadillas funcionan como comentarios de la línea
¿Cómo trabajar y acceder a los ficheros .properties con Java?
Para trabajar con este tipo de ficheros, Java proporciona la clase java.util.Properties, que a efectos prácticos, no deja de ser una tabla Hash con alguna facilidad más.
Una vez que ya conocemos en qué consisten los ficheros properties, vamos a comprobar cómo trabajar con ellos.
Lo primero que debemos hacer es crear una instancia de java.util.Properties y cargar el fichero de configuración.
Para cargar dicho fichero de propiedades, usaremos el método java.util.Properties.load(input), el cual necesita un parámetro de tipo InputStream, indicando la ruta donde se encuentra el fichero de configuración.
. . .
// create and load default properties
Properties defaultProps = new Properties();
FileInputStream in = new FileInputStream("file.properties");
defaultProps.load(in);
in.close();
...
Vamos a proponer una pequeña variación algo más dinámica para la carga usando getClassLoader y getResourceAsStream.
this.properties = new Properties();
try {
properties.load(Configuration.class.getClassLoader().getResourceAsStream("file.properties"));
} catch (IOException ex) {
ex.printStackTrace();
}
En este caso, mi archivo de propiedades se encuentra al nivel del primer paquete/package, tal y como se puede ver en la imagen, dentro de la carpeta src, por lo que cuando genere el proyecto (una aplicación web), el archivo de propiedades quedará dentro del directorio classes.
Accediendo a .properties en Java
Cómo acceder .properties en Java
Ya tenemos cargado desde Java nuestro archivo de configuración mediante un fichero .properties, así que únicamente necesitamos poder acceder a las propiedades de configuración.
Como ya hemos dicho, la clase java.util.Properties, no deja de ser una tabla Hash optimizada para este uso, así que acceder a las variables será muy intuitivo.
Podemos hacer uso del método getProperty de la siguiente manera sobre la instancia creada originalmente.
this.properties.getProperty(key)
Clase final para acceder a .properties en Java
Visto a grandes rasgos cómo acceder y trabajar con un fichero .properties desde Java, vamos a crear una clase Configuration.java implementando el patrón Singleton (que explicaremos en próximos artículos), que nos permitirá cargar y gestionar de forma transparente nuestro fichero de propiedades .properties desde una clase Java.
Para que la gestión sea más sencilla, añadiremos también dentro de la propia clase Configuration, unas cuantas constantes que nos permitan acceder de forma más sencilla a la propiedad que estamos buscando.
package com.v3.blog;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.Properties;
/**
*
* @author v3rgu1
*/
public class Configuration {
Properties properties = null;
/** Configuration file name */
public final static String CONFIG_FILE_NAME = "Configuration.properties";
/** Data base server */
public final static String DATABASE_SERVER = "dataBaseServer";
/** Data base name */
public final static String DATABASE_CATALOG = "dataBaseCatalog";
/** Data base user */
public final static String DATABASE_USER = "dataBaseUser";
/** Data base password */
public final static String DATABASE_PSWD = "dataBasePassword";
private Configuration() {
this.properties = new Properties();
try {
properties.load(Configuration.class.getClassLoader().getResourceAsStream(CONFIG_FILE_NAME));
} catch (IOException ex) {
ex.printStackTrace();
}
}//Configuration
/**
* Implementando Singleton
*
* @return
*/
public static Configuration getInstance() {
return ConfigurationHolder.INSTANCE;
}
private static class ConfigurationHolder {
private static final Configuration INSTANCE = new Configuration();
}
/**
* Retorna la propiedad de configuración solicitada
*
* @param key
* @return
*/
public String getProperty(String key) {
return this.properties.getProperty(key);
}//getProperty
}
¿Cómo será la llamada?
Configuration.getInstance().getProperty(Configuration.DATABASE_SERVER)