Curso de Desarrollo Web

Struts + Spring + Hibernate

MVC + Servicios

Spring Struts Action Hibernate Struts ViewDAO

Modelo General

Acceso a Datos: Hibernate

Servicios: DAO’s

Control: Struts Action’s

Vista: Struts + JSPFa

ctory

: Sp

ring

Configuración

JLPP

Configuración del Proyecto


Configuración de Proyecto

Desde CVSPregunte a su administrador de CVS

Desde CeroSiguiente diapositiva



Creación del Proyecto (Librerias) Crear un nuevo proyecto en Eclipse Agregar las librerías requeridas al

directorio WebContent/WEB-INF/lib.HibernateStrutsSpringTLD’s comunes (consultar administrador)



Creación del Proyecto (Librerias) Recargar el proyecto Deberían aparecer los WebLibraries en el

mismo.



Creación del Proyecto (Source)

Agregar el sourcefolder WEB-INF/classes al proyecto.Ver procedimiento.



Creación del Proyecto (Spring)

En la cartepa WEB-INF/classes crear un archivo applicationContext.xml



applicationContext.xml<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">

</beans>




Abrir el descriptor de aplicación del Proyecto y agregar el código de Spring.

<listener> <listener-class> edu.conalep.moroleon.common.spring.Decorator </listener-class></listener>

<context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:applicationContext.xml</param-value></context-param>




La clase Decorator puede ser reemplazada por la clase original de Spring, pero Decorator lanza un mensaje de error en caso de que este ocurra.



Creación del Proyecto (Hibernate)

Crear el paquete mapping donde se colocaran los mapeos de Hibernate.

Crear el archivo hibernate.properties en la carpeta src.

Crear los archivos de mapeo de Hibernate necesarios.



hibernate.propeties

hibernate.connection.driver_class=driver_jdbchibernate.connection.url=url_odbchibernate.connection.username=usuario_base_de_datoshibernate.connection.password=contraseñahibernate.dialect=dialecto_hibernatehibernate.show_sql=true



Creación del Proyecto (Hibernate + Spring) En la carpeta WEB-INF/classes crear el

archivo hibernate.xml. En el archivo applicationContext.xml

incluir el archivo hibernate.xml

<import resource=“hibernate.xml” />



hibernate.xml (parte 1)

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <value>classpath:hibernate.properties</value> </property></bean> <bean id="ds" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${hibernate.connection.driver_class}" /> <property name="url" value="${hibernate.connection.url}" /> <property name="username" value="${hibernate.connection.username}" /> <property name="password" value="${hibernate.connection.password}" /></bean>



hibernate.xml (parte 2)

<bean id="sf" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource" ref="ds" /> <property name="mappingResources"> <list> <value>xml’s de mapeo</value> </list> </property> <property name="hibernateProperties"> <value> hibernate.dialect=dialecto_hibernate hibernate.show_sql=true </value> </property></bean>



Creación del proyecto (Struts)

En la carpeta WEB-INF/classes crear un archivo struts.xml

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN" "http://struts.apache.org/dtds/struts-2.0.dtd"><struts> <constant name="struts.objectFactory" value="spring" /></struts>



Creación del proyecto (Struts)

En el descriptor de aplicación agregar el filter de Struts.

<filter> <filter-name>struts2</filter-name> <filter-class> org.apache.struts2.dispatcher.FilterDispatcher </filter-class></filter>

