jump to navigation

1000 visitas marzo 7, 2007

Posted by superpiwi in Uncategorized.
add a comment

Alcanzamos hoy las 1000 visitas. Que curioso, Pensaba que no habia tantas personas a las que les gustara Java como a mi. Es broma. Muchas gracias por vuestras visitas.

…Y tambien encriptame marzo 7, 2007

Posted by superpiwi in Java.
27 comments

En el post anterior comentaba como convertir a una cadena de texto nuestros objetos. ¿Porque no encriptarlos tambien?.Para ello, emplearemos un API de encriptacion muy sencillo de utilizar.

se llama Java Simplified Encryption

He escrito la siguiente clase, aunque realmente lo que hace es llamar a la clase TextEncryptor del API.


/**
* Encriptar.java
*
* Utilidad para codificar y decodificar textos mediante una palabra clave
*
* @author jdelgado
* @version 0.0.0.1 - 6 de Marzo 2007
*
* usa Java Simplified Encryption (http://www.jasypt.org/getting-started-easy.html)
*
*/
package comun.util.tools;
import org.jasypt.util.TextEncryptor;
public class Encriptar
{
/**
* Codifica un texto mediante una palabra clave
* @param mensaje el texto a codificar
* @param password la palabra clave
* @return el texto codificado
* @throws Exception excepcion levantada en caso de error
*/
static public String codifica(String mensaje,String password) throws Exception
{
try
{
TextEncryptor textEncryptor = new TextEncryptor();
textEncryptor.setPassword(password);
String encryptedText = textEncryptor.encrypt(mensaje);
//String plainText = textEncryptor.decrypt(myEncryptedText);
return encryptedText;
}
catch(Exception e)
{
throw e;
}
}
//----
/**
* Decodifica un texto mediante una palabra clave
* @param mensaje el texto a decodificar
* @param password la palabra clave
* @return el texto decodificado
* @throws Exception excepcion levantada en caso de error
*/
static public String decodifica(String mensaje,String password) throws Exception
{
try
{
TextEncryptor textEncryptor = new TextEncryptor();
textEncryptor.setPassword(password);
String Text = textEncryptor.decrypt(mensaje);
return Text;
}
catch(Exception e)
{
throw e;
}
}
//----
/**
* Para probar el correcto funcionamiento de la clase de ejemplo.
* @param args argumentos de entrada.
*/
public static void main(String[] args) {
try
{
String mensaje="Un Ubuntu para atraerlos a todos y atarlos en las tinieblas.";
String codigo_secreto="best";
System.out.println("Texto original: "+mensaje);
String cod = Encriptar.codifica(mensaje, codigo_secreto);
System.out.println("Texto encriptado: "+cod);
String texto_bien = Encriptar.decodifica(cod, codigo_secreto);
System.out.println("Texto desencriptado : "+texto_bien);
String texto_mal = Encriptar.decodifica(cod, "badpassword");
System.out.println("Texto desencriptado (bad password): "+texto_mal);
}
catch(Exception e)
{
e.printStackTrace();
}
}
//----
}
//end of class Encriptar.java

Como ejemplo codificamos el siguiente texto:


Un Ubuntu para atraerlos a todos y atarlos en las tinieblas.

Cuando ejecutamos el metodo de encriptacion con la password «best» obtenemos:


ppAz72th0T2W/ivcCpYEieRUdZ0LwQ+n39DpS5giD+9hX2owZgTKN30uoEqZujtXQBMtxNmXJAMe5HSNXNRtZ7j0YSqUOb6E

Si este texto lo desencriptamos con la password correcta, obtendremos el texto original. En caso contrario nos saltara una excepcion:


org.jasypt.exceptions.EncryptionOperationNotPossibleException

Echale un vistazo al API, tiene muchas mas posibilidades.

Serializame… marzo 7, 2007

Posted by superpiwi in Java, Javascript.
3 comments

He escrito una clase para serializar objetos java a un string XML y a cadenas JSON. (Para quien no lo sepa: ¿Que que es JSON?).
JSON (javascript object notation) es una forma de representar un objeto mediante una cadena de caracteres. Se suele emplear en JavaScript, aunque puedes usarlo donde mejor te venga. Yo lo suelo emplear con AJAX lo cuál me viene muy bien en muchas ocasiones en la que no quiero crear y parsear un XML (esto suele ser mas lento y tambien implica mas procesamiento).

