Hola mundo con JAXB

Esta ves regreso con un pequeño ejemplo para utilizar JAXB, una herramienta muy útil para manejar documentos XML. Esta se encarga de transformar una clase Java a XML y a la inversa. sin mas empiezo con el ejemplo. 

En este ejemplo utilizare 2 objetos: "usuario" y dentro de este un bean "empresa".

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Empresa {
 private int id;
 private String nombre;
 
 public int getId() {
  return id;
 }
 @XmlAttribute
 public void setId(int id) {
  this.id = id;
 }
 public String getNombre() {
  return nombre;
 }
 @XmlElement
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
}

import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class Usuario {
 
 
 private String nombre; 
 private String apellido; 
 private int id;
 private Empresa empresa;

 public String getNombre() {
  return nombre;
 }
 @XmlElement
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getApellido() {
  return apellido;
 }
 @XmlElement
 public void setApellido(String apellido) {
  this.apellido = apellido;
 }
 public int getId() {
  return id;
 }
 @XmlAttribute
 public void setId(int id) {
  this.id = id;
 }
 public Empresa getEmpresa() {
  return empresa;
 }
 @XmlElement
 public void setEmpresa(Empresa empresa) {
  this.empresa = empresa;
 }
 
}

Se puede apreciar que estoy utilizando 3 anotaciones diferentes:

•  @XmlRootElement .- esta anotación indica que la clase sera un bloque xml.
•  @XmlElement .- esta anotación indica que sera un elemento del bloque xml.
•  @XmlAttribute .- indica que la variable sera un atributo distintivo del bloque xml.

Ahora toca el turno de la clase encargada de convertir los beans de java a bloques xml.

import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

//clase que hara el marshalling
public class JavaToXML {
 
