Hibernate en Netbeans 6.7.1 (Java)
(my last post)
Hola gente como están espero bien, dejando de lado el fatídico terremoto ocurrido acá en mi país, me he propuesto publicar lo que probablemente sea mi último post de este blog de ARTICULOS TECNICOS.
Un día en clases con profesor conversábamos a cerca de formas de acceder a una base de datos y de cómo hacer un rollback con código Java para las transacciones, el menciono el framework Hibernate. Llegue a casa y me puse a investigar acerca de este Framework y lo encontre genial, la idea que “saltarme” parte del proceso bases de datos, consultas SQL, drivers etc. y centrarme solo en la lógica de la aplicación me pareció interesante.
El siguiente post-guía trata de una aplicación hecha utilizando hibérnate 3 en Netbeans 6.7.1 y pretende crear un ejemplo de Software de Remuneraciones (muy simple) con estas herramientas.
Here we go ¡!
Que Necesitamos
Pues un editor web, Mysql y Netbeans 6.7.1. Instalados
Por donde empezamos
- Lo primero crear la base de datos y los mas importante es tener las relaciones entre tablas bien definidas.
Nota: la estructura de la base de datos la pueden descargar al fina tbn. los tados.
En esta figura es clara la relación [one-to-many] quiere decir que un departamento puede tener muchos empleados, esta relación es clave a la hora de configurar el proyecto puesto que hibérnate tomaran esta base de datos y creara archivos de configuración y mapeo XML a partir de esta base de datos y estos serán la base para que nuestra aplicación o más bien dicho Hibernate tenga un buen desempeño.
nota:
El código SQL de la base de datos esta adjunta con el proyecto Netbeans al final
- Comportamiento de esta aplicación
Esta aplicación de ejemplo tiene el siguiente comportamiento.
Para el Guardado de datos.
- Los formularios (JSP) envían los datos a un Servlet mediante Ajax
- El Servlet toma los datos y crea un Objeto (Empleado o Departamento)
- El Servlet crea un una instancia de las clases de Gestión de Hibernación (clases HbnGestion) el cual tiene un método que necesita un argumento (Empleado o Departamento) que guarda el Objeto.
- El método de guardado envía una respuesta al Servlet corroborando un guardado de datos exitoso si así lo es.
- El Servlet imprime una respuesta (si la transacción fue exitosa o no) y la envía a la página JSP correspondiente.
- Ajax toma tal respuesta, despliega un Alert e imprime el mensaje en un <DIV> HTML.
- Creación del Proyecto en Netbeans
Ya tengo la base de datos mysql creada y perfectamente relacionada (Importante ¡!) seguiremos creando el proyecto en Netbeans, para ello:
- Archivo > Proyecto Nuevo y siguiente
- Seleccionamos en categoría JavaWeb y en Proyectos WebApplication y siguiente
- Luego daremos un nombre al proyecto en mi caso HibernateRemuneraciones siguiente
- Elegimos un servidor en mi caso Apache Tomcat 6.0.8 luego Java Versión Java EE 5
- Luego seleccionamos un Framework adicional, y como quiero trabajar con Hibernate seleccionamos Hibernate 3.2.5 Terminar.
Como nos habremos dado cuenta, Netbeans nos creo unos archivos de forma automática, pero solo destacaremos algunos, la página de inicio (index.jsp), el archivo de configuración de hibernate (hibernate.cfg.xml) y las librerías de hibérnate.
Creo que ya todos conocemos lo que son las paginas JSP y las librerías así que nos centraremos en el archivo de configuración y algunas características que iremos a utilizar aquí, para eso haremos doble clic en el archivo que se encuentra bajo el nodo por nombre de paquete predeterminado hibernate.cfg.xml y veremos algo como esto.
hibérnate.cfg.xml es un archivo de configuración en donde se especifican las propiedades de hibérnate, daremos un breve vistazo a lo más relevante.
1) Operador XML: Clicando en esta ficha veremos el código XML de toda esta configuración.
2) Propiedades de JDBC: Vemos aquí como las propiedades de conexión que se han cargado al momento de crear el proyecto, el Driver, la ruta de nuestra base de datos, el usuario y la contraseña.
3) Propiedades de configuración: Aquí veremos 2 cosas, la primera es elegir el dialecto que ocuparemos, es decir, que base de datos estamos utilizando (esto ya lo cargo netbeans cuando creamos el proyecto e identifico que nuestra base de datos era mysql) y lo segundo es definir si queremos que el proyecto depure nuestras consultas HQL en SQL.
4) Propiedades Varias: Aquí habilitaremos la creación de sesiones automáticas.
Expandimos el nodo de Propiedades de Configuración presionamos el botón agregar luego le damos los valores correspondientes.
Nuestra configuración nos quedara así(Especificamos dialecto SQL)
Luego clicamos en nodo de Propiedades varias y damos los valores señalados en la figura(Sesiones automaticas)
Terminando quedaría algo asi
La explicación de esta parte de la configuración está dada en los puntos 4 y 5.
Nuestro archivo de configuración (hibérnate.cfg.xml) o lo que necesitaremos de este archivo ya está listo, ahora clicamos en la ficha Operador XML (vista de código) y podremos ver nuestra configuración.
- Creación del archivo HibernateUtil.java
El siguiente paso será crear el archivo HibernateUtil.java. Este archivo lo que hace es crear un SessionFactory (objeto) que cargara la información sobre donde se encuentran los ficheros de mapeo de Hibernate.
Archivo > Archivo Nuevo > categoría Hibernar > archivo HibernateUtil / Siguiente y veremos algo así.
Indicamos el nombre de la clase creamos un paquete nuevo llamado remuneraciones e incluimos este archivo dentro y terminamos.
Codigo del archivo HibernateUtil.java
package remuneraciones;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.SessionFactory;
public class HibernateUtil {
private static final SessionFactory sessionFactory;
static {
try {
// Create the SessionFactory from standard (hibernate.cfg.xml)
// config file.
sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Log the exception.
System.err.println(“Initial SessionFactory creation failed.” + ex);
throw new ExceptionInInitializerError(ex);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
- Creación de archivos de Mapeo y clases de Java
Lo siguiente será crear los archivos de mapeo y las clases de java a partir de nuestra base de datos. Al generar esto, Netbeans lo que hará será tratar de relacionar la bases de datos con clases de java (objetos), creando por cada tabla una clase java con sus atributos (filas de la tabla) y un archivo XML en donde se especifican características de “objeto-tabla” como por ejemplo el nombre de la base de datos (catalog), el nombre de la tabla (table) y otras varias características más.
Empezaremos por crear un archivo de ingeniería inversa (hibérnate.reveng.xml) archivo que guardara la configuración de nuestras tablas, para eso:
Archivo > Archivo nuevo > categoría / Hibernate > Tipo de Archivo / Asistente de ingeniería inversa de Hibernate. El asistente nos mostrara lo siguiente.
Le dejamos el nombre por default la y la ruta será src/java esto es guardara el archivo junto con el archivo hibernate.cfg.xml en el paquete predeterminado, damos siguiente.
Seleccionamos nuestro archivo de configuración y agregamos las tablas a utilizar
Una vez agregado terminamos.
Ahora vamos al paquete predeterminado y vemos como junto al archivo Hibernate.cfg.xml quedo nuestro hibernate.reveng.xml, doble clic sobre el icono y veremos su código correspondiente que no es más que esto.
Luego de creado nuestro archivo de configuración de tablas procederemos a crear los Archivos de Mapeo de Hibernate, para eso:
Archivo > Archivo nuevo > categoría / hibérnate > tipo de archivo / Archivos de mapas de hibérnate POJOS de la base de datos > siguiente y el asistente nos mostrara algo como lo siguiente.
Seleccionamos si no lo están nuestros archivos de configuración checamos la casilla de características del lenguaje JDK 5 y lo demás lo dejamos como viene por default, tbn. debemos de indicar en que package quedaran nuestros archivos de clase y mapeo le indicaremos el package de “negocio” remuneraciones y terminamos.
Si expandimos el nodo del package remuneraciones nos daremos cuenta que se ha creado por cada tabla de nuestra base de datos un archivo de mapeo de Hibernate y una Clase Java con el mismo nombre como veremos a continuación.
Veamos que hay en el archivo de mapeo de la clase Departamentos, doble clic en el archivo Departamentos.hbm.xml.
Antes de seguir una pequeña introducción a estas etiquetas:
a) Class
- ü name: representa el nombre de la clase Java.
- ü table: representa la tabla de nuestra base de datos.
- ü Catalog: indica el nombre de la base de datos a trabajar.
b) Id
- ü name: nombre del id (identificador unico) de la clase Departamentos.
- ü type: es el tipo de dato de ese atributo.
c) column
- name: el nombre del identificador único de la tabla
d) generator:
- class: Indica de qué forma se incrusta el id en la base de datos.
e) Set
- Name: el nombre de la variable(arreglo) que contiene todos los empleados asociados a un Departamento(recordar las relaciones de tablas)
f) Key
- Column name: nombre del campo que guardara el id de la tabla referenciada, en este caso guardaremos el id del empleado en la tabla departamentos.
g) One-to-many: importante es entender que en una relación one-to-many la colección especificada no puede contener más de un objeto con el mismo identificador.
- Class: indica la clase con la que está relacionada.
Para más detalle dejo un manual mucho más detallado aquí.
Ahora echemos un vistazo a la clase Java generada por Netbeans Departamentos.java
Para los que no han visto Hibernate con Netbeans esta es una gran sorpresa. Netbeans ha generado una clase Java a partir de los campos de nuestra base de datos con sus atributos y métodos más comunes (getters, setters y constructores), solo algo hay que es fuera de lo común, la línea 8.
private Set<Empleados> empleadoses = new HashSet<Empleados>(0);
La Objeto de tipo HashSet es lo más parecido a un List (Arreglo) tiene la particularidad de no poder contener 2 veces el mismo valor. Y ya nos podemos imaginar que es lo que contendrá empleadoses, pues todos los empleados asociados a un Departamento, no así Empleados que no puede contener más de un Departamento.
- Checando que nuestra configuración esta correcta con una consulta HQL
Hemos avanzado bastante pero todavía queda, lo que necesitamos ahora es corroborar si es que lo que hemos creado (archivos de configuración etc.) están correctamente creados y para eso realizaremos algunas consultas HQL.
¿Pero que es HQL? HQL (Hibernate Query Languaje) es el lenguaje de consultas de Hibernate así como SQL o como FQL (el lenguaje de consultas de facebook) la particularidad de HQL es que estas consultas trabajan sobre Objetos de memoria y no directamente a una base de datos, me explico con el siguiente ejemplo y si funciona será un hecho que los archivos que hemos creado anteriormente están correctamente configurados.
Podéis descargar aquí la base de datos creada por mí con 42 filas con datos de empleados y departamentos o podéis cargar tus propios desde Netbeans o en un editor sql como SQLYog.
Here we go ¡
Para esto expandimos el nodo de paquete predeterminado y hacemos clic derecho sobre hibérnate.cfg.xml y clicamos Ejecutar consulta HQL.
Nos abrirá una ventana para realizar Consultas
Primera Consulta: Obteniendo la lista de Empleados
Como dije anteriormente las consultas HQL trabajan sobre Objetos de memoria, para seleccionar todos los Empleados tecleamos from Empleados, Netbeans nos mostrara la respectiva consulta en SQL como se indica más abajo
Ahora Presionamos el botón para la ejecución de la consulta he Hibernate, nos arroja nuestros primeros resultados.
Que interesante no?? Hibernate nos devolvió nuestra primera consulta pero por que En el Campo Departamento nos devuelve un Lugar de memoria en vez de un dato ¿? Pues bien, lo que ahí hay es un Objeto tipo Departamento y que está almacenado en ese lugar de la memoria.
Segunda Consulta: Seleccionemos los Empleados que no tienen Cargas familiares (Cargas = 0).
from Empleados as e where e.empCargas = 0
Dentro de esta consulta creamos una instancia de Empleados, e , y hacemos la comparación con su atributo empCargas.
Tercera Consulta: Seleccionemos todos los Empleados cuyo departamento sea el de Informatica y que los resultados los devuelva ordenados por apellido.
from Empleados as e where e.departamentos.depNombre = ‘Informatica’ order by e.empApellido
- Creación de Clases de Gestión de Consultas
Ya luego de haber comprobado que nuestra configuración esta sin errores porque nuestras consultas así lo demostraron, pasaremos a crear una clase de gestión de consultas de hibernate, que es la que utilizaremos para recuperar los datos y llevarlos a las vistas. Para esto clic derecho sobre source package > Nuevo > paquete Java y le damos por nombre Manejador.
Ahora clic derecho sobre nuestro paquete recién creado(Manejador) nuevo > clase Java, le damos por nombre HbnGestionEmpleados y terminar.
Nuestra clase de Gestión de Hibernate esta creada, pero falta programarla, partiremos por el constructor el atributo Session y el constructor vacio.
Nota: El código solo será en pantallazos ya que desordenado no ayuda de mucho, recuerden que el proyecto completo estará disponible al final, podéis ahí mirar cada detalle con mayor tranquilidad.
Clase HbnGestionEmpleados.java, importaciones y el atributo sesion.
Método addEmpleado: Este método lo que hará será guardar un Objeto tipo Empleados, para eso debes pasarle uno por parámetro.
Método ContarEmpleados: Este método cuenta la cantidad de Empleados en la tabla empleados, esto para crear el ID del empleado que se va a ingresar (sumándole 1). Hay mil formas y mejores de hacer un ID pero es a modo de ejemplo.
Método ListaEmpleados: Método que devuelve todos los empleados
Método ListaEmpleadosCargas: método que devuelve solo los empleados que tienen cargas familiares.
Clase HbnGestionDepartamentos: Acá solo mostraremos 1 método ya que la estructura es muy similar a la clase HbnGestionEmplados.
Método BuscaUnDepartamento: Este método tiene la función de buscar un Departamento específico en la base de datos. Cuando al Form de agregar empleado (addEmpleado.jsp) le demos el submit un Servlet resivira los datos, pero debemos de buscar el Departamento que nos envía el form, el que será el valor de lo que hayamos seleccionado en la lista desplegable. Invocaremos este método entonces para que nos devuelva el Objeto Departamento y podamos así crear un Empleado.
- Creación de las paginas JSP para el guardado y vistas de datos
El siguiente paso será crear las paginas JSP tanto para la acción de guardado de datos como para la vistas de estos mismos (Listas e Informes). De los formularios veremos solo la acción de guardado de Empleados ya que el guardado de Departamentos es muy similar, lo mismo para las acciones de vistas de datos, ahí solo veremos la vista del Informe ya que la otra es similar y menos compleja que esta.
- addEmpleados.jsp: Formulario que guarda Empleados, los datos son enviado mediante Ajax a un Servlet (lo veremos más adelante) que gestiona la creación del mismo.
- addDepto.jsp: Lo mismo para este formulario
- Listado.jsp: Acá se muestran todos los Empleados guardados.
- Informes.jsp: Este informe es muy simple, muestra todos los Empleados que tengan al menos una carga familiar y por cada carga agrega un bono de $5.000 pesos.
Formulario addEmpleados.jsp: Para agregar una nueva página jsp…
Archivo> Archivo Nuevo > categoría / web > tipo de archivo / jsp > siguiente y veremos algo así.
Ponemos el nombre de nuestra página y le decimos que estará ubicada en la carpeta Web Pages.
No me quiero pasar toda una noche explicando línea a línea esta página, así que me abocare a lo más relevante.
Veamos la línea en donde obtenemos el total de registros de Empleados, se invoca aquí la clase HbnGestionEmpleados y se llama un método que habíamos creado previamente, ContarEmpleados, que nos devolvía el total de Empleados, le damos el valor devuelto a una variable int le sumamos uno, con esto tendremos el ID del próximo Empleado que creemos.
Aunque no está en fin de este post me he tomado la molestia de incorporar tecnología Ajax para el envío de datos desde este formulario al Servlet correspondiente para que los procese.
Funciones javaScript para el evitar la modificación del ID. Cuando quiera pinchar al campo txtid le damos un alert y mandamos el foco al txtnombre y la limpieza de los campos.
Codigo del Formulario
<td>Id:</td>
<td><input value=”<%=id+1%>”">txtid” size=”5″ onClick=”foco();”></td>
<td> </td>
</tr>
<tr>
<td width=”110″>Nombre:</td>
<td width=”251″><label>
<input name=”txtname”">txtname” size=”20″ />
</label></td>
<td width=”64″> </td>
</tr>
<tr>
<td>Apellido:</td>
<td><label>
<input name=”txtapellido”">txtapellido” size=”20″ />
</label></td>
<td> </td>
</tr>
<tr>
<td>Cargas:</td>
<td><label>
<input name=”txtcargas”">txtcargas” size=”5″ />
</label></td>
<td> </td>
</tr>
<tr>
<td>Sueldo:</td>
<td><input name=”txtsueldo”">txtsueldo” size=”10″ /></td>
<td> </td>
</tr>
<tr>
<td>Departamento</td>
<td><label>
<select”>cboDepto”>
<%
List deptos;
<!– Acá se cargan todos los Departamentos al Select (html) llamando a la clase HbnGestionDepartamentos y rescatando todos los departamentos.à
int i;
HbnGestionDepartamentos ld = new HbnGestionDepartamentos();
deptos = ld.getDepartamentos();
for(i=0;i < deptos.size(); i++)
{
Departamentos d = (Departamentos) deptos.get(i);
%><option><%=d.getDepNombre()%></option>
<%
}
%>
</select>
</label></td>
<td> </td>
</tr>
<tr>
<td> </td>
<td align=”center”><label>
<input type=”button”">btnEnviar” value=”Enviar Formulario”
<!– Acá se hace la llamada a la función javascript Enviar() que envía los datos de este formulario de manera asíncrona al servlet à
onClick=”Enviar();” name=”btnEnviar” />
<input name=”Input” value=”Limpiar” />
</label></td>
<td> </td>
</tr>
<tr>
<td height=”25″><a href=”index.jsp”></a></td>
<td align=”center”><input name=”btnNuevo”">btnNuevo” value=”Nuevo Empleado”></td>
<td> </td>
</tr>
<tr height=”30″ >
<td height=”27″ colspan=”4″ bgcolor=”#0000FF”>
<div id=”message” style=”font-family:Arial; color:#F9F9F9;”></div>
</td>
A demás de el formulario y todo lo demás añadiremos una etiqueta DIV al final del formulario para cuando Ajax reciba la respuesta del Servlet nos despliegue su mensaje dentro de esta etiqueta.
Nuestro formulario en ejecución seria de esta forma
Nota: el menú de la navegación es lo de menos puedes linkearlo de la forma que quieras.
Como señale anteriormente el formulario addDepto.jsp no lo explicare porque es muy similar al de Empleados.
Vamos por el Informe y la recuperación de los Empleados con cargas y sus y una aplicación bonos por carga.
Informe.jsp y lo más importante.
Importaciones: La clase DecimalFormat la utilizaremos para darle un formato de moneda a lo que nos devuelva hibernate (sueldo) y el total de la planilla.
Variables a utilizar
Se imprimen los datos.
Nota: La vista en ejecución de este informe este en el siguiente paso.
- Creación de Servlets para la recepción de los Datos de los Formularios JSP.
El siguiente paso será crear dos Servlets, uno para Departamentos y otro para Empleados, la misión de estos será tomar los datos que enviaremos de los formularios de creación de empleados y departamentos (addEmpleados.jsp y addDeptos.jsp). Solo tocaremos el ServletEmpleados, veamos entonces el método preccessRequest de este Servlet pero primero agreguemos un Servlet al Proyecto.
Archivo > Archivo Nuevo > categoría / web > tipo de archivo / Servlet > siguiente… le damos por nombre ServletEmpleados y lo ubicamos en el paquete Manejador.
Veamos la ubicación de los Servlets y de los componentes de este proyecto en general.
Codigo del método processRequest del servlet ServletEmpleados
protected void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType(“text/html;charset=UTF-8″);
PrintWriter out = response.getWriter();
String name,apellido,depto=”";
int cargas=0;
int;
double sueldo=0;
try {
// si los campos no son nulos comienza la accion
if(request.getParameter(“txtid”) != null && request.getParameter(“txtname”) != null && request.getParameter(“txtapellido”) != null && request.getParameter(“txtcargas”) != null && request.getParameter(“txtsueldo”) != null)
{ // variable a utilizar saber si el guardado es exitoso
int succes;
//obtengo los datos
id = Integer.parseInt(request.getParameter(“txtid”));
name = request.getParameter(“txtname”);
apellido = request.getParameter(“txtapellido”);
cargas = Integer.parseInt(request.getParameter(“txtcargas”));
sueldo = Long.parseLong(request.getParameter(“txtsueldo”));
depto = request.getParameter(“cboDepto”);
//creo una instancia de Departamentos que sera el departamento del
// Empleado
Departamentos d = new Departamentos();
//creo una instancia de HbnGestionDepartamentos para obtener el departamento
//pasandole como parametro la variable depto que ahora contendra el valor del Select
//de addEmpleados.jsp
HbnGestionDepartamentos hgd = new HbnGestionDepartamentos();
HbnGestionEmpleados hge = new HbnGestionEmpleados();
Empleados e = new Empleados();
//me devuelve un Departamento y se lo asigno a d
d = hgd.BuscaUnDepartamento(depto);
//creo el objeto tipo Empleados con los datos del Formulario.
e.setIdEmpleado(id);
e.setEmpNombre(name);
e.setEmpApellido(apellido);
e.setEmpCargas(cargas);
e.setDepartamentos(d);
e.setEmpSueldo(sueldo);
//le paso mi Objeto Empleado a HbnGestionEmpleados(Hibernate)para que realice el guardado en el método addEmpleado
//este metodo addEmpleado me devolvera un entero.
succes = hge.addEmpleado(e);
//javax.swing.JOptionPane.showMessageDialog(null, e.getDepartamentos().getDepNombre());
//si es 1 el guardado fue exitoso
if (succes == 1)
{ //Hacemos una pausa para ver el gif de Ajax
Thread.sleep(2000);
//Enviamos la respuesta mediante Ajax
out.println(“Datos Guardados Satisfactoriamente”);
}else if(succes == 2)
{ //si es 2 algo ocurrio
Thread.sleep(2000);
out.println(“Ha ocurrido una Excepcion tipo Hibernate”);
}
}else{
Thread.sleep(2000);
out.println(“Al parecer Faltan campos por llenar, no se pudieron guardar los Datos”);
}
} catch(Exception e){
e.printStackTrace();
}
finally {
out.close();
}
}
Suponiendo que hemos ido revisando el proyecto y terminando las clases ServletDepartamentos y HbnGestionDepartamentos, esta ultima omití pero puedes revisar el codigo desde el proyecto, vamos a ejecutar el proyecto HibernateRemuneracines =)
Inicio
Agregar Empleados
Datos Guardados
Mantenedor Departamentos (Similar al de Empleados)
Listado de Empleados
Informe de Bonos a Empleados con al menos una carga
segunda parte
Ojala le allá servido a alguien este post – manual, aunque sea solo a uno, con eso estaré más que pagado.
Y como es el último post tiene que ser bueno y lo más completo posible, así que acá les dejo este manual de hibernate en pdf, la base de datos y el proyecto. Suerte a todos en especial a mis ex compañeros y mi profe =).
nota: bonus track Log4j
Hace un tiempo atrás escribí una articulo para 