Puedes encontrar informacion de JSON en http://www.json.org/

Bueno,… ¿Y para que nos puede servir convertir un objeto a una cadena de caracteres o a un XML String. Pues se me ocurren 2 buenas razones:

1) Para guardar el estado de un objeto . Es una manera de persistencia. Por ejemplo en una aplicacion de envio de paquetes, para la parte del seguimiento de un pedido, el pedido va pasando por diferentes estados, podriamos guardar el objeto en la base de datos, para posteriormente cuando cambie su estado, recuperarlo, actualizarlo y volver a guardarlo.

2) Para serializar un objeto, enviarlo por un socket a otra máquina y en el destino deserializarlo para poder acceder a sus métodos y propiedades o invocarlo remotamente.

No se, existen muchas mas utilidades. Seguro que se te ocurre alguna.

La clase se llama ObjectSerializer y es muy sencilla de utilizar. (La escribi hace tiempo, seguro que esto ha evolucionado, pero te puede ser util). Requiere de la siguiente libreria:

http://json-lib.sourceforge.net/

Aqui el código:


/**
* ObjectSerializer.java
*
* Clase de utilidad para codificar y decodificar un objeto a String empleando XML o una cadena JSON.
* Util por ejemplo para enviar el objeto a otra maquina e invocar sus metodos desde alli o para
* guardar su estado en la base de datos.
*
* @author jdelgado
* @version 0.0.1
* @since JDK 1.5
* @ide Eclipse 3.2 Callisto
* @revision 13 Julio 2006
*
* @note Para serializar/deserializar a JSON emplea la libreria json-lib.jar.
* @note Para serializar/deserializar a XML emplea las clases de Sun XMLEncoder y XMLDecoder.
*
* TODO: soporte para otros metodos (XStream, Castor, XMLBeans, etc...)
*/
package comun.util;
import java.beans.XMLEncoder;
import java.beans.XMLDecoder;
import java.io.*;
import net.sf.json.JSONObject;
import net.sf.json.JSONArray;
import java.util.Vector;
public class ObjectSerializer
{
public static int XML_METHOD=0;
public static int JSON_METHOD=1;
/**
* Codifica un objeto a un String.
* @param o objeto para codificar.
* @param method metodo de la codificacion: XML_METHOD o JSON_METHOD.
* @return un string con el objeto codificado.
* @throws Exception Excepcion levantada en caso de error.
*/
public static String encode(Object o,int method) throws Exception
{
ByteArrayOutputStream bout = null;
if (method==ObjectSerializer.XML_METHOD)
{
// serializar a xml
bout = new ByteArrayOutputStream();
XMLEncoder e = new XMLEncoder(bout);
e.writeObject(o);
e.close();
String s = bout.toString();
return s;
}
else if(method==ObjectSerializer.JSON_METHOD)
{
// serializar a cadena json (javascript object notation)
JSONObject jsonObject = JSONObject.fromObject( o );
return jsonObject.toString();
}
else
{
throw new Exception("unknown method");
}
//return null;
}
//------------------------------
/**
* Codifica un objeto a un String.
* @param o objeto para codificar.
* @param method metodo de la codificacion: XML_METHOD o JSON_METHOD.
* @return un string con el objeto codificado.
* @throws Exception Excepcion levantada en caso de error.
*/
public static Object decode(String s,int method) throws Exception
{
ByteArrayInputStream bin = null;
if (method==ObjectSerializer.XML_METHOD)
{
// deserializar a xml
bin = new ByteArrayInputStream(s.getBytes());
XMLDecoder d = new XMLDecoder(bin);
Object result = d.readObject();
d.close();
return result;
}
else if(method==ObjectSerializer.JSON_METHOD)
{
// serializar a cadena json (javascript object notation)
JSONObject jsonObject = JSONObject.fromString(s);
return jsonObject;
}
else
{
throw new Exception("method unknown");
}
//return null;
}
//------------------------------
public static void main(String[] args) {
try
{
com.sqlmap.User usuario = new com.sqlmap.User();
usuario.setLogin("superpiwi");
usuario.setPassword("superpiwi");
usuario.setProfile("Usuario");
usuario.setSid("00001");
com.sqlmap.User usuario1 = new com.sqlmap.User();
usuario1.setLogin("jose");
usuario1.setPassword("jose");
usuario1.setProfile("Usuario Jose");
usuario1.setSid("00001-01");
com.sqlmap.User usuario2 = new com.sqlmap.User();
usuario2.setLogin("soledad");
usuario2.setPassword("soledad");
usuario2.setProfile("Usuario Soledad");
usuario2.setSid("00001-02");
usuario.addUser(usuario1);
usuario.addUser(usuario2);
// Codificarlos
String XML_STRING = ObjectSerializer.encode(usuario, ObjectSerializer.XML_METHOD);
System.out.println("Codificado como XML:\r\n\r\n"+XML_STRING);
String JSON_STRING = ObjectSerializer.encode(usuario, ObjectSerializer.JSON_METHOD);
System.out.println("Codificado como JSON:\r\n\r\n:"+JSON_STRING);
// Decodificarlos
com.sqlmap.User MiUsuario = null;
JSONObject json = (JSONObject) ObjectSerializer.decode(JSON_STRING, ObjectSerializer.JSON_METHOD);
JSONArray array = json.getJSONArray("usuarios");
int numero = array.length();
for (int i=0;i<numero;i++)
{
JSONObject usuario_interno = array.getJSONObject(i);
String id=usuario_interno.getString("login");
System.out.println("usuario interno: "+id);
}
String login = (String) json.get("login");
System.out.println("usuario principal:"+login);
}
catch(Exception e)
{
e.printStackTrace();
}
}
}
//end of class ObjectSerializer.java