 public void marshalling( String rutaArchivo , Usuario bean ){
  try {

import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;

//clase que hara el marshalling
public class JavaToXML {
 
 public void marshalling( String rutaArchivo , Usuario bean ){
  try {
   //creamos un archivo
   File file = new File( rutaArchivo );
  
   //generamos una instancia de nuestro bean principal
   JAXBContext jaxbContext;  
   jaxbContext = JAXBContext.newInstance(Usuario.class);
   
   //preparamos la formacion del xml
   Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
   //indicamos que el resultado xml debe estar con formato, es decir: identado y no en un renglon
   jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
  
   //indicamos los destinos del xml resultante, en este caso el archivo y la consola
   jaxbMarshaller.marshal( bean , file);
   jaxbMarshaller.marshal( bean , System.out);
   
  } catch (JAXBException e) {
   e.printStackTrace();
  }
 }
 
 public static void main( String args [] ){
  JavaToXML ejemplo = new JavaToXML();
  
  Usuario bean = new Usuario();
  bean.setNombre( "perla" );
  bean.setApellido( "leal" );
  bean.setId( 12 );
  
  Empresa beanE = new Empresa();
  beanE.setId( 2 );
  beanE.setNombre( "Java-limos" );
  bean.setEmpresa( beanE );
  
  String rutaArchivo = "C:\\myEjemplo.xml";
  
  ejemplo.marshalling( rutaArchivo , bean );
 }
 
}

si ejecutamos el siguiente código obtendremos un archivo como el siguiente:

    leal
    
        Java-limos
    
    perla

proseguimos a crear la clase encargada de convertir el xml en beans de java

import java.io.File;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;

//Unmarshaller
public class XMLToJava {

 public void unmarshalling( String rutaArchivo ){
  try {
   //indicamos el archivo xml
   File file = new File( rutaArchivo );
   
   //creamos una instancia del bean principal
   JAXBContext jaxbContext = JAXBContext.newInstance(Usuario.class);
   
   //preparamos el convertidor xml a java
   Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
   
   //extraemos la informacion
   Usuario usuario = (Usuario) jaxbUnmarshaller.unmarshal(file);

   System.out.println( "nombre: " + usuario.getNombre() );
   System.out.println( "apellido: " + usuario.getApellido() );
   System.out.println( "id: " + usuario.getId() );
   System.out.println( "empresa: " + usuario.getEmpresa().getNombre() );
   
  } catch (JAXBException e) {
   e.printStackTrace();
  }
 }
 
 public static void main( String args [] ){
  XMLToJava ejemplo = new XMLToJava();
  
  String rutaArchivo = "C:\\myEjemplo.xml";
  ejemplo.unmarshalling( rutaArchivo );
 }
}

Como se puede ver es un código muy sencillo, basta con leer un poco la documentación y ponerse a jugar con el para poder crear xml mas complejos.

saludos. 

Encriptación utilizando el algoritmo AES Actualizado

Hace ya un tiempo escribí una entrada sobre la encriptación AES, y he de aceptar que cometí 2 errores en el código por tanto vuelvo a subir la clase principal y esta ves con el código en forma continua haciendo incapie en las diferencias contra el original, de este modo espero solventar los inconvenientes que causo el código anterior.

finalmente les comento que la clase AESKey utilizada en la entrada anterior queda intacta saludos.

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

public class AESEncriptacion {

 private AESKey aesKey;
 private final String ALGORITMO = "AES";
 private final int LONGITUD = 128;
 private final String CODIFICACION = "UTF-8";

 public AESEncriptacion(AESKey aesKey) throws Exception {  
  this.aesKey = aesKey;
 }
  
 public AESKey generaKey() throws Exception {
   KeyGenerator kgen = KeyGenerator.getInstance(ALGORITMO);
   kgen.init(LONGITUD);
   SecretKey skey = kgen.generateKey(); 
   AESKey aesKey = new AESKey();
   aesKey.setEncoded(HexToString(skey.getEncoded()));
   //originalmente estava (metida de pata)
   // aesKey.setEncoded(StringtoHex(skey.getEncoded()));
   return aesKey;
 }
 
 public String encripta(String cadena) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, 
 IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {  
    byte[] raw = StringToHex(aesKey.getEncoded());
    SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITMO);
    Cipher cipher = Cipher.getInstance(ALGORITMO);
    cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
    byte[] encrypted = cipher.doFinal(cadena.getBytes(CODIFICACION));
    String encriptado = HexToString(encrypted);
    return encriptado;
 }
 
 private String HexToString(byte[] arregloEncriptado) {
   String textoEncriptado = "";
   for (int i = 0; i < arregloEncriptado.length; i++) {
     int aux = arregloEncriptado[i] & 0xff;
     if (aux < 16) {
      textoEncriptado = textoEncriptado.concat("0");
     }
     textoEncriptado = textoEncriptado.concat(Integer.toHexString(aux));
   }
   return textoEncriptado;
 }
 
 private byte[] StringToHex(String encriptado) {
   byte[] enBytes = new byte[encriptado.length() / 2];
   for (int i = 0; i < enBytes.length; i++) {
     int index = i * 2;
     String aux = encriptado.substring(index, index + 2);
     int v = Integer.parseInt(aux, 16);
     enBytes[i] = (byte) v;
   }
   return enBytes;
 }
 
 public String desencriptar(String encriptado) throws InvalidKeyException, IllegalBlockSizeException, BadPaddingException,
   UnsupportedEncodingException, NoSuchAlgorithmException, NoSuchPaddingException {
   byte[] raw = StringToHex(aesKey.getEncoded());
   SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITMO);
   Cipher cipher = Cipher.getInstance(ALGORITMO);  
   cipher.init(Cipher.DECRYPT_MODE, skeySpec);
   byte[] original = cipher.doFinal(StringToHex(encriptado));
   String originalString = new String(original);
   return originalString;
 }
 
 public static void main(String args[]) throws Exception {
   AESKey aesKey = new AESKey();
     
   AESEncriptacion tmp = new AESEncriptacion(aesKey);
   //originalmente estava, error nuevamente
   //AESEncriptacion tmp = new AESEncriptacion();
   aesKey = tmp.generaKey();
    
   AESEncriptacion ejemplo = new AESEncriptacion(aesKey);
   
   String encriptado = ejemplo.encripta("123456789012345678");
   String desencriptado = ejemplo.desencriptar(encriptado);
   System.out.println(encriptado);
   System.out.println(desencriptado);
   System.out.println("***************************************************");
   encriptado = ejemplo.encripta("esto es un segundo ejemplo");
   desencriptado = ejemplo.desencriptar(encriptado);
   System.out.println(encriptado);
   System.out.println(desencriptado);
 }
}

Simple Paginador JavaScript

Ya mucho tiempo sin publicar, pero ps el trabajo no siempre deja hacerlo.

El dia de hoy regreso con un pequeño ejemplo para hacer un paginador en javascript, es una version editada de un ejemplo que encontre hace tiempo pero no recuerdo la pagina jejejeje.

Empesamos creando un pequeño archivo .js que llamare paginador...

//creamos una funcion que se llamara Pager que recibira el nombre de la tabla,
//y la cantidad de registros seran presentados por paginador 
//y finalmente que contendra 7 variables

function Pager(tableName, itemsPerPage) {
    this.tableName = tableName; // se asigna el nombre de la tabla al objeto
    this.itemsPerPage = itemsPerPage; // se asigna el numero de registros
    this.currentPage = 1; //indicamos cual es la pagina que presentaremos inicialmente
    this.pages = 0;//aun no sabemos cuantas paginas seran, por tanto lo declaramos a 0
    this.inited = false;//idicamos si ya inicio la tabla o no
    this.divisores = 0;//aun no sabemos la cantidad de divisores por eso la declaramos a cero
    this.cantidadDivs=5;//cantidad de divisores a mostrar por paginador
}

/**la variable divisores y cantidadDivs, son referencia a que mostraremos paginadores de 5 en 5, 
por ejemplo si tenemos 120 registros y los mostraremos de 10 en 10, con la variable divisores indicamos que mostraremos 5 divisores, 
es decir, mostraremos el paginador 1(registros 1-10), paginador 2(registros 11,20).. asi hasta el paginador 5(registros 41-50), 
y cuando le demos siguiente, se mostraran los paginadores 6 al 10 ( registros 51-100, 
separados en su respectivo paginador )*

Dentro de nuestra funcion crearemos una sub-funcion llamada init

this.init = function() {
    var rows = document.getElementById(tableName).rows;
    var records = (rows.length - 1); 
    this.pages = Math.ceil(records / itemsPerPage);
        
    this.divisores = Math.ceil( this.pages / this.cantidadDivs );     
        
    this.inited = true;
}
/**
obtenemos la cantidad de registos que contiene la tabla.

obtenemos la cantidad de registos, recordemos que las numeraciones empiesan en 0, para el caso de la variable rows.

obtenemos el numero de paginas que mostraremos.

obtenemos el numero de divisores que tendremos 
( recordemos que es como un agrupador para los paginadores )

colocamnos la variable inicializado como cierto
*/

Creamos nuestra funcion para poder mostrar los registros

this.showRecords = function(from, to) {        
    var rows = document.getElementById(tableName).rows;
    for (var i = 1; i < rows.length; i++) {
     if (i < from || i > to)  
        rows[i].style.display = 'none';
     else
        rows[i].style.display = '';
    }
}
/**
El metodo recibe el rango de registros, y lo unico que hace es colocar 
o borrar el estilo, en su apartado display a "none"
*/

Creamos nuestra funcion para poder mostrar los divisores

this.showDivs = function(pageNumber){  
    var divisorMostrar = Math.ceil(pageNumber / this.cantidadDivs);     
    for( var i = 1 ; i <= this.divisores ; i++ ){
     if( divisorMostrar == i ){
       document.getElementById('dv'+i).style.display = '';
     }else{
       document.getElementById('dv'+i).style.display = 'none';
        }
    }    
}
/**
obtenemos el id del agrupador de divisores, 
e igual agregamos o borramos el estilo display

por ahora no se preocupen por los ids, esos los veremos mas adelante
*/

Creamos nuestra funcion para poder mostrar un paginador

this.showPage = function(pageNumber) {
    if (! this.inited) {
     alert("La tabla no se inicializo");
     return;
    }
     
    this.showDivs(pageNumber);
     
    this.currentPage = pageNumber;
        
    var from = (pageNumber - 1) * itemsPerPage + 1;
    var to = from + itemsPerPage - 1;
    this.showRecords(from, to);
}   
/**
este metodo recibe su el id del paginador a mostrar
pero primero valida que la tabla este inicializada, para no mandar un error javascript

invocamos el metodo que mostrara los divs, y calculamos los registros que se han de mostrar
*/

Creamos los metodos que invocaran nuestros botones

    this.prev = function() {
       if (this.currentPage > 1)
          this.showPage(this.currentPage - 1);
    }
    
    this.first = function() {
        if (this.currentPage > 1)
            this.showPage( 1 );
    }
    
    this.next = function() {
        if (this.currentPage < this.pages) {
            this.showPage(this.currentPage + 1);
        }
    }    
    
