v3rgu1.com

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)

Hoy vamos a comprobar cómo conocer la cultura en la que se está ejecutando tu programa Java.

Pero, ¿qué es esto de la cultura?

El poder conocer la cultura en la que se está ejecutando un programa, nos permitirá acercarnos a construir un programa más agradable para el usuario final.

Además de las diferencias evidentes de idiomas, la cultura nos permitirá mostrar otros datos como fechas y números en los formatos correctos según la cultura y/o localización del cliente.

Un europeo, entenderá perfectamente la fecha 30/03/1983 como 30 de Marzo de 1983, mientras que un norte-americano esperaría 3/30/1983.

Nos permitirá la cultura por lo tanto internacionalizar nuestras aplicaciones de una forma más sencilla y elegante.

Para ello vamos a utilizar la clase Locale de java dentro del paquete java.util.

Según la propia definición de la clase Locale en la página de Sun… digo de Oracle: un objeto Locale representa una región geográfica, política y cultural específica.

Probemos con el siguiente código Java que utiliza la clase Locale de Java:

        Locale myLocale = Locale.getDefault();
        System.out.println("My country (ISO): " + myLocale.getCountry());
        System.out.println("My country name: " + myLocale.getDisplayCountry());

        System.out.println("My language (code): " + myLocale.getLanguage());
        System.out.println("My language (name): " + myLocale.getDisplayLanguage());

        System.out.println(myLocale.getDisplayName());

Este sencillo código nos permite conocer la cultura/localización de nuestra aplicación Java. Adicionalmente, estamos mostrando por pantalla algunas características del mismo como el país o el lenguaje actual.

La salida será la siguiente:

My country (ISO): ES
My country name: España
My language (code): es
My language (name): español
español (España)

My country (ISO): GB
My country name: United Kingdom
My language (code): en
My language (name): English
English (United Kingdom)

En futuros artículos veremos cómo seguir internacionalizando nuestras aplicaciones en Java.

En ocasiones nos puede resultar útil eliminar de una cadena de texto caracteres especiales, acentos o diacríticos (tíldes, diéresis, eñes, cedillas, etc).

Por ejemplo, en algunos sistemas de reservas aéreas o GDSs, como es el caso de Amadeus, necesitamos limpiar todos los textos que hacen referencia a nombres de pasajeros, direcciones y demás, de aquellos caracteres especiales no soportados por el sistema.

Vamos a ver 2 formas diferentes de eliminar estos caracteres especiales y acentos con 2 técnicas distintas:

1. Reemplazando cadenas de caracteres

    /**
     * Función que elimina acentos y caracteres especiales de
     * una cadena de texto.
     * @param input
     * @return cadena de texto limpia de acentos y caracteres especiales.
     */
    public static String remove1(String input) {
        // Cadena de caracteres original a sustituir.
        String original = "áàäéèëíìïóòöúùuñÁÀÄÉÈËÍÌÏÓÒÖÚÙÜÑçÇ";
        // Cadena de caracteres ASCII que reemplazarán los originales.
        String ascii = "aaaeeeiiiooouuunAAAEEEIIIOOOUUUNcC";
        String output = input;
        for (int i=0; i<original.length(); i++) {
            // Reemplazamos los caracteres especiales.
            output = output.replace(original.charAt(i), ascii.charAt(i));
        }//for i
        return output;
    }//remove1

2. Normalización Unicode. Descomposición canónica

Partamos en primer lugar del hecho de que un carácter puede ser representado de formas diferentes.
Visualicemos con un ejemplo estas diferentes formas de representar un mismo carácter:

        // Representación normal
        char c1 = 'í';
        // Representación UNICODE
        char c2 = '\u00ed';
        // Representación UNICODE en forma canónica
        char[] c3 = {'\u0069', '\u0301'};

¿En qué consiste la representación canónica?

La representación o descomposición canónica consiste simplemente (de forma muy resumida) en la descomposición del carácter en 2 partes:

– Parte 1: Letra base
– Parte 2: Acento

De esta forma, hemos podido representar el carácter i compuesto por la letra i (0x0061) y su acento (0x0301).

Una vez entendido el concepto de descomposición canónica, es hora de ponerlo en práctica para nuestro cometido: limpiar un texto de acentos y caracteres especiales obteniendo de esta manera un texto sólo de caracteres ASCII.

    /**
     * Función que elimina acentos y caracteres especiales de
     * una cadena de texto.
     * @param input
     * @return cadena de texto limpia de acentos y caracteres especiales.
     */
    public static String remove2(String input) {
        // Descomposición canónica
        String normalized = Normalizer.normalize(input, Normalizer.Form.NFD);
        // Nos quedamos únicamente con los caracteres ASCII
        Pattern pattern = Pattern.compile("\\p{ASCII}+");
        return pattern.matcher(normalized).replaceAll("");
    }//remove2

