MANEJO 'THREADs' CON RETORNO.

Muchas veces en JAVA, cuando requerimos utilizar 'Threads' para realizar flujos paralelos entre otros casos, nos vemos con la problemática de como obtener el valor de 'return' que el método 'run()' procesa. En esta oportunidad mostraré una forma fácil de como obtener dicho valor de retorno (sea cual sea el objeto). Los pasos son los siguientes:

Creamos la clase 'Usuario.java' que será el bean que procesaremos y parsearemos a nivel de los Threads.
   
    class Usuario{
         
          private String codigo;
          private String nombres;
          private String telefono;
         
          public Usuario( String codigo, String nombres,
String telefono ){
                 this.codigo   = codigo;
                 this.nombres  = nombres;
                 this.telefono = telefono;
          }
         
          public String getCodigo(){
                 return codigo;
          }
          public void setCodigo( String codigo ){
                 this.codigo = codigo;
          }
          public String getNombres(){
                 return nombres;
          }
          public void setNombres( String nombres ){
                 this.nombres = nombres;
          }
          public String getTelefono(){
                 return telefono;
          }
          public void setTelefono( String telefono ){
                 this.telefono = telefono;
          }
    }

Creamos la clase 'MensajeThread01.java' y 'MensajeThread02.java' que serán las clases que procesarán la lógica propia del negocio y que retornarán el objeto ya parseado por medio del método 'call()'. Así mismo, lo reslatado en ROJO, son los clases que pueden variar en base a los datos deseados para el retorno.

class MensajeThread01 implements Callable<Usuario>{
 
        public Usuario call(){

            Usuario vRespuesta = null;
           
            try{
                //-------------- [logica a procesar en hilos] --------------//
                Thread.sleep(2 * 1000);               
                vRespuesta = new Usuario( "2", "MIGUEL LEIVA", "98657852" );
                //-------------- [logica a procesar en hilos] --------------//
            }
            catch( final InterruptedException e ){
                   e.printStackTrace();
            }   
            return vRespuesta;
        }   
    }

    class MensajeThread02 implements Callable<Usuario>{
   
        public Usuario call(){

            Usuario vRespuesta = null;
           
            try{
                //-------------- [logica a procesar en hilos] --------------//
                Thread.sleep(3 * 1000);               
                vRespuesta = new Usuario( "1", "CESAR GUERRA", "98754852" );
                //-------------- [logica a procesar en hilos] --------------//
            }
            catch( final InterruptedException e ){
                   e.printStackTrace();
            }   
            return vRespuesta;
        }   
    }

Creamos el método 'procesarLogica' se encargará de lanzar las diferentes instancias de hilos. Así mismo, lo reslatado en ROJO, son los clases que pueden variar en base a los datos deseados para el retorno.

        public static void main( final String[] argumentos ){          
               TestThreadReturned x = new TestThreadReturned();
               x.procesarLogica();
        }

        public void procesarLogica(){
               System.out.println( "--------- [procesarLogica] - [INICIO] ---------" );
             
               final ExecutorService objServicio_01;
               final ExecutorService objServicio_02;
             
               final Future<Usuario> objTarea_01;
               final Future<Usuario> objTarea_02;
             
               objServicio_01 = Executors.newFixedThreadPool( 1 );      
               objServicio_02 = Executors.newFixedThreadPool( 1 );
             
               objTarea_01 = objServicio_01.submit( new MensajeThread01() );
               objTarea_02 = objServicio_02.submit( new MensajeThread02() );
             
               try{
                   final Usuario objRespuesta_01 = objTarea_01.get();
                   System.out.println( "- Codigo: ["   + objRespuesta_01.getCodigo()   + "]" );
                   System.out.println( "- Nombres: ["  + objRespuesta_01.getNombres()  + "]" );
                   System.out.println( "- Telefono: [" + objRespuesta_01.getTelefono() + "]" );
                   System.out.println( "" );
                 
                   final Usuario objRespuesta_02 = objTarea_02.get();
                   System.out.println( "- Codigo: ["   + objRespuesta_02.getCodigo()   + "]" );
                   System.out.println( "- Nombres: ["  + objRespuesta_02.getNombres()  + "]" );
                   System.out.println( "- Telefono: [" + objRespuesta_02.getTelefono() + "]" );
               }
               catch( final InterruptedException e ){
                      e.printStackTrace();
               }
               catch( final ExecutionException e ){
                      e.printStackTrace();
               }
               finally{          
                          objServicio_01.shutdownNow();
                          System.out.println( "--------- [procesarLogica] - [FIN] ---------" );
               }
         }              
    }
   
