Clases abstractas e interfaces

Clase abstracta: Una clase abstracta es aquella que declara al menos uno de sus metodos como abstracto, este tipo de clase no puede ser instanciada.

public abstract class PersonaAbstract {
    private String nombre;
    private Integer edad;
    private String sexo;

    public void metodo01() {
        System.out.println("Hola!!!");
    }

    public abstract void metodo02();
} 

Interface: Una interface es por definición una clase abstracta, con la diferencia de que todos sus métodos son abstractos.

public interface PersonaInterface {
     public void metodo01();
     public void metodo02();   
}

Configuración de un Pool de conexines con BoneCP

Actualmente le doy mantenimiento a un proyecto que se conecta a una BD MySQL, la carga al inicio no era muy grande y por simplicidad use la configuracion por defecto que me ofrece Spring para el DataSource:

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
    p:driverClassName="${dataSource.driver}"
    p:url="${dataSource.url}"
    p:username="${dataSource.username}"
    p:password="${dataSource.password}" />

La aplicación fue crecienco en cuanto a usuarios y transacciones, esto le pego al rendimiento y detecte que el problema se debia al pobre o nula administración de las conexiones a la BD, por tal motivo me di a la tarea de investigar como solventar esto y me encontre con BoneCP el cual se define asi mismo como una libreria para administrar el pool de conexiones de facil y libre uso.

Para descargar mediante Maven, colocar en el pom las siguientes dependencias:

<dependency>
        <groupId>com.jolbox</groupId>
    <artifactId>bonecp</artifactId>
    <version>0.7.1.RELEASE</version>
</dependency>

<dependency>
    <groupId>com.jolbox</groupId>
    <artifactId>bonecp-spring</artifactId>
    <version>0.7.1.RELEASE</version>
</dependency>

Finalmente mi DataSource quedo de la siguiente manera:

<bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">
        <property name="driverClass" value="${dataSource.driver}" />
        <property name="jdbcUrl" value="${dataSource.url}" />
        <property name="username" value="${dataSource.username}"/>
        <property name="password" value="${dataSource.password}"/>
        <property name="idleConnectionTestPeriod" value="60"/>
        <property name="idleMaxAge" value="240"/>
        <property name="maxConnectionsPerPartition" value="30"/>
        <property name="minConnectionsPerPartition" value="10"/>
        <property name="partitionCount" value="3"/>
        <property name="acquireIncrement" value="5"/>
        <property name="statementsCacheSize" value="100"/>
        <property name="releaseHelperThreads" value="3"/>
    </bean>

Probado y puesto en producción exitosamente. Saludos!!!

Invocación de métodos mediante scheduled con Spring

Buenas madrugadas, esta entrada nace por una pregunta que me hizo un amigo ¿Se puede mandar a ejecutar codigo java desde una aplicacion WEB sin necesidad de una interfaz grafica?, una tipica aplicación WEB espera una acción por parte del usuario para ir al servidor a ejecutar algo, pero podemos en nuestro contexto de la aplicación programar que se ejecute un metodo de alguna clase cualquiera de manera automatica, lo podriamos hacer configurando un listener en el web.xml o en este caso configurando una tarea programada en el contexto de Spring.

Para muestra basta un boton una aplicación de ejemplo, la aplicación se genero con NetBeans 7.2 y se creo usando Maven, el pom.xml ya tiene las dependencias necesarias.

Para descargar la aplicación de ejemplo clic aqui


Referencias

Manten limpio tu sistema LMDE

Si son como yo que se la pasan instalando y desistanlando software, descargando y borrando archivos, despues de un tiempo es necesario limpiar todo rastro de esas pruebas, borrar archivos inecesarios y en resumen mantener limpio nuestro sistema, existen un programas que uso a menudo Deborphan

Instalar Deborphan:
$ sudo aptitude install deborphan

Eliminar librerias huerfanas:
$ sudo dpkg --purge $(deborphan)

Borrar todo rastro despues de desinstalar un paquete:
$ sudo dpkg --purge $(deborphan --find-config)


