Propagación del contexto de persistencia

La propagación de contexto de persistencia se produce sólo para los EntityManager gestionados por el contenedor. En un EntityManager gestionado por el contenedor en el contexto de una transacción (caso común en un entorno Java EE), la propagación de transacciones JTA es la misma que la del contexto de persistencia. En otras palabras, los EntityManagers gestionados con ámbito de transacción obtenidos dentro de una misma transacción JTA comparten el mismo contexto de persistencia. En términos de Hibernate, esto significa que todos los gestores comparten la misma sesión.

Importante: el contexto de persistencia nunca es compartido por diferentes transacciones JTA o entre EntityManagers que no vienen del mismo EntityManagerFactory. Hay algunas

excepciones dignas de mención para la propagación del contexto al utilizar contextos extendidos de persistencia:

• Si, un SLSB, MDB o SFSB con un contexto de persistencia en ámbito de transacción invoca un método de un SFSB con contexto de persistencia extendido en la misma transacción JTA, se lanza una IllegalStateException.

• Si un SFSB con un contexto de persistencia extendido invoca a un SLSB o SFSB con contexto de persistencia de ámbito de transacción dentro de la misma transacción JTA, el contexto persistencia se propaga.

• Si un SFSB con un contexto de persistencia extendido llama a un SFSB o SLSB dentro de un contexto distinto de transacción JTA, el contexto de persistencia no se propaga.

• Si un SFSB con un contexto de persistencia extendido instancia otro SFSB con un contexto de persistencia extendido, el contexto de persistencia extendido es heredado por el segundo SFSB. Si el segundo SFSB sesión se llama con un contexto de transacción diferente que el primero, un IllegalStateException es lanzada.

• Si un SSB con contexto de persistencia extendido llama a un SFSB con un contexto persistencia extendido diferente en la misma transacción, una IllegalStateException es lanzada.

Introducción a JSP (Java Server Pages)

Las JavaServer Pages (JSP) nos permiten separar la parte dinámica de nuestras páginas Web del HTML estático. Básicamente, conseguimos incrustar código java dentro de un documento HTML cuya extensión ha de ser *.jsp.
Hay tres tipos de construcciones JSP que embeberemos en una página: elementos de script, directivas y acciones. Los elementos de script nos permiten especificar código Java que se convertirá en parte del servlet resultante, las directivas nos permiten controlar la estructura general del servlet, y las acciones nos permiten especificar componentes que deberían ser usuados, y de otro modo controlar el comportamiento del motor JSP. En el siguiente enlace podemos ver una tabla detallada de estas construcciones.
En el modelo MVC, JSP conformaría la vista de nuestra aplicación. En el siguiente tutorial se muestra más detalladamente la especificación JSP:
- Tutorial Servlets y JSP

Evitar recorrer listas con bucles implementando el método equals()

Cuando tenemos una lista de objetos y necesitamos comprobar que un elemento existe en ella podemos resolverlo creando un bucle(for,while,..) junto con una sentencia if que compruebe en cada iteración si el objeto existe. Una opción a esto consiste en lo siguiente:

• Sobreescribir el método equals() de la clase de dicho objeto y establecer qué atributos se tienen en cuenta a la hora de comparar.
• Instanciar un objeto de dicha clase con los mismos valores que el que buscamos
• Usar el método contains(Object o) de la lista con el objeto que hemos creado para comprobar si existe uno igual

En este enlace se muestra el código de dos clases: Agenda y Persona. La clase Agenda posee un atributo de tipo List que guarda la lista de personas y posee dos métodos para comprobar si existe un elemento en la lista. El primero, existeModo1(), utiliza un bucle for para hallar el elemento y el segundo, existeModo2(), utiliza el método contains().

Manejo de fechas

La API de java nos provee de dos clases para manejar fechas: Date y Calendar, ambas en el paquete java.util. Calendar ofrece más opciones y Date está en desuso.

Crear un objeto Calendar:

Calendar cal=Calendar.getInstance();

Esto nos crea un objeto Calendar con los datos del sistema. Para obtener los ditintos campos utilizamos el método get(int field) que nos devuelve un entero. La clase Calendar posee atributos estáticos que representan los distintos campos de una fecha:

cal.get(Calendar.DATE):devuelve el día
cal.get(Calendar.MONTH):devuelve el mes
cal.get(Calendar.YEAR):devuelve el año

Modificar un objeto Calendar:

Para ello recurrimos al método set(int field). Al igual que con get(int fiel) le pasamos como parámetro el campo que queremos modificar. Si lo que queremos es sumar una cantidad a uno de los campos podemos recurrir al método roll(int field,int cantidad), por ejemplo:

cal.roll(Calendar.DATE, -5): resta 5 días.
cal.roll(Calendar.MONTH, 5): suma 5 meses.

Formatear fechas:

Para formatear fechas podemos recurrir a la clase SimpleDateFormat del paquete java.text. El siguiente ejemplo nos muestra cómo usar dicha clase para darle formato a una fecha:

