Mostrando entradas con la etiqueta netbeans. Mostrar todas las entradas
Mostrando entradas con la etiqueta netbeans. Mostrar todas las entradas

lunes, 29 de julio de 2013

JavaServer Faces y PrimeFaces utilizando Maven y NetBeans parte 2




A continuación vamos a crear un pequeño sitio que muestre las bondades de utilizar JavaServer Faces utilizando como complemento PrimeFaces, para hacer esto tomaré como base el siguiente post JavaServer Faces y Primefaces utilizando Maven y Netbeans. Una vez configurado JavaServer Faces y Primefaces realizaremos lo siguiente:

Dentro de la carpeta "Source Packages" crearemos un paquete llamado "mx.com.geeksjava.ejemplojsfpt2.model" dentro de este paquete crearemos la clase "Persona".

 package mx.com.geeksjava.ejemplojsfpt2.model;  
 import java.io.Serializable;  
 public class Persona implements Serializable{  
   private String nombre;  
   private String apellidoPaterno;  
   private String apellidoMaterno;  
   private Integer edad;  
   private Character sexo;  
   private String rfc;  
   public Persona() {  
   }  
   public Persona(String nombre, String apellidoPaterno, String apellidoMaterno, Integer edad, Character sexo, String rfc) {  
     this.nombre = nombre;  
     this.apellidoPaterno = apellidoPaterno;  
     this.apellidoMaterno = apellidoMaterno;  
     this.edad = edad;  
     this.sexo = sexo;  
     this.rfc = rfc;  
   }  
   public String getNombre() {  
     return nombre;  
   }  
   public void setNombre(String nombre) {  
     this.nombre = nombre;  
   }  
   public String getApellidoPaterno() {  
     return apellidoPaterno;  
   }  
   public void setApellidoPaterno(String apellidoPaterno) {  
     this.apellidoPaterno = apellidoPaterno;  
   }  
   public String getApellidoMaterno() {  
     return apellidoMaterno;  
   }  
   public void setApellidoMaterno(String apellidoMaterno) {  
     this.apellidoMaterno = apellidoMaterno;  
   }  
   public Integer getEdad() {  
     return edad;  
   }  
   public void setEdad(Integer edad) {  
     this.edad = edad;  
   }  
   public Character getSexo() {  
     return sexo;  
   }  
   public void setSexo(Character sexo) {  
     this.sexo = sexo;  
   }  
   public String getRfc() {  
     return rfc;  
   }  
   public void setRfc(String rfc) {  
     this.rfc = rfc;  
   }  
 }  

Ahora vamos a crear otro paquete dentro de "Source Packages" llamado "mx.com.geeksjava.ejemplojsfpt2.controller", dentro de este paquete vamos a hacer "click secundario -> New->Other->JavaServer Faces->JSF Managed Bean".


Hacemos click en "Next" en el campo "Class Name" colocamos "PersonaController" y en el campo "Scope" seleccionaremos "session".


Esto nos va a generar el código base para un controlador, este código lo modificaremos de tal modo que quede de la siguiente forma:


 package mx.com.geeksjava.ejemplojsfpt2.controller;  
 import java.io.Serializable;  
 import java.util.ArrayList;  
 import java.util.List;  
 import javax.annotation.PostConstruct;  
 import javax.faces.bean.ManagedBean;  
 import javax.faces.bean.SessionScoped;  
 import mx.com.geeksjava.ejemplojsfpt2.model.Persona;  
 @ManagedBean  
 @SessionScoped  
 public class PersonaController implements Serializable {  
   private List<Persona> personas;  
   private Persona persona;  
   @PostConstruct  
   public void inicializa(){  
     personas=new ArrayList<Persona>();  
     persona=new Persona();  
   }  
   public String guardar(){  
     personas.add(persona);  
     persona=new Persona();  
     return "index.faces";  
   }  
   public List<Persona> getPersonas() {  
     return personas;  
   }  
   public void setPersonas(List<Persona> personas) {  
     this.personas = personas;  
   }  
   public Persona getPersona() {  
     return persona;  
   }  
   public void setPersona(Persona persona) {  
     this.persona = persona;  
   }  
 }  

Nos dirigimos a la sección "Web Pages" hacemos "click secundario->New-Other-JavaServer Faces->Facelets Template" y hacemos click en "Next".


En el campo "File Name" colocamos "template-base", en "Folder" colocamos "resources", seleccionamos el "Layout Style" que se muestra en la imagen y hacemos click en "Finish".