    this.last = function() {
        if (this.currentPage < this.pages) {
            this.showPage(this.pages);
        }
    }

/**
Son los metodos de los botones primero, anterior, siguiente, ultimo
*/    

Creamos el metodo principal que asignara ids a divisores a paginadores,

this.showPageNav = function(pagerName, positionId) {
     if (! this.inited) {
      alert("La tabla no esta inicializada");
      return;
     }
     var element = document.getElementById(positionId);
     
     var pagerHtml = '  inicio   ';
     pagerHtml += '  anterior   ';
        
     var divisor = 1;
     var idDivisor = 1;
     for (var page = 1; page <= this.pages; page++) {
      if( idDivisor==1 ){
       pagerHtml += '

';
      }  
      idDivisor = idDivisor+1;
         pagerHtml += '' + page + '';
         if(idDivisor==this.cantidadDivs+1){
          idDivisor=1;
          divisor=divisor+1
          pagerHtml += '
';
         }else if( page == this.pages ){
          pagerHtml += '
';
         }
        }
        pagerHtml += ' siguiente   ';            
        pagerHtml += ' fin ';
        
        element.innerHTML = pagerHtml;
    }

/**
verificamos que la tabla este inicializada.

recorremos las paginas calculadas anteriormente asignandole ids, la funcion onclick

finalmente todo ese codigo lo asignamos a una variable que es la encargada de pintar el html en nuestra pagina
*/

Solo nos resta invocar el codigo en nuestro html

recuerden colocar el 




   


      
Nombre
      
Apellido
      
Edad
   

      
Pruebas
      
Java
      
Limos
   




     

-->
Como ven no es tan dificil agregar un navegador simple, la parte de estilos ya les corresponde y si tienen comentarios u otra cosa se los agradecere

CONVERSIONES ENTRE FORMATOS DE TEXTO

Despues de ya un tiempo sin publicar una nueva entrada, regreso con un pequeño post muy util para convertir caracteres en formatos javacript, java, sql, html, xml.

Es una clase contenida en el paquete "commons-lang" llamada StringEscapeUtils, para el ejemplo utilizo la version 2.3 de commons-lang.

Esta clase es muy util, mas cuando tenemos que presentar datos en pantalla, por medio de jquery por ejemplo, no por jquery como tal, si no por en casi todas las ocaciones ie, que no realiza las conversiones como lo hacen los otros browsers.


y sin más, pongo el ejemplo:

import org.apache.commons.lang.StringEscapeUtils;

public class ConversionCaracteres {
 
 public static void convierteJavaScript( String texto ){
  System.out.println( "Convierte texto java : "+ texto 
+" a javaScript : " + StringEscapeUtils.escapeJavaScript(texto) );
 }
 
 public static void convierteJava( String texto ){
  System.out.println( "Convierte texto java : "+ texto 
+" a java : " + StringEscapeUtils.escapeJava(texto) );
 }
 
 public static void convierteXml( String texto ){
  System.out.println( "Convierte texto java : "+ texto 
+" a xml : " + StringEscapeUtils.escapeXml(texto) );
 }

 public static void convierteHtml( String texto ){
  System.out.println( "Convierte  texto java : "+ texto 
+"a html : " + StringEscapeUtils.escapeHtml(texto) );
 }
  
 
 public static void convierteJavaScriptAJava( String texto ){
  System.out.println( "Convierte texto javaScript : "+ texto 
+" a java : " + StringEscapeUtils.unescapeJavaScript(texto) );
 }
 
 public static void convierteJavaAJava( String texto ){
  System.out.println( "Convierte texto java : "+ texto 
+" a java : " + StringEscapeUtils.unescapeJava(texto) );
 }
 
 public static void convierteXmlAJava( String texto ){
  System.out.println( "Convierte texto xml : "+ texto 
+" a java : " + StringEscapeUtils.unescapeXml(texto) );
 }

 public static void convierteHtmlAJava( String texto ){
  System.out.println( "Convierte  texto html : "+ texto 
+"a java : " + StringEscapeUtils.unescapeHtml(texto) );
 }

 public static void main(String[] args) {
  
//  convierte java a otros formatos
  String texto = "Información con acentos.";
  convierteJavaScript( texto );
  convierteJava( texto );
  convierteXml( texto );
  convierteHtml( texto );
  
  System.out.println("\n");
  
//  convierte otros formatos a java
  String t1="Informaci\u00F3n con acentos.";
  String t2="Informaci\u00F3n con acentos.";
  String t3="Información con acentos.";
  String t4="Información con acentos.";
  convierteJavaScriptAJava( t1 );
  convierteJavaAJava( t2 );
  convierteXmlAJava( t3 );
  convierteHtmlAJava( t4 );
 }
}

para ejemplos menos cuchos pongo la ligua del api: Pulsa

CREANDO UN ARCHIVO DE EXCEL CON LA LIBRERIA POI

 la libreria poi es muy util para poder crear archivos de excel de una manera rapida y sensilla, tiene la funcionalidad de poder abrir una plantilla creada anteriormente para poder hacer el trabajo mas sensillo aun.


En este caso solo crearemos un excel muy sensillo.


1.- Necesitamos descargar la libreria poi, de la pagina de apache, en este caso utilizare la version "poi-3.8-beta4-20110826.jar"


2.- Crearemos 2 paquetes "com.excel.poi.ejemplo" y "com.excel.poi.test"


3.- En el primer paquete, crearemos la clase CrearExcel

package com.excel.poi.ejemplo;

import java.io.File;
import java.io.FileOutputStream;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRichTextString;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

public class CrearExcel {
 
 HSSFWorkbook libro;
 HSSFSheet hoja;
 HSSFRow fila;
 HSSFCell celda;
 HSSFRichTextString texto;
 
/**
*creamos un libro de excel, y sobre ese libro creamos una hoja
*/
 public void configuraLibroHoja(){
  libro = new HSSFWorkbook();
  hoja = libro.createSheet();
 }
 
/**
*creamos una fila y una columna, recordando que las numeraciones empiezan en 0
luego agregamos un texto
*/
 public void agregarTexto( int f , int c , String textoEscribir){
  fila = hoja.createRow( f );
  celda = fila.createCell( c );
  texto = new HSSFRichTextString( textoEscribir );
         celda.setCellValue(texto);
 }
 
/**
*creamos un fileOutputStream para guardar el archivo, 
y simplemente la informacion contenida en el libro la escribimos en el archivo
*/
 public void guardarArchivo( String rutaGuardar , String nombreArchivo){  
  try {
            FileOutputStream elFichero = 
new FileOutputStream( rutaGuardar + File.separator + nombreArchivo + ".xls" );
            libro.write(elFichero);
            elFichero.close();                       
        } catch (Exception e) {
         System.out.println(" no se pudo guardar el archivo en la ruta especificada " 
+ e.getMessage());
        }  
 }
}

4.- En el segundo paquete, crearemos la clase TestExcel

package com.excel.poi.test;

import com.excel.poi.ejemplo.CrearExcel;

public class TestExcel {

 /**
  * @param args
  */
 public static void main(String[] args) {
  //CLASE MUY SENSILLA DE UTILIZAR !
  CrearExcel myExcel = new CrearExcel();
  myExcel.configuraLibroHoja();
  myExcel.agregarTexto(1, 1, "Hola mundo desde Java-Limos");
  myExcel.guardarArchivo( "C://Users//JAVA-LIMOS//Documents//POI" , "ExcelJava_Limos");

 }

}

Esto de crear archivos de excel, con poi es relativamente sensillo. y como decia mi sensei, un programa es tan sensillo o complejo hasta donde nosotros queramos !

Creando una aplicacion con JSF RichFaces parte V

Esta es la ultima entrada respecto a RICHFACES, no agrego integracion con hibernate, por el hecho de que no he posteado sobre el de forma individual, como sea lo retomare en el futuro.

ahora solo nos queda crear un flujo basico que utiliza richfaces...

seran dos jsp, una pantalla de login y otra de bienvenida.

1.- jsp de login.

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<%@taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
 
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

html
    head
    /head
    body
    




