Materia: Web Security.

Tema: Seguridad en Hibernate.

Referencia: https://netbeans.org/kb/docs/web/hibernate-webapp.html

Introducción.
En este ejemplo se utiliza el IDE de NetBeans para crear y desplegar una aplicación Java Swing que muestra datos de una
base de datos. La aplicación utiliza el Framework Hibernate como capa de persistencia para recuperar POJOs (Plain Old
Java Objects) desde una base de datos relacional.

Hibernate es un ambiente que proporciona herramientas para el mapeo relacional de objetos (ORM). Aquí se muestra el
soporte Hibernate incluido en el IDE y cómo utilizar asistentes para crear los archivos necesarios de Hibernate. Después
de crear los objetos Java y configurar la aplicación para utilizar Hibernate, se crea una interfaz gráfica de usuario para la
búsqueda y visualización de los datos.

Este ejemplo es una aplicación web para la administración de una tienda de DVD, e incluye cómo crear una aplicación que
permita consultar el perfil de un actor basándose en la coincidencia del nombre o el apellido. Se puede extender la aplicación
para consultar los detalles de la película y añadir, actualizar o eliminar elementos. Se utiliza MySQL y la base de datos
sakila, pero se puede usar cualquier otro servidor de base de datos soportado con las aplicaciones de Hibernate.

Desarrollo.
1. Crear la Base de Datos.
En este ejercicio se usa la base de datos sakila de MySQL. La base de datos no se incluye al instalar el IDE y se necesita
crear primero la base de datos.
La base de datos sakila es una base de datos MySQL gratuita disponible desde el sitio de MySQL. Para crear la base de
datos sakila se descarga e instala el plugin de sakila utilizando el administrador de plugins. Después de instalar el plugin
se puede crear la base de datos sakila desde la ventana Services. La base de datos sakila se agrega a la lista de bases de
datos en el cuadro de diálogo Create MySQL Database.
1. Abrir el administrador de Plugins e instalar el plugin de Sakila Sample Database.

M. en C. Alejandro Cifuentes A. Página 1

 2. Después de instalar el plugin, iniciar el servidor de base de datos MySQL, ampliando el nodo Databases en la
ventana Services; digitar clic derecho en el nodo MySQL Server y seleccionar Start.

3. Digitar clic derecho en el nodo MySQL Server y seleccionar Create Database.

4. Seleccionar la base de datos sakila de la lista desplegable New Database Name del cuadro de diálogo Create
MySQL Database. Clic en OK.

Al digitar clic en OK, el nodo sakila se muestra bajo el nodo del servidor MySQL.

