Calculadora Básica en Ensamblador August 31st, 2010 by sxceron

Una calculadora en ASM x86 sin usar instrucciones “rarasâ€. Solo lo básico:

.model huge
 
; Imprime una cadena
prints macro _str_
 mov dx, offset _str_
 mov ah, 09h
 int 21h
endm
 
; Lee una cadena de caracteres
gets macro _buff_
 mov dx, offset _buff_
 mov ah, 0Ah
 int 21h
 mov dx, offset _buff_
endm
 
; Limpia la pantalla
limpia macro x, y
 mov ah, x
 int 10h
 mov ah, y
 int 10h
endm
 
.code
 
inicio:
 
; Direccion del segmento de datos en ds, es
mov ax, @data
mov ds, ax
 
menu:
limpia 0fh, 0
 
prints m0
prints m2
prints m1
call getche
 
sub al, 30h
cmp al, 1
je caso1
cmp al, 2
je caso2
cmp al, 3
je caso3
cmp al, 4
je caso4
cmp al, 5
je caso5
loop menu
 
caso1:
 call leer
 call suma
 call resultado
 prints m3
 prints res
 call getche
 jmp menu
 
caso2:
 call leer
 call resta
 cmp bh, 1
 jne sinsigno
 
 call resultado
 prints m3
 mov ah, 02h
 mov dl, '-'
 int 21h
 prints res
 call getche
 jmp menu
 
 sinsigno:
 call resultado
 prints m3
 prints res
 call getche
 jmp menu
 
caso3:
 call leer
 call multiplicacion
 call resultado
 prints m3
 prints res
 call getche
 jmp menu
 
caso4:
 call leer
 cmp cl, 0
 je divzero
 call division
 call resultado
 prints m3
 prints res
 call getche
 jmp menu
 divzero:
 prints diz
 call getche
 jmp menu
 
caso5:
 call quit
 
; ========= Procedimientos ===========
 
; ax = ch + cl
suma proc near
 mov al, ch
 mov bl, cl
 add ax, bx ; Por si la suma excede el byte
 ;mov ch, 1h
 ret
suma endp
 
; ax = ch - cl
resta proc near
 mov al, ch
 mov bl, cl
 cmp bl, al
 ja consigno
 sub al, bl
 mov ah, 0 ; No importa el signo
 ret
 consigno:
 sub bl, al
 mov al, bl
 mov ah, 0 ; No importa el signo
 mov bh, 1 ; El signo
 ret
resta endp
 
; ax = ch * cl
multiplicacion proc near
 mov al, ch
 mul cl
 ret
multiplicacion endp
 
; ax = ch / cl
division proc near
 mov al, ch
 div cl
 mov ah, 0 ; No importa el residuo
 ret
division endp
 
; Convierte el valor de ax, (el resultado de la operacion) a una cadena
resultado proc near
 mov ch, 2h ; Algo tiene que ver
 mov dx, 0h
 mov si, 8
 mov bx, 0
 
 ciclo:
 
 div divs[si]
 
 add al, 30h
 mov res[bx], al
 
 mov ax, dx
 mov dx, 0h
 
 cmp si, 0h
 je salto
 
 dec si
 dec si
 inc bx
 loop ciclo
 
 salto:
 ret
resultado endp
 
; Lee 2 valores del teclado y almacena los numeros en ch y cl
leer proc near
 
prints p1
gets n1
 
mov cl, 0h
mov bl, n1[1]
mov di, bx
mov si, 0h
 
conv:
 mov al, n1[di+1]
 sub al, 30h
 mul mult[si]
 add cl, al
 dec di
 inc si
 cmp di, 0h
 jne conv
 
mov ch, cl
 
prints p2
gets n2
 
mov cl, 0h
mov bl, n2[1]
mov di, bx
mov si, 0h
 
conv1:
 mov al, n2[di+1]
 sub al, 30h
 mul mult[si]
 add cl, al
 dec di
 inc si
 cmp di, 0h
 jne conv1
 
ret
leer endp
 
; Termina el programa
quit proc near
 mov ah,4ch
 int 21h
 ret
quit endp
 
; Lee un caracter
getche proc near
 mov ah, 01h
 int 21h
 ret
getche endp
 
.data
diz db 13,10, "Division por zero.", "$"
m0 db "CALCULADORA BASICA", 13, 10, "$"
m1 db "Selecciona la operacion a realizar:", 13, 10, "$"
m2 db "   1. Suma", 13, 10, "   2. Resta", 13, 10, 
      "   3. Multiplicacion", 13, 10, "   4. Division", 
      13, 10, "   5. Salir", 13, 10, "$"