Posterior a esto lanzamos el siguiente comando:
$ aptitude update && aptitude safe-upgrade && aptitude full-upgrade && aptitude clean && aptitude autoclean

Listo con esto ya deberiamos tener limpio y actualizo nuestro sistema, hasta la próxima. 

Primefaces

En mis andanzas en el mundo del desarrollo WEB empece con JSP y Servlets, la verdad era un dolor de cabeza trabajar con esta tecnologia sobre todo por la administración de las sesiones, yo venia trabajando con Swing y me sentia muy comodo y pense ¿por que no existe algo parecido en el desarrollo WEB?, Swing esta construido en base a componentes y acciones, el objetivo es que no pierdas tiempo creando estos componentes, solo los usas, de esta manera te enfocas en la programación del negocio. Entonces me entere que existia un framework llamado Java Server Faces (JSF) y que su objetivo era precisamente dar una alternativa a Swing en el mundo WEB, desde entonces vengo trabajando con este framewok, al momento van en la versión 2.x y existen muchas implementaciones que hace aun mas facil su uso, como: RichFaces, IceFaces, PrimeFaces, etc., ahora la pregunta es ¿cual debo de usar?, bueno pues me di a la tarea de investigar y encontre este comparativo, y en conclusión me decidi por PrimeFaces, la verdad me lleve una grata sorpresa ya que esta implementacion es facil de configurar, cuenta con mas de 100 componentes muy bien logrados (cabe señalar que internamente hace uso de jQuery), implementa ajax de manera natural, es muy ligero y tiene una buena y amplia documentación.

En futuras publicaciones explicare como hacer uso de esta implementación en conjunto con otros frameworks como Spring y Hibernate.

Alta cohesión y bajo acoplamiento.

La alta cohesión y el bajo acoplamiento son dos terminos que escuche por primera vez en un curso del Framework Spring, tratare de definirlo de la manera mas simple:

Cohesion: Trata de explicar que una clase en conjunto con sus atributos y metodos deben cumplir con un objetivo en especifico y concreto para el cual fue pensado en su diseño. Por ejemplo la clase OperacionesAritmeticas debe contener metodos como: suma, resta, multiplicacion y division y cada metodo debe cumplir con su tarea sin desviarse de su objetivo.

Acoplamiento: El acoplamiento es la dependencia que existe entre las clases, entre mas dependencia exista entre las clases que componen nuestro sistema mas complicado se vuelve realizar ajustes o mantenimiento al mismo. Por ejemplo si nuestro diseño del sistema contara con tres mudulos, el primer modulo realiza la tarea de interactuar con el usuario, el segundo publica servicios y el tercero contiene los objetos de dominio y el acceso a datos, si existiera una dependencia muy fuerte entre los tres modulos y sus respectivas clases cuando se nos pidiera realizar un ajuste o remover algun bug tendriamos que modificar el codigo de al menos tres clases en ves de una sola.

Por tal motivo en el diseño de cualquier sistema informatico independientemente del lenguaje de programación que se use es de buena practica tener una alta cohesión y un bajo acoplamiento. En futuras publicaciones explicare como conseguir esto de una manera practica usando Spring Framework.

Rendimiento en Linux disminuyendo el SWAPPING

Para todos aquellos que trabajan con sistemas Linux se les debe hacer muy familiar el termino "swap", para los que no, la swap es un area o partición del disco duro que sirve de intercambio o almacenamiento temporal de datos cuando existen procesos muy pesados corriendo y la memoria RAM resulta insuficiente, el proceso en el cual la RAM transfiere datos a la swap se le llama SWAPPING. Es obvio que si nuestra PC realiza constantemente este proceso el rendimiento del sistema se veria afectado y se notario lento, esto se debe por que el acceso al disco duro es mas lento que el acceso a la RAM.

Para las maquinas actuales que cuenten con 4GB de RAM o mas hay una solución, consta en disminuir el acceso a la swap lo mas que se pueda, esto se logra agregando el parametro "swappiness" al sistema, primeramente confirmemos el valor por default:

