•En JSP las acciones que se pueden realizar sobre las sesiones se lleva a cabo
mediante la interface HttpSession y los métodos que implementa. Esta interfaz está incluida
dentro del paquete javax.servlet.http y es utilizada por el contenedor de páginas JSP para
crear una sesión entre el servidor y el cliente.
Para obtener la sesión de un usuario se utiliza el método getSession() que devuelve
una interfaz de tipo HttpSession.
<%HttpSession sesion=request.getSession();%>
Una vez creado el objeto de tipo sesión es posible acceder a una serie de datos sobre
la misma. Uno de estos datos es idSession que devuelve un identificador único asociado a
una sesión:
<%HttpSession sesion=request.getSession();
out.println(“IdSesion: ”+sesion.getId());
%>
Es posible conocer el momento en el que se creó la sesión:
<%@page import=”java.util.*”
session=”true”%>
<%
HttpSession sesion=request.getSession();
out.println(“Creación: “+sesion.getCreationTime());
Date momento=new Date(sesion.getCreationTime());
out.println(“Creación: “+momento);
%>
También se puede conocer la fecha y hora de la última vez que el cliente accedió al
servidor con el que se creó la sesión, utilizando el método getLastAccesedTime():
<%
Date acceso=new Date(sesion.getLastAccessedTime());
out.println(“Último acceso: “+acceso+”;
%>
Teniendo en cuenta el momento en el que ser creó la sesión y la última vez que se
accedió al servidor, se puede conocer el tiempo que lleva el cliente conectado al servidor, o
lo que es lo mismo el tiempo que lleva el usuario navegando por la páginas JSP:
<%
long longDuracion=sesion.getLastAccessedTime();
sesion.getCreationTime();
Date duracion=new Date(longDuracion);
out.println(“Duracion:“+duracion.getMinutes()+”min.”+duracion.getSeconds()+”seg”);
%>
La interfaz HttpSession ofrece el método isNew() mediante el cual es posible saber
si la sesión creada es nueva o se está tomando de una previamente creada:
<%
HttpSession sesion=request.getSession();
out.println(“nueva: “+sesion.isNew());
%>
Si se ejecuta el ejemplo la primera vez el método devolverá true, ya que
previamente no había ninguna sesión y ha sido creada en ese instante. Si se recarga la
página devolverá false ya que la sesión ya ha sido creada.
Las sesiones no necesitan ningún tipo de mantenimiento, una vez creadas no es
necesario utilizarlas de forma obligatoria o tener que refrescar los datos asociados a las
mismas, se deben ver como una variable más con la diferencia que pueden ser utilizadas en
cualquier página independientemente del lugar en el que hayan sido creadas.
Guardar Datos de Sesion
Para guardar un objeto en una sesión se utiliza el método setAttribute(), que ha
sustituido al método putValue(). Este método utiliza dos argumentos:
-El primero es el nombre que identificará a esa variable.
-El segundo es el dato que se va a guardar.
SetAttribute(java.lang.String name, java.lang.Object value)
Un ejemplo de cómo guardar una cadena de texto en la sesión:
<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
sesion.setAttribute(“trabajo”,”Paginas de JSP”);
%>
Si se quiere pasar un parámetro que no sea un objeto es necesario realizar una
conversión:
<%@page import=”java.util.*” session=”true” %>
<%HttpSession sesion=request.getSession();
Integer edad=new Integer(26);
sesion.setAttribute(“edad”,edad);
%>
Si se hubiera utilizado el valor entero en vez del objeto Integer, el resultado habría
sido similar al siguiente.
Incompatible type for meted. Can’t convert int to java.lang.Object.
En el primer ejemplo este no sucedería puesto que una cadena es un objeto de tipo
String, no así un entero. Así habría sido igual si en el primer caso ponemos:
<%@page import=”java.util.*” session=”true” %>
&%
HttpSession sesion=request.getSession();
String nombre=new String(“Paginas de JSP·);
sesion.setAttribute(“trabajo”,nombre);
%>
En caso de tratarse objeto de tipo Vector (parecido a un array con dos diferencias: la
primera es que puede almacenar todo tipo de objetos, y la segunda es que no es necesario
establecer de forma previa el tamaño que va a tener) que almacene los 7 días de la semana.
El código sería el siguiente:
<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
Vector v=new Vector();
v.addElement(new String(“Lunes”));
v.addElement(new String(“Martes”));
v.addElement(new String(“Miercoles”));
v.addElement(new String(“Jueves”));
v.addElement(new String(“Viernes”));
v.addElement(new String(“Sábado”));
v.addElement(new String(“Domingo”));
sesion.setAttribute(“diasSemana”,v);
%>
Recuperar Datos de Sesion
Los datos que se guardan en la sesión permanecen ahí a la espera de ser utilizados.
Para ello es necesario realizar el proceso contrario a cuando se graban, comenzando por la
recuperación del objeto de la sesión para empezar a ser tratado.
Para poder realizar este paso se utiliza el método getAttribute() (anteriormente se
utilizaba el método getValue(), pero este método se encuentra en desuso), utilizando como
argumento el nombre que identifica al objeto que se quiere recuperar.
getAttribute(java.lang,String nombre)
Un ejemplo de recuperación de objetos almacenados en la sesión:
<%
HttpSession sesion=request.getSession();
Sesion.getAttribute(“nombre”);
%>
Cuando este método devuelve el objeto no establece en ningún momento de qué tipo
de objeto se trata (String, Vector...)
Por ello si se conoce previamente el tipo de objeto que puede devolver tras ser
recuperado de la sesión es necesario realizar un casting, para convertir el objeto de tipo
genérico al objeto exacto que se va a usar. Para realizar esta operación se añade el tipo de
objeto al lado de tipo
HttpSession que utiliza el método getAttribute() para obtener el objeto que devuelve:
<%
HttpSession sesion=request.getSession();
String nombre=(String)sesion.getAttribute(“nombre”);
out.println(“Contenido de nombre: “+nombre);
%>
Si no existe ningún objeto almacenado en la sesión bajo el identificador que se
utiliza en el método getAttribute(), el valor devuelto será null. Por ello habrá que prestar
especial atención ya que si se realiza el casting de un valor null el contenedor JSP
devolverá un error. Lo mejor en estos casos es adelantarse a los posibles errores que pueda
haber.
<%
if(sesion.getAttribute(“nombre”)!=null)
{
String nombre=(String)sesion.getAttribute(“nombre”);
out.println(“Contenido de nombre: “+nombre);
}
%>
En el caso de tipos primitivos deben de ser convertidos a objetos previamente a su
integración sesión de tal forma que su proceso de extracción viene a ser similar:
<%
HttpSession sesion=request.getSession();
Integer edad=(Integer)sesion.getAttribute(“edad”);
out.println(“Edad: “+edad.intValue());
%>
En esta ocasión el objeto devuelto y convertido a Integer no es del todo válido ya
que es necesario obtener de él el valor entero. Para ello se utiliza el método intValue() que
evuelve el valor que realmente se había guardado previamente en la sesión.
Por último, el ejemplo del vector guardado en la sesión tiene un tratamiento similar
al de los casos anteriores. El primer paso es recuperar el objeto de la sesión:
<%@page import=”java.util.*” session=”true” %>
<%
HttpSession sesion=request.getSession();
sesion.getAttribute(“diasSemana”);
%>
Como se sabe que el objeto es de tipo Vector se puede recuperar y convertir en un
solo paso:
Vector v= (Vector) sesion.getAttribute(“diasSemana”);
A partir de este momento se puede acceder a los elementos del vector
independientemente de si venía de una sesión o ha sido creado. Para ello se utiliza el
método size() que devuelve el tamaño del vector para ir leyendo cada uno de sus elementos:
<%
for(int i=0; i
{
out.println(“Dia: ”+(String)v.get(i)+”);
}
%>
Se ha realizado otro proceso de conversión que sin ser necesario, ayuda a entender
mejor el funcionamiento. Cuando se recupera un elemento de un vector (que se trata de un
objeto) es necesario realizar el casting y convertirlo a su tipo de objeto definitivo. El
resultado será el siguiente.
Para recuperar todos los objetos de una sesión se puede hacer uso también del
método getAttributeNames() de la interfaz HttpSession. Para recoger todos los objetos
almacenados en la sesión se recorre el objeto Enumeration que contiene el nombre de todos
los objetos que contiene la sesión y que ha sido devuelto por el método
getAttributeNames().
Cada nombre de atributo de la sesión se utiliza en la llamada a cada
método getAttribute(), que devolverá el objeto correspondiente.
<%@page contentType="text/html; charset=iso-8859-1" session="true"
language="java" import="java.util.*" %>
<%
HttpSession sesion=request.getSession();
String nombre=”Práctica de POO”;
Vector v=new Vector();
v.addElement(new String("Lunes"));
v.addElement(new String("Martes"));
v.addElement(new String("Miercoles"));
v.addElement(new String("Jueves"));
v.addElement(new String("Viernes"));
v.addElement(new String("Sábado"));
v.addElement(new String("Domingo"));
sesion.setAttribute("diasSemana",v);
sesion.setAttribute("nombre",nombre);
%>
Con el siguiente código se recupera los objetos
<%@page import="java.util.*" session="true" %>
<%
HttpSession sesion=request.getSession();
Enumeration enum=sesion.getAttributeNames();
String nombreAtributo;
while (enum.hasMoreElements())
{
nombreAtributo=(String)enum.nextElement();
out.println("Atributo:"+nombreAtributo);
if(nombreAtributo.equals("diasSemana"))
{
Vector v= (Vector);
sesion.getAttribute("diasSemana");
for(int i=0; i
{
out.println("Dia:"+(String)v.get(i));
}
}
else
out.println(""+sesion.getAttribute(nombreAtributo)+"");
}
%>