m3 db 10,13,"El resultado de la operacion es: ", "$"
p1 db 10,13,"Introduce el primer numero: ", "$"
p2 db 10,13,"Introduce el segundo numero: ", "$"
n1 DB 4,?,4 DUP('$'),'$'
n2 DB 4,?,4 DUP('$'),'$'
res DB 10 DUP('$'), '$'
mult db 1, 10, 100, 0
divs dw 1, 10, 100, 1000, 10000
.stack
 
end inicio

calculadoracalculadora1

calculadora3calculadora2

calculadora5calculadora4

+ Triángulo de Sierpinski en Java By sxceron August 28th, 2010 y hay 0 comentarios

El matemático polaco Waclaw Sierpinski introdujo este fractal en 1919. Partamos (iteración n=0) de  la superficie de un triángulo equilátero de lado unidad. Seguidamente (iteración n=1) tomemos los puntos medios de cada lado y construyamos a partir de ellos un triángulo equilátero invertido de lado 1/2. Lo recortamos. Ahora (iteración n=2) repetimos el proceso con cada uno de los tres triángulos de lado 1/2 que nos quedan. Así que recortamos, esta vez, tres triángulos invertidos de lado 1/4. En la figura animada observamos hasta cinco iteraciones sucesivas. Si repetimos infinitamente el proceso obtendremos una figura fractal denominada triángulo de Sierpinski.

triang1 Continue reading…

+ Cifrado por Permutación en Java By sxceron August 26th, 2010 y hay 0 comentarios

La principal idea del cifrado por permutación es la posición de las letras.

Por ejemplo, Alicia y Bob deciden que m (longitud de permutación) = 6 y

image

Alicia quiere enviar el siguiente texto: "he walked up and down the passage two or three times" y primero los divide en grupos de 6 letras: "hewalk edupan ddownt hepass agetwo orthre etimes" y usando la matriz de permutación  para relacionar cada letra con su nueva posición, queda:

WLEHKAUADENPONDDTWPSEHSAEWGAOTTRROEHIETESM.

El código en Java queda así:

public class CifradoPerm {
 
	public static void main(String args[]){
		int m    = 6;
		int pi[] = new int[]{3, 5, 2, 1, 6, 4};
 
		String textoclaro = "12345678910abc"
 
		String textocifrado = cifra(textoclaro, m, pi);
		System.out.println(textocifrado);
 
	}
 
	static public String cifra(String textoclaro, int m, int pi[]){
		char bloques[] = textoclaro.replaceAll(" ", "").toCharArray();
		int b = (int)(Math.ceil((float)bloques.length/(float)m));
		char permuta[] = new char[b*m];
 
		for( int i = 0; i < b; i++ ){
			for( int j = 0; j < m; j++ ){
				if( m*i+pi[j]-1 < bloques.length )
					permuta[m*i+j] = bloques[m*i+pi[j]-1];
				else
					permuta[m*i+j] = ' ';
			}
		}
		return new String(permuta);
	}
}

+ ¿Qué es el cloud computing? By sxceron August 26th, 2010 y hay 0 comentarios

La computación en la nube o cloud computing (en inglés) es un término usado para describir tanto una plataforma como un tipo de aplicación. Por una parte la plataforma puede ser un conjunto de servidores físicos o virtualizados, mientras que las aplicaciones pueden ser aquellas que son accesibles mediante internet.

image

La computación en la nube permite el cómputo en malla (grid computing), pero no debe ser confundido, ya que este último implica dividir una tarea en varias más pequeñas que pueden correr sobre diferentes servidores de manera paralela, mientras que el cloud computing provee una plataforma más amplia para la ejecución de múltiples tareas.

El cómputo en la nube puede verse como un sistema virtualizado de manera transparente que permite la ejecución de aplicaciones usando técnicas actuales como el balanceo de carga y la administración automática.

Continue reading…

+ Manejo de cadenas en ensamblador (x86) I By sxceron March 25th, 2009 y hay 0 comentarios

Ensamblador es un lenguaje de programacion de bajo nivel que permite comunicarnos con las interrupciones del procesador de manera casi directa.

Empezar a trabajar con ensamblador es un poco complicado al principio ya que al estar acostumbrados a C, Java, C#, el uso de nemonicos es desconocido para muchos.

