Posts Tagged ‘java’

1 05
05
2012

Cannot locate java installation in specified jdkhome

Sábado, mayo 5th, 2012

Hace algunos días, actualicé mi sistema operativo Ubuntu a su última versión 12.04 LTS Precise Pangolin, y si bien debo reconocer mejoras apreciables en el rendimiento diario del sistema, también me voy encontrando alguna sorpresa inesperada sobre programas usados hasta entonces que se han visto afectados por la actualización.

NetBeans logo

NetBeans logo

Una de esas sorpresas me la encontré hace unos minutos, al intentar abrir el IDE NetBeans, retornando el mensaje de error:

Cannot locate java installation in specified jdkhome

/usr/lib/jvm/…

Do you want to try to use default version?

Parece que la actualización a Ubuntu 12.04 LTS se llevó consigo la actualización de la instalación de Java, y ahora NetBeans es incapaz de localizarla.

Por lo tanto, simplemente vamos a avisar a nuestro IDE NetBeans la ruta donde se encuentra instalado Java para que todo vuelva a la normalidad. Para ello editamos el archivo netbeans.conf que encontrarás bajo

/usr/local/netbeans-7.x/etc/netbeans.conf

y modificamos la variable netbeans_jdkhome indicando tu directorio de instalación Java.

9 25
07
2011

Java y los ficheros .properties

Lunes, julio 25th, 2011

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

Accediendo a .properties en Java

Cómo acceder .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)
0 21
04
2011

Character decoding failed

Jueves, abril 21st, 2011

Hace algunos días, programando unos scripts en los que enviaba una petición a un servlet de Java a través de AJAX, me encontré con el siguiente mensaje de error en la consola, en mi caso, de Apache Tomcat:

