Java

JAVA - APLICACIÓN WEB, HIBERNATE CON SPRING
PARTE I - CREACIÓN DE LA BASE DE DATOS
7:52 P.M. HENRY JOE WONG URQUIZA 2 COMENTARIOS
"Si usa algún código del siguiente tutorial, den el icono de ME GUSTA del Facebook que se
encuentra en su mano derecha, para que se vuelva Seguidor del Blog y también
comentenos que tal les pareció el tutorial"
1. ENTORNO
• MySQL 5.1.
• NetBeans IDE 6.9.1
• Apache Tomcat
• JDK 1.6.0 - 21
2. INTRODUCCIÓN
En el siguiente tutorial vamos a desarrollar un carrito de compras o lo que seria un sistema de
ventas usando el lenguaje de programación Java con los framework de Hibernate y Spring y como
base de datos vamos a usar el MySQL 5.1. La base de datos que vamos a crear es una base de
datos con fines didácticos, dado que nos faltaría crear mas tablas, como la tabla cliente, unidad de
medida, etc pero si nos explayamos mucho nos quedaría muy largo el tutorial. Ademas en el
ejemplo no se explica como disminuir un stock, debido a que eso siempre se les pide a los alumnos
universitario que investiguen como hacerlo, pero si quieren una ayudita lo pueden hacer creando
Triggers en la base de datos. La aplicación se desarrollara en un formato web usando el patrón de
Modelo, Vista y Controlador. Espero que el ejemplo se de su utilidad.
2.1. JPA
Java Persistence API, más conocida por sus siglas JPA, es la API de persistencia desarrollada
para la plataforma Java EE e La Java Persistence API, a veces referida como JPA, es un
framework del lenguaje de programación Java que maneja datos relacionales en aplicaciones
usando la Plataforma Java en sus ediciones Standard (Java SE) y Enterprise (Java EE).

2.2 Framework
Un Framework es un conjunto estandarizado de conceptos, prácticas y criterios para enfocar un
tipo de problemática particular, que sirve como referencia para enfrentar y resolver nuevos
problemas de índole similar. En el desarrollo de software, un framework es una estructura
conceptual y tecnológica de soporte definida, normalmente con artefactos o módulos de software
concretos, con base en la cual otro proyecto de software puede ser organizado y desarrollado.
Típicamente, puede incluir soporte de programas, bibliotecas y un lenguaje interpretado entre otros
programas para ayudar a desarrollar y unir los diferentes componentes de un proyecto.
2.3. Hibernate
Hibernate es una herramienta de Mapeo objeto-relacional (ORM) para la plataforma Java (y
disponible también para .Net con el nombre de NHibernate) que facilita el mapeo de atributos entre
una base de datos relacional tradicional y el modelo de objetos de una aplicación, mediante
archivos declarativos o anotaciones en los beans de las entidades que permiten establecer estas
relaciones, esta ultima forma de notaciones es la que usaremos en nuestro proyecto. Hibernate se
usa para manipular las consultas hacia la base de datos y para que un proyecto en Hibernate sea
exitoso se tiene que tener en cuenta una buena Base de Datos, ya que las clases que se generan
con Hibernate están muy ligadas con la base de datos. Y si hacemos un cambio en la base de
datos también deberíamos de hacerlo en nuestro mapeo de las entidades que creamos.
2.4. Spring
Spring es un framework muy usado con Hibernate para poder hacer la programación un poco mas
limpia con Hibernate y es la encargada de manejar las transacciones.
3. DESARROLLO
En esta primera parte del tutorial vamos a crear la base de datos en MySQL 5.1., la base de datos
se llamara BDTutorial
3.1. Diseño de la base de datos
La base de datos tendría las siguientes tablas: Venta, Producto, Marca, Categoria, SubCategoria y
DetalleVenta. Se decidió crear mas tablas por el hecho de hacer un poco mas completo la
programación y poder mostrar tips de programación durante el desarrollo del tutorial.

El script de la base de datos les adjunto en el siguiente LINK
PARTE II - ESTRUCTURA PROYECTO
1. ENTORNO
• MySQL 5.1.
• Apache Tomcat
• JDK 1.6.0 - 21