$ sudo cat /proc/sys/vm/swappiness

por lo general los sistemas vienen configurado con el valor 60 (siempre sera un valor entre el 0 y el 100), esto significa que cuando se llegue a un 40% del uso total de la RAM se haga uso de la swap, mientras nuestro valor tienda mas al cero menos se usara la swap, yo recomiendo actualizar este valor a 20, de esta forma solo si se hace uso de hasta el 80% de nuestra RAM se usara la swap.

Modificamos el valor de la siguiente manera:

$ sudo sysctl vm.swappiness=20

Probamos abriendo varios programas y si notamos mejoria podriamos hacer el cambio permanente modificando el siguiente archivo:

$ sudo gedit /etc/sysctl.conf

y agregamos la siguiente linea al final del archivo: vm.swappiness=20

guardamo y reiniciamos nuestro sistema.

Instalando Java (JDK) en LMDE

Lo mas importante despues de instalar el sistema operativo es instalar y configurar Java, en este caso el JDK (Java SE Development Kit), primeramente hay que descargar el binario de aqui segun la arquitectura de su SO (32 o 64 bits), en este caso para mi SO el archivo es jdk-6u33-linux-x64.bin  

- Crear la carpeta donde colocaremos el archivo descargado:

$ sudo mkdir /usr/java

- Asignar permiso a tu usuario sobre la carpeta:

$ sudo chown -R usuario /usr/java/

- Copiamos el archivo descargado a la carpeta creada:

$ cp /home/usuario/Descargas/jdk-6u33-linux-x64.bin /usr/java/

- Le damos permiso de ejecución:

$ chmod a+x /usr/java/jdk-6u33-linux-x64.bin

- Lanzamos el instalador:

$ ./jdk-6u33-linux-x64.bin

- Le asignamos permiso a nuestro usuario sobre la carpeta creada durante la instalación:

$ chown -R usuario /usr/java/jdk1.6.0_33/

- Creamos los siguientes archivos:
$ sudo gedit /root/.bashrc
$ gedit /home/usuario/.bashrc

con el siguiente contenido:
export JAVA_HOME=/usr/java/jdk1.6.0_33
export PATH=$JAVA_HOME/bin:$PATH

guardamos y reniciamos nuestro sistema, este ultimo paso sirve para colocar las variables de entorno del JDK y podamos usar directamente los comando java.

Por ultimo:
$  sudo java -version

y nos debe arrojar:

java version "1.6.0_33"
Java(TM) SE Runtime Environment (build 1.6.0_33-b03)
Java HotSpot(TM) 64-Bit Server VM (build 20.8-b03, mixed mode)

Con esto comprobamos que instalamos y configuramos correctamente.

Instalar y configurar MySQL en LMDE

Buenas, ahora les traigo la forma simple de instalar y configurar MySQL en Linux, especificamente en mi distribución favorita LMDE:

1. Instalación de MySQL: 

sudo apt-get install mysql-server mysql-common mysql-client

Se buscaran los paquetes mysql-server, mysql-common y mysql-client en los repositorios, se instalaran automaticamente y lo unico que pedira el asistente es la contraseña de root (podemos dejarla en blanco, pero por tema de seguridad hay que darle una).

2. Iniciar, reiniciar y parar el servidor MySQL:

iniciar: $ sudo /etc/init.d/mysql start

reiniciar: $ sudo /etc/init.d/mysql restart

parar: $ sudo /etc/init.d/mysql stop

3. Arranque automatico del servidor MySQL al inicio del sistema:

$ sudo update-rc.d mysql defaults

4. Archivo de configuración:

El archivo de configuración es:  $ sudo gedit /etc/mysql/my.cnf

En este archivo podemos modificar aspectos como el puerto, el socket, el usuario, el host, etc.

5. Accerder a la consola de MySQL:

$ mysql -u root -p

Posteriormente te pedira la contraseña que ingresaste para root en la instalación y listo.