Para descarga la clase completa pulsar aquí: http://www.mediafire.com/download/97yy0w0oa70pmet/TestThreadReturned.java

CONTROL DE FERIADOS EN JAVA

Hace un tiempo, a causa de falta de tiempo, no posteo en mi  BLOG   pero hoy me animé a darme algo de tiempo para hacer este post y de  paso comentar sobre una buena solución para el filtrado de fechas no considerando dos reglas: 

- DOMINGOS.

- FERIADOS.

La solución en sí está manejada en base a un método principal público llamado:    procesarValidacionFeriados, el cual reutilizará algunos métodos privados para un mejor entendimiento:  

validarHoyEsDomingo
validarHoyEsFeriado
listaRegistrosFeriados
agregarRegistroFeriadoHasMap
cantidadRegistrosFeriadosEnTrama

En si la idea principal es tener las fechas "FERIADOS" configurables a nivel de .properties definiendo un formato específico, que serán jalados y procesados desde java de manera dinámica: 

//FORMATO PARA AGREGA REGISTRO EN TRAMA: 'DD-MM-YYYY-DESCRIPCION'  
private static final String TRAMA_LISTA_FERIADOS = "01-01-2014-Inicio del Año|17-04-2014-Semana Santa[Cambiante]|18-04-2014-Semana Santa[Cambiante]|01-05-2014-Del Trabajador|29-06-2014-San pedro y San Pablo|28-07-2014-Independencia del Perú|29-07-2014-Fiestas Patrias|30-08-2014-Santa Rosa de Lima|08-10-2014-Combate de Angamos|01-11-2014-Los Santos|08-12-2014-Inmaculada Concepción|25-12-2014-Navidad"; 
  

El resultado de la validación se puede apreciar en 3 pasos en la siguiente imagen: 

Para descarga el ejemplo dar click en siguiente: Enlace.

Hasta la próxima ... 

MANEJO DE DELAY EN JAVA

Muchas veces en nuestras aplicaciones necesitamos realizar un Delay de tiempo para realizar la respuesta de algunos aplicativos a los que nos conectamos, entre otras cosas, en esas situaciones muchos de nosotros hemos manejado algo ya conocido que es apoyarnos en al clase Thread y hacer un Thread.sleep. Pero lo que muchos no saben es que existe otra clase para el manejo de Delay de tiempo que se llama: java.util.concurrent.TimeUnit.

La diferencia en si es que: TimeUnit su manejo es mucho más facil y rápido pero lo que no saben es que esta clase: TimeUnit , internamente se apoya y hace un Thread.sleep.

Aquí un ejemplo de como trabajan ambas clases:

 import java.util.concurrent.TimeUnit;

/**
 * TestStopTiempo
 * @author JAVAMAN
 */
 public class TestStopTiempo{

    @SuppressWarnings( "unused" )
    public static void main( String[] argumentos ) throws InterruptedException{
        
        //FORMA #1:
        System.out.println( "--------- INICIO 'DELAY JAVA' [Thread.sleep] --------- " );
       
        int milisegundo = 1000;
        int segundo     = (1  * milisegundo);
        int minuto      = (60 * segundo);
        int hora        = (60 * minuto);
        int dia         = (24 * hora);
       
        Thread.sleep( 10 * segundo );
       
        //FORMA #2:
        System.out.println( "--------- INICIO 'DELAY JAVA' [TimeUnit] --------- " );
       
        int tiempo = 10;
 
        TimeUnit.SECONDS.sleep( tiempo );  
        //TimeUnit.MINUTES.sleep( tiempo );
        //TimeUnit.HOURS.sleep(   tiempo );
        //TimeUnit.DAYS.sleep(    tiempo ); 
    }
   
 }