02-abr-2011 23:50:29 org.apache.tomcat.util.http.Parameters processParameters
ADVERTENCIA: Parameters: Character decoding failed.
Parameter skipped.{id=[Ljava.lang.String;@137c90d, id=[Ljava.lang.String;@1709902, nbsp; <span class=[Ljava.lang.String;@14d626e}java.io.CharConversionException: EOF

Lo que en un primer momento tenía pinta de ser uno de tantos problemas que te vuelven loco buscando soluciones por internet, pero sin embargo la solución era mucho más sencilla de lo esperado.

Dentro de la colección de parámetros que construía para enviar hacia el servlet de Java, podían existir en ocasiones caracteres especiales tales como ‘%’, ‘$’, etc, que generaban el error mencionado: Character decoding failed.

La solución a este problema pasaba simplemente por codificar la cadena a enviar por AJAX en formato unicode, y para ello utilizaremos la función de javascript escape.

El código quedaría parecido a estas líneas:

    var params = "id=" + textAreaName + "&value=" + escape(text);
    $.ajax({
        url: "/MyApp/ajax/http/edit?id=" + id,
        type: 'GET',
        data: params,
        success: function(){ // your code }
    });
0 30
01
2011

Internacionalización y localización en Java

Domingo, enero 30th, 2011

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.

0 28
11
2010

Reflexión: la gran desconocida en la programación

Domingo, noviembre 28th, 2010

“En informática, reflexión (o reflexión computacional) es la capacidad que tiene un programa de ordenador para observar y opcionalmente modificar su estructura de alto nivel.”

Esta es la definición que aparece en wikipedia en referencia al concepto de reflexión en el mundo de la informática y la programación.

Es una definición un tanto abstracta, pero que nos permite intuir en qué consiste todo esto de la reflexión.

Siendo más concretos y prácticos, el uso de la reflexión a nivel de programación, nos permitirá, entre muchas otras cosas, crear instancias u objetos de dinámicamente de tipos concretos a partir del nombre de su clase. Podremos además, acceder a la información de los objetos, conociendo y/o ejecutando sus atributos y métodos públicos; y todo ello en tiempo de ejecución.

Vamos a plantear un pequeño ejemplo práctico de introducción al uso de reflexión en el lenguaje de programación Java.

Imaginemos la siguiente estructura de clases definida en el diagrama UML que se muestra a continuación.

Diagrama UML Reflexión

Reflexión en Java

Definiremos en primer lugar una clase abstracta denominada Vehicle. Esta clase padre define 2 métodos abstractos (acelerar/speedUp y frenar/brake) que deberán ser implementados por todas aquellas clases hijas que deseen heredar de Vehicle.

Clase (padre) Vehicle

package es.v3.test.reflection;

/**
 * Clase abstracta padre
 * @author v3rgu1.com
 */
public abstract class Vehicle {

    public String name;

    public abstract void speedUp();

    public abstract void brake();

}//Vehicle

A continuación crearemos 2 clases hijas que implementarán la clase abstracta padre Vehicle

Clase (hija) Car


package es.v3.test.reflection;

/**
 * Clase hija que hereda de Vehicle y representa un vehículo de tipo coche.
 * @author v3rgu1.com
 */
public class Car extends Vehicle {

    @Override
    public void speedUp() {
        System.out.println("Me llamo " + this.name + " y soy un coche que está acelerando");
    }

    @Override
    public void brake() {
        System.out.println("Me llamo " + this.name + " y soy un coche que está frenando");
    }

}//Car

Clase (hija) Motorcycle


package es.v3.test.reflection;

/**
 * Clase hija que hereda de Vehicle y representa un vehículo de tipo motocicleta.
 * @author v3rgu1.com
 */
public class Motorcycle extends Vehicle {

    @Override
    public void speedUp() {
        System.out.println("Me llamo " + this.name + " y soy una moto que está acelerando");
    }

    @Override
    public void brake() {
        System.out.println("Me llamo " + this.name + " y soy una moto que está frenando");
    }

}//Motorcycle

Una vez creadas estas 3 clases con las que llevaremos a cabo nuestros próximos ejemplos relacionados con la reflexión en programación, vamos a crear una clase ejecutable (main) con la que crearemos instancias en tiempo de ejecución de las clases hijas definidas anteriormente. Recuperaremos además la información de cada una de ellas y ejecutaremos sus métodos públicos sin previo conocimiento de ellos.

Pasaremos 2 argumentos a nuestra clase ejecutable por línea de comandos: el nombre de la clase a instanciar (“Car” o “Motorcycle”) y el nombre de nuestro vehículo.
Vamos a crear una instancia en tiempo de ejecución del tipo indicado en el primer argumento, para utilizar después sus métodos implementados speedUp & brake.

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {

        String nameClass = args[0];
        String nameVehicle = args[1];
        try {
            Class vehicleClass = Class.forName("es.v3.test.reflection." + nameClass);
            Field[] fields = vehicleClass.getFields();
            Method[] methods = vehicleClass.getDeclaredMethods();
            try {
                Vehicle vehicle = (Vehicle) vehicleClass.newInstance();
                vehicle.name = nameVehicle;
                vehicle.speedUp();
                vehicle.speedUp();
                vehicle.brake();
                for (int i=0; i<fields.length; i++) {
                    Field field = fields[i];
                    System.out.println("Campo '" + field.getName() + "': " + field.get(vehicle));
                }//for i
                for (int i=0; i<methods.length; i++) {
                    Method method = methods[i];
                    System.out.println("Voy ejecutar el método: '" + method.getName() + "'");
                    method.invoke(vehicle);
                }//for i
            } catch (IllegalArgumentException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvocationTargetException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InstantiationException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
            }
        } catch (ClassNotFoundException ex) {
            Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
        }

    }//main

Con la ayuda del API reflect de Java, hemos instanciado una clase sin conocer a priori el tipo de la misma y únicamente a partir de su nombre, pero veamos más en detalle las funciones utilizadas en el ejemplo.

java.lang.Class forName(String className) javadoc
Devuelve el objeto Class asociado a la clase o interface indicada en el nombre que recibe por parámetro.

java.lang.Object newInstance() javadoc
Crea una nueva instancia del objeto representado por la clase actual.

java.lang.reflect.Field[] getFields() javadoc
Retorna un array con todos los atributos con acceso público de la clase o interfaz representada.

java.lang.reflect.Method[] getMethods() javadoc
Devuelve un array que contiene todos los métodos públicos de la clase o interfaz representada.

java.lang.reflect.Method[] getDeclaredMethods() javadoc
Devuelve un array que contiene todos los métodos declarados en la clase o interfaz representada.

En próximo artículos, veremos cómo realizar este mismo ejemplo de reflexión en otros lenguajes de programación, así como el uso técnicas de reflexión más avanzadas.

27 09
11
2010

Eliminar acentos y caracteres especiales en Java

Martes, noviembre 9th, 2010

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"));
13 29
09
2010

Cómo manejar fechas en Java

Miércoles, septiembre 29th, 2010

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.