    /body
/html

2.- bean de login.

public class Login {
 private String nombre;
 private String password;
 
 public String getNombre() {
  return nombre;
 }
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }
 public String getPassword() {
  return password;
 }
 public void setPassword(String password) {
  this.password = password;
 } 
 public void limpiar(){
  setPassword("");
  setNombre("");
 }
}

3.- bean loginService.

public class LoginService{
private Login login;
public String loginAction() {  
 if(getLogin().getNombre()!=null && getLogin().getPassword()){   
  return "loginOk";
 }  
return null;
}
public void setLogin(Login login) {
 this.login = login;
}
public Login getLogin() {
 return login;
}
}

4.- jsp de bienvenida.

<%@page contentType="text/html" pageEncoding="UTF-8"%>

<%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
<%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
<%@taglib uri="http://richfaces.org/rich" prefix="rich"%>
<%@taglib uri="http://richfaces.org/a4j" prefix="a4j"%>
 
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

html
    head
    /head
    body
          
              
          
    /body
/html

5.- configuracion del faces config.

     /login.jsp
     
          loginOk
               /bienvenida.jsp
               
       



     /bienvenida.jsp

LISTO AQUI TENEMOS UN FLUJO BASICO PARA NUESTRO JSP, CON ESTO TERMINO LOS POST SOBRE RICHFACES BASICO, EN SIGUIENTES ENTRADAS PUBLICARE SOBRE FACELETS Y COSASQUE HARAN QUE FURULE MEJOR NUESTRO SISTEMA

Creando una aplicacion con JSF RichFaces parte IV

Despues de una larga ausencia, regreso con todas las ganas, a terminar este mini tutorial de richfaces.

En esta entrada señalare lo basico de richfaces y jsf como tal.

1.- Al utilizar jsf nos olvidamos de la mayoria de las etiquetas html que utilizabamos anteriormente

pero aparecen otras:

     <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
     <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
     <%@taglib prefix="rich" uri="http://richfaces.org/rich"%>
     <%@taglib prefix="a4j" uri="http://richfaces.org/a4j"%>

2.- El prefijo f

/**
* son el conjunto de etiquetas basicas de jsf puro, donde podemos encontrar
* vistas, select, validadores, es de algun modo poco utilizada
*/

3.- El prefijo h

/**
* en esta etiqueta podemos encontrar componentes html, como tablas, formularios
* cajas de texto, etiquetas, botones, selectores, etiquetas para imprimir mensajes
*/

4.- El prefijo rich

/**
* en esta etiqueta podemos encontrar, tablas, validadores, calendarios, selectores,
* menus de contexto, menus, arboles, efectos, etiquetas para utilizar google maps.
*/

5.- El prefijo a4j

/**
* con esta etiqueta utilizamos componentes ajax, como listeners,
* includes, botones, link, funciones js, formularios etc.
*/

6.- Donde agregamos los prefijos en nuestro jsp?

     <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
     <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
     <%@taglib prefix="rich" uri="http://richfaces.org/rich"%>
     <%@taglib prefix="a4j" uri="http://richfaces.org/a4j"%>

7.- Estructura basica de un jsp con jsf

    <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
     <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
     <%@taglib prefix="rich" uri="http://richfaces.org/rich"%>
     <%@taglib prefix="a4j" uri="http://richfaces.org/a4j"%>




    
        
        
    

8.- Definicion del faces-config.xml

    /index.jsp
    
        iniciar
        /inicio.jsp
        
    



  /inicio.jsp

AHORA PODEMOS REALIZAR UNA PEQUEÑA APLICACION JSF, Q ES LO QUE
SE PRETENDE EN LA SIGUIENTE ENTRADA... SALUDOS!

Creando una aplicacion con JSF RichFaces parte III

En esta ocacion haremos la integracion de nuestro proyecto con el framework de spring, que nos ayudara a hacer inyeccion de dependencias he integrar funcionalidades me una manera mas facil y transparente.

En la anterior entrada olvide comentar 2 puntos, donde poner el log4j y como invocarlo

     

     log4jConfigLocation     /WEB-INF/log4j.xml

     
          org.springframework.web.util.Log4jConfigListener
     

Ahora si para agregar spring a nuestro proyecto: 

1.- Agregando las librerias

/**
* En mi Caso utilizo las varsiones 3.0.5 de estos jar
* org.springframework.asm.jar
* org.springframework.beans.jar
* org.springframework.context.jar
* org.springframework.core.jar
* org.springframework.expression.jar
* org.springframework.web.jar
*/

2.- Creando el application-context.xml

3.- Modificando el web.xml

     contextConfigLocation               /WEB-INF/applicationContext-faces.xml
     
	


     
          org.springframework.web.context.ContextLoaderListener
     


     
          org.springframework.web.util.IntrospectorCleanupListener
     


     
          org.springframework.web.context.request.RequestContextListener
     

4.- Modificando el faces-config.xml

     org.springframework.web.jsf.DelegatingVariableResolver

5.- Creando los bean

/**
* lo hare estilo struts, un form que llamo bean y un action que llamo "cont"
* el bean lo coloco en com.tutorial.rich.faces.bean
* el contenedor lo coloco en com.tutorial.rich.faces.content
*/

public class Login {
private String usuario;
private String password;

public String getUsuario() {
	return usuario;
}
public void setUsuario(String usuario) {
	this.usuario = usuario;
}
public String getPassword() {
	return password;
}
public void setPassword(String password) {
	this.password = password;
}
}

/**
* agrego una llamada a mi log4j
*/
public class LoginCont {
	private static Logger log = Logger.getLogger(LoginCont.class);
	
private Login loginBean;

public Login getLoginBean() {
	return loginBean;
}
public void setLoginBean(Login loginBean) {
	this.loginBean = loginBean;
}

public String cmdLogin(){
	if(getLoginBean().getUsuario().equals("") 
|| getLoginBean().getPassword().equals("")){
		log.info("usuario invalido");
	}else{
		log.info("usuario valido");		
	}
	return null;
}
}

6.- Invocando al bean desde el jsp

NOTAS, HASTA AQUI TENEMOS CONFIGURADO SPRING Y UN EJEMPLO DE COMO ACCESAREMOS A LOS BEANS,
PERO AUN NO EXPLICO EL FUNCIONAMIENTO DE JSF, LO HARE AL MOMENTO QUE TENGAMOS HIBERNATE INTEGRADO CON NUESTRO PROYECTO..., RECUERDA SI TIENES DUDAS U OBSERVACIONES AGRADECERE TUS COMENTARIOS

Creando una aplicacion con JSF RichFaces parte II

Hola que tal, despues de una larga ausencia regreso con este tutorial de richfaces, espero no ausentarme tanto otra ves :P.

En la entrada anterior vimos como dejar nuestra aplicacion lista para utilizar este framework, en esta ocacion agregaremos la internacionalizacion y dejaremos habilitado nuestro log4j.

1.- Crearemos el paquete donde estaran nuestros resources y creando los resources

