Los servlets son objetos que corren dentro del contexto de un contenedor de servlets (ej: Tomcat) y extienden su funcionalidad. También podrían correr dentro de un servidor de aplicaciones (ej: OC4J Oracle), que, además de contenedor para servlet, tendrá contenedor para objetos más avanzados, como son los EJB (Tomcat sólo es un contenedor de servlets). La palabra servlet deriva de otra anterior, applet, que se refería a pequeños programas que se ejecutan en el contexto de un navegador web. Por contraposición, un servlet es un programa que se ejecuta en un servidor. El uso más común de los servlets es generar páginas web de forma dinámica a partir de los parámetros de la petición que envíe el navegador web.

Los formularios son una de las herramientas de que disponemos a la hora de hacer nuestras páginas Web interactivas, en el sentido de que nos permiten recopilar información de la persona que ve la página, procesarla y responder a ella, pudiendo de esta forma responder adecuadamente a sus acciones o peticiones. Los formularios están formados por una serie de controles distintos, cada uno de los cuales está asociado a un tipo concreto de datos o una acción predeterminada: botones de envío y borrado de datos, listas de selección, cajas de entrada de texto, etc. El resultado cualquier formulario es una lista de variables y valores asignados a las mismas, que tienen todos ellos un atributo en común: el nombre de su variable.

Etiqueta FORM:

action="Ruta": La manera en la que se va a manipular el formulario HTML se establece empleando el atributo action para el elemento de formulario. El atributo action se fija generalmente a una URL del programa que manipulará los datos del formulario.

method="get | post": Es también necesario especificar cómo se va a enviar el formulario a la dirección especificada por el atributo action. El atributo method indica cómo se enviarán los datos. Hay dos valores aceptables para el atributo method: get y post. Con el valor post, la información se enviara por la entrada estándar STDIO (la mas segura, pues no se pueden visualizar los datos que se envían) y con el valor get, se enviará a través de la URL.

enctype="application/x-www-form-urlencoded | multipart/form-data | text/plain": Indica el tipo de documento en formato MIME. El más usado para que lleguen el contenido a través de un mail con el método post sería "text/plain". Especifica el tipo de encriptación que se va a realizar con los datos que se van a enviar. Este atributo solamente se aplica si method es post.

target="_blank | _parent | _self | _top": Este atributo funciona igual que el homónimo de las etiquetas "< A >" y "< FRAME >" , e indica en qué ventana de una página con frames se debe mostrar el resultado del proceso de datos.

Etiqueta SELECT:

Esta etiqueta define una entrada de datos en forma de lista despegable. El usuario podrá elegir una o varias opciones de la lista según como se especifique. Sus atributos son:

name="nombre": Asigna un nombre identificador al campo. La opción elegida será asociada a este nombre cuando se envíen los datos del formulario.

size="numero": Es el número de opciones visibles. Si número=1 el campo de selección se muestra como una lista desplegable, mientras que si el valor de número es diferente se verá como una caja con barra de desplazamiento.

multiple: Permite elegir varias opciones de la lista. Para ello hay que mantener la tecla ctrl. (Control) pulsada mientras se van seleccionando.

disabled: Desactiva la lista, con lo cual no se podrás seleccionar ninguna opción.

Para introducir cada una de las opciones, se utiliza la etiqueta < OPTION >, cuyos parámetros son:

value:Fija el valor que será asociado al parámetro name de < SELECT > cuando se envíe el formulario. Este valor debe ser único para cada opción.

select: Establece la opción por defecto. Si no se especifica este parámetro en ninguna opción se tomará la primera de ellas por defecto.

Etiqueta TEXTAREA:

Esta pareja de etiquetas inserta una caja de texto de múltiples líneas, que a menudo se utiliza para introducir comentarios o datos largos en un formulario. Si no se introduce ningún texto entre ambas etiquetas la caja de texto aparecerá vacía, para que el usuario lo introduzca, pero si introducimos algún texto entre ambas este aparecerá inicialmente en la caja. Si el texto que contiene supera el espacio disponible en la caja aparecerá una barra de desplazamiento vertical. Los atributos y valores son:

