Download instituto politecnico nacional escuela superior de computó

INSTITUTO POLITECNICO NACIONAL
ESCUELA SUPERIOR DE COMPUTÓ
PRACTICA:
“Uso de Hibernate en una aplicación Web”
MATERIA:
WEB APPLICATION DEVELOPMENT
PROFESOR:
CIFUENTES ALVAREZ ALEJANDRO SIGFRIDO
ALUMNA:
ANA KAREN ECHAVARRIA ACOSTA
GRUPO:
3CM2
INTRODUCCION
En esta practica , se utiliza el IDE NetBeans para crear y desplegar una aplicación
Web que muestra datos de una base de datos. La aplicación web utiliza el marco de
Hibernate como la capa de persistencia para la recuperación y almacenamiento de
objetos típicos JAVA (POJOs) a una base de datos relacional.
Hibernate es el marco que proporciona herramientas para el mapeo relacional de
objeto (ORM). El tutorial se muestra cómo agregar soporte para el marco de
Hibernate para el IDE y crear los archivos necesarios de Hibernate. Después de crear
los objetos Java y configurar la aplicación para utilizar Hibernate, JSF se crea un bean
gestionado y las páginas JSF 2.0 para mostrar los datos.
Requisitos para llevar a cabo esta practica
Creacion de la base de datos.
1. Se descarga la base de datos Sakila, la cual es requerida para desarrollar esta
practica. (Descargar el archivo .ZIP)
2. Descomprimir el archivo .ZIP
3. En la consola de MySQL crear la base de datos e importar la base de datos.
4. En NetBeans se crea la conexión con MySQL
Creación de la aplicación web
En este ejercicio se creará un proyecto de aplicación web y se agregaran las
bibliotecas de Hibernate para el proyecto. Cuando se crea el proyecto, tendrá que
elegir Hibernate en el panel de Frameworks de l asistente New Project y especificar la
base de datos.
1. Elija Archivo> Nuevo Proyecto (Ctrl + Mayúsculas + N; ⌘ + Mayúsculas + N en
Mac) en el menú principal. Seleccione Aplicación Web de la categoría de
Java Web y haga clic en Siguiente.
2. Escriba DVDStore para el nombre del proyecto y establecer la ubicación del
proyecto.
3. Desmarque la opción Carpeta de uso dedicado, si esta selecciona. Haga clic
en Siguiente.
Para este tutorial no hay razón para copiar las bibliotecas del proyecto en una
carpeta específica, ya que no tendrá que compartir bibliotecas con otros usuarios.
4. Configurar el servidor para el servidor GlassFish 3 y fijar la versión Java EE Java
EE 6 Web. Haga clic en Siguiente.
5. Seleccione la casilla de verificación JavaServer Faces y el uso de las bibliotecas
por defecto JSF 2.0.
6. Seleccione la casilla de verificación Hibernate 3.2.5.
7. Seleccione la base de datos Sakila en el menú de conexión de base de datos
la lista desplegable. Haga clic en Finalizar.
Al hacer clic en Finalizar, el IDE crea el proyecto de aplicación web y abre el archivo
hibernate.cfg.xml y index.xhtml en el editor.
Si expande el nodo Bibliotecas en la ventana de Proyectos, se puede ver que el IDE
añade las bibliotecas de Hibernate para el proyecto.
Modificar el archivo de configuración de Hibernate
Cuando se crea un nuevo proyecto que utiliza el framework de Hibernate, el IDE crea
automáticamente el fichero de configuración hibernate.cfg.xml en la raíz del
classpath de contexto de la aplicación (en la ventana de Archivos, src / java). El
archivo se encuentra en el package> <default en el nodo Source Packages en la
ventana de proyectos. El archivo de configuración contiene información sobre la
conexión de base de datos, las asignaciones de recursos y otras propiedades de
conexión. Usted puede editar el archivo con el editor de multi-vista, o de modificar el
código XML directamente en el editor XML.
En este ejercicio va a modificar las propiedades predeterminadas especificadas en el
hibernate.cfg.xml para habilitar el registro de depuración para las sentencias SQL y
para permitir la gestión de Hibernate contexto de la sesión.
1. Abra hibernate.cfg.xml en la pestaña Diseño. Usted puede abrir el archivo
mediante la ampliación del nodo package> <default en los paquetes fuente
en la ventana de Proyectos y hibernate.cfg.xml doble clic.
2. En el editor de multi-vista XML, expanda el nodo Propiedades de configuración
en las propiedades opcionales.
3. Haga clic en Agregar para abrir el complemento Propiedad Hibernate cuadro
de diálogo.
4. En el cuadro de diálogo, seleccione la propiedad hibernate.show_sql y
establecer el valor a true. Esto permite que el registro de depuración de las
sentencias SQL.
5. Expanda el nodo Propiedades de Varios y haga clic en Agregar.
6. En el cuadro de diálogo, seleccione la hibernate.current_session_context_class
propiedades y establecer el valor de thread para permitir la gestión
automática de Hibernate contexto de la sesión.
7. Haga clic en Agregar nuevo bajo el nodo Propiedades y seleccione Varios
hibernate.query.factory_class en la lista desplegable Nombre de la propiedad.
8. Seleccione org.hibernate.hql.classic.ClassicQueryTranslatorFactory como el
valor de la propiedad. Haga clic en Aceptar.
Si hace clic en la ficha XML en el editor se puede ver el archivo en la vista XML. El
archivo debe ser similar al siguiente (las tres propiedades nuevas están en negrita):
<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>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.query.factory_class">
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
</property>
</session-factory>
</hibernate-configuration>
9. Guarde los cambios en el archivo.
Puede cerrar el archivo porque no es necesario editar el archivo de nuevo.
Creación del archivo de Ayudante HibernateUtil.java
Para utilizar Hibernate tiene que crear una clase auxiliar que se encarga de puesta en
marcha y que tiene acceso a SessionFactory de Hibernate para obtener un objeto
Session. La clase llama a configure () y carga el archivo de configuración
hibernate.cfg.xml y después construye la SessionFactory para obtener el objeto
Session.
En esta sección se utiliza el asistente de archivo nuevo para crear la clase de ayuda
HibernateUtil.java.
1. Haga clic en el nodo Source Packages y seleccione Nuevo> Otros para abrir el
asistente de New File.
2. Seleccione Hibernet en la lista Categorías y HibernateUtil.java de la lista Tipos
de archivo. Haga clic en Siguiente.
3. Escriba HibernateUtil para el nombre de clase y dvdrental para el paquete.
Haga clic en Finalizar.
El asistente genera un archivo hibernate.reveng.xml ingeniería inversa y abre el
archivo en el editor. Puede cerrar el archivo de la ingeniería inversa, ya que no tendrá
que editar el archivo.
Generación de archivos de mapeo de Hibernate y las clases Java
En este tutorial se utiliza un POJO (Plain Old Java objeto) para representar los datos en
cada una de las tablas de la base de datos que va a utilizar. La clase Java especifica
los campos de las columnas de las tablas y utiliza setters y getters simples para
recuperar y escribir los datos. Para asignar los POJOs a las tablas que usted puede
utilizar un archivo de mapeo de Hibernate, o el uso de anotaciones en la clase.
Puede utilizar los archivos de mapeo Hibernate y POJOs de un asistente para crear
base de datos de POJOs múltiples y archivos de mapeo basadas en tablas de bases
de datos. Cuando se utiliza el asistente, seleccione todas las tablas para las que
desea POJOs y archivos de asignación y el IDE a continuación, genera los archivos
para usted, basado en las tablas de bases de datos y agrega las entradas de mapeo
para hibernate.cfg.xml. Cuando se utiliza el asistente, puede elegir los archivos que
desea que el IDE para generar (sólo los POJOs, por ejemplo) y seleccione las
opciones de generación de código (generar el código que utiliza EJB 3 anotaciones,
por ejemplo).
Nota. El IDE también tiene asistentes para ayudarle a crear POJOs individuales y
archivos de asignación a partir de cero.
Crear el archivo de hibernación inversa Ingeniería
Si usted desea utilizar los archivos de mapeo Hibernate y POJOs de un asistente de
base de datos, primero debe crear un archivo de hibernate.reveng.xml ingeniería
inversa. Los archivos de mapeo Hibernate y POJOs de un asistente de base de datos
requiere hibernate.reveng.xml y hibernate.cfg.xml.
El archivo de la ingeniería inversa le permite tener un mayor control sobre la
estrategia de mapeo de base de datos. La ingeniería inversa de Hibernate asistente
crea un archivo de ingeniería inversa con una configuración predeterminada que se
puede editar en el editor XML.
Para crear el archivo de hibernación inversa ingeniería, realice los siguientes pasos.
1. Haga clic en el nodo Source Packages en la ventana de Proyectos y
seleccione Nuevo> Otros para abrir el asistente de New File.
2. Seleccione Hibernar Asistente para ingeniería inversa en la categoría de
Hibernate. Haga clic en Siguiente.
3. Especifique hibernate.reveng como nombre de archivo y src / java para la
carpeta. Haga clic en Siguiente.
4. Seleccione hibernate.cfg.xml en el menú archivo de configuración de la lista
desplegable, si no está seleccionado.
5. Seleccione las siguientes tablas de las tablas disponibles y haga clic en Agregar
para agregar las tablas para las tablas seleccionadas.
o
actor
o
categoría
o
película
o
film_actor
o
film_category
o
lengua
Haga clic en Finalizar.
El asistente genera un archivo hibernate.reveng.xml ingeniería inversa y abre el
archivo en el editor. Puede cerrar el archivo de la ingeniería inversa, ya que no tendrá
que editar el archivo.
La creación de los archivos de mapeo Hibernate y POJOs
Puede utilizar los archivos de mapeo Hibernate y POJOs de un asistente de base de
datos para generar los archivos para usted. El asistente puede generar un POJO y un
archivo de asignación correspondiente a cada mesa que seleccione en el asistente.
Los archivos de mapeo son archivos XML que contienen datos acerca de cómo las
columnas de las tablas se asignan a los campos en los POJOs. Usted necesita tener los
archivos hibernate.reveng.xml y hibernate.cfg.xml para utilizar el asistente.
Para crear los POJOs y archivos de asignación mediante un asistente, realice los
siguientes pasos.
1. Haga clic en el nodo Source Packages en la ventana de Proyectos y
seleccione Nuevo> Otros para abrir el asistente de New File.
2. Seleccione Hibernete archivos de asignación y POJOs de una base de datos en
la categoría de Hibernate. Haga clic en Siguiente.
3. Asegúrese de que los archivos hibernate.cfg.xml y hibernate.reveng.xml se
seleccionan en las listas desplegables.
4. Seleccione JDK 5 Características del lenguaje en las opciones de configuración
general.
5. Asegúrese de que el Código de dominio y las opciones de Hibernate XML
Asignaciones están seleccionados.
6. Seleccione dvdrental para el nombre del paquete. Haga clic en Finalizar.
Al hacer clic en Finalizar el IDE genera POJOs y Hibernate archivos de mapeo con los
campos asignados a las columnas especificadas en hibernate.reveng.xml. El IDE
también añade entradas de asignación de hibernate.cfg.xml.
<hibernate-configuration>
<session-factory>
<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">myusername</property>
<property name="hibernate.connection.password">mypassword</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.current_session_context_class">thread</property>
<property name="hibernate.query.factory_class">
org.hibernate.hql.classic.ClassicQueryTranslatorFactory
</property>
<mapping resource="dvdrental/FilmActor.hbm.xml"/>
<mapping resource="dvdrental/Language.hbm.xml"/>
<mapping resource="dvdrental/Film.hbm.xml"/>
<mapping resource="dvdrental/Category.hbm.xml"/>
<mapping resource="dvdrental/Actor.hbm.xml"/>
<mapping resource="dvdrental/FilmCategory.hbm.xml"/>
</session-factory>
</hibernate-configuration>
Tenga en cuenta. Confirme que los elementos de mapeo se enumeran después de
que los elementos de la propiedad en el archivo hibernate.cfg.xml.
Puede ampliar el paquete dvdrental para ver los archivos generados por el asistente.
Usted puede utilizar el asistente de asignación de hibernación si desea crear un
archivo de mapeo de Hibernate que asigna una tabla específica de una clase
específica.
Creación de la FilmHelper.java Ayudante de Clase
Ahora va a crear una clase de ayuda en el paquete de dvdrental que se utiliza para
realizar consultas de Hibernate en la base de datos. Se utilizará el lenguaje de
consulta de Hibernate (HQL) editor para construir y probar las consultas para
recuperar datos. Después de probar las consultas que se va a crear métodos en la
clase de ayuda que construyen y ejecutar las consultas. A continuación, llamará a los
métodos de la clase de ayuda de un grano de JSF administrados.
Creación de la Clase
En esta sección podrás utilizar el asistente de nuevo archivo para crear el ayudante
de clase en el paquete de FilmHelper.java dvdrental. Va a crear una sesión de
Hibernate llamando getSessionFactory en HibernateUtil.java y crear algunos métodos
de ayuda para crear consultas para recuperar datos de la base de datos. Se llamará
a los métodos auxiliares de las páginas JSP.
1. Haga clic en el nodo de origen del paquete dvdrental y seleccione New> Java
Class para abrir el asistente de archivo nuevo.
2. Escriba FilmHelper para el nombre de la clase.
3. Confirme que dvdrental es seleccionado como el paquete. Haga clic en
Finalizar.
4. Añadir el siguiente código (en negrita) para crear una sesión de Hibernate.
public class {FilmHelper
Session session = null;
public FilmHelper() {
this.session = HibernateUtil.getSessionFactory().getCurrentSession();
}
}
5. Haga clic derecho en el editor y elegir las importaciones Fix (Alt-Shift-I; ⌘ +
Mayúsculas + I en Mac) para agregar las declaraciones de importación
requeridos (org.hibernate.Session) y guardar los cambios.
Ahora va a modificar FilmHelper.java agregar métodos que consulten la base de
datos.
Enumerar los títulos de las películas y recuperación de los actores mediante una
consulta HQL
En este ejercicio creará una consulta de Hibernate Language (HQL) consulta que
consulta la base de datos para recuperar una lista de los títulos de las películas de la
tabla de Cine. A continuación, agregue un método que cuestiona tanto el actor y
tablas Film_actor a buscar a los actores involucrados en una película en particular.
La tabla de Cine cuenta con 1000 registros por lo que el método para recuperar la
lista de las películas debe ser capaz de recuperar los registros basados en la clave
principal filmId. Va a utilizar el editor de HQL para construir y probar la consulta HQL.
Después de haber creado la consulta correcta va a agregar un método a la clase
que puede generar la consulta adecuada.
1. Haga clic derecho en el nodo del proyecto en la ventana de Proyectos y elegir
limpiar y construir.
2. Haga clic derecho en hibernate.cfg.xml en la ventana de Proyectos y
seleccione Ejecutar consulta HQL para abrir el editor de consultas HQL.
3. Seleccione hibernate.cfg de la lista desplegable en la barra de herramientas.
4. Pruebe la conexión escribiendo lo siguiente en el editor y hacer clic en el botón
Ejecutar consulta HQL ( ) En la barra de herramientas.
from Film
Al hacer clic en Ejecutar consulta HQL puede ver los resultados de la consulta en la
ventana inferior del editor de consultas HQL.
Si hace clic en el botón SQL se puede ver el equivalente de consulta SQL.
select film0_.film_id as col_0_0_ from sakila.film film0_
5. Escriba la consulta siguiente para recuperar los registros de la tabla de Cine en
el identificador de la película es entre 100 y 200.
from Film as film where film.filmId between 100 and 200
La ventana de resultados muestra una lista de registros. Ahora que ha probado que
la consulta devuelve los resultados deseados, puede utilizar la consulta en la clase de
ayuda.
6. Añadir los getFilmTitles siguiente método para FilmHelper.java para recuperar
las películas donde el id película es entre un cierto rango especificado por las
variables startID y endID.
public List getFilmTitles(int startID, int endID) {
List<Film> 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<Film>) q.list();
} catch (Exception e) {
e.printStackTrace();
}
return filmList;
}
7. Agregue el siguiente método getActorsByID que recupera a los actores en una
película en particular. El método construye la consulta mediante filmId como la
variable de entrada.
public List getActorsByID(int filmId){
List<Actor> 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<Actor>) q.list();
} catch (Exception e) {
e.printStackTrace();
}
return actorList;
}
8. Fije sus importaciones y guardar los cambios. Al fijar sus importaciones debe
elegir java.util.List y org.hibernate.Query.
Adición de métodos auxiliares adicionales
Ahora va a agregar otros métodos auxiliares que crean consultas basadas en una
variable de entrada. Usted puede comprobar las consultas en el editor de consultas
HQL.
1. Agregue el siguiente método para recuperar una lista de categorías de
acuerdo a filmId.
public Category getCategoryByID(int filmId){
List<Category> categoryList = null;
try {
org.hibernate.Transaction tx = session.beginTransaction();
Query q = session.createQuery("from Category as category where
category.categoryId in (select filmCat.category.categoryId from FilmCategory as
filmCat where filmCat.film.filmId='" + filmId + "')");
categoryList = (List<Category>) q.list();
} catch (Exception e) {
e.printStackTrace();
}
return categoryList.get(0);
}
2. Agregue el siguiente método para recuperar una sola película de acuerdo a
filmId.
public Film getFilmByID(int filmId){
Film film = null;
try {
org.hibernate.Transaction tx = session.beginTransaction();
Query q = session.createQuery("from Film as film where film.filmId=" + filmId);
film = (Film) q.uniqueResult();
} catch (Exception e) {
e.printStackTrace();
}
return film;
}
3. Agregue el método siguiente para recuperar el lenguaje cinematográfico de
acuerdo a langId.
public String getLangByID(int langId){
Language language = null;
try {
org.hibernate.Transaction tx = session.beginTransaction();
Query q = session.createQuery("from Language as lang where lang.languageId="
+ langId);
language = (Language) q.uniqueResult();
} catch (Exception e) {
e.printStackTrace();
}
return language.getName();
}
4. Guarde los cambios.
Creación de la JSF Managed Bean
En este ejercicio creará un 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 de ayuda para recuperar los registros. La especificación JSF 2.0 le permite
utilizar las anotaciones en una clase de bean para identificar la clase como un JSF
Managed Bean, para especificar el alcance y para especificar un nombre para el
frijol.
Para crear el Managed Bean, realice los siguientes pasos.
1. Haga clic en el nodo de origen del paquete dvdrental y seleccione Nuevo>
Otros.
2. Seleccione JSF Managed Bean de la categoría JavaServer Faces. Haga clic en
Siguiente.
3. Tipo FilmController el nombre de clase.
Usted usará el nombre de filmController haba administrado como el valor de la
inputText y CommandButton en el index.xhtml página JSF al llamar a métodos en el
grano.
4. Seleccione dvdrental para el paquete.
5. Escriba filmController para el nombre que se utilizará para el Managed Bean.
6. Establecer el ámbito de la Sesión. Haga clic en Finalizar.
Al hacer clic en Finalizar, el IDE crea la clase de frijol y se abre a la clase en el editor. El
IDE añade el ManagedBean @ y anotaciones @ SessionScoped.
@ManagedBean
@SessionScoped
public class FilmController {
/** Creates a new instance of FilmController */
public FilmController() {
}
}
Tenga en cuenta. Tenga en cuenta que el nombre del bean gestionado no se
especifica explícitamente. De forma predeterminada, el nombre del grano es el
mismo que el nombre de la clase y comienza con una letra minúscula. Si desea que el
nombre de la haba de ser diferente del nombre de la clase, puede especificar
explícitamente el nombre como un parámetro de las anotaciones @ ManagedBean
(por ejemplo, @ ManagedBean (name = "myBeanName").
1. Agregue los campos siguientes (en negrita) a la clase.
@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. Agregue el siguiente código (en negrita) para crear la instancia FilmController y
recuperar las 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. Añadir los siguientes métodos que se utilizan para mostrar la tabla y navegar
por las páginas.
4.
public boolean isHasNextPage() {
if (endId + pageSize <= recordCount) {
return true;
}
return false;
}
public boolean isHasPreviousPage() {
if (startId-pageSize > 0) {
return true;
}
return false;
}
public String next() {
startId = endId+1;
endId = endId + pageSize;
recreateModel();
return "index";
}
public String previous() {
startId = startId - pageSize;
endId = endId - pageSize;
recreateModel();
return "index";
}
public int getPageSize() {
return pageSize;
}
public String prepareView(){
current = (Film) getFilmTitles().getRowData();
return "browse";
}
public String prepareList(){
recreateModel();
return "index";
}
Los métodos que devuelven "índex" o "browse" le pedirá el controlador de
navegación JSF para intentar abrir una página llamada index.xhtml o browse.xhtml.
La especificación JSF 2.0 permite el uso de reglas de navegación implícitos en las
aplicaciones que utilizan la tecnología de Facelets. En esta aplicación, no hay reglas
de navegación se configuran en faces-config.xml. En su lugar, el controlador de
navegación a tratar de localizar una página adecuada en la aplicación.
5. Añadir los siguientes métodos que acceden a la clase de ayuda para obtener
los detalles adicionales de la película.
public String getLanguage() {
int langID = current.getLanguageByLanguageId().getLanguageId().intValue();
String language = helper.getLangByID(langID);
return language;
}
public String getActors() {
List actors = helper.getActorsByID(current.getFilmId());
StringBuffer totalCast = new StringBuffer();
for (int i = 0; i < actors.size(); i++) {
Actor actor = (Actor) actors.get(i);
totalCast.append(actor.getFirstName());
totalCast.append(" ");
totalCast.append(actor.getLastName());
totalCast.append(" ");
}
return totalCast.toString();
}
public String getCategory() {
Category category = helper.getCategoryByID(current.getFilmId());
return category.getName();
}
6. Fije sus importaciones (Ctrl + Mayúsculas + I) y guardar los cambios.
La creación de las páginas web
En este ejercicio creará 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, creará 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.
Creación de template.xhtml
En primer lugar, se creará el template.xhtml JSF Facelets Template que se utiliza en la
composición de la index.xhtml y páginas browse.xhtml.
1. Haga clic derecho en el nodo del proyecto DVDStore en la ventana de
Proyectos y seleccione Nuevo> Otros.
2. Seleccione la plantilla Facelets en la categoría JavaServer Faces. Haga clic en
Siguiente.
3. Escriba Template para el nombre de archivo y seleccione el primer estilo de
diseño CSS.
4. Haga clic en Finalizar.
Al hacer clic en Finalizar, el template.xhtml archivo se abre en el editor. La
plantilla contiene el código predeterminado siguiente.
<h:body>
<div id="top" class="top">
<ui:insert name="top">Top</ui:insert>
</div>
<div id="content" class="center_content">
<ui:insert name="content">Content</ui:insert>
</div>
</h:body>
5. Modificar el elemento <ui:insert> para cambiar el nombre por defecto
generado al "cuerpo".
<div id="content" class="center_content">
<ui:insert name="body">Content</ui:insert>
</div>
6. Guarde los cambios.
El contenido incluido dentro del elemento name="body"> <ui:define en index.xhtml
browse.xhtml y se insertará en el lugar identificado con <ui:insert Contenido
name="body"> </ ui: insert> en la plantilla.
Modificación de index.xhtml
Al crear la aplicación web, el IDE genera automáticamente la index.xhtml página. En
este ejercicio se modifica la página para mostrar una lista de títulos de películas. La
página JSF llama a los métodos en el JSF bean gestionado FilmController para
recuperar la lista de las películas y, a continuación se muestra una tabla con los títulos
de las películas y las descripciones.
1. Expanda la carpeta de Páginas Web en la ventana de Proyectos y index.xhtml
abierto en el editor.
El Asistente para nuevo proyecto generado por la página por defecto
index.xhtml siguiente.
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html">
<h:head>
<title>Facelet Title</title>
</h:head>
<h:body>
Hello from Facelets
</h:body>
</html>
2. Modificar la página para utilizar el <ui:composition> JSF y los elementos
<ui:define> y añadir un elemento <h:form>.
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:ui="http://java.sun.com/jsf/facelets">
<ui:composition template="./template.xhtml">
<ui:define name="body">
<h:form>
</h:form>
</ui:define>
</ui:composition>
</html>
uando comienza a escribir las etiquetas, el IDE agrega xmlns: ui =
"http://java.sun.com/jsf/facelets" declaración de biblioteca de etiquetas.
Los elementos <ui:composition> y <ui:define> se utilizan en combinación con la
plantilla de página que va a crear. Las referencias de elementos <ui:composition> la
ubicación de la plantilla que será utilizada por esta página. Las referencias de
elementos <ui:define> la posición en la plantilla que el código cerrado ocupará.
3. Añade los enlaces de navegación siguientes que llaman a los métodos
anteriores y el siguiente JSF managed bean.
<ui:define name="body">
<h:form>
<h:commandLink action="#{filmController.previous}" value="Previous
#{filmController.pageSize}" rendered="#{filmController.hasPreviousPage}"/>
<h:commandLink action="#{filmController.next}" value="Next
#{filmController.pageSize}" rendered="#{filmController.hasNextPage}"/>
</h:form>
</ui:define>
4. Agregue el siguiente elemento DataTable (en negrita) para generar la tabla
para mostrar los elementos recuperados.
<h:form styleClass="jsfcrud_list_form">
<h:commandLink action="#{filmController.previous}" value="Previous
#{filmController.pageSize}" rendered="#{filmController.hasPreviousPage}"/>
<h:commandLink action="#{filmController.next}" value="Next
#{filmController.pageSize}" rendered="#{filmController.hasNextPage}"/>
<h:dataTable value="#{filmController.filmTitles}" var="item" border="0" cellpadding="2"
cellspacing="0" rowClasses="jsfcrud_odd_row,jsfcrud_even_row" rules="all"
style="border:solid 1px">
<h:column>
<f:facet name="header">
<h:outputText value="Title"/>
</f:facet>
<h:outputText value="#{item.title}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value="Description"/>
</f:facet>
<h:outputText value="#{item.description}"/>
</h:column>
<h:column>
<f:facet name="header">
<h:outputText value=" "/>
</f:facet>
<h:commandLink action="#{filmController.prepareView}" value="View"/>
</h:column>
</h:dataTable>
<br/>
</h:form>
5. Guarde los cambios.
La página de índice mostrará ahora una lista de títulos de películas en la base de
datos. Cada fila de la tabla incluye un enlace "Ver" que invoca el método
prepareView en el bean gestionado. El método prepareView devuelve "navegar" y se
abrirá browse.xhtml.
. Nota Cuando se escriba la etiqueta <f:facet>, el IDE se sumará xmlns:. F = "tag
http://java.sun.com/jsf/core declaración de la biblioteca Confirme que la biblioteca
de etiquetas se declara en el archivo.
Creación de browse.xhtml
Ahora va a crear la página browse.xhtml para mostrar los detalles de la película
seleccionada. Puede utilizar la plantilla de Facelets asistente del cliente para crear la
página basada en la plantilla de template.xhtml JSF Facelets que ha creado.
1. Haga clic con el botón DVDStore nodo del proyecto en la ventana de
Proyectos y seleccione Nuevo> Otros.
2. Seleccione Cliente Facelets de plantilla en la categoría JavaServer Faces. Haga
clic en Siguiente.
3. Escriba buscar el nombre de archivo.
4. Busque la plantilla de la página haciendo clic en Más para abrir el cuadro de
diálogo Buscar archivos.
5. Expanda la carpeta de Páginas Web y seleccione template.xhtml. Haga clic en
Seleccionar archivo.
6. Seleccione <ui:composition> de la etiqueta raíz generado. Haga clic en
Finalizar.
Al hacer clic en Finalizar, el browse.xhtml archivo se abre en el editor con el
siguiente código.
<ui:composition xmlns:ui="http://java.sun.com/jsf/facelets"
template="./template.xhtml">
<ui:define name="top">
top
</ui:define>
<ui:define name="body">
body
</ui:define>
</ui:composition>
Se puede ver que el nuevo archivo especifica el archivo de template.xhtml y que la
etiqueta <ui:define> tiene el nombre de la propiedad = "body"
7. Agregue el siguiente código (en negrita) entre las etiquetas <ui:define> para
crear la forma y llamar a los métodos de la gestión FilmController frijol para
recuperar los datos y llenar el formulario.
<ui:composition xmlns:ui="http://java.sun.com/jsf/facelets"
template="./template.xhtml"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<ui:define name="top">
top
</ui:define>
<ui:define name="body">
<h:form>
<h:panelGrid columns="2">
<h:outputText value="Title:"/>
<h:outputText value="#{filmController.selected.title}" title="Title"/>
<h:outputText value="Description"/>
<h:outputText value="#{filmController.selected.description}"
title="Description"/>
<h:outputText value="Genre"/>
<h:outputText value="#{filmController.category}"/>
<h:outputText value="Cast"/>
<h:outputText value="#{filmController.actors}"/>
<h:outputText value="Film Length"/>
<h:outputText value="#{filmController.selected.length} min" title="Film
Length"/>
<h:outputText value="Language"/>
<h:outputText value="#{filmController.language}" title="Film Length"/>
<h:outputText value="Release Year"/>
<h:outputText value="#{filmController.selected.releaseYear}" title="Release
Year">
<f:convertDateTime pattern="MM/dd/yyyy" />
</h:outputText>
<h:outputText value="Rental Duration"/>
<h:outputText value="#{filmController.selected.rentalDuration}" title="Rental
DUration"/>
<h:outputText value="Rental Rate"/>
<h:outputText value="#{filmController.selected.rentalRate}" title="Rental
Rate"/>
<h:outputText value="Replacement Cost"/>
<h:outputText value="#{filmController.selected.replacementCost}"
title="Replacement Cost"/>
<h:outputText value="Rating"/>
<h:outputText value="#{filmController.selected.rating}" title="Rating"/>
<h:outputText value="Special Features"/>
<h:outputText value="#{filmController.selected.specialFeatures}"
title="Special Features"/>
<h:outputText value="Last Update"/>
<h:outputText value="#{filmController.selected.lastUpdate}" title="Last
Update">
<f:convertDateTime pattern="MM/dd/yyyy HH:mm:ss" />
</h:outputText>
</h:panelGrid>
<br/>
<br/>
<h:commandLink action="#{filmController.prepareList}" value="View All List"/>
<br/>
</h:form>
</ui:define>
</ui:composition>
</html>
Se puede ver que browse.xhtml y index.xhtml utilizará la plantilla de la misma página.
8. Guarde los cambios.
La ejecución del proyecto
Los fundamentos de la solicitud se ha completado. Ahora puede ejecutar la
aplicación para comprobar si todo funciona correctamente.
1. Haga clic en Ejecutar proyecto principal en la barra de herramientas principal o
haga clic en el nodo de aplicación DVDStore en la ventana de Proyectos y
seleccione Ejecutar.
El IDE guarda todos los archivos modificados, se basa la solicitud, e implementa la
aplicación en el servidor. El IDE se abre una ventana del navegador a la URL
http://localhost:8080/DVDStore/ que muestra la lista de las películas.
2. En el explorador, haga clic en "Ver" para cargar browse.xhtml para ver los
detalles de la película.