SimpleDateFormat formater=new SimpleDateFormat();
formater.applyPattern("dd/MM/yy");
String fechaFormateada=formater.format(cal.getTime());

¡¡Ojo!!:

La clase Calendar le asigna el valor 0 al mes de enero y no 1, esto hay que tenerlo en cuenta a la hora de manejar fechas

Filtros

¿QUÉ SON LOS FILTROS?

Los filtros son clases que nos permiten realizar ciertas operaciones sobre una petición (HttpServletRequest) antes de ser entregada al servlet destino y de la misma manera nos permite realizar ciertas operaciones sobre la respuesta (HttpServletResponse) de un servlet antes de ser entregada al cliente. La siguiente figura nos muestra dicho proceso:



Hay que tener en cuenta que:

• Podemos tener más de un filtro para procesar la petición dispuestos en cadena
• Un mismo filtro puede atender las peticiones de más de un servlet
• Un filtro puede procesar únicamente la petición o únicamente la respuesta

¿QUÉ ACCIONES PODEMOS REALIZAR EN UN FILTRO?

Los filtros nos pueden permitir verificar los datos que el usuario envía a la aplicación, darle un formato determinado a esos datos, desviar la petición a otro servlet para que la procese antes de enviar la información al servlet destino, darle formato a la respuesta que envía el servlet, modificar convenientemente la respuesta de un servlet (por ejemplo una imagen, un fichero pdf, etc), etc. Hay dos importantes ventajas que nos ofrecen los filtros:

• Descarga al servlet de realizar ciertas tareas relacionadas con la petición y la respuesta
• Si está adecuadamente diseñado, nos permite reutilizar ese filtro en distintas aplicaciones

¿CÓMO SE CREA UN FILTRO?

• Creamos una clase que implemente la interfaz javax.servlet.Filter
• Implementamos sus métodos
• Damos de alta el filtro en el fichero web.xml
  

Uso de Listeners

¿QUÉ ES UN LISTENER?

Un Listener (o escuchador) es una clase que implementa la interfaz Listener y que nos permite realizar ciertas acciones ante un evento determinado. Los eventos que atiende un escuchador son:

• Cuando se inicia la aplicación (se crea el objetos ServletContext) y cuando se termina
  
• Cuando se inicia una sesión (se crea un objeto HttpSession) y cuando se cierra
  
• Cuando se realiza una petición (se crea un objeto HttpServletRequest) y cuando se destruye
  

La siguiente figura muestra el evento que produce cada objeto y el escuchador que atiende a dicho evento:



¿QUÉ ACCIONES PODRÍAMOS REALIZAR ANTE ESTOS EVENTOS?

Los escuchadores nos permiten inicializar las varibles de aplicación comunes a todos los usuarios (ServletContextListener), inicializar variables de sesión para un usuario (HttpSessionListener), hacer comprobaciones sobre los datos que el usuario envía a la aplicación (ServletRequestListener) o cualquier otra acción que necesitemos.

¿CÓMO SE CREA UN LISTENER?

• Creamos una clase que implemente la interfaz Listener
• Implementamos sus métodos
• Lo damos de alta en el fichero web.xml
  

Esctructura de directorios de una aplicación web

Una aplicación web desarrollada en java tiene una estructura similar a la siguiente:

aplicacion/
.../archivo.html
.../archivo.jsp
.../img/archivo.png
.../css/archivo.css
.../html/otro.html
.../jsps/otro.jsp
-------------------------------------------------------
Las carpetas y documentos anteriores conforman el contenido accesible desde el navegador
-------------------------------------------------------
.../WEB-INF/web.xml(Archivo de despliegue de la aplicaión)
.../WEB-INF/classes/es.cea...(Aquí van las clases de nuestra aplicación)
.../WEB-INF/lib/libreria.jar(Aquí van las librería necesarias para la aplicación)

Colecciones de objetos

Java nos provee de distintos tipos de estructuras para almacenar colecciones de objetas y poder operar sobre dichas colecciones. Entre los más importantes nos encontramos con las listas (List), los mapas (Map) y los conjuntos (Set). Los conjuntos se diferencian de los otros dos en que no pueden tener elementos duplicados (aquí entra en juego la sobreescritura del método equals() para determinar la duplicidad de los objetos).
En los servlets podemos usar el método println(variable_estructura) para imprimir todos los objetos que contiene la estructura (aquí interviene la sobreescritura del método toString() de los objetos almacenados). La forma en que se imprimen es entre corchetes y separados por comas los distintos objetos:

[objeto1,objeto2,...,objetoN]

Introducción a las sesiones en los Servlets

Para poder obtener un objeto HttpSession recurrimos al método getSession() del objeto HttpServletRequest. De este modo podemos crear variables de sesión mediante el método setAttribute(clave,valor) del objeto HttpSession y acceder a esas variables con el método getAttribute(clave). El método getAttribute(clave) devuelve un objeto de tipo Object así que es necesario hacer casting al tipo adecuado cuando recuperamos la variable. Ejemplo:

