Cómo Crear un Proyecto JSF 2 con JEE 8 Paso a Paso [Guía Completa]

Cómo Crear un Proyecto JSF 2 con JEE 8 Paso a Paso [Guía Completa]

JavaServer Faces (JSF) es un framework de Java que se utiliza para construir interfaces de usuario basadas en web. Proporciona un modelo de programación basado en componentes, lo que permite a los desarrolladores construir aplicaciones web de manera más estructurada y eficiente. Algunas características de JSF 2 incluyen:

  • Componentes reutilizables: Facilita el uso de componentes de UI que se pueden reutilizar en diferentes partes de la aplicación.
  • Gestión del estado de la vista: Permite que el estado de la interfaz de usuario se mantenga entre las peticiones HTTP.
  • Soporte para AJAX: Permite interacciones más dinámicas sin necesidad de recargar toda la página.
  • Integración con otras tecnologías: Se puede combinar con otros frameworks y bibliotecas como CDI (Contexts and Dependency Injection) para mejorar la funcionalidad.

JEE 8 (Java Platform, Enterprise Edition 8) es una plataforma de programación que proporciona una API y un entorno de tiempo de ejecución para el desarrollo y ejecución de aplicaciones empresariales en Java. Algunas características de JEE 8 incluyen:

  • API de Java EE: Incluye APIs como JPA (Java Persistence API), EJB (Enterprise JavaBeans), JAX-RS (Java API for RESTful Web Services), entre otros.
  • Soporte para microservicios: Facilita la creación de aplicaciones distribuidas y basadas en microservicios.
  • Mejoras en la seguridad: Proporciona opciones de autenticación y autorización más robustas.
  • Facilidad de desarrollo: Mejora la productividad del desarrollador a través de herramientas y estándares.

Servidores de Aplicaciones Compatibles

Algunos servidores de aplicaciones que son compatibles con JSF 2 y JEE 8 incluyen:

  • Apache TomEE: Una versión de Tomcat que incluye soporte para Java EE.
  • WildFly: Anteriormente conocido como JBoss, es un servidor de aplicaciones ligero y flexible.
  • GlassFish: El servidor de referencia para Java EE, desarrollado inicialmente por Sun Microsystems.
  • Payara Server: Un fork de GlassFish que se enfoca en el soporte y la estabilidad.
  • IBM WebSphere Liberty: Un servidor de aplicaciones modular y ligero para Java EE.
  • Oracle WebLogic: Un servidor de aplicaciones comercial muy utilizado en entornos empresariales.

Estos servidores permiten a los desarrolladores implementar y ejecutar aplicaciones que utilizan tanto JSF 2 como JEE 8.

Crear Proyecto JSF2 con JEE8

Antes de comenzar, asegúrate de tener instalados los siguientes componentes:

  • JDK 1.8 o superior: Necesario para ejecutar Java EE 8.
  • Un servidor de aplicaciones: Como Apache Tomcat, WildFly o GlassFish.
  • Un IDE: Recomendamos Eclipse, IntelliJ IDEA o NetBeans para el desarrollo.

Para crear un proyecto web con Java utilizando JSF2 y Java EE8, asegurarte de que funcione tanto en servidores de aplicaciones Java EE  (como GlassFish, Payara, JBoss, WildFly )como en contenedores de servlets (como Tomcat o Jetty), es necesario ajustar las dependencias en función de los servidores.

Aquí te dejo una guía para crear el proyecto y las dependencias que necesitarías para cada tipo de servidor. 

1. Estructura del proyecto maven

El proyecto puede seguir la estructura básica de una aplicación web Java usando Maven. Crea un proyecto Maven con las siguientes configuraciones mínimas:

				
					/my-jsf-app
  ├── src
  │   ├── main
  │   │   ├── java
  │   │   ├── resources
  │   │   └── webapp
  │   │       ├── WEB-INF
  │   │       │   └── web.xml
  │   │       └── index.xhtml
  └── pom.xml

2. Configurar el archivo pom.xml

El archivo pom.xml gestionará las dependencias. Dependiendo del servidor de aplicaciones o contenedor de servlets, deberás incluir diferentes dependencias.

Para servidores de aplicaciones Java EE (GlassFish, Payara, JBoss, WildFly)

En servidores de aplicaciones Java EE completos, no necesitas incluir explícitamente todas las dependencias de Java EE, ya que estos servidores ya las proveen. Simplemente puedes definir la API de Java EE como una dependencia con un «scope» de provided.

Estos servidores (GlassFish, Payara, WildFly, JBoss) ya incluyen la implementación de JSF, así que las dependencias son mínimas.

Copiar 
<dependencies>
    <!-- Java EE 8 API -->
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>8.0</version>
        <scope>provided</scope>
    </dependency>
    
    <!-- JSF (No es necesario, ya que los servidores Java EE completos incluyen JSF 2) -->
    <!-- Opcional: Si deseas usar una versión específica de JSF puedes agregar esta dependencia -->
    <dependency>
        <groupId>javax.faces</groupId>
        <artifactId>javax.faces-api</artifactId>
        <version>2.3</version>
        <scope>provided</scope>
    </dependency>
