Integra Spring Boot con Jakarta Server Faces mediante JoinFaces
Integrar Spring Boot con JSF (Jakarta Server Faces) puede ser una excelente opción para desarrolladores que buscan combinar lo mejor de ambos marcos de trabajo. Spring Boot es conocido por su simplicidad y productividad al crear aplicaciones Java empresariales, mientras que JSF es una potente tecnología para la construcción de interfaces de usuario en aplicaciones web. Al integrarlos, los desarrolladores pueden aprovechar las características de Spring Boot como su configuración automática, administración de dependencias y soporte para microservicios, mientras disfrutan de la estructura de componentes y el manejo de la vista que ofrece JSF. Esta combinación facilita el desarrollo de aplicaciones web robustas y escalables, manteniendo una arquitectura limpia y modular.
Sin embargo, antes de integrar ambos marcos, surgen varias preguntas que deben ser respondidas para garantizar una integración exitosa. ¿Es correcto usar Spring Boot y JSF? ¿Existen problemas de rendimiento o de compatibilidad entre las tecnologías que puedan afectar el rendimiento de la aplicación? Además, ¿Cómo se pueden manejar las transacciones de base de datos y la seguridad al integrar ambos marcos en un solo proyecto? Estas son algunas de las interrogantes clave que todo desarrollador debe considerar al implementar Spring Boot con JSF.
¿Es correcto usar Spring Boot y JSF?
Sí, es posible y correcto usar Spring Boot y JSF juntos, aunque no es la combinación más común. Spring Boot está más asociado con frameworks modernos como Thymeleaf o Spring MVC, pero frameworks como JoinFaces han hecho que la integración de Spring Boot con JSF sea más fluida.
¿Existen problemas de rendimiento o de compatibilidad entre las tecnologías que puedan afectar el rendimiento de la aplicación?
La integración de Spring Boot con JSF no debería presentar problemas de rendimiento graves si se configura adecuadamente. Sin embargo, es importante tener en cuenta que JSF puede ser más pesado que otros marcos de UI como Thymeleaf o JSP, especialmente cuando se manejan grandes cantidades de datos o peticiones. La compatibilidad no suele ser un problema importante, pero los desarrolladores deben estar al tanto de que tanto Spring como JSF gestionan los componentes y el estado de forma diferente, lo que puede requerir una configuración adicional o ajustes de rendimiento.
¿Cómo se pueden manejar las transacciones de base de datos y la seguridad al integrar ambos marcos en un solo proyecto?
En cuanto a las transacciones, Spring Boot ofrece un excelente soporte de transacciones mediante el uso de @Transactional, lo que facilita el manejo de la persistencia de datos. Si estás utilizando JSF con Spring Boot, puedes aprovechar este soporte de transacciones para asegurar la coherencia de los datos, incluso en un entorno JSF. En cuanto a la seguridad, Spring Security es una herramienta poderosa que se integra perfectamente con Spring Boot, y puede ser configurada para proteger las rutas y recursos tanto en el backend como en el frontend de JSF. Para una integración sin problemas, asegúrate de utilizar los filtros y configuraciones de seguridad adecuados para manejar tanto las autenticaciones como las autorizaciones dentro de tu aplicación web.
En resumen, integrar Spring Boot con JSF es completamente factible y puede ser una opción muy robusta para aplicaciones empresariales, siempre que se gestionen adecuadamente los ciclos de vida, configuraciones, y aspectos de seguridad y transacciones.
1. Crear Proyecto Spring Boot
La forma más sencilla de comenzar a utilizar Spring Boot es a través del inicializador Spring Boot que está disponible en https://start.spring.io/
- Asegúrate de utilizar Spring Boot en su versión 3 y seleccionar las dependencias que necesitas.
- Considera siempre la versión de Java a utilizar, como vemos en este caso el JDK 17 es la versión compatible desde ahora dejando a un lado la versión del JDK 8 y JDK 11.
A continuación, descargue el proyecto y descomprima en su ordenador con WinRAR. En la siguiente sección, le mostraremos cómo adaptar esta aplicación Spring Boot 3 para que se ejecute con JSF, PrimeFaces y OmniFaces usando JoinFaces.
2. Configurar el POM
A continuación, necesitamos aplicar algunos cambios en nuestro pom.xml.
Al integrar Spring Boot con JSF, es importante considerar las dependencias necesarias que puede encontrarlas en el sitio oficial de GitHub de JoinFaces.
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.joinfaces</groupId>
<artifactId>joinfaces-platform</artifactId>
<version>5.4.0</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<!-- JSF -->
<dependency>
<groupId>org.joinfaces</groupId>
<artifactId>faces-spring-boot-starter</artifactId>
</dependency>
<!-- PrimeFaces -->
<dependency>
<groupId>org.primefaces</groupId>
<artifactId>primefaces</artifactId>
<version>14.0.6</version>
<classifier>jakarta</classifier>
</dependency>
<!-- PrimeFlex -->
<dependency>
<groupId>org.webjars.npm</groupId>
<artifactId>primeflex</artifactId>
<version>3.3.1</version>
</dependency>
<!-- OmniFaces -->
<dependency>
<groupId>org.omnifaces</groupId>
<artifactId>omnifaces</artifactId>
<version>4.5.1</version>
</dependency>
<!-- otras dependencias -->
</dependencies>
3. Configurar algunas propiedades de la aplicación
Para que Spring Boot pueda ser desplegado con JSF, necesitas hacer unas configuraciones en el application.properties.
El propósito de esta configuración se debe a que anteriormente no usábamos el archivo web.xml para configurar el ambiente web de JSF y otras configuraciones, por ende, ahora con JoinFaces existen propiedades que nos simplifican este trabajo el cual puedes encontrar a detalle en la documentación de JoinFaces, en este caso te mostrare las propiedades principales a utilizar para correr tu proyecto.
# Puerto de despliegue
server.port=8090
# Conexion a base de datos mysql
spring.datasource.url=jdbc:mysql://localhost:3306/db_springboot_jsf?createDatabaseIfNotExist=true
spring.datasource.username=root
spring.datasource.password=
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
# Ajustes JSF
# Indicamos si el proyecto esta en modo desarrollo o produccion (development/production)
joinfaces.faces.project-stage=development
# Establece el nombre del servlet que manejará las peticiones
joinfaces.faces-servlet.name=FacesServlet
# Esta propiedad define los patrones de URL o las extensiones a leerse
joinfaces.faces-servlet.url-mappings=*.jsf,*.xhtml
# Define el estado de los datos en la vista si en "server" o "client".
joinfaces.faces.state-saving-method=server
# Valida los campos nulos en true de los formularios
joinfaces.faces.validate-empty-fields=true
## Ajustes PrimeFaces
# Tema (por default es el tema de saga, tema oscuro es vela)
joinfaces.primefaces.theme=saga
## Ajustes OmniFaces
# Indica que leera todas las rutas de las vistas para ejecutarlas sin la extension .xhtml o cualquier otra utilizadas
joinfaces.omnifaces.faces-views-scan-paths=/
# Activa siempre el escaneo
joinfaces.omnifaces.faces-views-scanned-views-always-extensionless=true4. Estructura del Proyecto
Cuando trabajas con JoinFaces en una aplicación web, la estructura de paquetes y archivos debe estar bien organizada para aprovechar tanto las convenciones de Spring Boot como las características de JSF. Aquí te presento una estructura sugerida para un proyecto JoinFaces:
src/
└── main/
├── java/
│ └── com.example.myapp/ <-- Paquete base
│ ├── config/ <-- Configuración del proyecto
│ │ └── AppConfig.java
│ ├── controller/ <-- Managed beans / controladores JSF
│ │ ├── UserController.java
│ │ └── ProductController.java
│ ├── model/ <-- Entidades JPA
│ │ ├── User.java
│ │ └── Product.java
│ ├── repository/ <-- Repositorios JPA
│ │ ├── UserRepository.java
│ │ └── ProductRepository.java
│ ├── service/ <-- Servicios (lógica de negocio)
│ │ ├── UserService.java
│ │ └── ProductService.java
│ └── Application.java <-- Clase principal de Spring Boot
└── resources/
├── META-INF/
│ └── resources/ <-- Archivos estáticos y páginas JSF
│ ├── templates/ <-- Plantillas comunes (ej. layouts.xhtml)
│ ├── views/ <-- Vistas JSF (ej. login.xhtml, home.xhtml)
│ └── resources/
│ ├── css/ <-- Archivos CSS personalizados
│ ├── js/ <-- Archivos JS personalizados
│ └── images/ <-- Imágenes
├── application.properties <-- Configuración de Spring Boot
└── logback-spring.xml <-- Configuración de logs (opcional)
Configuración de la vista/pagina JSF index.xhtml:
El desarrollo de aplicaciones con Jakarta Server Faces junto a Spring Boot viene con unos cambios en la estructura, anteriormente se guardaba dentro de una carpeta llamada webapp ahora se guarda en en “src/main/resources/META-INF/resources/” .
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:faces="jakarta.faces"
xmlns:ui="jakarta.faces.facelets"
xmlns:f="jakarta.faces.core"
xmlns:h="jakarta.faces.html"
xmlns:pt="jakarta.faces.passthrough"
xmlns:cc="jakarta.faces.composite"
xmlns:c="jakarta.tags.core"
xmlns:fn="jakarta.tags.functions">
<h:head>
<title>Mi Proyecto JSF 3</title>
</h:head>
<h:body>
<h1>Hola, Mundo!</h1>
</h:body>
</html>Conclusión
En este tutorial, hemos alcanzado el objetivo de integrar Spring Boot con JSF, demostrando cómo utilizar los poderosos componentes web de JSF para desarrollar rápidamente aplicaciones web dentro de un entorno Spring Boot. Este artículo está dirigido tanto a quienes provienen del mundo de JSF y están comenzando a explorar Spring Boot, como a aquellos con experiencia que desean integrar ambas tecnologías en sus proyectos actuales.
Aunque JSF enfrenta competencia de frameworks de JavaScript como React, Vue y Angular, que ofrecen soluciones similares para el desarrollo web, es importante recordar que tanto JSF como estos frameworks requieren conocimientos de HTML, CSS y JavaScript. Si bien la curva de aprendizaje de los frameworks de JavaScript modernos puede ser empinada y consumir más tiempo en comparación con JSF, la integración de Spring Boot y JSF puede ser una excelente opción para proyectos que ya utilizan estas tecnologías o que buscan una solución rápida y eficiente.
Si bien no es el objetivo de este tutorial hacer una comparación directa entre JSF y otros frameworks MVC modernos, es relevante señalar que muchos desarrolladores optan por tecnologías más recientes debido a su modularidad, independencia y enfoque en el desarrollo ágil. Para proyectos pequeños, puede ser más práctico considerar alternativas modernas. Sin embargo, para quienes ya están familiarizados con JSF y necesitan una solución rápida y eficaz en su entorno de Spring Boot, esta integración puede ser una opción valiosa.
Tutorial de Configuración
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.