Los nemonicos son palabras cortas reservadas de cada set de instrucciones de cada procesador que permiten ejecutar operaciones sobre el procesador y la memoria. Una de las funciones en el x86 mas usual es la de INT, ya que con esta llamamos a una interrupcion del equipo y pedimos un servicio.

Algunas de las interrupciones como la 21h contienen dentro muchas funciones que permiten acceder a diferentes servicios.

En este post voy a hacer uso de esta interrupcion y algunas de sus funciones para manipular cadenas de caracteres (que en teoria, son cadenas de cualquier cosa) y mostrar algunos ejemplos clasicos de aplicacion.

Como les habia mencionado antes, la interrupcion 21h tiene dentro varias funciones que se deben establecer en el registro AH (AX en su parte alta) de donde el procesador leera que servicio se invocara.

Ahora veamos algunos ejemplos basicos de asm con cadenas.

Copiar una cadena a otra

.model small
 
.code
 
inicio:
 
; Direccion del segmento de datos en ds, es
mov ax, @data
mov ds, ax
mov es, ax
 
; Leer de izq a derecha
cld
 
; Asigna las cadenas a copiar
mov cl,20   ; Longitud
lea si,cad1 ; Origen
lea di,cad2 ; Destino
rep movsb   ; Mueve la cadena
 
; Imprime cad1
lea dx,cad1
mov ah,9h ; Funcion 9H de la interrupcion 21h para imprimir una cadena en pantalla
int 21h   ; La cadena debe estar en dx
 
; Imprime cad2
lea dx,cad2
mov ah,9h ; Funcion 9H de la interrupcion 21h para imprimir una cadena en pantalla
int 21h   ; La cadena debe estar en dx
 
; Termina el programa
mov ah,4ch ; Funcion 4CH de la int 21H para finalizar el programa con codigo de retorno
int 21h    ; El codigo es opcional y va en AL
 
.data
cad1 db 10,13,"Esta es la cadena1", "$"
cad2 db 20 dup (' '), "$"
 
.stack
 
end inicio

Nota: .model small especifica el modelo de memoria, especificado por las siguientes opciones.

  • TINY: El codigo y los datos estan en el mismo segmento de maximo 64k.
  • SMALL: El codigo y los datos estan en diferentes segmentos, pero estos no superan los 64k
    Es usado en la mayoria de elas aplicaciones
  • MEDIUM: El codigo puede sobrepasar los 64k, pero el segmento de datos no.
  • COMPACT: El codigo es menor a 64k, pero el segmento de datos puede ser mayor.
  • LARGE: En este caso, tanto el segmento de datos como el de codigo pueden sobrepasar los 64k.
  • HUGE: Igual que LARGE, pero los arreglos declarados tambien pueden ser mayores a 64k.

+ Sistema básico de Cache con AspecJ + Anotaciones By sxceron February 21st, 2009 y hay 0 comentarios

Una de las ventajas de usar aspectos sobre un proyecto, es que podemos agregar modulos de funcionalidad sin tener que tocar una sola linea de código de nuestra aplicación.

En este tutorial veremos como implementar un sistema básico de caching usando aspectj con anotaciones. Las anotaciones nos servirán para especificar que bloques de código o que funciones serán guardadas en cache.

Primero que nada necesitamos crear una nueva anotación que identifique que métodos van a ser cacheados por el aspecto. La anotación quedaría de la siguiente forma:

Cachable.java

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Cachable {
}

Ahora vamos a crar nuestro aspecto y dentro de el un Advice(Around). Around por si no lo saben, es ejecutado como su nombre lo dice, alrededor del método, y permite detener la ejecución de este y regresar un valor ó continuar normalmente.

CacheAspect.java

import java.util.HashMap;
import java.util.Map;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import annotations.Cachable;
 
@Aspect
public class CacheAspect {
 
    final static int TIME_CACHE = 300;
    private final Map<string, CacheJoinPoint> cache = new WeakHashMap<string, CacheJoinPoint>();
 