name="nombre": Asigna un nombre identificador al campo, que será asociado en el envío del formulario al texto introducido en la caja de texto.

cols="x": Define el número de columnas visibles de la caja de texto.

rows="y": Define el número de filas visibles de la caja de texto.

wrap="valor": Justifica automáticamente el texto en el interior de la caja. Este atributo es de uso complicado.

Según las recomendaciones si su valor es VIRTUAL se enviará todo el texto seguido, en una línea, mientras que si vale PHYSICAL el texto se enviará separado en líneas físicas, pero así como se define no lo admiten los navegadores. Usemos cual usemos de los dos el resultado es el mismo: justificación por líneas físicas, y así y todo se producen saltos de línea indeseados.

disabled: Desactiva la caja de texto.

readonly: Impide que el contenido de la caja sea modificado por el usuario.

Etiqueta LABEL:

La etiqueta label sirve para representar el texto asociado a controles que no tienen implícitamente un valor de texto. En el caso de los botones por ejemplo su texto se saca a partir de su atributo value, que es su label implícito. Los controles que no tienen labels implícitos, como los campos de texto, radios o checkboxes por ejemplo, pueden utilizar etiquetas label para indicar el texto que les corresponde. Cada etiqueta label puede estar asociada únicamente a un control de formulario. Esta asociación se realiza mediante el atributo for, indicando el id del control de formulario al que queremos asociar el label. Es posible asociar un label con un control sin utilizar el atributo for, para ello es suficiente con que el control esté dentro de la etiqueta label. Uno de los beneficios que obtendremos utilizando etiquetas label será en el manejo de listas de radiobuttons o checkboxes. Mediante la asociación de un label, el usuario no tendrá por obligación que pinchar en el control para marcarlo o desmarcarlo, podrá hacerlo también pulsando sobre el texto del label.

A la hora de enviar información a un servlet tenemos dos formas: mediante el método GET y mediante el método POST. Existen una serie de diferencias entre pasarlos de una forma u otra:

Metodo POST: Este método solo esta accesible desde los formularios. Se envían los parámetros de forma implícita junto a la página, es decir, al pasar los parámetros, nosotros no vemos reflejado en ningún sitio qué parámetros son y cual es su valor.

Método GET: Este método envía los parámetros de forma explicita junto a la página, mostrando en la barra de navegación los parámetros y sus valores.

Lo primero que conocer son las formas de pasar información a una página web (vía POST y vía GET). Las diferencias, a grandes rasgos, son que las peticiones vía GET encadenan los valores a pasar a la página web en la URL, mientras que si hacemos una petición vía POST se pasará la información de forma implícita.

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)+"");
}
%>

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.

Creación de cookies

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

En esta ocasión el contenido del valor a guardar en el cookie está en la variable “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);
%>

Una vez que se ha creado un cookie, es necesario establecer una serie de atributos para poder ser utilizado. El primero de esos atributos es el que se conoce como tiempo de vida.

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

Si se utiliza un valor positivo, el cookie será destruido después de haber pasado ese tiempo, si el valor es negativo el cookie no será almacenado y se borrará cuando el usuario cierre el navegador. Por último si el valor que se establece como tiempo es cero, el cookie será borrado.

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(“/”); %>

Para conocer el valor de path, se puede utilizar el método getPath().

<% out.println(“cookie visible en: “+unCookie.getPath()); %>

Existe un método dentro de la clase Cookie que permite establecer el dominio desde el cual se ha generado el cookie. Este método tiene su significado porque un navegador sólo envía al servidor los cookies que coinciden con el dominio del servidor que los envió. Si en alguna ocasión se requiere que estén disponibles desde otros subdominios se especifica con el método setDomain(). Por ejemplo, si existe el servidor web en la página www.paginasjsp.com , pero al mismo tiempo también existen otros subdominios como usuario1.paginasjsp.com, usuario2.paginasjsp.com, etc.

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”); %>

Igualmente, para conocer el dominio sobre el que actúa el cookie, basta con utilizar el método getDomain() para obtener esa información. Una vez que se ha creado el objeto Cookie, y se ha establecido todos los atributos necesarios es el momento de crear realmente, ya que hasta ahora sólo se tenía un objeto que representa ese cookie.

