Tutorial Hibernate y JavaServer Faces (JSF)

En este tutorial usaremos NetBeans para crear una aplicación web que recoja datos de una base de datos y los enseñe en una página web mediante java Server faces (JSF). La aplicación web usa el Framework Hibernate como capa de persistencia para la recuperación y el almacenamiento de Plain Old Java Objects (POJO).

Requerimientos mínimos:

Creando la base de datos

Creamos una base de datos con el dump “sakila”, un ejemplo gratuito que esta disponible en la página de MySQL. Podéis usar cualquier herramienta para administrar la base de datos como phpMyAdmin, MySQL Administrator, Emma…

Creando el proyecto de la aplicación web

Ahora crearemos una aplicación web. Añadiremos las librerías de Hibernate y JSF.

1. Creamos un nuevo proyecto. Elegimos aplicación web desde la categoría Java web.
2. Escribimos el nombre del proyecto.
3. Deseleccionamos la opción de carpetas dedicadas.
4. Servidor Glassfish 3 y Java EE 6
5. Seleccionamos Java Server faces y podemos escoger la librería por defecto o PrimeFaces. Recomiendo PrimeFaces para una apariencia más elegante.
6. Seleccionamos Hibernate y configuramos la base de datos.

Modificando el fichero de configuración de Hibernate

Cuando creamos un proyecto que usa el Framework de Hibernate, se genera automáticamente un fichero llamado “hibernate.cfg.xml” que contiene información sobre la conexión a la base de datos, mapeo de recursos y otras propiedades. Podemos editar este fichero mediante el editor multi vista o el editor xml.
Vamos a editarlo para trabajar con hibernate.

1. Abrimos el archivo hibernate.cfg.xml con doble click. Se abrirá en el modo multi vista.
2. Dentro de propiedades opcionales expandimos las propiedades de configuración
3. Añadimos una propiedad hibernate: hibernate.show_sql = true
4. Expandimos el nodo propiedades miscelánea y añadimos: properties hibernate.current_session_context_class = thread
5. Volvemos a añadir en miscelánea: hibernate.query.factory_class = org.hibernate.hql.classic.ClassicQueryTranslatorFactory

Ahora el fichero en XML debería de ser algo como:

    
        org.hibernate.dialect.MySQLDialect
        com.mysql.jdbc.Driver
        jdbc:mysql://localhost:3306/sakila
        root
        ######
        true
        thread
        org.hibernate.hql.classic.ClassicQueryTranslatorFactory
    

Creando un archivo HibernateUtil.java Helper

Para utilizar Hibernate tienes que crear una clase auxiliar que se encarga de la puesta en marcha y que accede a SessionFactory de Hibernate para obtener un objeto Session. La clase activa la función configure() y carga el archivo de configuración hibernate.cfg.xml y luego construye el SessionFactory para obtener el objeto Session.

1. Abrimos el asistente y creamos un HibernateUtil.java en la categoría Hibernate

Generación de archivos de mapeo Hibernate y las clases Java

En este tutorial se utiliza un POJO (plain old objeto Java) para representar los datos en cada una de las tablas de la base de datos que se va a utilizar. La clase Java especifica los campos de las columnas en las tablas y utiliza setters y getters simples para recuperar y escribir los datos.
Creando un archivo Hibernate Reverse Engineering

1. Igual que antes abrimos el asistente, categoría Hibernate, archivo hibernate.reveng
2. Seleccionamos hibernate.cfg.xml en el combo
3. Seleccionamos las tablas que usaremos en la aplicación web y le damos a finish. (seleccionar todas)

Creando Los archivos de mapeo de Hibernate y los POJOs

1. Nuevo archivo, categoría Hibernate.
2. Seleccionar Hibernate Mapping Files and POJOs
3. Seleccionar en los combos hibernate.cfg.xml y hibernate.reveng.xml
4. Seleccionamos JDK5, Domain Code y Hibernate Xml Mappings

El aspecto de hibernate.cfg.xml es el siguiente:

  
    org.hibernate.dialect.MySQLDialect
    com.mysql.jdbc.Driver
    jdbc:mysql://localhost:3306/sakila
    myusername
    mypassword
    true
    thread
    org.hibernate.hql.classic.ClassicQueryTranslatorFactory
    
    
    
    
    
    
  

Y los paquetes:

Creando el FilmHelper.java Helper class

Esta clase se utiliza para realizar consultas de Hibernate en la base de datos. Se utiliza el editor de Hibernate query language (HQL) para probar las consultas y recuperar los datos.

Creando la clase

1. Nuevo archivo Java class
2. Nombre: FilmHelper
3. Añadimos este código:

public class FilmHelper {

    Session session = null;

    public FilmHelper() {
        this.session = HibernateUtil.getSessionFactory().getCurrentSession();
    }

}

   4. Corregir los imports

Usando HQL query

