UploadFile con Icefaces + Hibernate + Anotaciones

2
10955

UploadFile con Icefaces + Hibernate + Anotaciones.

0. Índice de contenidos.

1. Introducción

Este tutorial pretende servir de gu
de inicio
para todos aquellos usuarios que comienzan a dar sus primeros pasos en ICEfaces,
JSF e Hibernate,y también,como pueden servirse de Netbeans IDE como entorno de desarrollo
fácil e intuitivo para dar soporte a estas tecnologías,
confeccionando de una manera rápida nuestro entorno de trabajo.

Objetivos

  • 1.Manejar comoponentes ICEfaces para la interfaz de usuario.
  • 2.Ver como JSF gestiona la capa de control,comunicando la presentación con la lógica de negocio.
  • 3.Servirnos de Hibernate para obtener una capa de persistencia más sencilla y mantenible.

2. Entorno

El tutorial está escrito usando el siguiente entorno:

  • Hardware: Portátil Dell Latitude E5500(Core Duo T9550 2.66GHz, 4GB RAM, 340 GB HD).
  • Sistema operativo: Windows XP.
  • JDK 1.6.0_1
  • NetBeans 6.5
  • Icefaces 1.8.0
  • Hibernate 3.2.5
  • Tomcat 6.0.18
  • MySQL 5.1
  • Internet Explorer

3. La aplicación

La aplicación consiste en un listado donde se muestra los ficheros que tenemos en nuestro servidor. Podría quedar algo como:



y una pantalla de edición de los ficheros,tanto para editar uno existente como para subir un nuevo fichero.

4. Creando nuestro proyecto

Lo primero es crear un nuevo proyecto.

seleccionamos proyecto web.

Damos nombre a nuestro proyecto y le indicamos la ubicación de nuestro workspace

seleccionamos el servidor,en nuestro caso Tomcat.

y por último seleccionamos los frameworks necesarios.ICEfaces,JavaServerFaces e Hibernate 3.2.5 .

En el pantallazo no aparece pero Hibernate 3.2.5 esta el ultimo de la lista.

Nuestro proyecto quedaría algo como:

Podemos observar que en Libraries nos ha colocado todas las dependencias necesarias,además de crearnos los ficheros de configuración
de JSF (faces-config.xml) y el fichero de configuración de Hibernate(hibernate.cfg.xml) que veremos mas adelante.

5. Capa de Persistencia

La capa de persistencia son los cimientos de la aplicación.

Cualquier desarrollo por sencillo que sea,podría interactuar con una base de datos para insertar,modificar
y recuparar información.Aquí es donde entra en juego Hibernate facilitando el
proceso mediante mecanismos de mapeo objeto/relaccional(Object Relational Mapping,ORM) y
simplificando la programación de la capa de persistencia como veremos a continuación.


Dentro de la capa de persistencia hemos de diferenciar dos partes:

  • Definicion de las entidades persistentes de Hibernate
  • Definicion de los clases DAO ,que se encargaran de gestionar la logica de Hibernate,ya que nuestra lógica de negocio
    no tiene por qué saber como Hibernate gestiona el acceso a los datos.

5.1 Las Entidades

Creamos la única entidad de nuestra aplicación.Así quedaría la clase:

De la clase hay que destacar el uso de anotaciones que serviran ha Hibernate
para saber que el objeto es una entidad,cual es el id de la entidad,que este id
sera generado por la base de datos y cual serán los nombres y algunas otras
propiedades básicas para las columnas.

5.2 El DAO

Primero definimos una interface,de esta manera en un futuro podríamos
cambiar la implementación en caso de utilizar otro motor de persistencia distinto a Hibernate.


Continuamos implementando el DAO.


Como podemos ver se trata de una implementación sencilla ya que solo necesitamos
dos operaciones básicas para cubrir la funcionalidad de nuestra aplicación:

  • 1.Insertar y modifcar datos de lo que se encargará el método guardar().
  • 2.Recuperar información de lo que se encargará el método listartodos()

Vemos que de una manera rápida hemos creado nuestra capa de persistencia teniendo
la ventaja de que trabajando de esta manera podremos decirle ha Hibernate en su
fichero de configuración que sea el mismo el que cree las tablas correspondientes en
base de datos a partir de las clases definidas como entidades persistentes.

6. Capa de Negocio.

Como hemos visto anteriormente la funcionalidad de nuestra aplicación es muy sencilla
por lo que nuestra lógica de negocio también lo será.En realidad en esta clase
solo estamos delegando el control al DAO para que realice la operación correspondiente.


7. Capa de Control.

Aquí es donde JSF entra a formar parte de nuestra aplicación.

Esta capa es la encargada de gestionar la comunicación entre la presentación y
la lógica de negocio ,gestionando los eventos provocados por el usuario al realizar
distintas acciones (pulsar un botón,cambios de valores,seleccionar una opción …).
y ejecutando código java para responder a cada una de las acciones.