    @Around("execution(* *(..)) && @annotation(annotations.Cachable)")
    public Object aroundProfileMethods(final ProceedingJoinPoint thisJoinPoint)
		throws Throwable {
        final String thisJoinPointName = AspectJHelper.getJoinPointName(thisJoinPoint);
        final String thisJoinPointArgs = AspectJHelper.getJointPointArgs(thisJoinPoint);
        final String objName = thisJoinPointName + "-" + thisJoinPointArgs;
        CacheJoinPoint obj = this.cache.get(objName);
        if (obj == null) {
            Object value = thisJoinPoint.proceed();
            CacheJoinPoint cjp = new CacheJoinPoint(System.currentTimeMillis(), value);
            this.cache.put(objName, cjp);
            return value;
        }else{
            if(System.currentTimeMillis() - obj.getTime() > TIME_CACHE){
                Object value = thisJoinPoint.proceed();
                CacheJoinPoint cjp = new CacheJoinPoint(System.currentTimeMillis(), value);
                this.cache.put(objName, cjp);
                return value;
            }
        }
        return obj.getValue();
    }
}

El aspecto es muy sencillo, la constante TIME_CACHE determinará cuanto tiempo durará nuestro objeto en cache en milisegundos. El HashMap es un pequeño contenedor de objetos y será usado para guardar los valores regresados por los métodos ya ejecutados.

WeakHashMap. Esta clase implementa java.util.Map, pero las keys se almacenan como objetos con referencias débiles. Con esto se dejará la responsabilidad de vaciar la caché al recolector de basura.

La clase CacheJoinPoint nos servirá como referencia para guardar tanto el valor regresado por el método ejecutado, como la hora a la que fue ejecutado para determinar despues si este ya excedio su tiempo de vida y tendría que ser ejecutado nuevamente, de lo contrario es obtenido del cache.

CacheJoinPoint.java

public class CacheJoinPoint {
    private Object value;
    private long time;
 
    public CacheJoinPoint(long time, Object value){
        this.time = time;
        this.value = value;
    }
 
    public long getTime() {
        return time;
    }
 
    public void setTime(long time) {
        this.time = time;
    }
 
    public Object getValue() {
        return value;
    }
 
    public void setValue(Object value) {
        this.value = value;
    }
}

La clase AspectJHelper nos sirve como auxiliar para regresar un nombre único a cada método ejecutado y sus argumentos (en caso de que existan).

AspectJHelper.java

import org.aspectj.lang.JoinPoint;
 
public class AspectJHelper {
 
    public static final String getJoinPointName(final JoinPoint joinPoint) {
        return joinPoint.getThis().getClass().getSimpleName() +
		"." + joinPoint.getSignature().getName();
    }
 
    public static final String getJointPointArgs(final JoinPoint joinPoint) {
        final StringBuilder buf = new StringBuilder();
        for (final Object arg : joinPoint.getArgs()) {
            buf.append(arg.getClass().getSimpleName() + "-" + arg + "+");
        }
        return buf.toString().replaceAll("\\+$", "");
    }
}

Por último, para hacer uso de la cache solo es necesario poner una anotacion sobre el metodo que vayamos a querer guardar en la cache, de esta forma:

@Cachable
public Objeto getObjeto(int param) {
	...
	return value;
}

+ Introduccion a XStream parte 1 By sxceron January 15th, 2009 y hay 0 comentarios

Existen muchas librerias de  java que permiten el manejo de xml(DOM4J, XPath, SAX, etc), pero no todas ellas nos permiten mapear o convertir facilmente de XML a POJOs y viceversa.

XStream es una libreria que tiene muchas opciones a la hora de converitir nuestro xml a una clase de java (conversores, persistencia, json, alias, anotaciones, etc). XStream hace uso de la API Reflection de java para hacer el mapeo del xml, asi que nuestras clases tendran que llevar los campos con sus respectivos set/get.

Para hace uso de esta libreria, prmero hay que bajarnos la distribucion binaria de la pagina http://xstream.codehaus.org/download.html

Agregar los archivos en el classpath ó en las librerias de nuestro proyecto NetBeans.

El archivo xstream-[version].jar es el nucleo de la API y XPP3 es una implementacion mas veloz que el estandar JAXP para el parseo de XML.

Ahora vamos a hacer nuestro primer ejemplo de serializacion con XStream.

Para empezar necesitamos crear un POJO (Un simple archivo java que contiene propiedades y sus respectivos set & get).

Persona.java

public class Persona {
    private String nombre;
    private int edad;
    private List amigos = new ArrayList();
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public int getEdad() {
        return edad;
    }
 
    public void setEdad(int edad) {
        this.edad = edad;
    }
 
    public List getAmigos() {
        return amigos;
    }
 
    public void addAmigo(String amigo) {
        amigos.add(amigo);
    }
}

Despues de eso vamos a crear una aplicacion java, en este caso una con main para hacer uso de la libreria.

XStreamTest.java

