Curso de Desarrollo Web

Struts + Spring + Hibernate MVC + Servicios

Modelo General Acceso a Datos: Hibernate Servicios: DAO’s Control: Struts Action’s Vista: Struts + JSP Factory: Spring

Configuración JLPP Configuración del Proyecto

Configuración de Proyecto

Desde CVS

Pregunte a su administrador de CVS

Desde Cero

Siguiente diapositiva

Configuración del Proyecto

Creación del Proyecto (Librerias)

Crear un nuevo proyecto en Eclipse

Agregar las librerías requeridas al directorio WebContent/WEB-INF/lib.

Hibernate

Struts

Spring

TLD’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> Configuración del Proyecto

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> Configuración del Proyecto

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_jdbc hibernate.connection.url=url_odbc hibernate.connection.username=usuario_base_de_datos hibernate.connection.password=contraseña hibernate.dialect=dialecto_hibernate hibernate.show_sql=true Configuración del Proyecto

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” /> Configuración del Proyecto

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> Configuración del Proyecto

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> Configuración del Proyecto

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> Configuración del Proyecto

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> Configuración del Proyecto

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 Acceso a Datos: Hibernate

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-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="edu.conalep.moroleon.opd.mapping"> </hibernate-mapping> Acceso a Datos: Hibernate

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.

Acceso a Datos: Hibernate

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> Acceso a Datos: Hibernate

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> Acceso a Datos: Hibernate

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> Acceso a Datos: Hibernate

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> Acceso a Datos: Hibernate

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> Acceso a Datos: Hibernate

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.

Acceso a Datos: 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 datos

Editar datos

Eliminar datos

Recuperar datos

Recuperar 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’s Vista: 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.

Control: Struts Action’s Vista: Struts + JSP

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.

Control: Struts Action’s Vista: Struts + JSP

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.

Control: Struts Action’s Vista: Struts + JSP <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