1- Click derecho en el proyecto y le damos a Clean and Build
2- Click derecho en hibernate.cfg.xml y le accedemos a HQL query editor
3- Seleccionamos hibernate.cfg.xml en el combo
4- Testeamos la conexión escribiendo

from Film

y clicando en:

Nos mostrará lo siguiente:

Ahora podemos añadir el código que queramos. Por ejemplo añadimos el método getFilmTitles a FilmHelper.java para recuperar las películas con ID dentro de un rango específico:

public List getFilmTitles(int startID, int endID) {
    List filmList = null;
    try {
        org.hibernate.Transaction tx = session.beginTransaction();
        Query q = session.createQuery ("from Film as film where film.filmId between '"+startID+"' and '"+endID+"'");
        filmList = (List) q.list();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return filmList;
}

Y ahora añadimos este otro método getActorsByID para recuperar los actores:

public List getActorsByID(int filmId){
    List actorList = null;
    try {
        org.hibernate.Transaction tx = session.beginTransaction();
        Query q = session.createQuery ("from Actor as actor where actor.actorId in (select filmActor.actor.actorId from FilmActor as filmActor where filmActor.film.filmId='" + filmId + "')");
        actorList = (List) q.list();

    } catch (Exception e) {
        e.printStackTrace();
    }

    return actorList;
}

Podemos añadir los métodos que queramos aquí, dependiendo la información que queramos recuperar de la base datos.

Creando el JSF Managed Bean

Los métodos en el managed bean se utilizan para mostrar los datos en las páginas JSF y para acceder a los métodos de la clase helper para recuperar los registros.

1. Pinchamos dentro del paquete con el botón derecho y seleccionamos nuevo -> otros
2. Seleccionamos JSF Managed Bean
3. Nombre: FilmController
4. Nombre que usará el managed Bean: filmController
5. Scoper = session

Al darle a Finalizar, el IDE agregará las anotaciones @ManagedBean y @SessionScoped.

@ManagedBean
@SessionScoped
public class FilmController {

    /** Creates a new instance of FilmController */
    public FilmController() {
    }

}

1. Ahora añadimos:

@ManagedBean
@SessionScoped
public class FilmController {
    int startId;
    int endId;
    DataModel filmTitles;
    FilmHelper helper;
    private int recordCount = 1000;
    private int pageSize = 10;

    private Film current;
    private int selectedItemIndex;
}

2. Añadimos el siguiente código para crear un FilmController y recuperar películas

/** Creates a new instance of FilmController */
    public FilmController() {
        helper = new FilmHelper();
        startId = 1;
        endId = 10;
    }

    public FilmController(int startId, int endId) {
        helper = new FilmHelper();
        this.startId = startId;
        this.endId = endId;
    }

    public Film getSelected() {
        if (current == null) {
            current = new Film();
            selectedItemIndex = -1;
        }
        return current;
    }


    public DataModel getFilmTitles() {
        if (filmTitles == null) {
            filmTitles = new ListDataModel(helper.getFilmTitles(startId, endId));
        }
        return filmTitles;
    }

    void recreateModel() {
        filmTitles = null;
    }

3. Podemos añadir los métodos que queramos para recuperar más datos de la base de datos, si quisieramos.
4. Arreglamos los imports y guardamos.

Creando las páginas web

En este ejercicio crearán dos páginas web para la visualización de los datos. Se modificará el index.xhtml generado por el IDE para agregar una tabla que muestra las películas en la base de datos. A continuación, crearemos browse.xhtml para mostrar los detalles de una película cuando haga clic en el enlace "Ver" en la tabla. También se creará una plantilla de página JSF que es utilizado por index.xhtml y browse.xhtml.

Creando template.xhtml
Primero crearemos el template que usaremos en el index.xhtml y en Browne.xhtml

1. Click derecho en el proyecto: nuevo->otros y en la categoría JavaServer Faces clicamos en Facelets template
2. Nombre: template
3. Al finalizar modificamos el código:

    

Top
    

Content
    

Y cambiamos lo que esta en negrita:

Content

Modificando index.xhtml

Cuando se crea la aplicación web, el IDE genera automáticamente el index.xhtml. Ahora lo modificaremos para que muestre una lista de títulos de películas. La JSF llama a los métodos del Managed Bean para que muestre una tabla con los títulos y descripciones.

1.  Esto es lo que contiene index.xhtml:

        
    
    
        Hello from Facelets
    

Lo modificaremos de esta manera: 

    
        
            

            
        
    

2.  Añadimos el siguiente código para que se muestren las películas:

3. Ahora generamos el browse.xhtml. Nuevo archivo -> java Server faces -> facelets template cliente
4. Seleccionamos template.xhtml como template

5. Y añadimos este código en Browse.xhtml:

        
            top
        

        
        
            
                
                    
                    
                    
                    
                    
                    

                    
                    


                    
                    

                    
                    

                    
                    
                        
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    
                        
                    
                
                

                

                
                

            

        
    

Ahora solo falta ejecutar la aplicación.