Desarrollo Web

JSF + Spring + Hibernate

Jorge Luis Palacio Pineda
Introducción

Este material se usa como complemento
al material previamente mostrado con
Struts.

El motivo de la presente es actualizar la
información para cubrir las versiones
actuales de Spring y JSF.

Cubre Spring 2 y JSF 1.2
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Objetivo

Crear un entorno de trabajo que incluya
Spring, Struts e Hibernate.

Permitir integrar estas tres tecnologías en
una aplicación Web.

Dar la opción a extender la aplicación.
Arquitectura

DAO’s

JSF Spring Hibernate DB

Services
Distribución Física

Servidor
Internet Web
DB
(MySQL)
Software Utilizando

Eclipse 3.3.1

Web Tools Platform 2.0.1

Spring 2.0

JSF RI 1.2

Hibernate 3.2

Tomcat 6.0

Junit 3.8
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Creación de Proyecto

Tomamos un proyecto Web Dinámico
regular con el siguiente Facet:
 JSF 1.2

Dynamic Web Module 2.5

Java 5.0

JavaServer Faces 1.2

Registros en web.xml (JSF)
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>
javax.faces.webapp.FacesServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
Explicación

El servlet registrado permite atender las
peticiones.

El filtro nos permite tomar todas las
peticiones al subdirectorio virtual /faces/

Las peticiones se reenvían al JSF mismo.
Registros en web.xml (Spring)
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:applicationContext.xml</param-value>
</context-param>

<listener>
<display-name>Spring Decorator</display-name>
<listener-class>
com.jlpp.sample.utils.SpringDecorator
</listener-class>
</listener>

<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
Explicación

El componente context-param nos indica
donde buscar la configuración Spring.

El primer listener nos dice que carguemos
Spring en el entorno.

El segundo listener se utiliza para permitir
acceder al App de Spring desde el
contexto del servidor.
Clase SpringDecorator

Esta clase envia los errores de arranque
de Spring a consola.

Se usa para depuración.

Guarda una referencia al contexto Spring
para referenciarlo desde otras partes del
programa.
//Implementación del decorador
//Los métodos omitidos deben sobreescribirse con llamadas a ccl
public class SpringDecorator extends ContextLoaderListener {
//Variable encapsulada del entorno
private ContextLoaderListener cll;
//App Web de Spring
private static WebApplicationContext wac;

public SpringDecorator() {
cll = new ContextLoaderListener();
}

//Crea el objeto interno y guarda el WebApp

public void contextInitialized(ServletContextEvent arg0) {
try {
cll.contextInitialized(arg0);
wac = WebApplicationContextUtils.getWebApplicationContext
(arg0.getServletContext());
} catch(Exception e) {
e.printStackTrace();
}
}

//Ejemplo de llamada interna

public ContextLoader getContextLoader() {
return cll.getContextLoader();
}

public static WebApplicationContext getSpringContext() {

return wac;
}
}
Comentarios

La referencia estática permite leer desde
otros objetos el WAC.

El WAC es indispensable para replicar las
funcionalidades de Spring a la aplicación
original.

El mismo principio de Decorator se aplica
a todos los componentes de la solución.
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
DAO

Son objetos que abstraen las
funcionalidades de acceso a datos.

Permiten abstraer el acceso a datos.

Capa de
App DAO
Acceso a Datos
Implementación Básica
public interface BasicDao {
public boolean agregar(Object o);
public boolean editar(Object o);
public boolean borrar(Object o);
//Buscar duplicados antes de agregar
public boolean hayRepetido(Object o);
//Buscar dependientes antes de borrar
public boolean hayDependiente(Object o);
public List cargar();
public List cargarUno(Serializable id);
public List cargarCondicion(String prop, Object val);
}
Ejercicio

Generalmente la implementación del
BasicDao:
 Toma como constructor el nombre base de la
clase que maneja.
 Implementa las operaciones ABC+M de
manera general.

Como ejercicio desarrolle la clase
BasicDAO
Extendiendo los DAO’s

Podemos extender los DAO’s en caso de
ser necesario.
Operaciones Triviales BasicDao
colocadas aquí

GenericDao SpecialDao

Métodos extra y
operaciones
especializadas, como
SpecificDao1 SpecificDao2
cargarLibrosDeAutor o
un eliminar diferente
podrían estar aqui
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
VariableResolver

Componente de JSF utilizado desde la
versión 1.1

Se encarga de crear las variables
necesarias por el EL.

Actualmente se encapsula dentro de un
ELResolver.
Descripción del VR

Sobreescribes el método de resolución:

Primeramente creamos una clase
SpringVariableResolver que extienda
VariableResolverImpl.

Y sobrescribiremos el método
resolveVariable(FacesContext fc, String
var)…
Sobreescritura del Método