Envio de correo electronico con JavaMail

En esta entrada mostrare la forma de mandar un correo electronico usando una cuenta de gmail y utilizando la libreria JavaMail, utilizare interfaces e implementaciones:

Antes que nada, se deben descargar el API

La interfaz:

public interface MailServices {
   
    public void enviar(String mailReceptor, String asunto, String cuerpo) throws ScaseMailException;
   
}


La implementación:

public class MailServicesImpl implements MailServices {

    final String miCorreo = "cuenta@gmail.com";
    final String miContraseña = "xxxxxxxx";
    final String servidorSMTP = "smtp.gmail.com";
    final String puertoEnvio = "465";
    String mailReceptor = null;
    String asunto = null;
    String cuerpo = null;

    @Override
    public void enviar(String mailReceptor, String asunto, String cuerpo) throws ScaseMailException {

        try {
            this.mailReceptor = mailReceptor;
            this.asunto = asunto;
            this.cuerpo = cuerpo;

            Properties props = new Properties();
            props.put("mail.smtp.user", miCorreo);
            props.put("mail.smtp.host", servidorSMTP);
            props.put("mail.smtp.port", puertoEnvio);
            props.put("mail.smtp.starttls.enable", "true");
            props.put("mail.smtp.auth", "true");
            props.put("mail.smtp.socketFactory.port", puertoEnvio);
            props.put("mail.smtp.socketFactory.class",
                    "javax.net.ssl.SSLSocketFactory");
            props.put("mail.smtp.socketFactory.fallback", "false");

            Authenticator auth = new autentificadorSMTP();
            Session session = Session.getInstance(props, auth);

            MimeMessage msg = new MimeMessage(session);
            msg.setText(cuerpo);
            msg.setSubject(asunto);
            msg.setFrom(new InternetAddress(miCorreo));
            msg.addRecipient(Message.RecipientType.TO, new InternetAddress(
                    mailReceptor));
            Transport.send(msg);
        } catch (Exception e) {
            throw new ScaseMailException(e.toString(), e.getMessage());
        }
    }
   

    private class autentificadorSMTP extends javax.mail.Authenticator {

        public PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication(miCorreo, miContraseña);
        }
    }
}

Excepciones personalizadas en Java

Una excepción en Java es un error que se genera en tiempo de ejecución dentro de una aplicación, existen diferentes tipos de excepciones de las que podemos hacer uso o personalizar la propia, para que nos serviria esto?, pues podemos tratar como una excepcion todo aquello que se salga del flujo normal de nuestra aplicación o aquello que no cumpla con la logica del negocio.

Para esto declaramos una clase que extienda de la clase Exception (esta es la clase mas general de las excepciones):

public class JvieraMailException  extends Exception {
   
    private String descripcion;
   
    public JvieraMailException(String mensaje)
    {
        super(mensaje);
        this.descripcion = "";
    }
   
    public JvieraMailException(String mensaje, String descripcion)
    {
        super(mensaje);
        this.descripcion = descripcion;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }   
   
}

En esta clase declaramos dos constructores, en los cuales pasamos como parametro el mensaje y la descripción de la excepción personalizada, a continuación muestro como usarla:

 public void validarEnteroPositivo(int valor) throws JvieraMailException
   {
       if(valor < 0)
       {
           throw new JvieraMailException("Error en el valor.", valor+" No es un entero positivo");
       }   
   }  

Convertir el StackTrace de Java a String

En esta ocasión les traigo una clase utilitaria que me sirvio para convertir el StackTrace de una exception a una cadena de String, esto surgio por la necesidad de enviar por correo electronico el StackTrace del errror generado a mi cuenta en gmail.

public final class StackTraceUtil {

    public static String getStackTrace(Throwable aThrowable) {
        final Writer result = new StringWriter();
        final PrintWriter printWriter = new PrintWriter(result);
        aThrowable.printStackTrace(printWriter);
        return result.toString();
    }
  