/*
     * El paquete lo llamare com.tutorial.rich.resources
     * crearemos dos resources los cuales llamaremos
     * ApplicationResources_en_EN.properties y
     * ApplicationResources_es_MX.properties respectivamente
     * ApplicationResources_ es el nombre generico que les damos 
     * a nuestros resources, por lo cual le podemos dar cualquier nombre
     * es_MX o en_EN son los codigos de lenguaje y pais
     * si quieres saber mas de esto busca informacion sobre la clase Locale de java
     */

     /* La informacion contenida en ApplicationResources_en_EN.properties
     *
     * login_lblTituloPag=Login
     * login_lblUsuario=User
     * login_lblPassword=Password
     */

     /* La informacion contenida en ApplicationResources_es_MX.properties
     *
     * login_lblTituloPag=Login
     * login_lblUsuario=Usuario
     * login_lblPassword=Contraseña
     */

     /*
     * ¿ Por que no usuamos los timpicos login.lbl.titulo.pag 
     * y utilizamos login_lblTituloPag ?
     * por que a diferencia de Strust por ejemplo, jsf reconoce el punto
     * como si intentaramos acceder a un elemento de un objeto
     * por lo tanto utilizamos el guion bajo, "para este ejemplo"
     * no es una norma
     */

2.- Modificando el faces-config

    


     
          com.tutorial.rich.resources.ApplicationResources
          msgs
     
     
          en_EN
     

3.- Agregando un JSP con etiquetas, que cambiaran dependiendo del idioma

/*
     * En el jsp que se creo por default, (index) agregaremos en la parte superior 
     * las siguientes taglibs
     */

     <%@taglib prefix="f" uri="http://java.sun.com/jsf/core"%>
     <%@taglib prefix="h" uri="http://java.sun.com/jsf/html"%>
     <%@taglib prefix="rich" uri="http://richfaces.org/rich" %>

     /*
     * En el body del jsp agregaremos lo siguiente
     */
     
          
               
                    
                         						
                    
                    

                    
		
                    

                    

                    
          
     
     /*
     * no explicare el porque de cada etiqueta, hasta la siguiente entrada
     * pero observen que para acceder a los mensajes utilizo por ejemplo
     * 
     * en value hago el llamado a la etiqueta msgs que declaramos en el faces-config
     * luego solo hago referencia a la etiqueta del resource que deseo utilizar
     */

4.- Configurando web.xml

     
     
     
          faces/index.jsp
     

5.- Probando la aplicacion

/*
      * para probar solo es mover el codigo en el faces-config  de
      * en_EN a
      * es_MX
      */

6.- Configurando log4j

Creando una aplicacion con JSF RichFaces parte I

Esta ocacion haremos una aplicacion con jsf, utilizando el framework RichFaces, iremos desde la configuracion basica, manejo de sessiones, interna internacionalizacion, configuracion de log4j (que ya vimos), integracion con Spring, Hibernate.

por lo tanto sera una serie de post ligueramente extensa :)

En esta primer post, solo tomare la configuracion basica de un proyecto con jsf y su integracion con rich

1.- Primero hay que descargar las siguientes librerias

commons-beanutils
commons-collections
commons-digester
commons-logging

richfaces-api-3.3.3
richfaces-impl-3.3.3
richfaces-ui-3.3.3

2.- Lo siguiente si utilizas MyEclipce, NetBeans, es lo mismo, cambia ligeramente para Eclipce (Faltarian mas librerias)

/**
Para MyEclipce

1.- Crear un proyecto web
2.- Agregar capacidades para JSF

Para NetBeans

1.- Crear un proyecto JSF simple, (no crear un proyecto para woodstock o icefaces)

Agregarles las librerias antes descargadas
*/

3.- Viendo la estructura basica de un proyecto jsf

/**
Una ves creado nuestro proyecto podemos ver 2 caracteristicas diferentes a un proyecto web normal

El primero es que ha cambiado nuestro web.xml

El segundo, se ha creado un archivo faces-config.xml a la altura de web.xml
*/

4.- Analizando al faces-config

5.- Modificando el web.xml

 
  javax.faces.STATE_SAVING_METHOD
  server
 


 
  org.richfaces.SKIN
  blueSky
 


 
  org.richfaces.LoadScriptStrategy
  ALL
 


 
  org.richfaces.LoadStyleStrategy
  ALL
 


 
  org.richfaces.CONTROL_SKINNING
  enable
 


 
  ajax4jsf
  org.ajax4jsf.Filter
 

 
  ajax4jsf
  Faces Servlet
  REQUEST
  FORWARD
  INCLUDE
 



 
  Faces Servlet
  javax.faces.webapp.FacesServlet
  0
 


 
  Faces Servlet
  /faces/*
 


 
  faces/index.jsp
 

Hasta aqui solo tenemos la configuracion basica para ejecutar rich faces, en la siguiente entrada haremos nuestro primer hola mundo . . .

CONEXION A UNA BD ORACLE

En esta ocacion veremos el ya choteadisimo ejemplo de una conexion a bd, en este caso utilizare oracle, y el metodo de conexion thin

1.- Descargar el jar de conexion a oracle (en mi caso utilizare ojdbc14.jar)

2.- Crear el conjunto de paquetes a utilizar

com.conexion.dao
com.conexion.impl
com.conexion.interfaz
com.conexion.main

3.- Creamos la interfaz de conexion

package com.conexion.interfaz;

import java.sql.Connection;

public interface ConexionI {
 public boolean conectar();
 public boolean desconectar();
 public Connection getConexion();
 public String getSentenciaSQL();
 public void setSentenciaSQL(String sentenciaSQL);
}

4.- Creamos la clase que proveera los datos de conexion

package com.conexion.impl;

public class DatosConexion {
 private String usr;
 private String pass;
 private String server;
 private String tipoConexion;
 
 public DatosConexion(){
  setTipoConexion("jdbc:oracle:thin:");
  setServer("@127.0.0.1:1521:miServer");
  setPass("miPass");
  setUsr("miUsr");
 }

/*
 Los Metodos get y set
*/
}

5.- Creamos la implementacion de la interfaz

package com.conexion.impl;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

import com.conexion.interfaz.ConexionI;

public class ConexionOracle implements ConexionI {

 private Connection conexion;
 private DatosConexion datos;
 private String sentenciaSQL;

 public boolean conectar() {
  try {
   datos = new DatosConexion();
   DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver());
   setConexion(DriverManager.getConnection(getDatos().getTipoConexion()
     + getDatos().getServer(), getDatos().getUsr(), getDatos()
     .getPass()));
   return true;
  } catch (SQLException e) {
   System.out.println("Error al Conectar a la bd ...");   
   return false;
  }
 }

 public boolean desconectar() {
  try {
   if (getConexion() != null) {
    if (!getConexion().isClosed()) {
     getConexion().close();
    }
   }
   return true;
  } catch (SQLException e) {
   System.out.println("Error al Desconectar a la bd ...");
   return false;
  }
 }

/*
 Los Metodos get y set
*/

}

6.- Creamos la clase DAO de persona