</dependencies>

Para contenedores de servlets (Tomcat, Jetty, etc.)

En contenedores de servlets como Tomcat y Jetty, es necesario agregar explícitamente las dependencias para JSF, ya que estos servidores no son servidores Java EE completos y no incluyen todas las especificaciones de Java EE (como JSF) de forma predeterminada.

En este caso, debes incluir las implementaciones de JSF, ya que los contenedores de servlets como Tomcat o Jetty no las incluyen.

Copiar 
<dependencies>
    <!-- Java EE 8 API (Servlets y otros) -->
    <dependency>
        <groupId>javax</groupId>
        <artifactId>javaee-api</artifactId>
        <version>8.0</version>
        <scope>provided</scope>
    </dependency>

    <!-- JSF 2.3 (Implementación: Mojarra o MyFaces) -->
    <dependency>
        <groupId>org.glassfish</groupId>
        <artifactId>javax.faces</artifactId>
        <version>2.3.9</version>
    </dependency>
    
    <!-- Para Tomcat/Jetty también puedes usar MyFaces en lugar de Mojarra -->
    <!-- MyFaces -->
    <!--
    <dependency>
        <groupId>org.apache.myfaces.core</groupId>
        <artifactId>myfaces-api</artifactId>
        <version>2.3.10</version>
    </dependency>
    <dependency>
        <groupId>org.apache.myfaces.core</groupId>
        <artifactId>myfaces-impl</artifactId>
        <version>2.3.10</version>
    </dependency>
    -->
</dependencies>

3. Estructura del proyecto WEB

  • Coloca tus archivos JSF (páginas XHTML) en el directorio src/main/webapp/.
  • El archivo de configuración principal de JSF (si es necesario) será faces-config.xml, ubicado en src/main/webapp/WEB-INF/.
Configuración del archivo faces-config.xml:
 
Copiar 
<faces-config xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee 
    http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_3.xsd"
    version="2.3">
</faces-config>

Configuración del archivo web.xml:

El archivo web.xml será el descriptor de despliegue que conectará tu aplicación con JSF.

Copiar 
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
    http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
    version="3.1">

    <!-- Faces Servlet -->
    <servlet>
        <servlet-name>FacesServlet</servlet-name>
        <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <servlet-mapping>
        <servlet-name>FacesServlet</servlet-name>
        <url-pattern>*.xhtml</url-pattern>
    </servlet-mapping>

    <!-- Welcome file list -->
    <welcome-file-list>
        <welcome-file>index.xhtml</welcome-file>
    </welcome-file-list>

</web-app>

Configuración de la vista/pagina JSF index.xhtml:

Copiar 
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:h="http://xmlns.jcp.org/jsf/html"
      xmlns:ui="http://xmlns.jcp.org/jsf/facelets"
      xmlns:f="http://xmlns.jcp.org/jsf/core">
    <h:head>
        <title>Mi Proyecto JSF 2</title>
    </h:head>
    <h:body>
        <h1>Hola, Mundo!</h1>
    </h:body>
</html>

Configuración del persistence.xml:

Para configurar el motor de base de datos mediante JPA/HIBERNATE se utiliza Java Persistence Api en su version 2.1 en “src/main/resources/META-INF” 

Copiar 
<persistence version="2.1" 
            xmlns="http://xmlns.jcp.org/xml/ns/persistence" 
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
            xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
    <!-- Define Persistence Unit -->
    <persistence-unit name="CRUD_PU" transaction-type="JTA">
        <jta-data-source>java:/CrudJsfDS</jta-data-source>
        <exclude-unlisted-classes>false</exclude-unlisted-classes>
        <properties>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
        </properties>
    </persistence-unit>
</persistence>

Este proyecto funcionará tanto en servidores de aplicaciones Java EE completos como en contenedores de servlets al configurar las dependencias correctas para cada entorno.

Tutorial de Configuración

Conclusión

Dependiendo de la plataforma que elijas (Java EE application server o un contenedor de servlets), debes ajustar las dependencias en tu archivo pom.xml. Los servidores Java EE ya incluyen muchas de las librerías necesarias, mientras que en Tomcat o Jetty debes incluirlas manualmente.

¿Te ha gustado?, comparte en redes sociales
¿Te ha gustado?, comparte en redes sociales

WALTER ROSERO

Creador de Walter Rosero - SuperTecnoDroid | Responsable del Canal de YouTube Walter Rosero. Amante de la tecnología y juegos, me gusta aportar con un granito de arena al aprendizaje y la enseñanza. Soy editor y compositor en el área multimedia. Combino mi pasión por la enseñanza a través  de la World Wide Web.

Picture of WALTER ROSERO

WALTER ROSERO

Hola soy Robinson Rosero, me dedico a crear contenido por medio de la World Wide Web, para ayudar a las personas y así poder desarrollar experiencia con nuevas ideas.

Articulos Relacionados