2. INTRODUCCIÓN
El proyecto se desarrolla en una aplicación web en Netbeans. Y utilizaremos un modelo de
programación en capas. Se recomienda tener conocimientos previos sobre Hibernate y Spring, ya
que aca abordaremos los tips de desarrollo de un proyecto Web.
3. DESARROLLO
3.1. Creación del Proyecto
Crearemos un proyecto en Netbeans y para ellos abrimos el Netbeans y nos vamos al menú File
--> New Proyect y elegimos un proyecto Web

Y al proyecto le pondremos como nombre SistemaVentasHibernateSpring y como servidor
seleccionamos el Apache Tomcat
3.2. Añadiendo Librerías
Al proyecto debemos de agregar las librerías propias del Netbeans como son
• Hibernate JPA
• Spring Framework 3.0.2.
• MySQL JDBC Driver
Y debemos de agregar mas siguientes librerías extras al proyectos que lo pueden descargar de
AQUI. Quedando el proyecto de la siguiente manera.

3.3. Estructura de Paquetes
Debemos de crear paquetes en el proyecto. Para crear un paquete debemos de hacer clic derecho
en el proyecto y luego ir a New --> Package

Los paquetes que creamos serán los siguientes

Ahora explicaremos el porque de esta estructura.
• com.hwongu.entity: En este paquete se encontraran todas las clases mapeadas de la
base de datos. Las clases con todas sus relaciones.
• com.hwongu.dao: Se crearan interfaces donde se definirá los métodos que llamaran a la
base de datos. Y también se creara una interfaz de la cual todas las interfaces de este
paquete tendrán que heredar de ella.
• com.hwongu.dao.impl: Se implementaran todos los métodos que se definieron en el
paquete anterior.
• com.hwongu.service: Se crearan interfaces donde se definirá los métodos que llamaran
a los métodos del paquete com.hwongu.dao. Y también se creara una interfaz de la cual
todas las interfaces de este paquete tendrán que heredar de ella.
• com.hwongu.service.impl: Se implementaran todos los métodos que se definieron en el
paquete anterior.
Se usaran interfaces debido a que Spring se encargará de proporcionarnos una instancia de una
clase que implemente dichas interfaces. La estructura sera el siguiente por cada DAO habrá un
SERVICE.
3.4. Archivo archivo applicationContext.xml
Spring necesita de un archivo de configuración básico en formato XML donde se añadirán todos los
objectos que deberán existir en la aplicación al inicializarse la misma. Ademas especifica otros
parámetros como el tipo de conexión a usar, si se debe mostrar sentencias SQL al momento de
ejecutar el código, entre otras configuraciones. Este archivo lo guardaremos dentro de nuestra
carpeta WEB-INF de nuestro proyecto. Para eso hacemos clic derecho en la carpeta WEB-INF y

seleccionamos la opcion de New->XML Document , si no lo encuentran deben de entrar a la opcion
New->Other y buscar este tipo de archivo (XML Document)
Al archivo le pondremos como nombre applicationContext.xml y ademas tenemos que tener en
cuenta la siguente arquitectura del JPA:

• La clase javax.persistence.EntityManagerFactory nos ayuda a crear objetos de
EntityManager utilizando el patrón de diseño del Factory (fábrica).
• La clase javax.persistence.EntityManager es la interfaz principal de JPA utilizada para la
persistencia de las aplicaciones. Cada EntityManager puede realizar operaciones CRUD
(Create, Read, Update, Delete) sobre un conjunto de objetos persistentes.
• La clase javax.persistence.Entity es una anotación Java que se coloca a nivel de clases
Java serializables y que cada objeto de una de estas clases anotadas representa un
registro de una base de datos.
• Cada instancia de EntityManager tiene una relación de uno a uno con una instancia de
javax.persistence.EntityTransaction, permite operaciones sobre datos persistentes de
manera que agrupados formen una unidad de trabajo transaccional, en el que todo el
grupo sincroniza su estado de persistencia en la base de datos o todos fallan en el intento,
en caso de fallo, la base de datos quedará con su estado original. Maneja el concepto de
todos o ninguno para mantener la integridad de los datos.
Y porque comence explicando la arquitectura JPA? Debido a que en el archivo que hemos creado
debemos de especificar los valores para el EntityManager. Por ejemplo en este archivo
agregaremos los valores de que dataSource se debe usar (conexión a base de datos), si
deseamos mostrar las sentencias SQL (showSQL) que en este caso es TRUE, quien es el
proveedor de base de datos (database) que en este caso es MYSQL.
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
">
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">