import com.thoughtworks.xstream.XStream;
 
public class XStreamTest {
 
    public static void main(String[] args) {
        XStream xstream = new XStream();
        xstream.alias("persona", Persona.class);
        Persona yo = new Persona();
        yo.setNombre("Sergio Ceron");
        yo.setEdad(19);
        yo.addAmigo("Some friend ;)");
        String xml = xstream.toXML(yo);
        System.out.println(xml);
    }
 
}

Al ejecutar este ejemplo veremos algo asi:

  Sergio Ceron
  19
 
    Some friend ;)

Para que vean que hace la sentencia xstream.alias, la pueden quitar y el xml se generará sin ningun error pero de la siguiente forma:

  Sergio Ceron
  19
 
    Some friend ;)

Donde xstreamsample es el paquete donde esta la clase Persona. Es decir, cambia el nombre completo de la clase por el alias que especifiquemos para que nuestro xml se vea mejor.

Por otra parte, para regresar el xml a una clase java, es tan sencillo como lo siguiente.

public static void main(String[] args) {
        XStream xstream = new XStream();
        xstream.alias("persona", Persona.class);
 
        String xml =
                "
" +
                "   Sergio Ceron" +
                "   19" +
                "   " +
                "       Some friend ;)" +
                "   " +
                "";
        Persona yo = (Persona)xstream.fromXML(xml);
        System.out.println( "Me llamo: " + yo.getNombre() );
        System.out.println( "Tengo: " + yo.getEdad() + " años" );
        System.out.println( "Mis amigos: " );
        for( String amigo : yo.getAmigos() )
            System.out.println( amigo );
    }

Y el resultado es:


Me llamo: Sergio Ceron

Tengo: 19 años

Mis amigos:

Some friend ;)

Como ven, es muy sencillo serializar con xstream. Despues veremos algunas funciones mas complejas de esta libreria como conversores y el uso de anotaciones para simplificar codigo.

+ Spring + Hibernate + Acegi ( Custom UserDetailsService ) By sxceron January 13th, 2009 y hay 0 comentarios

En este tutorial quiero mostrar como implementar un UserDetailsService personalizado que nos permita recueperar el usuario que ha iniciado sesion en acegi cargando el objeto en la sesión de Hibernate.

Bueno, la verdad no pondre el tutorial completo desde cero, espero que esto les sirva de ayuda pero la parte de la implementacion de acegi + hibernate + spring la dejare para otro tutorial, el truco aqui es que hay cosas que no estan bien documentadas y esta es una de ellas.

La parte que hay que agregar/modificar en el applicationContext.xml de spring es la siguiente:

<bean id="daoAuthenticationProvider"
	class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
        <property name="userDetailsService">
		<ref bean="userDetailsService" />
        </property>
        <property name="passwordEncoder">
		<ref local="passwordEncoder"/>
	</property>
    </bean>
 
    <!-- Custom User Detail Service -->
    <bean id="userDetailsService"
	class="org.security.AuthenticationJdbcDaoImpl">
        <property name="dataSource">
            <ref bean="dataSource"/>
        </property>
        <property name="userInfoObjectTypes">
            <list>
                <value>Usuario</value>
            </list>
        </property>
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

Donde:

  • userDetailsService: Es el bean que obtendra el usuario que ha iniciado sesión y lo dara de alta en la sesion de Hibernate
  • org.security.AuthenticationJdbcDaoImpl: Es la clase donde estara la autenticacion personalizada
  • userInfoObjectTypes: Es una dependencia que inyectaremos para decirle de que tabla debera obtener el usuario que haya iniciado sesion, pongo una lista en caso de que sean mas de una tabla donde este nuestro usuario usando herencias o algo asi.
  • dataSource: Es el bean que deberiamos ya tener y que apunta a el orgien de datos del sistema de persistencia que estemos usando
  • sessionFactory: Es el session factory de Hibernate

Y bueno de aqui nos vamos a la clase AuthenticationJdbcDaoImpl.

import org.acegisecurity.userdetails.UserDetails;
import org.acegisecurity.userdetails.UsernameNotFoundException;
import org.acegisecurity.userdetails.jdbc.JdbcDaoImpl;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.dao.DataAccessException;
 
public class AuthenticationJdbcDaoImpl extends JdbcDaoImpl {
 
    private String[] userInfoObjectTypes;
    private SessionFactory sessionFactory;
 