Modificamos "template-base.xhtml".

 <?xml version='1.0' encoding='UTF-8' ?>   
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
 <html xmlns="http://www.w3.org/1999/xhtml"  
    xmlns:ui="http://java.sun.com/jsf/facelets"  
    xmlns:h="http://java.sun.com/jsf/html">  
   <h:head>  
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />  
     <h:outputStylesheet library="css" name="default.css"/>  
     <h:outputStylesheet library="css" name="cssLayout.css"/>  
      <title>Geeks Java México</title>  
   </h:head>  
   <h:body>  
     <div id="top" class="top">  
       <ui:insert name="top">Geeks Java México!</ui:insert>  
     </div>  
     <div>  
       <div id="left">  
         <ui:insert name="left">  
           <h:link outcome="index.faces" value="Inicio"/>            
         </ui:insert>  
       </div>  
       <div id="content" class="left_content">  
         <ui:insert name="content"></ui:insert>  
       </div>  
     </div>  
   </h:body>  
 </html>  


Con esto tendremos una plantilla para trabajar, esta plantilla puede ser aplicada para múltiples páginas de tal modo que no tengamos que reescribir el estilo que deseamos en el sistema. Una vez hecho esto hacemos "Click secundario en Web Pages->New->Other->JavaServer Faces->Facelets Template Client" y damos click en "Next".

Colocamos los siguientes campos "File Name = index" y en "Template" seleccionamos "Browse", seleccionamos "template-base.xhtml", hacemos click en "Select File" y presionamos "Finish".



Modificamos el archivo "index.xhtml".

 <?xml version='1.0' encoding='UTF-8' ?>  
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">  
 <html xmlns="http://www.w3.org/1999/xhtml"  
    xmlns:ui="http://java.sun.com/jsf/facelets"  
    xmlns:h="http://java.sun.com/jsf/html"  
    xmlns:p="http://primefaces.org/ui"  
    xmlns:f="http://java.sun.com/jsf/core">  
   <body>  
     <ui:composition template="./resources/template-base.xhtml">  
       <ui:define name="content">  
         <h:form>  <h1>Personas</h1><br/>
           <p:panelGrid columns="3">  
             <h:outputText value="Nombre"/>  
             <p:inputText id="nombre_p" required="true" value="#{personaController.persona.nombre}"/>  
             <p:message for="nombre_p"/>  
             <h:outputText value="Apellido Paterno"/>  
             <p:inputText id="appat_p" required="true" value="#{personaController.persona.apellidoPaterno}"/>  
             <p:message for="appat_p"/>  
             <h:outputText value="Apellido Materno"/>  
             <p:inputText id="apmat_p" value="#{personaController.persona.apellidoMaterno}"/>  
             <p:message for="apmat_p"/>  
             <h:outputText value="RFC"/>  
             <p:inputText id="rfc_p" required="true" maxlength="13" value="#{personaController.persona.rfc}"/>  
             <p:message for="rfc_p"/>  
             <h:outputText value="Edad"/>  
             <p:inputText id="edad_p" value="#{personaController.persona.edad}"/>  
             <p:message for="nombre_p"/>  
             <h:outputText value="Sexo"/>  
             <p:selectOneRadio id="sexo_p" required="true" value="#{personaController.persona.sexo}">  
               <f:selectItem itemLabel="Masculino" itemValue="m"/>  
               <f:selectItem itemLabel="Femenino" itemValue="f"/>  
             </p:selectOneRadio>  
             <p:message for="sexo_p"/>  
             <p:commandButton action="#{personaController.guardar()}" ajax="false" value="Guardar"/>  
           </p:panelGrid>  
         </h:form>  <br/>
         <p:dataTable id="tabla_personas" value="#{personaController.personas}" var="_persona" rowKey="#{_persona.rfc}"  
                paginator="true" rows="5">  
           <f:facet name="header">  
             <h:outputText value="Personas"/>  
           </f:facet>  
           <p:column headerText="Nombre Completo">  
             <h:outputText value="#{_persona.nombre} #{_persona.apellidoPaterno} #{_persona.apellidoMaterno}"/>  
           </p:column>  
           <p:column headerText="RFC">  
             <h:outputText value="#{_persona.rfc}"/>  
           </p:column>  
           <p:column headerText="Edad">  
             <h:outputText value="#{_persona.edad}"/>  
           </p:column>  
           <p:column headerText="Sexo">  
             <h:outputText value="#{_persona.sexo}"/>  
           </p:column>  
         </p:dataTable>  
       </ui:define>  
     </ui:composition>  
   </body>  
 </html>  

Hacemos click secundario en el nombre del proyecto y seleccionamos "Run".


Esperamos a que se despliegue la aplicación en nuestro navegador por defecto y el resultado.