    public static String getCustomStackTrace(Throwable aThrowable) {
        final StringBuilder result = new StringBuilder("ERROR: ");
        result.append(aThrowable.toString());
        final String NEW_LINE = System.getProperty("line.separator");
        result.append(NEW_LINE);

        for (StackTraceElement element : aThrowable.getStackTrace()) {
            result.append(element);
            result.append(NEW_LINE);
        }
        return result.toString();
    }
}

Referencias: javapractices

Encriptando con Java usando MD5

MD5 (abreviatura de Message-Digest Algorithm 5, Algoritmo de

Resumen del Mensaje 5) es uno de los algoritmos de reducción criptográfico mas usado en la actualidad y su objetivo es ocultar el verdadero valor de un mensaje encriptandolo, de esta manera para cualquier mensaje siempre nos resultara un número de 32 dígitos hexadecimal, por ejemplo:

MD5("Esto sí es una prueba de MD5") = e99008846853ff3b725c27315e469fbc

MD5("") = d41d8cd98f00b204e9800998ecf8427e

En mi caso tenia la necesidad de guardar en una tabla de la Base de Datos todos los usuarios y contraseñas del sistema, por tema de seguridad no se puede guardar las contraseñas directamente, para eso mismo use MD5, el cual es un metodo nativo en MySQL, de esta manera cuando un usuario queria ingresar al sistema encriptaba por MD5 la contraseña ingresada y la comparaba con la guardada en la BD y si correspondia le permitia el acceso.

A continuación muestro los metodos usados para el proposito:

public static String encriptarPorMD5(String clave) {
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            return hex(md.digest(clave.getBytes("CP1252")));
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

public static String hex(byte[] array) {
        StringBuilder sb = new StringBuilder();

        for (int i = 0; i < array.length; ++i) {
            sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1, 3));
        }

        return sb.toString();
    }

Linux Mint Debian Edition LMDE

Quiero presentarles mi distribución linux para escritorio favorita, Linux Mint Debian Edition (pensaron que era ubuntu?). Realmente el area de los Sistemas Operativos no es mi fuerte, soy programador y como tal me conformaba con cualquier plataforma en donde me sintiera comodo desarrollando, pero como en cualquier profesión siempre hay que ampliar horizontes y siendo una persona que apoya la filosofia del software libre, me propuse la tarea de invetigar, instalar y configurar alguna distribución de linux que fuera de mi agrado y que se adaptara a mis necesidades, pasando por distribuciones como Ubuntu, Open Suse, Fedora, Centos, Linux Mint y LMDE.

LMDE es una distribución rolling basada en Debian Testing, esto quiere decir que es 100% compatible con Debian y con sus repositorios, existen versiones de 32 y 64 bits, cuenta con dos tipos de escritorios MATE y XFCE.

Limpiar los componente contenidos en un JPanel

En el mundo Java el estandar para las interfaces de usario en aplicaciones de escritorio es Swing y me he topado muchas veces con la necesidad de limpiar un formulario despues que un usuario realizo algua accion, si el panel contiene 10 componentes no hay tanto problema pero imaginen un panel con 50 componentes de diferente tipo (inputTexts, combos, checks, radios, etc) esto se volveria muy tedioso, para esto podemos hacer uso de una propiedad que existe desde la version 5 de Java, Reflection :

 public static void limpiarPanel(JPanel panel) {
        if (panel != null) {
            for (Component item : panel.getComponents()) {

                if (item instanceof JTextField) {
                    ((JTextField) item).setText(null);
                } else if (item instanceof JCheckBox) {
                    ((JCheckBox) item).setSelected(false);
                } else if (item instanceof JComboBox) {
                    ((JComboBox) item).setSelectedIndex(0);
                } else if (item instanceof JFormattedTextField) {
                    JFormattedTextField jftf = (JFormattedTextField) item;

                    InputVerifier verificador = jftf.getInputVerifier();
                    jftf.setInputVerifier(null);
                    jftf.setText(null);
                    jftf.setValue(null);
                    jftf.setInputVerifier(verificador);
                } else if (item instanceof JCheckBox) {
                    ((JCheckBox) item).setSelected(false);
                }
            }
        }
    }