En el ejemplo instancio una clase User, y relleno algunos de sus atributos (no te proporciono el codigo de esta clase, pero puedes usar cualquiera de las tuyas).

Al convertirlo a XML obtenemos algo como lo siguiente:


<?xml version="1.0" encoding="UTF-8"?>
<java version="1.5.0_08" class="java.beans.XMLDecoder">
<object class="com.sqlmap.User">
<void property="login">
<string>superpiwi</string>
</void>
<void property="password">
<string>superpiwi</string>
</void>
<void property="profile">
<string>Usuario</string>
</void>
<void property="sid">
<string>00001</string>
</void>
<void property="usuarios">
<object class="java.util.Vector">
<void method="add">
<object class="com.sqlmap.User">
<void property="login">
<string>jose</string>
</void>
<void property="password">
<string>jose</string>
</void>
<void property="profile">
<string>Usuario Jose</string>
</void>
<void property="sid">
<string>00001-01</string>
</void>
</object>
</void>
<void method="add">
<object class="com.sqlmap.User">
<void property="login">
<string>soledad</string>
</void>
<void property="password">
<string>soledad</string>
</void>
<void property="profile">
<string>Usuario Soledad</string>
</void>
<void property="sid">
<string>00001-02</string>
</void>
</object>
</void>
</object>
</void>
</object>
</java>

Si lo codificamos como un String JSON obtenemos lo siguiente:


{"phone":"","password":"superpiwi","sid":"00001","login":"superpiwi","description":"","project":"","usuarios":[{"phone":"","password":"jose","sid":"00001-01","login":"jose","description":"","project":"","usuarios":null,"email":"","profile":"Usuario Jose"},{"phone":"","password":"soledad","sid":"00001-02","login":"soledad","description":"","project":"","usuarios":null,"email":"","profile":"Usuario Soledad"}],"email":"","profile":"Usuario"}

En el resto del ejemplo recuperamos los valores de los atributos a partir de la cadena JSON. Si quisieramos mapearlos de nuevo a un objeto tendriamos que implementar un metodo que fuera leyendo los atributos a partir de la cadena y asignandoselos a la clase.
Solo un comentario, para indicar el uso del elemento JSONArray, lo que he hecho en la clase User es tener un vector de usuarios, que voy rellenando con el metodo add, es decir, tengo un usuario principal y un atributo «usuarios» que realmente es un vector de mas usuarios.

Para acceder a un elemento simple empleariamos el JSONObject, pero para acceder a esta lista de elementos (que a su vez son JSONObject) empleariamos el JSONArray.