martes, diciembre 13, 2011

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 !

viernes, octubre 21, 2011

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

miércoles, octubre 19, 2011

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!

martes, agosto 16, 2011

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

miércoles, agosto 10, 2011

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
     
     
     


 

	
								
					
	
	
				
					
	

	
		
		
		
	

martes, junio 07, 2011

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 . . .

lunes, junio 06, 2011

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

miércoles, mayo 25, 2011

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

martes, mayo 24, 2011

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 ! ! !

martes, mayo 17, 2011

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 :)

 



lunes, mayo 16, 2011

Conexion a un SFTP

Ahora modificaremos el proyecto que realizamos en la entrada anterior.

Segimos utilizando la libreria jscape.

1.- Modificamos la interfaz agregando

           public Sftp getSftp();

2.- La anterior implementacion que teniamos nos pedira que la modifiquemos agregando el metodo, para hacerlo facil que solo retorne un null

3.- Creamos la siguiente implementacion que llamaremos SFTPImpl y sustituiremos nuesta variable ftp por una sftp

          private Sftp sftp;
          //agregamos sus metodos set y get

4.- El resto del codigo queda de la siguiente casi igual siendo el metodo desconectar en ves de que haga referencia a el ftp sera al sftp, el que cambia y por poco es el metodo conectar


          public boolean conectar() {
          try {
          SshParameters parametros = new 
SshParameters(
                    getDatosConexion().getDominio(), 
                    getDatosConexion().getUsuario(), 
                    getDatosConexion().getPassword()
          );
          sftp = new Sftp(parametros);
          sftp.connect();
          sftp.setBinary();
          System.out.println("Conectado al SFTP...");
          return true;
          } catch (SftpException e) {
          System.out.println("Error al conectar al SFTP");
         
          return false;
          }
         
          public boolean desconectar() {
          if(sftp!=null){
                     if(sftp.isConnected()){

                             sftp.disconnect();
                             return true;
                     }
          }
          return false;
          }


5.- En el metodo main solo hay que cambiar la referencia a la implementacion y listo ya podemos conectar a un servidor sftp


***una opcion para servidor sftp gratis puede ser: core FTP mini-sftp-server

Conexion a un FTP

Esta ocacion hablare un poco de como conectarnos a un ftp,sftp, y ftps

Empesaremos con la conexion a un ftp

1.- Crearemos un proyecto con 3 paquetes
          com.conexion.bean
          com.conexion.configuracion
          com.conexion.main


2.- Utilizaremos la libreria jscape.jar para realizar el uso del ftp, podremos utilziar otra libreria, pero utilizare esta por la facilidad de crear una conexion a un sftp


3.- En el paquete bean crearemos uno llamado DatosConexion con los siguientes datos
          dominio
          usuario
          password
           //sus metodos get y set

4.- En el paquete com.conexion.configuracion crearemos una Interfaz, q en mi caso llamare IConfiguracionConexion que tendra los siguientes metodos
          public boolean conectar();
          public boolean desconectar();
          public void setDatosConexion getDatosConexion();
          public DatosConexion getDatosConexion();
          public Ftp getFtp();
**Ftp proviene de la libreria jscape y en especifico com.jscape.inet.ftp.Ftp

5.- En el mismo paquete crearemos la prime implementacion, que llamare ConexionFTPImpl y contendra
          private DatosConexion datosConexion;
          private Ftp ftp;
          //sus metodos get y set

/*
creamos un nuevo ftp con los datos de conexion que tenemos
le agregamos un escuchador a nuestro ftp
intentamos establecer la conexion con el ftp
le indicamos que los datos que enviaremos o recibiremos seran tipop binario
recordemos que un ftp puede convertir la informacion a binario o a codigo ascii
para enviarla o recibirla
*/
          public boolean conectar(){
          try{
                    ftp = new Ftp(
                              getDatosConexion().getDominio() , 
                              getDatosConexion().getUsuario() , 
                              getDatosConexion().getPassword()
                              );
                     ftp.addFtpListener(this); 
                     ftp.connect();
                     ftp.setBinary();
                     System.out.println("Conectado al FTP..."); 
                     return true;

          }catch(FtpException e){
                    System.out.println("Error al conectar al ftp");
          }
          return false;

           

          public boolean desconectar(){
          if(ftp!=null){
                    if(ftp.isConnected()){
                              ftp.disconnect();
                              System.out.println("Desconectado del ftp...");

                    }
                    return true;
          }
          return false;
          }  

6.- En nuestro paquete main crearemos una clase Principal donde pondremos nuestro metodo main agregando nuestro codigo
          IConfiguracionConexion conexion = new ConexionFTPImpl();
          conexion.setDatosConexion(new DatosConexion());   
          conexion.getDatosConexion().setDominio("127.0.0.1");
          conexion.getDatosConexion().setPassword("java-limos-pass");
          conexion.getDatosConexion().setUsuario("java-limos");          conexion.conectar();          conexion.desconectar();


7.- Para el ejemplo utilize FileZilla Server, que es mi servidor ftp, dando un usuario "java-limos" y un pass "java-limos-pass"