<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="database" value="MYSQL" />
<property name="showSql" value="true" />
</bean>
</property>
</bean>
Pero ustedes se preguntaran en donde especifico la ubicación de mi base de datos, el usuario con
el cual me conecto. Pues en este mismo archivos debemos de agregar otras especificaciones
como las siguientes.
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />
<property name="url" value="jdbc:mysql://localhost:3306/sysventas" />
<property name="username" value="root" />
<property name="password" value="mysql" />
</bean>
Solo se debe de cambiar los valores(values) de las propiedades (property)
• "driverClassName" que viene a ser el driver de conexion de base de datos que vamos a
utilizar
• "url" que es la ubicación de nuestra base de datos
• "username" con que usuario nos vamos a conectar a la base de datos
• "password" la clave del usuario de mi base de datos

Y ahora como ustedes saben las actualizaciones hacia la base de datos se debe de hacer bajo una
transacción, anteriormente nosotros creábamos la transacción y teníamos que verificar que si no
había errores y recién hacíamos el commit o el rollback según sea el caso. Pues ahora con
hibernate y spring nos ahorramos todo este trabajo gracias a una anotación que debemos de poner
en este mismo archivo, esta anotación o propiedad se le conoce como el tx:annotation-driven que
va a ser el encargado de procesar todos los beans que tengan la anotación @Transactional y
envolverá en un proxies todas ellas para iniciar una transacción con el transactionManager
(anteriormente configurado) y le van a dar commit/rollback al final del método. Hay que tener en
cuenta que si usamos configuración de transacciones basada en anotaciones, solo se necesitara
tener un única PlatformTransactionManager definido en el applicationContext. Y el codigo seria el
siguiente:
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />
Y una ultima configuración que debemos de hacer, es decirle a Hibernate y Spring en que paquete
se encuentran nuestras clases
<context:component-scan base-package="com.hwongu" />
El archivo al final debería quedar de la siguiente manera
<?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:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
<bean
class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostP
rocessor" />
<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFac
toryBean">
<property name="dataSource" ref="dataSource" />
<property name="jpaVendorAdapter">
<bean
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
<property name="database" value="MYSQL" />
<property name="showSql" value="true" />
</bean>
</property>
</bean>
<bean id="dataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver" />

<property name="url"
value="jdbc:mysql://localhost:3306/sysventas" />
<property name="username" value="root" />
<property name="password" value="mysql" />
</bean>
<bean id="transactionManager"
class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory"
ref="entityManagerFactory" />
</bean>
<tx:annotation-driven transaction-manager="transactionManager" />
<context:component-scan base-package="com.hwongu" />
</beans>
Y si lo desean ver en colores acá les paso la imagen

Y acá acabamos estar parte del tutorial, muy pronto tendremos la tercera parte, no desesperen :)
PARTE III - ENTIDADES
1. ENTORNO
• MySQL 5.1.