Como pueden ver Si hacemos click en el botón "Guardar" y no llenamos de forma adecuada los campos aparecerán mensajes para realizarnos la notificación (Estos mensajes pueden ser modificados), podemos ver que tenemos una tabla de datos con paginación de 5 en 5 controlada por PrimeFaces (Es posible utilizar carga floja para la información) todo esto sin necesidad de utilizar JavaScript para realizar validaciones ni paginación.

El uso de JavaServer Faces es muy poderoso para la capa de presentación, más adelante presentaremos un Post en el cuál se detalle como combinar esto con Spring y Spring Data para almacenar la información.

Si tienen dudas o comentarios no duden en escribir en la sección de comentarios :)




--------->>>>>>>Autor: Alejandro Agapito Bautista
--------->>>>>>>>>>>>Oracle Certified Java Programer
--------->>>>>>>>>>>>Oracle Certified Web Components Developer
--------->>>>>>>>>>>>IBM Certified Academic Assosiate DB2.
--------->>>>>>>Twitter: @raidentrance
--------->>>>>>>Contacto:raidentrance@gmail.com

jueves, 18 de julio de 2013

JavaServer Faces y PrimeFaces utilizando Maven y NetBeans

A continuación crearemos un pequeño ejemplo que ejemplificará el uso de JavaServer Faces 2.1 y PrimeFaces 3.1.1 utilizando el IDE Netbeans 7.1.1.

Lo primero que vamos a hacer es crear un proyecto 

Creación de proyecto Maven

Colocamos los datos del proyecto para mi caso colocaré los que se muestran en la imagen:


Datos del proyecto

Oprimimos el botón de siguiente, seleccionamos Glassfish 3.x como servidor de aplicaciones y seleccionamos Finalizar.

Una vez que se crea el proyecto podemos ver la estructura del proyecto que tenemos:

    -Web Pages: En esta carpeta se guardarán los archivos referentes a las paginas de Internet, tales como JSP'S, JSF Pages,HTML, XHTML, entre otros, así como archivos de configuración de JSF y de la aplicación tales como : web.xml y faces-config.xml(en este momento no existen pero los crearemos más adelante) .

    -Source package: En esta carpeta crearemos todo el código Java que funcionará dentro de nuestra aplicación.

    -Dependencies: En esta carpeta podremos ver las dependencias incluidas dentro de nuestro proyecto, se puede ver que por default se incluye una dependencia llamada javaee-web-api-6.0.jar, esta dependencia contiene el api de JavaEE 6.

    -Java dependencies: En esta carpeta podremos obtener información sobre la versión de java que utilizaremos, en este caso voy a utilizar JDK 7.

    -Proyect Files: En este lugar se crearán los archivos del proyecto, aquí podremos encontrar el archivo clave para maven, este archivo es el POM.xml del cual hablaremos más adelante.



Una vez creado el proyecto vamos a dar click secundario al proyecto ->Properties->Frameworks->Add->JavaServer Faces.

En este lugar vamos a agregar la configuración para JavaServer Faces.

    -En la pestaña de Libraries vamos a dar click en Registred Libraries y seleccionaremos JSF 2.1.

    -En la pestaña de Configuración vamos a JSF Servlet URL Pattern escribiremos *.faces.

    -En la pestaña de Components podemos ver que aparece PrimeFaces, pero no lo seleccionaremos ya que la versión que aparece disponible es la versión 2.2.1 y nosotros utilizaremos la versión más reciente que es la 3.1.1.



Oprimimos Ok y veremos algunos cambios en el proyecto, el primero y el más importante es la creación de una carpeta dentro de Web Pages llamada WEB-INF y el archivo web.xml, este archivo es un archivo clave dentro de las aplicaciones web en java y es donde podremos ver la configuración de JSF, el segundo es la creación de la carpeta Other Sources, es aquí donde colocaremos archivo que utilizaremos dentro de nuestra aplicación tales como archivos .properties, el tercer cambio es la inclusión de las dependencias de JSF en la carpeta de dependencies y el cuarto es la creación de una pagina llamada index.xhtml, la cual es una página de ejemplo de JSF.Todos estos cambios los veremos a detalle.




1.-Archivo web.xml

Como ya lo mencionamos este archivo es el corazón de nuestra aplicación web y es en este lugar donde encontraremos la configuración de JavaServer Faces. Vamos a analizar a detalle   los puntos importantes de este archivo.

Lo primero que vamos a analizar son las siguientes líneas las cuales representan un parámetro que nos dice en que modo vamos a estar trabajando con JSF, en este momento podemos ver que esta en modo Development o Desarrollo, pero este puede tomar los valores: Production, Development, UnitTest, SystemTest y Extensión. Estos valores lo único que representan es el tipo de mensajes que veremos dentro de la aplicación.


 <context-param>
        <param-name>javax.faces.PROJECT_STAGE</param-name>
        <param-value>Development</param-value>
  </context-param>