Recuperaremos el contexto WAC
WebApplicationContext ac =
SpringDecorator.getSpringContext();

Si Spring no sabe manejar el bean,
delegamos al VR original
If(!wac.containsBean(var))
return super.resolveVariable(fc, var);
Sobreescritura del Método

Posteriormente creamos una sesión
fc.getExternalContext().getSession(true);

Buscamos el Scope apropiado
Map<String, Object> scope = null;
if(ac.isPrototype(var))
scope = fc.getExternalContext().getRequestMap();
else {
if(ac.isSingleton(var))
scope = fc.getExternalContext().getApplicationMap();
else
scope = fc.getExternalContext().getSessionMap();
}
Sobreescritura del Método

Si el scope no es valido terminamos
if(scope == null) return null;

Si el scope ya tiene la variable la usamos
if(scope.containsKey(var))
return scope.get(var);

En caso contrario lo creamos y regresamos
Object o = wac.getBean(var);
scope.put(var, o);
Return o;
Implicaciones de la Implementación

El scope se averigua a partir de la forma

en que se instancia el bean.
 Todo objeto que sea un singleton será de
contexto Aplicación.
 Todo objeto prototype será de contexto
Request.
 El resto de los objetos será de scope session.
Configuración del VR

En el archivo faces-config.xml
<!– Configuración del VariableResolver -->
<application>
<variable-resolver>
com.jlpp.sample.utils.SpringVariableResolver
</variable-resolver>
</application>
Alcance

Sobreescribir el VariableResolver nos
permite sobrescribir todas las expresiones
de EL.

#{objeto.variable} = Resuelve con el
nuevo VariableResolver.

No se pueden crear ni validators,
converters.
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Application y ApplicationFactory?

Existe un objeto ApplicationFactory que se
encarga de crear los objetos Application.

El objeto Application contiene el VR y
otros componentes necesarios del
entorno.

Sobrescribiéndoles podemos cambiar el
comportamiento normal del Application.
Redefinir el Application

Extender la clase Application en
SpringApplication.

Declarar una variable interna de tipo
Application.

Aplicar un Decorator para todos los
métodos.

Es importante declarar un constructor que
tome un objeto Application como
parámetro.
Redefinir los métodos apropiados

Implementar los métodos propios de
ApplicationImpl.

Redefinir los métodos adecuados
 createValidator(String);
 createComponent(String);
 createConverter(String);
Sobrescribiendo createXXX

El código es simple, tratas de crear el objeto original. Si no
es posible creas uno desde Spring.
try {
return original.createXXX(nombre);
} catch(Exception e) {
WebApplicationContext wac =
SpringDecorator.getApplicationContext();
return (ClaseRetorno) wac.getBean(nombre);
}
Sobrescribir createComponent

Este método tiene una sobrecarga que
hay que implementar:
public UIComponent createComponent(ValueBinding bind,
FacesContext context, String nombre)
throws FacesException {
try {
UIComponent uic = (UIComponent) bind.getValue(context);
if(uic != null)
return uic;
uic = interno.createComponent(nombre);
return uic;
} catch(FacesException fe) {
return createComponent(nombre);
}
}
Sobrescribir createConverter

Ejercicio
 Existe una sobrecarga del método que toma
como parámetro un objeto de tipo Class.
 Por medio del WebApplicationContext
podemos recuperar todos los beans de cierta
clase.

Implementar el método createConverter
Métodos de Utilería

Creamos un método para crear App’s
adecuado.

Simplemente intenta regresar el Application,
pero si no es del tipo adecuado crea un nuevo
decorador y lo regresa.

public static Application crearApp(Application app) {

if(app instanceof SpringApplication)
return app;
return new SpringApplication(app);
}
Sobrescribir el ApplicationFactory

Cuando redefinimos un ApplicationFactory

el entorno JSF nos permite analizar la
instancia original.

Usando este principio podemos construir
un Decorator del ApplicationFactory
normal.

La clase SpringApplicationFactory debe
extender de ApplicationFactoryImpl
Descripción

Todos los métodos son de un Decorator,
excepto getApplication();

Se muestran los constructores
public Application getApplication() {
return SpringApplication.crearApp
(original.getApplication());
}

public SpringApplicationFactory() { ; }
public SpringApplicationFactory(ApplicationFactory af) {
super();
setApplicationFactory(af);
}
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Pegándole Hibernate

El hecho de complementar Hibernate es
trivial.

La configuración de los beans
determinados se hace mediante Spring.

El material puede encontrarse en
anteriores presentaciones.
Contenidos

Descripción

Configuración

Descripción del DAO

VariableResolver

Application y ApplicationFactory

Complementando con Hibernate

Después de…
Después de

Intentenlo, y si tienes dudas o sugerencias
pues contactenme:

Jorge Luis Palacio Pineda

juliocombativo@gmail.com