Las clases que formaran parte de la capa de control son los denomidados
managed-bean de JSF.En nuestro caso,al tener dos pantallas definiremos dos
managed-bean,uno para cada pantalla.

Mas adelante veremos que para que JSF sepa que estas clases forman parte de
la capa de control hemos de definirlas en el faces-config.xml .

Para la pantalla con el listado de ficheros:


En este managed-bean la implementación es muy sencilla ya que solo nos servirá
para mostrar la lista con todos los registros de nuestra tabla en base de datos.

Para la pantalla de edición:

Este managed-bean es el que contiene el control para el resto de las funcionalidades
de nuestra aplicacion.En la capa de presentación veremos como los
componentes ICEfaces lanzan cada uno de los metodos dependiendo de la
accion realizada por el usuario.

Es importante a la hora de implemetar los distintos managed-bean saber los tipos de eventos que maneja JSF:

  • 1. Evento Action:Se produce al activarse el componente que implementa la interface
    ActionSource.Se trata de botones e hiperlinks.
  • 2. Evento Value-change:Se produce al cambiar el dato de un componente UIInput o sus
    subclases.Solo se lanza en caso de haber errores de validación,además el valor del atributo inmediate
    cambia su actuación.
  • 3. Evento Data-Model:Se produce al cambiar la columna seleccionada en un componente de
    tipo UIData.


También es importante saber como trata estos eventos:

  • 1.Implemtando una clase Listener que recoja los eventos y registrando esta en el
    componente que los produce mediante el tag actionListener o valueChangeListener.
  • 2. Implementando un metodo en los managed-bean que sea referenciado desde el componente con una expresion de
    metodo en el atributo apropiado de este.

8. Capa de Presentación.

Para la capa de presentación utilizaremos ICEfaces.Este framework basado en
JSF nos habilita un set de componentes de interfaz de usuario rico y potente.

En este caso en concreto utilizaremos distintos componentes como outputtext,inputtext,
datatable e inputfile.

Pantalla listado:

De esta página destacaremos:

  • Componente datatable

    • Atributo value:Sirve para indicar al componente el origen de los datos.
    • Atributo binding:Sirve pasa asociar el componente a una propiedad de managed-bean de edición con el fin de porder recuperar la fila seleccionada.
  • Componente commandButton
    • Atributo action:Indicamos el método que se ejecutará al pulsar y que devolverá la navegación de la aplicación.Las
      reglas de navegación las definiremos el el fichero faces-config.xml

Pantalla de edición:

De esta página destacaremos:

  • Componente inputFile

    • Atributo actionListener:Indicamos que método de control se ejecutará al pulsar el boton de upload
    • Atributo progressListener:Para indicar el método que gestiona la barra de progreso asociada

Para renderizar la barra de progreso utilizamos el componente outputProgress.

9. Configuracion de Hibernate y JSF.

Para configurar Hibernate debemos editar el fichero hibernate.cfg.xml


Mediante este fichero estamos indicando a Hibernate todo lo que necesita saber
para integrarse con base de datos.Cabe destacar la propiedad «hibernate.hbm2ddl.auto»
que sirve para que Hibernate cree la tablas al arrancar la aplicación.Opción muy recomendable en desarrollo.

También es importante como indicamos cual van a ser nuestras entidades persistentes
mediante mapping class.

Para la configuraciónn de JSF editamos el fichero faces-config.xml


En este fichero definimos nuestros managed-bean y las reglas de navegación de la aplicación.

10. Conclusiones.

Como conclusión podemos decir que los frameworks que hemos utilizado para construir nuestra
aplicación proporcionan una serie de facilidades que hacen que el desarrollo se lleve a cabo de una manera
coherente y estructurada.Además reduciremos el tiempo de desarrollo para la capa de persistencia gracias a Hibernate
,siendo esta facilmente mantenible,nos hemos servido de JSF para diferenciar claramente el control del negocio y nuestra presentación será
mucho mas flexible,dinámica y profesional.

Por lo tanto iniciarse en el uso de estas tegnologías es una opción muy recomendable a la hora de realizar desarrollos web.

Un saludo.

Saul

mailto:sgdiaz@autentia.com

2 Comentarios

  1. muy buen tutorial, pero incompleto, sin el código fuente, es complicado despejar dudas cuando se es principiante ante las tecnologías que allí se presentan, por favor, he visto muchos tutoriales, y todos bueno, pero sin el CÓDIGO FUENTE, no es muy claro tu objetivo, Gracias, por favor, si tu intención es colaborar y ayudar igual a la de todos, agreguen el código fuente, nuevamente, Gracias.

Dejar respuesta

Please enter your comment!
Please enter your name here