package com.conexion.dao;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import com.conexion.impl.ConexionOracle;
import com.conexion.interfaz.ConexionI;

public class PersonaDAO {
 public void consultaDatos() {
  try {
   ConexionI conexionBD = new ConexionOracle();
   PreparedStatement ps;
   ResultSet rs;
   if (conexionBD.conectar()) {
    System.out.println("Conectado ... ");

    conexionBD
      .setSentenciaSQL("select ID_PERSONA, NOMBRE from PERSONAS order by ID_PERSONA");

    ps = conexionBD.getConexion().prepareStatement(
      conexionBD.getSentenciaSQL());

    rs = ps.executeQuery();

    while (rs.next()) {
     System.out.print(" ID: " + rs.getInt("ID_PERSONA"));
     System.out.println(" NOMBRE: " + rs.getString("NOMBRE "));
    }

    if (conexionBD.desconectar()) {
     System.out.println("Desconectado ... ");
    }
   }
  } catch (SQLException e) {
   System.out.println("Error en la sentencia sql");
  }
 }
}

7.- Realizamos nuestro Test

package com.conexion.main;

import com.conexion.dao.PersonaDAO;

public class Test {
 public static void main(String[] args) {
  PersonaDAO persona = new PersonaDAO();
  persona.consultaDatos();
 }
}

Como se puede observar, realizar una conexion a bd, es de lo mas facil

Encriptacion utilizando el algoritmo RSA

En esta ocacion veremos un ejemplo de encriptacion sobre RSA, para entenderlo mejor ps date una leida del algoritmo

1.- Crearemos una clase RSAKeys

public class RSAKeys {
/**
RSAPrivateKey esta en java.security.interfaces
*/
 private RSAPrivateKey privateKey;
 private String exponente;
 private String modulus;
//sus metodos get y set
}

2.- Agregamos la libreria commons-codec
En mi caso utilizare commons-codec-1.5

3.- Creamos la clase RSAEncriptacion

public class RSAEncriptacion {
 
 private final String ALGORITMO="RSA";
 private final String CODIFICACION = "UTF-8";
 private final Integer LONGITUD=512;
 private final Integer BASE = 16;

}

4.- Creamos el metodo generarKeys

/**
Obtenemos una instancia de un keyPairGenerator (GENERADOR DE PAR DE LLAVES)
basado en el algoritmo RSA 

Inicializamos al generador de llaves, dandole el tamaño de la llave

En una clase KeyPair guardamos las llaves generadas

En una llave publica y privada guardamos los resultados del keyPair

En nuestra clase RSAKeys guardamos la llave privada, y el modulo y exponente
de la llave publica, esto para generarla despues. 

Esto lo puedes hacer con la llave privada
*/
public RSAKeys generarKeys() throws Exception{
 KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITMO);
 kpg.initialize(LONGITUD);
 KeyPair kp = kpg.genKeyPair();
 RSAPublicKey publicKey = (RSAPublicKey) kp.getPublic();
 RSAPrivateKey privateKey = (RSAPrivateKey) kp.getPrivate();  
 RSAKeys keys = new RSAKeys();
 keys.setExponente(publicKey.getPublicExponent().toString(BASE));
 keys.setModulus(publicKey.getModulus().toString(BASE));
 keys.setPrivateKey(privateKey);  
 return keys;
}

5.- Realizamos el metodo obtenPublicKey

/**
Delego las exepciones a una capa superior

Realizo una instancia de un keyFactory en base al algorimo

Creo una RSAPublicKeySpec (es diferente de un RSAPublicKey) en base al modulo 
y al exponente

Obtengo una llave publica a partir de mi fabrica de keys dandole como parametro
mi publicKeySpec

Finalmente hago un cast de mi publicKey a un RSAPublicKey
*/
public RSAPublicKey obtenPublicKey(String modulo, String exponente) 
throws NoSuchAlgorithmException, InvalidKeySpecException
{
 KeyFactory fact = KeyFactory.getInstance(ALGORITMO);
 RSAPublicKeySpec publicKey = new RSAPublicKeySpec( new BigInteger(modulo 
, BASE) , new BigInteger (exponente , BASE) );
 PublicKey pubKey = fact.generatePublic(publicKey);
 return (RSAPublicKey) pubKey;
}

6.- Realizamos el metodo Encriptar

/**
Obtengo un RSAPublicKey a partir de mi metodo antes construido

Creo una instancia de cipher en base a mi algoritmo (Recuerda que este me ayuda a
encriptar y desencriptar)

Configuro mi cipher en modo encriptador y le paso como algoritmo mi llave publica

Cifro mi texto con el metodo doFinal de cipher

Ahora por medio de la clase Hex convierto a char mi arreglo de bytes, en ves 
de utilizar el metodo HexToString del post pasado (Mas facil nop  ¬¬ )

Finalmente convierto mi char[] a String
*/
public String encriptar(String texto, String modulo, String exponente) 
throws Exception {
 RSAPublicKey publicKey = obtenPublicKey(modulo, exponente);
 Cipher cipher = Cipher.getInstance(ALGORITMO);
 cipher.init(Cipher.ENCRYPT_MODE,  publicKey);
 byte[] cifrado = cipher.doFinal(texto.getBytes());
 char [] charEncriptado = Hex.encodeHex(cifrado);
 String textoEncriptado = new String(charEncriptado);
 return textoEncriptado;
}

7.- Realizamos el metodo Desencriptar

/**
Inicializamos una instancia de cipher ...

Lo configuramos en modo Decript

Obtenemos en arreglo de bytes desencriptado

Finalmente creamos un String en base a nuestro arreglo de bytes y la codificacion
*/
public String desencriptar(String decript, RSAPrivateKey privateKey) 
 throws Exception {
 Cipher cipher = Cipher.getInstance(ALGORITMO);
 cipher.init(Cipher.DECRYPT_MODE, privateKey);
 byte[] desencriptado= Hex.decodeHex(decript.toCharArray()); 
 byte[] desci = cipher.doFinal(desencriptado);
 return new String(desci, CODIFICACION);
}

8.- Nuestro Metodo Main

public static void main(String[] args) throws Exception {
 RSAEncriptacion encriptacion = new RSAEncriptacion();  
 RSAKeys keys = encriptacion.generarKeys(); 

 String textoOriginal = "Mi Texto Original";  
 String textoEncriptado = encriptacion.encriptar(textoOriginal , keys.getModulus() , keys.getExponente());
 String textoDesencriptado = encriptacion.desencriptar(textoEncriptado, keys.getPrivateKey());
  
 System.out.println("T Encriptado: " + textoEncriptado);
 System.out.println("T Desencriptado: " + textoDesencriptado);
}

Encriptacion utilizando el algoritmo AES

En esta ocacion haremos un pequeño ejemplo de una clase que encripte y desencripte mediante el algoritmo AES (Advanced Encryption Standard)
  
1.- Creamos una clase AESKey
Esta clase solamente contendra una variable que sera nuestra key, que nos servira para encriptar y desencriptar

