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

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.

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

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;