    @Override
    protected void initMappingSqlQueries() {
        super.setUsersByUsernameQuery("select nombre as username, password, enabled"
		+" from usuario where nombre = ?");
        super.setAuthoritiesByUsernameQuery("select usuario.nombre as username, "
		+"authorities.permission as authority from usuario, authorities, "
		+"usuario_authorities where usuario_id=usuario.id and "
		+"autorities_id=authorities.id and usuario.nombre = ?");
        super.initMappingSqlQueries();
    }
 
    @Override
    public UserDetails loadUserByUsername(String username) {
        try {
            UserDetails user = super.loadUserByUsername(username);
            Session session = sessionFactory.openSession();
            for (int i = 0; i < userInfoObjectTypes.length; i++) {
 
                Object userInfo = session.createQuery("from " + userInfoObjectTypes[i] +
			" where nombre = '" + username + "'").uniqueResult();
                if (userInfo != null) {
                    session.close();
                    return new CustomUser(user.getUsername(), user.getPassword(),
			user.isEnabled(), user.getAuthorities(), userInfo);
                }
            }
            session.close();
            return new CustomUser(user.getUsername(), user.getPassword(),
			user.isEnabled(), user.getAuthorities());
        } catch (UsernameNotFoundException ex1) {
            ex1.printStackTrace();
            throw ex1;
        } catch (DataAccessException ex2) {
            ex2.printStackTrace();
            throw ex2;
        }
    }
 
    public void setUserInfoObjectTypes(String[] userInfoObjectTypes) {
        this.userInfoObjectTypes = userInfoObjectTypes;
    }
 
    public void setSessionFactory(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }
}

La clase CustomUser

import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.userdetails.User;
 
public class CustomUser extends User {
 
    private Object userInfo;
 
    public CustomUser(String username, String password, boolean isEnabled,
			GrantedAuthority[] authorities, Object user) {
        super(username, password, isEnabled, true, true, true, authorities);
        this.setUserInfo(user);
    }
 
    public CustomUser(String username, String password, boolean isEnabled,
			GrantedAuthority[] arrayAuths) {
        super(username, password, isEnabled, true, true, true, arrayAuths);
    }
 
    public Object getUserInfo() {
        return userInfo;
    }
 
    public void setUserInfo(Object userInfo) {
        this.userInfo = userInfo;
    }
}

Como se daran cuenta, el userInfo es el que tendra nuestro usuario logueado, pero como tambien veran este esta siendo cargado desde una sesion nueva y esto causa muchos problemas a la hora de tener colecciones en nuestros entity beans, asi que lo que hartemos sera reasociarlo con la otra sesion una vez que se haya autenticado.

Esta vez lo hare con icefaces y desde un controlador de spring.

@Resource
private Dao dao;
...
public String auth_login_action(){
        try{
            authenticate( j_username.getText(), j_password.getValue().toString() );
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            CustomUser customUser = (CustomUser)(auth.getPrincipal());
            for( GrantedAuthority ga : customUser.getAuthorities() )
                System.out.println( ga.getAuthority() );
            Object usuario =  customUser.getUserInfo();
            dao.lock(usuario);
            if( usuario instanceof Empleado ){
                empleadoMgr.setEmpleado((Empleado)usuario);
            }
            return "sucess";
        }catch(Exception e){}
        return null;
    }
...

Aqui @Resource es una anotacion de java para inyectar el Dao que esta con hibernate, eso depende de cada quien tener el suyo( Si no saben como crearlo despues subire otro tutorial para eso ).

La parte importante es la de dao.lock que si no usan un Dao, podria ser:

session.lock(usuario, LockType.NONE)

getHibernateTemplate().lock(usuario, LockType.NONE)

Y es la que se encarga de reasociar el objeto de una sesión a otra dentro del contexto de Hibernate.

Después de todo esto las colecciones no se cargaran a menos que tengamos un FetchType EAGER con anotaciones o si fijamos lazy=”false” y dejamos fetch por defecto (fetch=”select”), implica que cuando se recuperen los datos de TA también se recuperan los de TB, pero se hará con 1+n consultas a la base de datos.

Otra forma de cargar una coleccion que es mas eficiente es por ejemplo:

Hibernate.initialize(empresa.getEmpleados());

Esta ultima sentencia forza a cargar una coleccion de un entity bean.

Por ahora eso seria todo, si tienen dudas o partes de esto que no entiendan me pueden enviar un correo a ceronxero (arroba) hotmail (punto) com y tratare de responder lo mas rapido en la medida de lo posible.

Saludos.