Es todo saludos.

MANEJO API: JSOUP

Buen día en esta oportunidad mostraré el manejo de una API que resultó ser muy buena ya que no hace mucho tiempo me recomendaron, su nombre es: JSOUP (http://jsoup.org/download), es una API para el parsing de datos HTML, XML cuanto estos se encuentran embebidos en un dato Spring.

En realidad es muy fácil vas con descargar el API: jsoup-1.7.2.jar y ubicarla dentro del LIB de tu APP, posteriormente a este paso ya se puede acceder a los beneficios de dicha API. (Por restriccón del BLOG se cambiará los símbolos MAYOR y MENOR por CORCHETES).

Por EJEMPLO:
Si tenemos un STRING:

String cadenaHTML_02 = " [STRONG] " +
"   [FONT id='nombres' COLOR='WHITE' SIZE='3']CESAR RICARDO[/FONT] " +
" [/STRONG]: " +
" [STRONG] " +
"   [FONT id='apellidos' COLOR='WHITE' SIZE='3']GUERRA ARNAIZ[/FONT]" +
" [/STRONG]";

Y queremos obtener los datos del contenido de XML bastaría con hacer un método que internamente jale ya sea por ID o por el nombre del TAG, de la siguiente manera:

/*
* test_02
* @param cadenaHTML    
*/

public void test_02( String cadenaHTML ){
                       
Document objDocumento  = Jsoup.parse( cadenaHTML );
Element  objElemento_01 = objDocumento.select(  "FONT" ).first();
Element  objElemento_02 = objDocumento.getElementById ( "apellidos" );

String vTextoAtributo_ObjHTML_01 = objElemento_01.text
String vTextoAtributo_ObjHTML_02 = objElemento_02.text();         
                            
System.out.println( "" );
System.out.println( "- HTML FILTRADO #1: [" + objElemento_01  + "]" );
System.out.println( "- HTML FILTRADO #2: [" + objElemento_02  + "]" );
System.out.println( "" );
System.out.println( "- TEXTO 'HTML' #1: [" + vTextoAtributo_ObjHTML_01 + "]" );
System.out.println( "- TEXTO 'HTML' #2: [" + vTextoAtributo_ObjHTML_02 + "]" );

}

El resultado sería el siguiente:

- HTML FILTRADO #1: [[font id="nombres" color="WHITE" size="3"]CESAR RICARDO[/font]]
- HTML FILTRADO #2: [[font id="apellidos" color="WHITE" size="3"]GUERRA ARNAIZ[/font]]
- TEXTO 'HTML' #1: [CESAR RICARDO]
- TEXTO 'HTML' #2: [GUERRA ARNAIZ]

Otro ejemplo muy usado es cuando se almacena en una cadena una lista de objetos. En este caso si es requerido realizar el parsing, para ello también nos podríamos apoyar de esta API de la siguiente manera:
          

String cadenaHTML_04 =
"[productos]" +        
"  [producto]" +
"    [nombre]AAA0001[/nombre]" +
"    [descripcion]PAQUETE #1[/descripcion]" +
"    [codigo]AAA[/codigo]" +
"    [precio]11[/precio]" +
"    [megas]200[/megas]" +
"    [vigencia]1[/vigencia]" +
"  [/producto]" +
"  [producto]" +
"    [nombre]BBB0002[/nombre]" +
"    [descripcion]PAQUETE #2[/descripcion]" +
"    [codigo]BBB[/codigo]" +
"    [precio]22[/precio]" +
"    [megas]300[/megas]" +
"    [vigencia]24[/vigencia]" +
"  [/producto]" +
"[productos]";

De la misma forma que la anterior hacemos un método que obtendrá los datos pero esta vez nos apoyaremos en un bean para almacenar la data.   

/**

 * @author cguerra
 * ProductosBean
 */

 public class ProductosBean{
                private String nombre;
                private String descripcion;
                private String codigo;
                private String precio;
                private String megas;
                private String vigencia; 

                //Constructores ...
                public ProductosBean(){
                }                            

                public ProductosBean( String nombre, String descripcion,
                                                             String codigo, String precio,
                                                             String megas,  String vigencia ){

                               super();
                               this.nombre      = nombre;
                               this.descripcion = descripcion;
                               this.codigo      = codigo;
                               this.precio      = precio;
                               this.megas       = megas;
                               this.vigencia    = vigencia;
                }
             
                @Override
                public String toString() {

              return "ProductosBean [nombre=" + nombre
                         + ", descripcion=" + descripcion
                        + ", codigo="            + codigo
                        + ", precio="      + precio
                        + ", megas="       + megas
                      + ", vigencia="    + vigencia  + "]";
                }
..
…..
…….


Ahora crearemos el método respectivo:

  /*

    * test_04
    * @param cadenaHTML
    */
     public void test_04( String cadenaXML ){                            

      Document objDocumento = Jsoup.parse( cadenaXML );                            

     List[ProductosBean] listaProductosBean = new ArrayList[ProductosBean]();
     ProductosBean       objProductosBean   = null;                            

     Elements objElement_01 = objDocumento.select( "nombre"      );
     Elements objElement_02 = objDocumento.select( "descripcion" );
     Elements objElement_03 = objDocumento.select( "codigo"      );
     Elements objElement_04 = objDocumento.select( "precio"      );
     Elements objElement_05 = objDocumento.select( "megas"       );
     Elements objElement_06 = objDocumento.select( "vigencia"    );
                            

      List[String] listaDatos_01 = new ArrayList[String]();
      List[String] listaDatos_02 = new ArrayList[String]();
      List[String] listaDatos_03 = new ArrayList[String]();
      List[String] listaDatos_04 = new ArrayList[String]();
      List[String] listaDatos_05 = new ArrayList[String]();
     List[String] listaDatos_06 = new ArrayList[String]();                           

          for( int i=0; i[objElement_01.size(); i++ ){
                Element objElemento_01 = objElement_01.get( i );
                String  codigoPaquete  = objElemento_01.text();

                 listaDatos_01.add( codigoPaquete );

               }                          

       for( int j=0; j[objElement_02.size(); j++ ){
                                                Element objElemento_02     = objElement_02.get( j );
                                                String  descripcionPaquete = objElemento_02.text();
                                              
                                                listaDatos_02.add( descripcionPaquete );
                               }                                                         

      for( int x=0; x[objElement_03.size(); x++ ){
            Element objElemento_03 = objElement_03.get( x );
            String  codigoSMS      = objElemento_03.text();

            listaDatos_03.add( codigoSMS );
     }
                                          
       for( int y=0; y[objElement_04.size(); y++ ){
              Element objElemento_04 = objElement_04.get( y );
              String  precio         = objElemento_04.text();                                              

              listaDatos_04.add( precio );
      }               

       for( int z=0; z[objElement_05.size(); z++ ){
                Element objElemento_05 = objElement_05.get( z );
               String  mbInc          = objElemento_05.text();                                              

              listaDatos_05.add( mbInc );

      }
                             
     for( int w=0; w[objElement_06.size(); w++ ){
              Element objElemento_06 = objElement_06.get( w );
               String  vigencia       = objElemento_06.text();                                              

                listaDatos_06.add( vigencia );
       }            
                            
         //LISTA #1:
         for( int i=0; i[listaDatos_01.size(); i++ ){                                     

               objProductosBean = new ProductosBean();
                                              
               String nombre = listaDatos_01.get( i );
                objProductosBean.setNombre( nombre );
                                              
                //LISTA #2:
               for( int j=i; j[listaDatos_02.size(); j++ ){
                    String descripcion = listaDatos_02.get( j );                                                              

                     if( i == j ){      
                          objProductosBean.setDescripcion( descripcion ); 
                     }
                     else{
                             break;                  
                     }

  //LISTA #3:
   for( int x=i; x[listaDatos_03.size(); x++ ){
           String codigo = listaDatos_03.get( x );                                                                              
if( j == x ){    
     objProductosBean.setCodigo( codigo );
  }
        else{
                break;

  }
                                                                            
   //LISTA #4:
         for( int y=i; y[listaDatos_04.size(); y++ ){
               String precio = listaDatos_04.get( y );
                                                                                             
              if( x == y ){  
                   objProductosBean.setPrecio( precio );
             }
            else{
                   break;
           }
                                                                                             
          //LISTA #5:
         for( int z=i; z[listaDatos_05.size(); z++ ){
              String megas = listaDatos_05.get( z );                                                                                                             

      if( y == z ){
          objProductosBean.setMegas( megas );
   }
  else{
          break;
 }

//LISTA #6:
 for( int w=i; w[listaDatos_06.size(); w++ ){

     String vigencia = listaDatos_06.get( w);                                                                                                                            

 if( z == w ){ 
     objProductosBean.setVigencia( vigencia );                                                        

 }
  else{
           break;
             }
            }
           }
         }
         }  
       }

        listaProductosBean.add( objProductosBean );
  }

 System.out.println( listaDatos_01 );
 System.out.println( listaDatos_02 );
 System.out.println( listaDatos_03 );
 System.out.println( listaDatos_04 );
 System.out.println( listaDatos_05 );
  System.out.println( listaDatos_06 );
                            
 System.out.println( "RESULTADO: " + listaProductosBean );                       
}

El resultado sería el siguiente:
[AAA0001, BBB0002]
[PAQUETE #1, PAQUETE #2]
[AAA, BBB]
[11, 22]
[200, 300]
[1, 24]

RESULTADO: [ProductosBean [nombre=AAA0001, descripcion=PAQUETE #1, codigo=AAA, precio=11, megas=200, vigencia=1], ProductosBean [nombre=BBB0002, descripcion=PAQUETE #2, codigo=BBB, precio=22, megas=300, vigencia=24]]
 
Para descargar el ejemplo completo dar click: AQUÍ

MODIFICACIÓN DE .PROPERTIES EN FÍSICO.

Buen día en esta oportunidad mostraré una forma de cómo realizar una modificación sobre un archivo .properties en caliente.  En si esto me sucedió el año pasado en mi trabajo ya que nos llegó un requerimiento dentro del cual se pedía que algunos datos que se jalaban de un .properties deberían ser cambiantes en el tiempo, debido a ellos se tenía que no solo manejar en memoria los cambios sino que estos datos deberían ser aplicados en físico sobre algunos campos del .properties.
La verdad que no sabía bien cómo hacerlo pero poco a poco se me vinieron ideas a la mente y este fue el dummy que arme como base de manera independiente.
 

1. Para el manejo de las excepciones posibles las clase son las siguientes:
   - BaseException.java
   - FileException.java


2. Se está manejando una clase utilitaria para la manipulación de del fichero, carga y   modificación de datos del  .properties en el Hastmap, etc:
   - UtilFichero.java


3. Para la ejecución del Dummy:
   - TestUpdateProperties.java

    
4. Archivo de configuración a modificar:
   - MiFichero.properties


LÓGICA:

La lógica del Dummy es que existe un método que recibirá dos parámetros: “EL CAMPO” y la “DESCRIPCION” del .PROPERTIES. Luego, se validará las rutas de existencia del fichero .properties. Si es que existiera se cargarían todos los datos del .properties dentro de un Hashmap. Luego, se modificará un campo del Hashmap en base al dato inicial: “EL CAMPO” y se actualizará la “DESCRIPCION”.Luego, se creará un .properties TEMPORAL en el cual se grabará el contenido del Hashmap (Ya con el cambio). Después, se eliminará el .properties original, Finalmente, se renombrará el archivo TEMPORAL por el nombre original del .properties. En si  el proceso es muy rápido.



Para más detalle descargar el ejemplo completo desde: AQUÌ.

GENERACIÓN DE CÓDIGO AUTOGENERADO ALFANUMÉRICO

En algunas situaciones es necesario realizar códigos autogenerados para asociarlos a diferentes datos como IDs. En esta oportunidad mostraré una manera muy fácil de como autogenerar un código alfanumérico de 32 caracteres.

La idea es del Dummy es crear un AUTOGENERADO de 32 caracteres de tipo AlfaNumérico, en base a 2 métodos uno para aleatorios ENTEROS y otro método para aleatorios de tipo CADENA:

 /*
 * Test_CodigoAleatorio
 */
 public class Test_CodigoAleatorio{
 
   /*
    * main     
    */
    public static void main( String[] argumentos ){
              
        Test_CodigoAleatorio x = new Test_CodigoAleatorio();
      
        String codigo = x.getCodigoAleatorioEstandar();
      
        System.out.println( codigo );
    }
  
   /*
    * getCodigoAleatorioEstandar   
    * @return String
    */
    public String getCodigoAleatorioEstandar(){
      
        String codigoAleatorio = "";
      
        for( int i=0; i<32 br="" i="" nbsp="">            
             if( i%2 == 0  ){
                 codigoAleatorio = (codigoAleatorio + this.getAleatorionLetras() );
             }
             else{                
                  codigoAleatorio = (codigoAleatorio + this.getAleatorionNumeros( 0, 9 ) );
             }
        }
      
        return codigoAleatorio;      
    }
    
   /*
    * getAleatorionNumeros   
    * @param  num_01
    * @param  num_02
    * @return int
    */
    private int getAleatorionNumeros( int num_01, int num_02 ){
        if( num_02 < num_01 ){
            return (int)( ( num_02 - num_01 + 1 ) * Math.random() + num_01 );
        }
        else{
            return (int)( ( num_01 - num_02 + 1 ) * Math.random() + num_02 );
        }
    }
  
   /*
    * getAleatorionLetras   
    * @return int
    */
    private String getAleatorionLetras(){
        
           String [] abecedario = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
                                    "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"  };

           int    numLetraRandon = this.getAleatorionNumeros( 1, 26 );
           String letra          = abecedario[ numLetraRandon ];
         
           return letra;
    }
  
 }

 Esto es todo hasta la próxima....

'OFUSCACION' DE CODIGO CON 'PROGUARD'

En muchas oportunidades es común que algunos PROGRAMADORES FREELANCE dependiendo del contrato que hayan negociado, deseen proteger su código, JAR, WAR, etc, para que de esta manera la empresa o cliente ante alguna modificación requería de su servicio otra vez. El método de encriptación aplicado se le conoce como OFUSCAR y existen en el mercado algunas herramientas que nos facilitan esta forma. Buscando alguna que me convenza me encontré con una muy buena llamada: ProGuard y pasare a describirla.

ProGuard es una librería hecha en JAVA que nos permite OPTIMIZAR y OFUSCAR (dificultar la visión) del código JAVA una vez que este esté compilado. También, optimiza el ByteCode al eliminar líneas de código que no se utilizan, cambia de nombre las clases, campos y métodos con nombres cortos haciendo el código casi indescifrable.

Para descargar ProGuard vamos a: http://proguard.sourceforge.net

Para Dummy preparado me base en uno más simple de Internet al cual mejore y detalle la explicación para facilitar conocimiento de su manejo.

REQUERIMIENTO:

1. Eclipse (en mi caso v3.6).
2. El descomprimido de ProGuard (Dentro viene con su interfaz grafica).
3. El decompilador Java JD-GUI v0.3.3.

En si el Dummy lo que hace es generar en base a un JAR_ORIGINAL por ejemplo otro JAR_OFUSCADO el cual funciona perfectamente igual que el anterior pero el cual si lo decompilamos mediante alguna herramienta decompiladora el código será ilegible ya sea en lo relacionado a OBJETOS, CLASES, METODOS, VARIABLES, DECLARACIONES, etc., esto hará que tu código no lo puedan alterar. También, ProGuard brinda en la generación la capacidad de MEJORAR el código existente eliminando trozos de código que no es usado, reduciendo en tamaño significativamente del JAR, generando también un archivo de EQUIVALENCIA de lo que se ha OFUSCADO y finalmente, generando una plantilla de CONFIGURACION para que al momento de volver a querer OFUSCAR dicho JAR ya no tener que hacer todos los pasos otra vez.

Para mas detalle descargar el ejemplo completo descargarlo de: AQUÌ.