Escribir un archivo a partir de una lista de String con Java

Nuevamente haciendo uso del poder del paquete java.io en especifico las clases FileWriter y PrintWriter escribiremos un archivo a partir de una lista de String:

/**    
     * @param ruta Ruta en la cual depositaremos el archivo
     * @param nombreArchivo Nombre que le daremos al archivo
     * @param registros Lista de String que se escribiran en el archivo
     */
    public static void escribirArchivo(String ruta, String nombreArchivo, List registros) {
        FileWriter fichero = null;
        PrintWriter pw = null;
        try {
            fichero = new FileWriter(ruta + nombreArchivo);
            pw = new PrintWriter(fichero);

            for (String item : registros) {
                pw.println(item);
            }

        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (null != fichero) {
                    fichero.close();
                }
            } catch (Exception e2) {
                e2.printStackTrace();
            }
        }
    }

Nota: importar las clases java.io.FileWriter y  java.io.PrintWriter;

Validar si una fecha es valida con Java

En este metodo hacemos uso de la clase  SimpleDateFormat para validar que una fecha cumpla con el formato dd/MM/yyyy (dia/mes/año), esto aplicaria en los casos en donde es necesario que el usuario ingrese la fecha manualmente sin hacer uso de algun componente como jCalendar

 public static boolean isFechaValida(String fecha) {
        try {
            SimpleDateFormat formatoFecha = new SimpleDateFormat("dd/MM/yyyy", Locale.getDefault());
            formatoFecha.setLenient(false);
            formatoFecha.parse(fecha);
        } catch (ParseException e) {
            return false;
        }
        return true;
    }

Nota: importar la clase java.text.SimpleDateFormat;

Copiar un archivo de una ruta a otra con Java

Mostrando el poder del java.nio haciendo uso de la clase FileChannel.

public static void copyFile(File archivoOrigen, File archivoDestino) {
        try {
            FileChannel in = (new FileInputStream(archivoOrigen)).getChannel();
            FileChannel out = (new FileOutputStream(archivoDestino)).getChannel();
            in.transferTo(0, archivoOrigen.length(), out);
            in.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

Nota: importar la siguiente clase java.nio.channels.FileChannel

Listar los archivos de una carpeta recursivamente con Java

Me parece muy potente y practica las clases del paquete java.io para muestra basta un boton metodo. El siguiente metodo lista todos los archivos dentro de una carpeta usando recursividad.

 public static void listarArchivosRecursivamente(File file, String ruta) {
        File[] ficheros = file.listFiles();

        for (int i = 0; i < ficheros.length; i++) {
            if (ficheros[i].isDirectory()) {
                listarArchivosRecursivamente(ficheros[i], ficheros[i].getAbsolutePath());
            } else {
                System.out.println(ruta+"/"+ficheros[i]);
            }
        }
    }

Conocer el nombre y la IP de la PC con Java

En alguna ocasión tuve la necesidad de guardar en la BD el log de los movimientos dentro de la aplicación de los usuarios, el nombre del usuario lo obtenía desde la misma aplicación (login), pero un usuario podría entrar a la aplicación en una maquina distinta a la que tenia asignada, por lo tanto era necesario saber el nombre e IP de la maquina desde la cual estaba realizando la operación, los siguientes métodos me resolvieron el problema:

Retorna el nombre de la PC:

public static String getNombrePc() {
        try {
            InetAddress address = InetAddress.getLocalHost();
            return address.getHostName();
        } catch (Exception e) {
            Logger.getLogger(Util.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

Conocer la IP de la maquina:

  public static String getIpPc() {
        try {
            return InetAddress.getLocalHost().getHostAddress();
        } catch (Exception ex) {
            Logger.getLogger(Util.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

Nota: importar las clases del paquete: java.net.InetAddress;

El inicio

Este es el enésimo blog que inicio, espero ser regular y constante en mis publicaciones.