La siguiente parte es la configuración del servlet de JavaServer Faces, a través del cual tienen que pasar todas las peticiones, en estas líneas lo que podemos ver es  que si se recibe una petición de un recurso cuya extensión sea .faces debe pasar por el Servlet llamado Faces Servlet cuya clase es  javax.faces.webapp.FacesServlet. Esto lo que nos indica es que cuando vallamos a referirnos dentro de la aplicación a una pagina hecha con JavaServer Faces debemos colocar la extensión .faces.

  <servlet>
        <servlet-name>Faces Servlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>Faces Servlet</servlet-name>
        <url-pattern>*.faces</url-pattern>
    </servlet-mapping>

Con esto tenemos la configuración de JSF.

2.-La carpeta de Other sources es el lugar donde colocaremos los archivos de configuración del proyecto, tales como archivos .xml o .properties.

3.-Las dependencias que aparecen en la carpeta de dependencies ya estan incluidas dentro de la dependencia javaee-web-api-6.0.jar, por tal motivo las podemos quitar de la aplicación dando click secundario sobre ella y oprimiendo el botón "Remove Dependency" esto se debe hacer en todas las dependencias menos en javaee-web-api-6.0.jar.



4.-La pagina index.jsp ya no será necesaria dentro de nuestra aplicación debido a que a partir de ahora vamos a utilizar archivos con extensión .xhtml llamados (Facelets) por tal motivo nos podemos sentir libres de borrar el archivo index.jsp. En la pagina index.xhtml es donde pondremos nuestro código JSF.


Con esto tenemos lista la configuración de JSF correctamente, hasta este momento nuestro proyecto se debe ver como se muestra en la siguiente imagen:


Como ya se mencionó antes con esto tenemos configurado JSF para poder trabajar con el, lo único que nos hace falta es la configuración de PrimeFaces para esto entraremos en la pagina de  http://primefaces.org/downloads.html  en la cual podremos encontrar las dependencias y el repositorio necesario para configurar PrimeFaces.

Lo primero que debemos hacer es copiar el repositorio que se encuentra en la pagina, este repositorio lo debemos de agregar al archivo de configuración pom,xml de nuestro proyecto. Para hacer esto dentro de la etiqueta <repositories>  agregaremos el repositorio de maven que copiamos de la pagina de primefaces.org, una vez hecho esto vamos a agregar dentro de nuestras dependencias la dependencia de PrimeFaces que vamos a descargar.

Repositorio de PrimeFaces:


<repository>  
    <id>prime-repo</id>  
    <name>PrimeFaces Maven Repository</name>  
    <url>http://repository.primefaces.org</url>  
    <layout>default</layout>  
</repository>  

Dependencia de PrimeFaces:



<dependency>  

    <groupId>org.primefaces</groupId>  

    <artifactId>primefaces</artifactId>  
    <version>3.3.1</version>  
</dependency>  

Una vez hecho esto nuestro proyecto se debe ver de la siguiente forma:

Una vez hecho esto damos click secundario al proyecto y seleccionamos la opción "Build with Dependencies" para descargar la dependenca de PrimeFaces. Una vez hecho esto nos iremos al archivo index.xhtml y agregaremos el namespace de primefaces, esto es agregar dentro de la etiqueta <html> el atributo xmlns:p="http://primefaces.org/ui", con esto estará configurado primefaces dentro de nuestra página utilizando el prefijo "p".Para probar que PrimeFaces fue configurado correctamente vamos a escribir dentro de la etiqueta body lo siguiente:

<p:calendar/>

Nuestro archivo index.xhtml debe quedar de la siguiente forma :

Listo esto nos iremos al nombre del proyecto, click secundario Run  y veamos PrimeFaces en acción :


Como podemos ver ya tenemos lista nuestra aplicación para trabajar con JSF 2.1 Primefaces 3.1.1 y Maven.

Coloco adjunto el proyecto en el siguiente archivo:  EjemploJSF.rar 

Gracias y espero sea de su utilidad.

--------->>>>>>>Autor: Alejandro Agapito Bautista
--------->>>>>>>>>>>>Oracle Certified Java Programer
--------->>>>>>>>>>>>Oracle Certified Web Components Developer
--------->>>>>>>>>>>>IBM Certified Academic Assosiate DB2.
--------->>>>>>>Twitter: @raidentrance
--------->>>>>>>Contacto:raidentrance@gmail.com