Comprobemos el resultado final de nuestras 2 técnicas:

        System.out.println("1. " + RemoveAccents.remove1("Mañana será un día mejor"));
        System.out.println("2. " + RemoveAccents.remove1("Mañana será un día mejor"));

Como no podía ser menos, el primer artículo tenía que estar relacionado con el lenguaje de programación Java.

El manejo de fechas en Java puede resultar en un principio un poco menos intuitivo que en otros lenguajes tales como PHP o Visual Basic. Sin embargo, para trabajar con fechas de una forma más cómoda, contamos con la clase java.util.Calendar.

Calendar es una clase base abstracta con la que podremos representar y manejar fechas (objetos de tipo Date), así como modificar y obtener sus datos enteros tales como YEAR, MONTH, DAY, etc…

Para instanciar un objeto de clase Calendar, tendremos 2 opciones:

• Opción A: Utilizar el método getInstance(), que nos proporcionará un objeto Calendar cuyos campos han sido inicializados con la fecha y la hora actuales.
• Opción B: Utilizar el constructor de la clase GregorianCalendar. Esta clase es a su vez una subclase de java.util.Calendar, que nos proporciona un calendario estándar usado comunmente en la mayor parte del mundo.

A continuación mostramos el código de las 2 opciones mencionadas:

Date date = new Date();
Calendar calendar1 = Calendar.getInstance();
Calendar calendar2 = new GregorianCalendar();

Una vez instanciado el objeto Calendar, ya podemos manejar las fechas a nuestro antojo.

¿Cómo extraer los datos individuales de la fecha?

¿A que os suenan los famosos getters y setters…? pues esta clase no iba a ser menos.
La clase java.util.Calendar nos proporciona un único método get(int field) para extraer cualquier atributo del calendario que indiquemos en el atributo field, tal y como veremos a continuación en el siguiente código de ejemplo.
NOTA: Ten en cuenta que valores como el mes o el día de la semana comienzan por 0, no por 1.

// Instanciamos el objeto Calendar
Calendar calendar = Calendar.getInstance();
// Obtenemos el valor del año, mes y día.
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int date = calendar.get(Calendar.DATE);
System.out.println("AÑO ACTUAL: " + year);
System.out.println("MES ACTUAL: " + month);
System.out.println("DÍA ACTUAL: " + date);

¿Cómo modificar los atributos o valores de la fecha?

Al igual que disponemos del método get(int field) para obtener cualquier valor de una fecha, disponemos también del método set(int field, int value) para modificarlo.
Deberemos pasar 2 parámetros:

• field: atributo de la fecha que queremos modificar
• value: nuevo valor a asignar

Veamos a continuación un ejemplo de cómo modificar los atributos año, mes y día:

calendar.set(Calendar.YEAR, 2020);
calendar.set(Calendar.MONTH, 02); // OJO: Recueda que los valores de los meses comienzan por 0.
calendar.set(Calendar.DATE, 30);

Además del método simple set(int field, int value), disponemos también de 3 métodos más sobrecargados set que nos permitirán asignar fechas completas en un único paso:

// Asignamos año, mes y día.
calendar.set(2020, 02, 30);
// Asignamos año, mes, día, horas y minutos.
calendar.set(2020, 02, 30, 19, 00);
// Asignamos año, mes, día, horas, minutos y segundos.
calendar.set(2020, 02, 30, 19, 00, 55);

¿Cómo sumar y restar fechas?

He aquí uno de los métodos más útiles cuando queremos operar con fechas: add(int field, int amount).
Con la misma estructura que el método set(int field, int amount), podremos sumar (y por lo tanto restar) cantidades de diferentes valores a una fecha.

• field: atributo de la fecha que queremos modificar y cuya cantidad pasaremos en el parámetro amount
• amount: cantidad a sumar o restar (valores negativos) a la fecha

Viajemos en el tiempo y rejuvenezcamos 10 años:

// Sumamos 30 minutos a la fecha actual.
calendar.add(Calendar.MINUTE, 30);
// Sumamos 100 días a la fecha actual.
calendar.add(Calendar.DATE, 100);
// Restamos 10 años a la fecha actual.
calendar.add(Calendar.YEAR, -10);

Para más información sobre la clase Calendar podéis acceder también a la documentación de Sun (o de Oracle, como más os guste).

Espero que el artículo os haya sido de utilidad. Como habéis comprobado, la clase Calendar nos facilita la vida cuando queremos manejar fechas en java, y es muy fácil e intuitiva de utilizar. En próximas entregas, veremos cómo realizar más operaciones con fechas.