• Apache Tomcat
• JDK 1.6.0 - 21
2. INTRODUCCIÓN
Luego de haber configurado nuestro archivo applicationContext.xml en el capitulo dos de este
tutorial, debemos de mapear nuestras clases.
2.1. Mapeo
Mapeo consiste en representar cada tabla de la base de datos como una clase o un conjunto de
clases. Y gracias a ello podemos seguir trabajando con Clases en Java sin preocuparnos de la
base de datos. Y nos permitirá ademas cuando entre dos tablas existe integridad referencial,
tendremos un clase que hace referencia a otra. Es por ese motivo que para que un proyecto en
Hibernate tenga éxito se tiene que tener en cuenta un buen diseño de base de datos desde el inicio
para no cambiar nuestras clases y volver hacer un re-mapeo de nuestras clases. Existe dos formas
de realizar el mapeo
• Usando un archivo de configuracion
• Usando anotaciones
Yo por lo general uso el modelo anotaciones debido a que la configuración lo hacemos en la misma
clase y no tendríamos que estar configurando a cada rato un archivo de configuración.
2.2. Entidad
Con el mapeo generamos clases que tienen la misma estructura de nuestra base de datos. A estas
clases les llamamos entidades. La entidades serian clases con atributos propias de la tabla con sus
respectiva equivalencia entre el tipo de dato de la base de datos con el tipo de dato en Java. Eso
quiere decir si es un tabla XYZ tenemos la columna NOMBRE que es del tipo VARCHAR en Java
tendríamos un atributo NOMBRE con el tipo de dato STRING. Pero como Java sabe que una clase
es una entidad ??? Pues al inicio de la declaracion de la clase debemos de poner la anotacion
@Entity que nos dice que nuestra clase es una entidad y ademas debemos de poner la notacion
@Table(name=”Tabla”) para decir a que tabla hacer referencia nuestra clase. Por ejemplo
@Entity
@Table(name = "producto")
public class Producto implements Serializable {
....
....

Sobre el tema de mapeo y entidades en internet hay mucho material, les recomiendo el siguiente
enlace y este otro para poder saber mas sobre el tema.
3. DESARROLLO
3.1. Creando nuestras entidades
Netbeans nos ayuda a generar nuestra entidades de forma automática, para crear nuestras
entidades debemos de hacer clic derecho en nuestro paquete "com.hwongu.entity" y luego ir a la
opción New-->Entity Class from Database. Si no le sale esta opción ir a New-->Other y buscar la
opción "Entity Class from Database".
Y el formulario que nos sale es la de elegir nuestra conexión de base de datos que vamos a usar,
si es que no tuviéramos nuestra base de datos en el combo deberíamos crear una

nueva conexión a nuestra base de datos y para eso debemos de seleccionar la opción de "New
Database Connection" y poner los parámetros de conexión con la base de datos.
Al hacer eso no mostrar las tablas que tenemos en la base de datos a la cual nos hemos
conectado y luego presionamos el botón de "Add All" para generar todas nuestras clases
mapeadas con la base de datos.

De ahí nos pedirá con que nombre queremos llamar a las clases que se generaran. Dejamos los
nombres por defecto ya que es el estandar que se usa para el mapeo de las
clases. También debemos de quitar el check en la opción que dice "Generate Name Query
Annotations...", pero porque quitamos esta opcion ??? Si dejamos activada esta opcion, Netbans
generia querys a su manera para consultar datos a nuestras tablas y les pondria un sinonimo para
poder llamarlo desde un metodo, por ejemplo
"SelectAll" seria equivalente a decir "SELECT P FROM Producto P"
Y en lugar de ejecutar la siguiente sentencia
entityManager.createQuery("SELECT P FROM Producto P")
Solo bastaría con llamar al nombre equivalente del query anterior

entityManager.createNamedQuery("SelectAll ")
En ciertos casos es útil esta opción, pero se debe de dejar limpia la entidad y los querys ponerlo
solo en la capa del DAO
Después nos pedirá el modelo de carga de datos a usar o lo que comúnmente se le conoce como
FETCH, En JPA hay dos tipos de carga de datos EAGER y LAZY. Pero cual es la diferencia ???
Para explicar la diferencia les pondré el siguiente caso, como ustedes vieron la tabla Venta de
nuestro tutorial se relaciona con nuestra tabla DetalleVenta con un relación de uno a muchos, eso
quiere decir que una Venta tienen muchos DetalleVenta. Cuando nosotros ponemos a una
propiedad en el modo EAGER no traemos la información completa de los detalle de la venta desde

la clase Venta de forma automática en cambio cuando ponemos en LAZY no lo trae en
forma automática, teniendo que cambiar de cierta forma nuestro query para traer su información.
La opcion Collection Type quiere decir que las relaciones de uno a mucho como las va a traer. Por
ejemplo si estoy en venta podría tener un List, Set de detalle de ventas.
Y al final veremos nuestros entitys generados de forma automática.

Publicado en: henry wong,hibernate,java,spring,upao

Java

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Java

Similar a Java (20)

Último

Último (10)

Java