public class AESKey {
 private String encoded;

 public String getEncoded() {
  return encoded;
 }

 public void setEncoded(String encoded) {
  this.encoded = encoded;
 }
}

2.- Primero crearemos nuestra clase encriptacion

public class AESEncriptacion {
 //el resto del codigo ira aqui :)
}

3.- Crearemos nuestro metodo crearKey

private final String ALGORITMO = "AES";//algoritmo (si cambia la imprementacion tambien)
private final int LONGITUD = 128;//longitud de la llave ()
private final String CODIFICACION = "UTF-8";//como se convertira a byte, esto sera mas adelante

/**
Agrego un constructor que recibe como parametros un AESKey
*/
public AESEncriptacion(AESKey aesKey) throws Exception {  
 this.aesKey = aesKey;
}

public AESKey generaKey() throws Exception {
 KeyGenerator kgen = KeyGenerator.getInstance(ALGORITMO);
 kgen.init(LONGITUD);
 SecretKey skey = kgen.generateKey(); 
 AESKey aesKey = new AESKey();
 aesKey.setEncoded(StringtoHex(skey.getEncoded()));
 return aesKey;
}

4.- Crearemos nuestro metodo Encriptacion

/**
Estoy delegando las exepciones a el metodo que ocupe a encripta.

Convierto una cadena, q en este caso es mi key a un arreglo de bytes
el cual se lo asigno junto con el algoritmo a la clase SecretKeySpec.

Obtengo una instancia de Chiper en base al algoritmo, esta me ayudara
a encriptar y desencriptar mis codigos

A mi variable chiper la pongo en modo encripcion y le paso mi key secreta

Obtengo un arreglo de bytes que representa a mi cadena encriptada (resultado
de la encripcion)

Para que pueda guardar por ejemplo en bd mi cadena encriptada, paso el arreglo
de bytes a una cadena, esto lo hago con ayuda del metodo hexToString que veremos
mas adelante
*/
public String encripta(String cadena) 
  throws NoSuchAlgorithmException,
  NoSuchPaddingException, InvalidKeyException,
  IllegalBlockSizeException, BadPaddingException,
  UnsupportedEncodingException 
{  
  byte[] raw = StringToHex(aesKey.getEncoded());
  SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITMO);
  Cipher cipher = Cipher.getInstance(ALGORITMO);
  cipher.init(Cipher.ENCRYPT_MODE, skeySpec);
  byte[] encrypted = cipher.doFinal(cadena.getBytes(CODIFICACION));
  String encriptado = HexToString(encrypted);
  return encriptado;
}

5.- Crearemos nuestro metodo HexToString

/**
Por medio de un for recorro cada posicion del arreglo de bytes

En la variable aux obtengo la posicion deseada, indicando que es un hexadecimal
por medio de 0xff

Como un hexadecimal lo representare con 2 poficiones ff, 0f, 12... etc
en caso de que el resultado fuera menor a 16 solo obtendria 1 posicion
lo que me daria problemas al momento de desencriptar

En caso de ser menor a 16, le concateno un 0 a mi cadena, luego simplemente 
concateno mi variable aux, indicando que la guardate en un formato String
que representara un hexadecimal > Integer.toHexString(aux)

Al Final retorno una cadena que representa a mi arreglo de bytes, de esta forma
podre guardar la informacion en una bd, o imprimirla de una forma entendible
*/
private String HexToString(byte[] arregloEncriptado) {
 String textoEncriptado = "";
 for (int i = 0; i < arregloEncriptado.length; i++) {
  int aux = arregloEncriptado[i] & 0xff;
  if (aux < 16) {
   textoEncriptado = textoEncriptado.concat("0");
  }
  textoEncriptado = textoEncriptado.concat(Integer.toHexString(aux));
 }
 return textoEncriptado;
}

 
6.- Crearemos nuestro metodo StringToHex

/**
Creo un arreglo de bytes, del tamaño de mi cadena / 2
(por eso el agregar un 0 si hera menor a 16 en el metodo de HexToString)

Por medio de un for recorro a mi arreglo

Dentro del fofr en la variable index guardare la posicion * 2, esto para siempre
tomar pares 2, 4, 6, etc...

En la variable aux guardo un subString de index a index+2 (0-2,2-4) siempre sera en pares, no hay fallas por que el metodo HexToString me retorno una cadena par

En una variable int, guardo el parseo del segmento de cadena, con base 16 (Hexadecimal)

Para finalizar en la posocion correspondiente de mi arreglo de bytes hago un cast
para guardar mi variable entera

Finalmente retornaria un arreglo de bytes identico al que recibio el metodo
HexToString, por tanto obtengo mi arreglo encriptado :)
*/
private byte[] StringToHex(String encriptado) {
 byte[] enBytes = new byte[encriptado.length() / 2];
 for (int i = 0; i < enBytes.length; i++) {
  int index = i * 2;
  String aux = encriptado.substring(index, index + 2);
  int v = Integer.parseInt(aux, 16);
  enBytes[i] = (byte) v;
 }
 return enBytes;
}

7.- Crearemos nuestro metodo Desencripcion

/**
Del mismo modo delego las excepciones a un nivel superior

Obtengo un arreglo de bytes a partir de mi key

Se lo asigno junto con el algoritmo a la clase SecretKeySpec.

Obtengo una instancia de Chiper en base al algoritmo

A mi variable chiper la pongo en modo desencripcion y le paso mi key secret

Obtengo un arreglo de bytes a partir de mi cadena encriptada

Al final creo un String a partir de mi arreglo de bytes

Esto no lo hice antes, como algunos ejemplos de la red, por que ? 
por que de este modo si lo hiciera desde el metodo encriptar, habria algunos
caracteres que no se podrian representar, por lo tanto se perderia
la integridad de la informacion.

Es mas pueden intentar realizar el programa sin utilizar HexToString y StringToHex
haciendo las conversiones del tipo new String(byte[]) y no trabajaria su codigo
*/
public String desencriptar(String encriptado) throws InvalidKeyException,
  IllegalBlockSizeException, BadPaddingException,
  UnsupportedEncodingException, NoSuchAlgorithmException,
  NoSuchPaddingException 
{
 byte[] raw = StringToHex(aesKey.getEncoded());
 SecretKeySpec skeySpec = new SecretKeySpec(raw, ALGORITMO);
 Cipher cipher = Cipher.getInstance(ALGORITMO);  
 cipher.init(Cipher.DECRYPT_MODE, skeySpec);
 byte[] original = cipher.doFinal(StringToHex(encriptado));
 String originalString = new String(original);
 return originalString;
}

8.- Crearemos nuestro Implementacion

public static void main(String args[]) throws Exception {
 AESKey aesKey = new AESKey();
  
 AESEncriptacion tmp = new AESEncriptacion();
 aesKey = tmp.generaKey();
 
 AESEncriptacion ejemplo = new AESEncriptacion(aesKey);

 String encriptado = ejemplo.encripta("123456789012345678");
 String desencriptado = ejemplo.desencriptar(encriptado);

 System.out.println(encriptado);
 System.out.println(desencriptado);
 }