HttpServletRequest req;
req.getSession().setAttribute("nombre","raul"); //Declaramos la variable de sesión
String nombre=(String)req.getSession().getAttribute("nombre"); //Recuperamos la variable

Atajos de teclado en Eclipse I

Eclipse nos provee de una serie de atajos de teclado que facilita nuestro trabajo

• Ctrl+1 sobre un elemento del código (variable, método, atributo, clase,...) nos ofrece sugerencias sobre él.
• Escribir syso y después teclear Ctrl+Espacio nos genera la instrucción System.out.println
• Si pulsamos Ctrl+click sobre cualquier elemento del código nos permite navegar por el código como si de una página web se tratase. Por ejemplo, si hacemos esta operación sobre una variable de tipo Persona declarada en una clase Agenda nos llevaría al código de la clase Persona. Con Alt+flecha izquierda volvemos al código donde ejecutamos Ctrl+click.
• Si estamos tecleando código y pulsamos Ctrl+Espacio nos aparece el diálogo de sugerencia de código para poder autocompletar.
  

Sobreescritura de métotos desde Eclipse

Eclipse nos provee de las opciones necesarias para sobreescribir o implementar ciertos métodos. Siguiendo con la línea de la anterior entrada, podemos sobreescribir los métodos toString() y equals(Object) de la siguiente manera:

• Elegimos la opción Source->Override/Implements Methods...
• En el diálogo que nos aparece elegimos los métodos que queremos sobreescribir
• Nos aparece el código de los métodos elegidos y sólo queda implementar el código

En el caso del método equals(Object) tenemos una opción aún mejor:

• Elegimos la opción Source->Generate hashCode() and equals()...
• En el diálogo elegimos los atributos que servirán de criterio para la igualdad
• Se genera en nuestra clase los métodos correspondientes y su código.

Otras dos opciones muy útiles del menú Source son:

• Generate Getters and Setters...
• Generate Constructor using Fields...

La primera opción nos genera el código de los métodos getAtributo()-setAtributo() para cada uno de los atributos que le indiquemos en el cuadro de diálogo que se nos muestra. En el segundo caso se nos genera el código de un constructor que inicializa los atributos que le indiquemos en el cuadro de diálogo que nos aparece.

Sobreescritura de métotos heredados de Object

Todas las clases en Java (incluidas las que creamos nosotros) heredan implícitamente de la clase Object. De esta clase heredamos los siguientes métodos:

• toString()
• equals(Object)
• hashCode()
• finalize()
• clone()

De los métodos antes mencionados es interasante la sobreescritura de dos de ellos. Al igual que imprimimos un String o cualquier variable primitiva en pantalla, podemos imprimir un objeto. Cuando imprimimos un objeto lo que ocurre es que se llama al método toString() del objeto y se imprime la cadena que este método nos devuelve. Según como esté implementado, la salida será una u otra. Por defecto este método imprime en pantalla la clase a la que pertenece el objeto y la dirección de memoria del mismo en el siguiente formato:

paquete.Clase@direccion

En el caso de las clases de envoltorio este método está sobreescrito para que muestre una cadena con el valor primitivo que encapsula. En nuestras clases podemos sobreescribirlo para que muestre el valor de los atributos que nos interese mostrar en vez de recurrir a métodos getVariable() y tener que transformar la salida en un String. En este ejemplo lo vemos:

public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
System.out.println(p1);
}
}

La salida de la anterior clase nos daría como resultado:

NOMBRE: Pepe
EDAD: 30

En el caso de las colecciones de objetos, esto nos permitiría recorrer la colección e imprimir el valor de las variables con sólo llamar a nuestro método toString() sobreescrito.

El otro método que nos puede interesar sobreescribir es el método equals(Object). Este método compara dos objetos y nos devulve true o false en caso de que sean iguales o no. Según como esté implemetado el método en cada clase, los criterios de igualdad variarán. Nos puede interesar en las clases que creamos determinar los criterios a tener en cuenta para establecer esa igualdad sobreescribiendo el método equals(Object). Siguiendo con el ejemplo anterior:

public class Persona{
private String nombre;
private Integer edad;
public Persona(String n,Integer e){
nombre=n;
edad=e;
}
@Override
public String toString(){
return "NOMBRE: "+nombre+"\nEDAD: "+edad;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
if (nombre == null) {
if (other.nombre != null)
return false;
} else if (!nombre.equals(other.nombre))
return false;
return true;
}
public static void main(String[] args){
Persona p1=new Persona("Pepe",new Integer(30));
Persona p2=new Persona("Pepe",new Integer(25));
boolean igual=p1.equals(p2);
System.out.println(p1);
System.out.println(p2);
System.out.println("\nEs igual: "+igual);
}
}

El ejemplo anterior nos devolverá que la variable igual es true ya que el criterio de igualdad que hemos definido es el atributo nombre:

NOMBRE: Pepe
EDAD: 30
NOMBRE: Pepe
EDAD: 25

Es igual: true