Para crear el fichero cookie real, se utiliza el método addCookie() de la interfaz HttpServletResponse:

<% response.addCookie(unCookie); %>

Una vez ejecutada esta línea es cuando el cookie existe en el disco del cliente que ha accedido a la página JSP. Es importante señalar que si no se ejecuta esta última línea el cookie no habrá sido grabado en el disco, y por lo tanto, cualquier aplicación o página que espere encontrar dicho cookie no lo encontrará.

Recuperar cookies

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 Cookie unCookie=todosLosCookies[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()+”); %>

Caducidad

Todas las cookies tienen un período de caducidad. Cuando este tiempo se cumple, la cookie desaparece. Teniendo en cuenta este comportamiento cabe distinguir cuatro tipos de cookies:
Cookies de sesión: desaparecen cuando se acaba la sesión, entendiendo por sesión el período de tiempo que un usuario está en un sitio web de manera continuada con la misma ventana del navegador.

Cookies permanentes: si la fecha de caducidad de la cookie se corresponde con un futuro lejano, se puede decir que la cookie que es permanente. Esto no es del todo cierto, como se ha observado, ya que los navegadores cuentan con un espacio limitado para almacenar cookies de manera que las más nuevas hacen desaparecer a las más viejas cuando dicho espacio está totalmente ocupado.

Cookies con fecha de caducidad: a veces los sitios web establecen cookies con una fecha de caducidad concreta. Por ejemplo, se puede utilizar una cookie para recordar a un cliente que existe una oferta. Esta cookie tendrá necesariamente la fecha de caducidad de la propia oferta, más allá de la cual no tienen ningún sentido que siga existiendo.

Cookies para borrar: borrar una cookie existente es como volver a escribirla con una fecha de caducidad anterior a la fecha actual.

Dominios y Subdominios

Toda cookie está vinculada con un dominio o subdominio. Además existe una restricción impuesta por el propio estándar de manera que no es posible acceder a cookies de otro dominio o subdominio que no sea el de la propia URL donde se encuentra la página web. Esto significa que una página web en la dirección www.idg.es, por ejemplo, sólo podrá acceder a las cookies vinculadas con los dominios www.idg.es y .idg.es.

Como ya se verá más adelante, las distintas tecnologías, ya sean de cliente o de servidor, disponen de los mecanismos necesarios para implementar dicho vínculo.

Una cookie que es del dominio .idg.es será accesible desde cualquier URL que sea del tipo ordenadores .idg.es, internet.idg.es, o incluso, www.ordenadores.idg.es o www.internet.idg.es. La restricción se extiende desde el caso general hasta los casos particulares.

Ahora bien, una cookie del dominio www.internet.idg.es no será accesible desde una página web que se encuentre bajo la dirección URL www.ordenadores.idg.es. Si se desea que ambos sitios compartan cookies no queda más remedio que éstas sean del dominio .idg.es, que es compartido por ambos.

Cookies con Java

Java es una de las tecnologías que más se utilizan en actualidad a la hora de desarrollar aplicaciones Web. Cada vez es mayor el número de portales y sitios web que se han construido utilizando páginas JSP o servlets. Evidentemente el API que se encuentra por detrás ofrece los recursos necesarios para poder leer y/o escribir cookies.

En el paquete estándar javax.servlet.http se encuentra la clase Cookie recogida de la siguiente forma:

public class Cookie implements Cloneable

El constructor de la clase se define como:

public Cookie(String name, String value);

El primer parámetro se corresponde con el nombre de la cookie y el segundo con el valor de la misma. El resto de los métodos de la clase cookie se divide en dos grupos: los método getXXX sirven para obtener información de la cookie; los métodos setXXX sirven para establecer las características de la cookie. A continuación de muestra un resumen de ambos grupos:

Métodos getXXX
public String getComment();
public String getDomain();
public int getMaxAge();
public String getName();
public String getPath();
public boolean getSecure();
public String getValue();
public void setComment(String purpose);

SUBIR