9.- Se me olvidava, te coloco los importes por si las moscas :)

import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

NOTA: Al final De una Forma Ligeramente Simple podemos encriptar utilizando el Algoritmo AES, En posteriores post colocare otras formas de encripcion

Sin miedo ! ! !

Lectura de Archivos, y Guardado En BD (SQLLOADER DE ORACLE)

En la entrada anterior vimos como leer un archivo por medio de flatworm, siendo una forma util de guardara informacion sobre una bd.

Oracle nos proporciona una herramienta que nos permite guardar la informacion de un archivo, directamente en las tablas que deceemos.

Algunas ventajas que tenemos son:
* No necesitamos tener a java como intermediario
* No necesitamos configurar nada en oracle, solo tener el cliente completo (tener en el cliente slq loader), o en su defecto ejecutar la aplicacion desde el server
* Automaticamente se crean los archivos de log
* Podemos indicar el numero maximo de errores antes de terminar una aplicacion


Desventajas
* Al igual que cuando modificamos una tabla, esta queda desabilitada hasta que termine de realizarse modificaciones sobre ella


1.- Para hacer uso de esta herramienta, primero crearemos un archivo de configuracion donde indicamos en que tablas guardaremos la informacion del archivo y lo guardaremos con una extension .ctl


load data
replace
into table PRODUCTOS(
EnExistencia                    POSITION(1:5)              char NULLIF EnExistencia=BLANKS
          "TRIM(:EnExistencia)"
Nombre                            POSITION(6:25)            char NULLIF Nombre=BLANKS
          "TRIM(:Nombre)"
Codigo                             POSITION(26:30)           char NULLIF Codigo=BLANKS
          "TRIM(:Codigo)"
FechaInventario                 POSITION(31:40)          char NULLIF FechaInventario=BLANKS
          "TRIM(:FechaInventario)"
Vendidas                          POSITION(26:30)          char NULLIF Vendidas=BLANKS
          "TRIM(:Vendidas)"
)


2.-Ahora Crearemos un archivo con extension .par, el cual contendra la ruta del archivo log, los errores maximos, tambien datos de conexion

USERID=usuarioBD/passwordBD
CONTROL=rutaArchivoCTL
LOG=archivoLog.log
ERRORS=100


3.- Ahora para ejecutarlo, solo abrimos una consola de sql, ya sea del lado del server o en el cliente (recuerda q tiene que tener instalado sql loader) y escribimos los siguiente


sqlldr PARFILE=rutaArchivoPar DATA=archivoALeer


***LISTO, SE EJECUTA LA APLICACION, SE GUARDAN LOS DATOS EN LA BD Y SE CREA EL ARCHIVO DE LOG


ESTA ES UNA FORMA MUY SENSILLA DE GUARDAR DATOS EN UNA BD, SIN PASAR POR JAVA, EL DETALLE ES TENER SQLLDR EN NUESTRO SERVER O EN EL CLIENTE

Lectura de Archivos Mediante FlatWorm

Vamos a Reutilizar el Framework FlatWorm para poder ahora leer datos de un archivo, siempre y cuando sabemos la longitud de cada campo

Para tal motivo realizaremos lo siguiente:


1.- creamos un proyecto y le agregamos las siguientes librerias:
            commons-beanutils.jar
            commons-collections-3.0.jar
            commons-logging.jar
            flatworm-2.0.1.jar
****Recuerda, no es obligatorio utilizar estas versiones de librerias, pero las pongo para que te sea mas facil seguir el ejemplo

2.- Creamos 4 paquetes
            com.archivos.bean
            com.archivos.configurador
            com.archivos.lectura
            com.archivos.main

3.- En el paquete bean, agregamos el bean que Productos que utilizamos en la entrada Creacion De Archivos III

4.- En el paquete Configurador, del mismo modo copiamos la clase DatosIniciales que tenemos en Creacion De Archivos III

5.- En el paquete lectura creamos una clase llamada LecturaArchivo agregando el siguiente codigo

            private DatosIniciales datos;
            private FileParser parser;
            private BufferedReader br;
            private FileFormat ff;
            //agregar sus metodos set y get


public void cerrar(){
try {
             if(br!=null){            
                          br.close();            
             }        
} catch (IOException e) {
             System.out.println("C 1");
}
} 

/*
Creamos un parceador para poder pasar de un xml a un formato de archivo
en un stream obtenemos el archivo a leer
el stream lo guardamos en un buffer para poder ser leido
*/
public void configurar(){
try {
             ConfigurationReader parserC = new ConfigurationReader();       
             ff = parserC.loadConfigurationFile(getDatos().getArchivoWarm());
             InputStream in;       
             in = new FileInputStream(
                          getDatos().getRutaSubidaArchivo()+getDatos().getNombreArchivo());
             br = new BufferedReader(new InputStreamReader(in));        
} catch (FileNotFoundException e) {
             System.out.println("Archivo no encontrado");
} catch (FlatwormUnsetFieldValueException e) {
             System.out.println("Error de Archivo Warm");
} catch (FlatwormConfigurationValueException e) {
             System.out.println("Error en la Configuracion del Archivo Warm");
}         
}


/*
Guardamos en un campoMach un record obtenido del buffer
preguntamos si el nombre del record obtenido es igual a nuestro beanWarm q tenemos mapeado en nuestro xml
si es asi obtenemos el bean Productos, obteniendolo del record . get bean (de un mismo record se pueden obtener multiples beans)
solo nos resta imprimir la informacion
*/
public void leer(){
 try {
             MatchedRecord results;       
             while ((results = ff.getNextRecord(br)) != null){
                          if (results.getRecordName().equals(getDatos().getRecordWarm())){
                          Productos prod = (Productos) results.getBean(getDatos().getBeanWarm());
                          System.out.println("******************");
                          System.out.println("Codigo: "+prod.getCodigo());
                          System.out.println("En Existencia: "+prod.getEnExistencia());

                          System.out.println("Fecha Inventario: "+prod.getFechaInventario());
                          System.out.println("Nombre: "+prod.getNombre());
                          System.out.println("Vendidas: "+prod.getVendidas());
                          }
             }
} catch (FlatwormInvalidRecordException e) {
              System.out.println("Record Invalido");
} catch (FlatwormInputLineLengthException e) {
              System.out.println("Longitud de la Linea invalida");
} catch (FlatwormConversionException e) {
              System.out.println("No se pudo realizar una conversion de datos");
} catch (FlatwormUnsetFieldValueException e) {
              System.out.println("Error de Campo Vacio");
} catch (FlatwormCreatorException e) {
              System.out.println("Error de Creacion del Bean");
} 
}

Como se puede observar, el leer puede ser un poco engorroso en comparacion con otras tecnicas como la tradicional de lectura de archivos, pero de este modo podemos modificar la longitud de los campos a leer sin recompilar codigo y es mas facil guardarlo en una bd, por ejemplo :)

En otra entrada veremos como realizar esto a traves de Oracle, sin pasar por java :)