Manual JSP
¿Qué es una Sesión?
Una sesión es una serie de comunicaciones entre un cliente y un servidor en la que se realiza un intercambio de información. Por medio de una sesión se puede hacer un seguimiento de un usuario a través de la aplicación. El tiempo de vida de una sesión comienza cuando un usuario se conecta por primera vez a un sitio web pero su finalización puede estar relacionada con tres circunstancias:
-Cuando se abandona el sitio web.
-Cuando se alcanza un tiempo de inactividad que es previamente establecido, en este caso la sesión es automáticamente eliminada. Si el usuario siguiera navegando se crearía una nueva sesión.
-Se ha cerrado o reiniciado el servidor.
Una posible aplicación de las sesiones es en el comercio electrónico. En este caso una sesión permite ir eligiendo una serie de productos e irlos añadiendo a nuestro “carrito” y así hasta finalizar la compra. Sin el uso de sesiones no se podría hacer porque al ir navegando de una página a otra se iría perdiendo toda la información. También se utilizan para la identificación de usuarios, en la que se deben de introducir un login y un password. Después de haber hecho esto el usuario tendrá una serie de permisos sobre las páginas que va a visitar, de tal forma que si un usuario intenta pasar a una página si haberse identificado, el sistema comprobará que no se ha identificado y sería redireccionado a la página de identificación. Para poder realizarse estas operaciones es necesario almacenar en unas tipo sesión la información necesaria para saber que el usuario se ha identificado correctamente. Para poder hacer uso de las sesiones en JSP hay que poner el atributo session de la directiva page a true, de esta forma se notifica al contenedor que la página interviene en un proceso que utiliza las sesiones del protocolo HTTP:
<%@page session=’true’%>
El manejo de las sesiones impide el intercambio de datos entre ellas ya que se trata información específica para cada usuario e incluso si se trata del mismo usuario.
Manejo de las Sesiones
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 objetos en una Sesión
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
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
<%@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
}
}
else
out.println(""+sesion.getAttribute(nombreAtributo)+"");
}
%>
Principales métodos:
• Enumeration getAttributeNames(): este método devuelve en un objeto Enumeration
del paquete java.util, que contiene los nombres de todos los objetos almacenados en
la sesión actual.
• long getCreationTime(): devuelve la fecha y hora en la que fue creada la sesión,
medido en milisegundos desde el 1 de enero de 1970.
• String getId(): devuelve una cadena que se corresponde con el identificador único
asignado a la sesión. Luego se ve que este valor se corresponde con el valor de el
cookie.
• JSESSIONID utilizada para poder realizar el mantenimiento de la sesión de un
usuario determinado, y en el caso de no utilizar cookies se corresponde con la
información que se añade al final de cada enlace cuando se utiliza el mecanismo de
reescritura de URLs.
• long getLastAccesesedTime(): devuelve en milisegundos la fecha y hora de la
última vez que el cliente realizó una petición asociada con la sesión actual.
• int getMaxInactiveInterval(): devuelve el máximo intervalo de tiempo, en segundos,
en el que una sesión permanece activa entre dos peticiones distintas de un mismo
cliente, es decir, es el tiempo de espera máximo en el que pertenece activa una
sesión sin que el cliente realice ninguna petición relacionada con la sesión actual. El
valor por defecto que puede permanecer inactiva unas sesión es de 30 segundos.
• servlets (servlet container) destruirá la sesión, liberando de la memoria todos los
objetos que contiene la sesión que ha caducado.
• void invalidate(): este método destruye la sesión de forma explícita, y libera de
memoria todos los objetos (atributos) que contiene la sesión.
• boolean isNew(): devuelve verdadero si la sesión se acaba de crear en la petición
actual o el cliente todavía no ha aceptado la sesión (puede rechazar el cookie de
inicio de sesión).
• void removeAttribute(String nombreAtributo): elimina el objeto almacenado en la
sesión cuyo nombre se pasa por parámetro. Si el nombre del objeto indicado no se
corresponde con ninguno de los almacenados en la sesión, este método no realizará
ninguna acción.
• void setAttribute(String nombre, Object valor): almacena un objeto en la sesión
utilizando como referencia el nombre indicado como parámetro a través de un
objeto String.
• void setMaxInactiveInterval(int intervalo): establece, en segundos, el máximo
tiempo que una sesión puede permanecer inactiva antes de ser destruida por el
contenedor de servlets.
Las sesiones vistas anteriormente basan su funcionamiento en los cookies. Cuando
se hace uso de la interfaz HttpSession de forma interna y totalmente transparente al
programador se está haciendo uso de los cookies. De hecho cuando a través de una página
JSP se comienza una sesión, se crea un cookie llamado JSSESIONID. La diferencia es que
este cookie es temporal y durará el tiempo que permanezca el navegador ejecutándose,
siendo borrada cuando el usuario cierre el navegador.
El objetivo de utilizar cookies es poder reconocer al usuario en el momento en el
que se conecta al servidor. Una de las páginas que recoge la petición del usuario puede
comprobar si existe un cookie que ha dejado anteriormente, si es así, sabe que ese usuario
ya ha visitado ese website y por lo tanto puede leer valores que le identifiquen. Otro de los
usos de los cookies es ofrecer una personalización al usuario. En muchos sitos web es
posible elegir el color de fondo, el tipo de letra utilizado, etc... Estos valores pueden ser
almacenados en cookies de forma que cuando acceda de nuevo al web y se compruebe la
existencia de esos valores, serán recuperados para utilizarlos en la personalización de la
página tal y como el usuario estableció en su momento.
Un ejemplo que se ha podido encontrar en muchas webs es en el momento de
realizar un registro o solicitar el alta en un área restringida, ya que en muchas ocasiones
existe un checkbox que cuando se selecciona permite recordar el nombre de usuario a falta
de que sólo se escriba la clave.
Utilizando también el identificador idSession que se genera en un sesión como ya
hemos visto y guardándolo en el cookie se pueden mostrar mensajes personalizados en el
momento en el que el usuario acceda de nuevo al website.
Para trabajar con cookies se utiliza la clase Cookie que está disponible en paquete
javax.servlet.http. Por medio de esta clase se pueden crear cookies, establecer sus valores y
nombres, alguna de sus propiedades, eliminarlas, leer valores que almacenan, etc.
Un cookie almacenado en el ordenador de un usuario está compuesto por un nombre
y un valor asociado al mismo. Además, asociada a este cookie pueden existir una serie de
atributos que definen datos como su tiempo de vida, alcance, dominio, etc.
Cabe reseñar que los cookies, no son más que ficheros de texto, que no pueden
superar un tamaño de 4Kb, además los navegadores tan sólo pueden aceptar 20 cookies de
un mismo servidor web (300 cookies en total).
Para crear un objeto de tipo Cookie se utiliza el constructor de la clase Cookie que
requiere su nombre y el valor a guardar. El siguiente ejemplo crearía un objeto Cookie que
contiene el nombre “nombre” y el valor “objetos”.
<%
Cookie miCookie=new Cookie(“nombre”,”objetos”);
%>
También es posible crear cookies con contenido que se genere de forma dinámica.
El siguiente código muestra un cookie que guarda un texto que está concatenado a la
fecha/hora en ese momento:
<%@page contentType="text/html; charset=iso-8859-1" session="true"
language="java" import="java.util.*" %>
<%
Cookie miCookie=null;
Date fecha=new Date();
String texto= “Este es el texto que vamos a guardar en el
cookie”+fecha;
miCookie=new Cookie(“nombre”,texto);
%>
También se pueden guardar valores o datos que provengan de páginas anteriores y
que hayan sido introducidas a través de un formulario:
<%
Cookie miCookie=null;
String ciudad= request.getParameter(“formCiudad”);
miCookie=new Cookie(“ciudadFavorita”,ciudad);
%>
Por defecto, cuando creamos un cookie, se mantiene mientras dura la ejecución del
navegador. Si el usuario cierra el navegador, los cookies que no tengan establecido un
tiempo de vida serán destruidos.
Por tanto, si se quiere que un cookie dure más tiempo y esté disponible para otras
situaciones es necesario establecer un valor de tiempo (en segundos) que será la duración o
tiempo de vida del cookie. Para establecer este atributo se utiliza el método setMaxAge().
El siguiente ejemplo establece un tiempo de 31 días de vida para el cookie “unCookie”:
<%
unCookie.setMaxAge(60*60*24*31);
%>
Otros de los atributos que se incluye cuando se crea un cookie es el path desde el
que será visto, es decir, si el valor del path es “/” (raíz), quiere decir que en todo el site se
podrá utilizar ese cookie, pero si el valor es “/datos” quiere decir que el valor del cookie
sólo será visible dentro del directorio “datos”. Este atributo se establece mediante el método
setPath().
<%
unCookie.setPath(“/”);
%>
<%
out.println(“cookie visible en: “+unCookie.getPath());
%>
Si no se establece la propiedad domain se entiende que el cookie será visto sólo
desde el dominio que lo creó, pero sin embardo si se especifica un nombre de dominio se
entenderá que el cookie será visto en aquellos dominios que contengan el nombre
especificado.
En el siguiente ejemplo hace que el cookie definido en el objeto “unCookie” esté
disponible para todos los dominios que contengan el nombre “.paginasjsp.com”. Un
nombre de dominio debe comenzar por un punto.
<%
unCookie.setDomain(“.paginasjsp.com”);
%>
Para crear el fichero cookie real, se utiliza el método addCookie() de la interfaz
HttpServletResponse:
<%
response.addCookie(unCookie);
%>
El proceso de recuperar un cookie determinado puede parecer algo complejo, ya que
no hay una forma de poder acceder a un cookie de forma directa. Por este motivo es
necesario recoger todos los cookies que existen hasta ese momento e ir buscando aquél que
se quiera, y que al menos, se conoce su nombre.
Para recoger todos los cookies que tenga el usuario guardados se crea un array de
tipo Cookie, y se utiliza el método getCookies() de la interfaz HttpServletRequest para
recuperarlos:
<%
Cookie [] todosLosCookies=request.getCookies();
/*El siguiente paso es crear un bucle que vaya leyendo todos los
cookies.*/
for(int i=0;i
/*A continuación se compara los nombres de cada uno de los
cookies con el que se está buscando. Si se encuentra un cookie con
ese nombre se ha dado con el que se está buscando, de forma que se
sale del bucle mediante break. */
if(unCookie.getName().equals(“nombre”))
break;
}
/*Una vez localizado tan sólo queda utilizar los métodos apropiados
para obtener la información necesaria que contiene.*/
out.println(“Nombre: “+unCookie.getName()+”);
out.println(“Valor: “+unCookie.getValue()+”);
out.println(“Path: “+unCookie.getPath()+”);
out.println(“Tiempo de vida:“+unCookie.getMaxAge()+”);
out.println(“Dominio: “+unCookie.getDomain()+”);
%>
Resumen de la interfaz "HTTPSESSION"
Cookies: creación y recuperación
COOKIES
Creación de cookies
Recuperación de cookies