<filter-mapping> <filter-name>struts2</filter-name> <url-pattern>/*</url-pattern></filter-mapping>



Prueba Inicial

Arrancar el contexto para revisar si este esta funcionando de manera adecuada.

La configuración del proyecto esta entonces completa.


Los Mapeos Hibernate

JLPP



Consideraciones

Los mapeos deberian estar en su propio paquete llamado mapping.

El modelo general de mapeo:<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mappingPUBLIC "-//Hibernate/Hibernate Mapping DTD//EN""http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping package="edu.conalep.moroleon.opd.mapping"> </hibernate-mapping>



Clases

Los mapeos hibernate se crean a partir de clases.

Estas clases se definen como elementos class dentro del mapeo.

Toda clase debe tener un id. Las clases pueden tener varias

propiedades.



Mapeo Básico de Clase

<class name=“Clase” table=“tabla”> <id name=“id_de_clase” column=“id_de_tabla” type=“int|long”> <generator class=“increment” /> </id>

 <property name=“propiedad” column=“columna” type=“int” />  <property name=“propiedad2” column=“columna2” type=“string” length=“12” />  <property name=“propiedad3” column=“columna3” type=“int” unique=“true” /></class>



Mapeo de relaciones Uno a Varios<class name=“Padre” table=“padre”> <id name=“id” type=“long” column=“id_padre”> <generator class=“increment” /> </id>

<set name=“hijos”> <key column=“id_padre” /> <one-to-many class=“Hijo” /> </set></class>

<class name=“Hijo” table=“hijo”> <id name=“id” type=“long” column=“id_padre”> <generator class=“increment” /> </id> <many-to-one name=“padre” column=“id_padre” class=“Padre” /></class>



Mapeo de relaciones Uno a Uno<class name=“Padre” table=“padre”> <id name=“id” type=“long” column=“id_padre”> <generator class=“increment” /> </id>

<one-to-one name=“hijo” class=“Hijo” /></class>

<class name=“Hijo” table=“hijo”> <id name=“id” type=“long” column=“id_padre”> <generator class=“foreign”> <param name=“property”>padre</param> </generator> </id> <one-to-one name=“padre” class=“Padre” /></class>



Mapeo de relaciones Varios a Varios<class name=“Libro” table=“libro”> <id name=“id” type=“long” column=“id_libro”> <generator class=“increment” /> </id>

<set name=“autores” table=“libro_autor”> <key column=“id_libro” /> <many-to-many class=“Autor” /> </set></class>

<class name=“Autor” table=“autor”> <id name=“id” type=“long” column=“id_autor”> <generator class=“increment” /> </id> <set name=“libros” table=“libro_autor” inverse=“true”> <key column=“id_autor” /> <many-to-many class=“Libro” /> </set></class>



Mapeo de Herencia<class name=“Padre” table=“padre”> <id name=“id” type=“long” column=“id_padre”> <generator class=“increment” /> </id>

<joined-subclass name=“Hijo1” table=“hijo1”> <key column=“id_hijo1” /> <property … /> </joined-subclass>

<joined-subclass name=“Hijo2” table=“hijo2”> <key column=“id_hijo2” /> </joined-subclass></class>



Generación de Base de Datos y POJO’s

Si el proyecto incluye un archivo build.xml o build-hibernate.xml puede utilizarse el target export-ddl para crear la base de datos y gen-java para crear los POJO’S.

Por seguridad los POJO’s quedan en otra carpeta con el nombre hibernate.


Servicios

JLPP

Servicios: DAO’s


Consideraciones

Los servicios se localizan en un paquete service o bien en paquetes services de cada paquete de modulo.

Son clases JAVA que implementan las funcionalidades necesarias para abstraer Hibernate de las capas superiores.

Servicios: DAO’s


Modelo Básico de Servicio

Un servicio es una interfaz que debería implementar métodos para:Agregar datosEditar datosEliminar datosRecuperar datosRecuperar un dato unico

Servicios: DAO’s


Interfaz Básica de Servicio

Servicios: DAO’s

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); //Seter y Getter del SessionFactory de Hibernate public void setSessionFactory(SessionFactry sf); public SessionFactory getSessionFactory();}


Implementación

Los DAO’s pueden implementarse en base a código puro de Hibernate o bien utilizando HibernateTemplate, una clase de Spring.

Cuando una clase requiera determinadas funciones extra estas pueden agregarse en un Dao heredado.

Servicios: DAO’s


Herencia Sugerida

Servicios: DAO’s

BasicDao

GenericDao SpecialDao

SpecificDao1 SpecificDao2

Métodos extra y operaciones

especializadas, como cargarLibrosDeAutor o un eliminar diferente

podrían estar aqui

Operaciones Triviales colocadas aquí

Struts

JLPP

Control: Struts Action’sVista: Struts + JSP


Consideraciones

Los actions deberían estar en el paquete action o en el paquete action de cada paquete de modulo.

Los JSP’s que usan struts deberían estar organizados en paquetes que representen los modulos y los casos de uso.



Struts + DAO’s

Los Action de Struts y las JSP van a seguir funcionando igual, salvo que las operaciones con objetos Hibernate se van a realizar por medio de DAO’s.

Cada action debe agregar un geter y seter para un DAO interno que realice las operaciones.



Cambios al struts.xml

El atributo class de cada Action cargado y configurado por Spring deberá de corresponder con el nombre del bean que lo crea.


<action name=“nombre” class=“el_bean”></action>

<bean id=“el_bean” />

Spring

JLPP

Factory: Spring


Consideraciones

Traten de poner nombres significativos a los beans.

Si son muchos beans utilizar archivos separados y la etiqueta import.

Factory: Spring


Descripción General

Spring se encarga de instanciar objetos y configurarlos en tiempo de ejecución.

Crea objetos como el SessionFactory (o Hfactory o Singleton) y los hace accesibles de una manera sencilla.

Factory: Spring


Ejemplo de Spring

Factory: Spring

<bean name=“un_dao” class=“clase_de_dao”>  <property name=“sessionFactory” ref=“sf” /></bean>

<!– Cada vez que se requiera el action crea una nueva instancia --><bean name=“action_dao” class=“clase_action” scope=“prototype”>  <property name=“dao” ref=“un_dao” /></bean>


Implicaciones

Solamente declarando geters y seters en las clases y registrando los beans con spring podemos usarlos con la certeza de que estarán completamente configurados.

Factory: Spring

Technology

Curso de Desarrollo Web