5. Digitar clic derecho en el nodo sakila y seleccione Connect. Se crea un nodo de conexión de base de datos para
sakila (jdbc:mysql://localhost:3306/sakila [username on Default]) y se muestra bajo el
nodo Databases. Cuando se abre una conexión, al expandir el nodo de conexión se muestran los datos en la base
de datos.

2. Crear de la Aplicación Swing del Proyecto.

En este caso se crea el proyecto con una aplicación Swing, denominada DVDStoreAdmin.
1. Seleccionar File > New Project. Seleccionar Java Application en la categoría de Java. Clic en Next.

M. en C. Alejandro Cifuentes A. Página 2

 2. Ingresar DVDStoreAdmin como nombre del proyecto y establecer la ubicación del proyecto.
3. Desactivar la opción Use Dedicated Folder, si se encuentra seleccionada.
4. Deshabilitar Create Main Class. Clic en Finish.

Digitando en Finish, se crea el proyecto en el IDE. El proyecto no tiene una clase principal. Se creará un formulario y luego
la clase principal.

3. Agregar Hibernate al Proyecto.

Para agregar Hibernate a un proyecto se agregan las bibliotecas Hibernate que se incluyen con el IDE, digitando clic derecho
en el nodo Libraries en la ventana de Projects, seleccionar Add Library y seleccionando del cuadro de diálogo la biblioteca
Hibernate.

El IDE incluye asistentes para crear los archivos de Hibernate que necesita el proyecto. Si se crea el archivo de configuración
de Hibernate con un asistente del IDE, se agregan automáticamente las bibliotecas Hibernate al proyecto.

Crear el Archivo de Configuración de Hibernate

M. en C. Alejandro Cifuentes A. Página 3

El archivo de configuración de Hibernate (hibernate.cfg.xml) contiene información sobre la conexión de base de datos, las
asignaciones de recursos, y otras propiedades de conexión. Cuando se crea un archivo de configuración de Hibernate con
un asistente, se especifica la conexión de base de datos seleccionándola de una lista de conexión de base de datos registrada
en el IDE. Al generar el archivo de configuración del IDE se agrega automáticamente la información de conexión y el
dialecto de información basado en la conexión de base de datos seleccionada. El IDE también añade automáticamente la
biblioteca Hibernate al classpath del proyecto. Después de crear el archivo de configuración se edita el archivo usando el
editor de vistas múltiples, o editar el código XML directamente en el editor Source.
1. Digitar clic derecho en el nodo Source Packages en la ventana de Projects y seleccionar New > Other para abrir el
asistente New File.

2. Seleccionar Hibernate Configuration Wizard de la categoría de Hibernate. Haga clic en Next.

3. Conservar la configuración predeterminada en la sección Name and Location (se desea crear el archivo en la carpeta
src). Clic en Next.

4. Seleccionar la conexión sakila en la lista desplegable Database Connection. Database Dialect no se modifica. Clic
en Finish.

M. en C. Alejandro Cifuentes A. Página 4

Al finalizar, el hibernate.cfg.xml se abre en el editor de código fuente. El IDE crea el archivo de configuración en la raíz
del contexto classpath de la aplicación (en la ventana Files, WEB-INF/classes). En la ventana Projects el archivo se
encuentra en el paquete fuente <default package>. El archivo de configuración contiene información sobre una sola base
de datos. Si se conectan varias bases de datos, se pueden crear varios archivos de configuración en el proyecto, uno para
cada servidor de base de datos, pero predeterminadamente la clase de utilería de ayuda utilizará el archivo
hibernate.cfg.xml situado en la raíz.

Si expande el nodo Libraries en la ventana Projects se puede ver que el IDE agrega los archivos JAR de Hibernate
necesarios y el conector JAR de MySQL.

Nota. El IDE NetBeans 8.0 incluye las bibliotecas Hibernate 4. Las versiones anteriores del IDE incluyen Hibernate 3.

Modificación del Archivo de Configuración de Hibernate

Se editan las propiedades predeterminadas especificadas en hibernate.cfg.xml para habilitar el registro de depuración para
los enunciados SQL.
1. Abrir el hibernate.cfg.xml en la pestaña Design. Se puede abrir el archivo expandiendo el nodo Configuration
Files en la ventana de Projects y digitando doble clic en hibernate.cfg.xml.
2. Expandir el nodo Configuration Properties en Optional Properties.
3. Clic en Add para abrir el cuadro de diálogo Add Hibernate Property.
4. En el cuadro de diálogo, seleccionar la propiedad hibernate.show_sql y establecer el valor con true. Clic en
OK. Esto permite la depuración de los enunciados SQL.

M. en C. Alejandro Cifuentes A. Página 5

 5. Clic Add en el nodo Miscellaneous Propertites y seleccionar hibernate.query.factory_class en la lista
desplegable Property Name.
6. Ingresar org.hibernate.hql.internal.classic.ClassicQueryTranslatorFactory en el
valor de la propiedad Property Name. Esta es la clase del traductor de fábrica que se utiliza en Hibernate 4 y que
se incluye con el IDE. Clic OK.

Nota: Si se usa el IDE NetBeans 7.4 o anterior, se selecciona org.hibernate.hql.classic.ClassicQueryTranslatorFactory

como el valor de la propiedad en el cuadro de diálogo. El IDE NetBeans 7.4 y los anteriores incluyeron Hibernate 3.

Si se digita clic en la pestaña Source en el editor se puede ver el archivo en vista XML. El archivo debe ser similar al
siguiente:
<hibernate-configuration>
<session-factory name="session1">
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/sakila</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">######</property>
<property name="hibernate.show_sql">true</property>

M. en C. Alejandro Cifuentes A. Página 6

 <property
name="hibernate.query.factory_class">org.hibernate.hql.internal.classic.ClassicQueryTranslatorFacto
ry</property>
</session-factory>
</hibernate-configuration>

7. Guardar los cambios del archivo.

Después de crear la forma y configurarla como la clase principal se podrá ver la consulta SQL en la ventana de salida del
IDE cuando se ejecute el proyecto.

Creación del Archivo de Ayuda HibernateUtil.java

Para utilizar Hibernate se crea una clase de ayuda manejar el arranque y que se tenga acceso al SessionFactory de
Hibernate para obtener un objeto Session. La clase invoca al método configure( ) de Hibernate, carga el archivo de
configuración hibernate.cfg.xml y luego construye el SessionFactory para obtener el objeto Session.

En esta sección se utiliza el asistente New File para crear la clase HibernateUtil.java de ayuda.
1. Clic derecho en el nodo Source Packages y seleccionar New > Other para abrir el asistente New File.
2. Seleccionar Hibernate de la lista Categories y HibernateUtil.java de la lista File Types. Clic en Next.

3. Ingresar HibernateUtil en el nombre de clase y sakila.util en el nombre del paquete. Clic Finish.

M. en C. Alejandro Cifuentes A. Página 7

Al digitar Finish, el archivo HibernateUtil.java se muestra en el editor. Se puede cerrar el archivo porque no es necesario
editarlo.

4. Generar los Archivos de Mapeo de Hibernate y las Clases Java.

Se utiliza un sólo objeto POJO de Java, Actor.java, para representar los datos en la tabla ACTOR de la base de datos. La
clase especifica los campos de las columnas de las tablas y utiliza setters y getters para recuperar y escribir los datos.
Para asignar Actor.java a la tabla ACTOR se puede utilizar un archivo de mapeo Hibernate o utilizar anotaciones en la clase.

Se puede utilizar el asistente de ingeniería inversa y los archivos de mapeo Hibernate y POJOs de un asistente de base de
datos para crear múltiples POJOs y archivos de mapeo basados en tablas de bases de datos que se seleccionen.
Alternativamente, se pueden utilizar los asistentes del IDE para ayudar a crear los POJOs individuales y los archivos de
asignación a partir de cero.

NOTA MUY IMPORTANTE: Cuando se desea crear archivos de varias tablas, lo deseable es utilizar los asistentes. Aquí
solamente sólo es necesario crear un POJO y un archivo de mapeo, por lo que basta crear los archivos de forma individual.
Como se indica a continuación.

Creación Individual de los archivos POJO y de Mapeo.

Un archivo POJO es una sola clase Java que usa el asistente New Java Class para crear la clase y luego editarla para
agregar los métodos getters y setters necesarios. Después de crear el POJO, se utiliza un asistente para crear un
archivo de mapeo de Hibernate para asignar la clase al JTable y añadir información de mapeo para hibernate.cfg.xml.
Cuando se crea un archivo de asignación desde cero se mapean los campos a las columnas en el editor XML.

Nota. Esta sección puede ser optativa, pero se utiliza para la creación individual de los archivos POJO y de mapeo que se
crean con el asistente de la base de datos para los archivos de mapeo de Hiberante y POJOs.
1. Clic derecho en el nodo Source Packages en la ventana Projects y seleccionar New > Java Class para abrir el
asistente New Java Class.

2. En el asistente, ingresar Actor en el nombre de la clase y sakila.entity en el paquete. Clic en Finish.

3. Realizar los siguientes cambios (en negritas) en la clase para implantar la interfaz Serializable y agregar los
campos para las columnas de la tabla.
public class Actor implements Serializable {
private Short actorId;
private String firstName;
private String lastName;
private Date lastUpdate;

M. en C. Alejandro Cifuentes A. Página 8

}
4. Clic derecho en el editor y seleccionar Insert Code y seleccionar Getter y Setter en el menú emergente para
insertar los métodos getters y setters de los campos.
5. En el cuadro de diálogo Generate Getters and Setters, seleccionar todos los campos y clic en Generate.

6. Actualizar los imports y guardar los cambios.

Después de crear el POJO para la tabla, se crea el archivo de Mapeo Hibernate para Actor.java.
1. Clic derecho en el nodo de paquetes fuente sakila.entity en la ventana Projects y seleccionar New > Other para
abrir el asistente New File.

2. Seleccionar Hibernate Mapping Wizard de la categoría Hibernate. Clic en Next.

M. en C. Alejandro Cifuentes A. Página 9
 3. Ingresar Actor.hbm en el nombre del archivo y verificar que la carpeta sea src/sakila/entity. Clic en Next.

4. Ingresar sakila.entity.Actor en Class to Map y seleccionar actor de la lista desplegable Database

Table. Clic en Finish.

Al digitar clic en Finish el archivo de mapeo Actor.hbm.xml de Hibernate se abre en el editor. El IDE también agrega
automáticamente una entrada para el recurso de mapeo al hibernate.cfg.xml. Se pueden ver los detalles de la entrada
expandiendo el nodo Mapping en la vista Design del hibernate.cfg.xml o en la vista XML. La entrada mapping en la
vista XML es similar a lo siguiente:
<mapping resource="sakila/entity/Actor.hbm.xml"/>
</session-factory>
</hibernate-configuration>

5. Mapear los campos de Actor.java a las columnas de la tabla ACTOR realizando los siguientes cambios (en negritas)
al Actor.hbm.xml.
<hibernate-mapping>

M. en C. Alejandro Cifuentes A. Página 10

 <class name="sakila.entity.Actor" table="actor">
<id name="actorId" type="java.lang.Short">
<column name="actor_id"/>
<generator class="identity"/>
</id>
<property name="firstName" type="string">
<column length="45" name="first_name" not-null="true"/>
</property>
<property name="lastName" type="string">
<column length="45" name="last_name" not-null="true"/>
</property>
<property name="lastUpdate" type="timestamp">
<column length="19" name="last_update" not-null="true"/>
</property>
</class>
</hibernate-mapping>

Nota: Se puede utilizar la finalización de código en el editor para completar los valores al modificar el archivo de mapeo.
De forma predeterminada, el elemento generado class tiene una etiqueta de cierre. Debido a la necesidad de agregar
elementos de propiedades entre las etiquetas de apertura y cierre de class, es necesario realizar los siguientes cambios (en
negrita). Después de realizar los cambios se puede utilizar la finalización de código entre las etiquetas class.
<hibernate-mapping>
<class name="sakila.entity.Actor" table="actor">
</class>
</hibernate-mapping>

6. Clic en el botón Validate XML en la barra de herramientas y guardar los cambios.

Cuando se crean los archivos individuales POJOs y de mapeo de Hibernate puede ser conveniente personalizar más la
aplicación.

Creación del Archivo de Ingeniería Inversa.

El archivo de la ingeniería inversa (hibernate.reveng.xml) es un archivo XML que se utiliza para modificar la
configuración predeterminada utilizada cuando se generan los archivos Hibernate de los metadatos de la base de datos
especificada en hibernate.cfg.xml. El asistente genera el archivo con la configuración básica predeterminada. Se puede
modificar el archivo para especificar explícitamente el esquema de base de datos que se utiliza para filtrar las tablas que no
se deben utilizar y para especificar cómo se asignan los tipos JDBC a tipos Hibernate.
1. Clic derecho en el nodo Source Packages y seleccionar New > Other para abrir el asistente New File.

2. Seleccionar Hibernate de la lista Categories y Hibernate Reverse Engineering Wizard de la lista File Types.
Clic en Next.

M. en C. Alejandro Cifuentes A. Página 11

 3. Ingresar hibernate.reveng en el nombre de archivo.

4. Mantener el src predeterminado en Location. Clic en Next.

5. Seleccionar actor en el panel Avaliable Tables y clic en Add. Clic Finish.

El asistente genera el archivo hibernate.reveng.xml de ingeniería inversa. Cerrar el archivo de ingeniería inversa, ya que
no se necesitará editar el archivo.

Creación de los Archivos de Mapeo de Hibernate y POJOs Desde una Base de Datos.

M. en C. Alejandro Cifuentes A. Página 12

La creación de los archivos de mapeo Hibernate y POJOs con un asistente de base de datos genera archivos basados en las
tablas de una base de datos. Cuando se utiliza el asistente, el IDE genera los POJOs y los archivos de mapeo basados en las
tablas de base de datos especificados en hibernate.reveng.xml y luego agrega las entradas de mapeo al hibernate.cfg.xml.
Cuando se utiliza el asistente, se pueden elegir los archivos que se deseen que el IDE genere (sólo los POJOs, por ejemplo)
y seleccionar las opciones de generación de código (generan código que utiliza anotaciones EJB 3, por ejemplo).
1. Clic derecho en el nodo Source Packages en la ventana de Projects y seleccionar New > Other para abrir el
asistente New File.

2. Seleccionar Hibernate Mapping Files and POJOs from Database en la categoría Hibernate. Clic en Next.

3. Seleccionar hibernate.cfg.xml en la lista desplegable Hibernate Configuration Files, si no está seleccionada.

4. Seleccionar hibernate.reveng.xml de la lista desplegable Hibernate Reverse Engineering File, si no está
seleccionada.
5. Asegurarse de la selección de las opciones Domain Code y Hibernate XML Mappings.
6. Ingresar sakila.entity en el nombre del paquete. Clic en Finish.

Al digitar clic en Finish, el IDE genera el POJO Actor.java con todos los campos necesarios y genera un archivo de mapeo
Hibernate y añade la entrada de mapeo a hibernate.cfg.xml.

Ahora, ya se tiene el POJO y los archivos Hibernate relacionados necesarios para crear la interface gráfica GUI de Java para
la aplicación. También, se creará y agregará una consulta HQL que consulta la base de datos para recuperar los datos. En
este proceso también se utiliza el editor HQL para construir y probar la consulta.

M. en C. Alejandro Cifuentes A. Página 13

 5. Crear la Interfaz Gráfica de Usuario GUI.
En esta sección, se crea un formulario con JFrame con algunos campos para el ingreso y visualización de datos. También,
se agrega un botón que activará la consulta a la base de datos para recuperar los datos.

Creación del Formulario JFrame.

1. Digitar clic derecho en el nodo del proyecto en la ventana de Projects y seleccionar New > Other para abrir el
asistente New File.

2. Seleccionar JFrame Form de la categoría Swing GUI Forms. Clic en Next.

3. Ingresar DVDStoreAdmin en el nombre de la clase y sakila.ui en el paquete. Clic en Finish.

Al finalizar, el IDE crea la clase y abre el formulario JFrame en la vista Design del editor.

Agregando Elementos al Formulario.

Ahora, se agregan los elementos de interfaz de usuario al formulario. Cuando el formulario se abre en la vista Design en el
editor, la paleta se muestra en la parte derecha del IDE. Para agregar un componente al formulario, arrastrar el componente

M. en C. Alejandro Cifuentes A. Página 14

de la paleta al área de formulario. Después de agregar el componente se necesita modificar el valor predeterminado de la
propiedad Variable Name del componente.
1. Arrastrar un Label y cambiar el texto por Actor Profile.
2. Arrastrar un Label y cambiar el texto por First Name.
3. Arrastrar un TextField junto a la etiqueta First Name y borrar el texto predeterminado.
4. Arrastrar un Label y cambiar el texto por Last Name.
5. Arrastrar un TextField junto a la etiqueta Last Name y borrar el texto predeterminado.
6. Arrastrar un Button y cambiar el texto por Query.
7. Arrastrar un Table al formulario.
8. Modificar los valores de Variable Name de los siguientes elementos de la interfaz de acuerdo a los valores de la
tabla siguiente.
Se puede modificar el valor de Variable Name de un elemento digitando clic derecho en el elemento en la vista Design y
seleccionando Change Variable Name. Alternativamente, se puede cambiar el Variable Name directamente en la ventana
Inspector. No es necesario asignar un valor al nombre de la variable de los componentes Label.
Element Variable Name
TextField First Name firstNameTextField
TextField Last Name lastNameTextField
Button Query queryButton
Table resultTable
9. Guardar los cambios.

En la vista Design el formulario debe ser similar al siguiente.

Ahora, se posee un formulario para crear el código y asignar eventos a los componentes del formulario. Enseguida, se
construyen las consultas basadas en Hibernate Query Language para recuperar datos. Después de construir las consultas
se agregan los métodos la formulario para invocar la consulta apropiada cuando se digite el botón de consulta.

6. Crear las Consultas en el Editor de Consultas HQL.

En el IDE se construyen y prueban las consultas basadas en el lenguaje de consulta de Hibernate HQL (Hibernate Query
Language) utilizando el HQL Query Editor. Mientras se ingresa la consulta, el editor muestra la consulta SQL equivalente
(traducida). Al digitar el botón Run HQL Query en la barra de herramientas, el IDE ejecuta la consulta y muestra los
resultados en la parte inferior del editor.
En este caso se utiliza el HQL Editor para construir las consultas HQL que recuperan una lista de los atributos de los actores
basándose en la coincidencia del nombre o apellido. Antes de agregar la consulta a la clase se utiliza el HQL Query Editor
para probar que la conexión esté funcionando correctamente y que la consulta produzca los resultados deseados. Antes de
ejecutar la consulta, primero se compila la aplicación.
1. Digitar clic derecho en el nodo del proyecto y seleccionar Build.

M. en C. Alejandro Cifuentes A. Página 15

 2. Expandir el nodo del paquete fuente <default package> en la ventana Projects.
3. Digitar clic derecho sobre hibernate.cfg.xml y seleccionar Run HQL Query para abrir el editor de HQL.

4. Probar la conexión escribiendo from Actor en el HQL Query Editor. Clic en el botón Run HQL Query en
la barra de herramientas. Al digitar sobre Run HQL Query se deben mostrar los resultados de la consulta en el
panel inferior del HQL Query Editor.

Después de digitar en el botón Run HQL Query:

M. en C. Alejandro Cifuentes A. Página 16

 5. Ingresar la siguiente consulta en el HQL Query Editor y seleccionar Run HQL Query para comprobar los resultados
de la consulta, cuando la cadena de búsqueda es 'PE'.
from Actor a where a.firstName like 'PE%'

La consulta regresa una lista de los atributos de aquellos actores cuyos nombres inician con 'PE'.
Si se digita el botón SQL, ubicado arriba de los resultados, debe mostrarse la siguiente consulta SQL equivalente:
select actor0_.actor_id as col_0_0_ from sakila.actor actor0_
where (actor0_.first_name like ‘PE%’)

6. Abrir una nueva pestaña del HQL Query Editor e ingresar la siguiente consulta en el panel del editor. Clic en Run
HQL Query:
from Actor a where a.lastName like ‘MO%’

La consulta regresa una lista con los detalles de los actores cuyos apellidos inician con 'MO'.

M. en C. Alejandro Cifuentes A. Página 17

La prueba de las consultas demuestra que se regresan los resultados deseados. Lo siguiente es la implantación de las
consultas en la aplicación para que la consulta apropiada se invoque digitando el botón Query del formulario.

7. Agregar la Consulta al Formulario.

Ahora, se modifica el DVDStoreAdmin.java para agregar las cadenas de consulta y crear los métodos para construir e
invocar una consulta que contenga las variables de entrada. También, es necesario modificar el controlador de eventos del
botón para invocar la consulta correcta y añadir un método para mostrar los resultados de la consulta en la tabla.
1. Abrir el DVDStoreAdmin.java y digitar clic en la pestaña Source.
2. Agregar las siguientes cadenas de la consulta (negritas) a la clase.
public DVDStoreAdmin() {
initComponents();
}
private static String QUERY_BASED_ON_FIRST_NAME="from Actor a where a.firstName like '";
private static String QUERY_BASED_ON_LAST_NAME="from Actor a where a.lastName like '";

3. Agregar los siguientes métodos para crear la consulta basadas en la cadena de entrada del usuario.
private void runQueryBasedOnFirstName() {
executeHQLQuery(QUERY_BASED_ON_FIRST_NAME + firstNameTextField.getText() + "%'");
}

private void runQueryBasedOnLastName() {

executeHQLQuery(QUERY_BASED_ON_LAST_NAME + lastNameTextField.getText() + "%'");
}

Los métodos invocan al método executeHQLQuery () y crean la consulta combinando la cadena de consulta con la
cadena de búsqueda introducida por el usuario.

4. Agregar el método executeHQLQuery().

private void executeHQLQuery(String hql) {
try {
Session session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
Query q = session.createQuery(hql);
List resultList = q.list();
displayResult(resultList);
session.getTransaction().commit();
} catch (HibernateException he) {
he.printStackTrace();
}
}

El método executeHQLQuery() invoca a Hibernate para ejecutar la consulta seleccionada . Este método utiliza la clase
de utilería HibernateUtil.java para obtener la Hibernate Session.

5. Digitar clic derecho en el editor y seleccione Fix Imports que genera los enunciados imports para las bibliotecas
Hibernate (org.hibernate.Query , org.hibernate.Session) y java.util.List. Guardar los
cambios.
6. Crear el controlador de eventos del botón Query cambiando a la vista Design y digitar doble clic en el botón
Query.

El IDE crea el método queryButtonActionPerformed y muestra el método en la vista Source.

M. en C. Alejandro Cifuentes A. Página 18

 7. Modificar el método queryButtonActionPerformed agregando el siguiente código para que se ejecute una
consulta cuando el usuario digite el botón.
private void queryButtonActionPerformed(java.awt.event.ActionEvent evt) {
if(!firstNameTextField.getText().trim().equals("")) {
runQueryBasedOnFirstName();
} else if(!lastNameTextField.getText().trim().equals("")) {
runQueryBasedOnLastName();
}
}
8. Agregar el siguiente método para mostrar los resultados en el JTable.
private void displayResult(List resultList) {
Vector<String> tableHeaders = new Vector<String>();
Vector tableData = new Vector();
tableHeaders.add("ActorId");
tableHeaders.add("FirstName");
tableHeaders.add("LastName");
tableHeaders.add("LastUpdated");

for(Object o : resultList) {
Actor actor = (Actor)o;
Vector<Object> oneRow = new Vector<Object>();
oneRow.add(actor.getActorId());
oneRow.add(actor.getFirstName());
oneRow.add(actor.getLastName());
oneRow.add(actor.getLastUpdate());
tableData.add(oneRow);
}
resultTable.setModel(new DefaultTableModel(tableData, tableHeaders));
}
9. Digitar clic derecho en el editor y seleccionar Fix Imports para generar los enunciados imports de
java.util.Vector y java.util.List. Guardar los cambios.

Nota: En este caso la clase List es una estructura de datos y no un componente del AWT, que también posee un
componente gráfico tipo List.

Después de guardar el formulario, se puede ejecutar el proyecto.

8. Ejecutar el Proyecto.
Ahora que la codificación está completa, se ejecuta la aplicación. Antes de ejecutar el proyecto, se especifica la clase
principal de la aplicación en el cuadro de diálogo de propiedades del proyecto. Si no se especifica la clase principal, se
solicitará que se configure la primera vez que se ejecute la aplicación.
1. Digitar clic derecho en el nodo del proyecto en la ventana Projects y seleccionar Properties.
2. Seleccionar la categoría Run en el cuadro de diálogo Project Properties.
3. Ingresar sakila.ui.DVDStoreAdmin en la clase principal. Digitar clic en OK.

M. en C. Alejandro Cifuentes A. Página 19

Como alternativa, se puede digitar el botón Browse y seleccionar la clase principal en el cuadro de diálogo.

4. Seleccionar Run Project en la barra principal de herramientas para iniciar la aplicación.

A la izquierda se muestra el árbol de archivos completo. Ingresar una cadena de búsqueda en el campo de texto First Name
o Last Name y digitar clic en Query para buscar un actor y ver los detalles, como se indica enseguida:

En la ventana de salida del IDE se muestra la consulta SQL que recupera los resultados mostrados.

EJERCICIO: Actualizar los imports y plugins necesarios para que la aplicación completa se ejecute
adecuadamente.
1. Agregar un captcha, ID y contraseña para ingresar a la aplicación.
2. Agregar un campo de comentarios para atacar vía SQL Injection y XSS Scripting.
Probar la actualización del ejercicio e instalarlo en un servidor Web para probar su correcta ejecución. Utilizar el
DBMS MySQL para la base de datos en el servidor Web. Generar un reporte completo con detalles e imágenes de
la aplicación.

M. en C. Alejandro Cifuentes A. Página 20