Guía 2026: 40 Preguntas y Respuestas Expertas de Entrevista JSF

¿Preparándose para una entrevista de JavaServer Faces (JSF)? Esta guía presenta las preguntas más desafiantes que evalúan tanto profundidad conceptual como experiencia práctica. Ya sea un recién graduado, un ingeniero experimentado o un arquitecto senior, estos escenarios le ayudarán a articular mejores prácticas y resolver problemas del mundo real.

Descargue una versión PDF gratuita de las preguntas: Preguntas y Respuestas de Entrevista JSF

1) ¿Qué es JSF y cuáles son sus principales beneficios y características?

JSF es un framework basado en componentes del lado servidor que simplifica el desarrollo de UI para aplicaciones Java EE/Jakarta EE. Ofrece un rico conjunto de componentes reutilizables, un modelo dirigido por eventos y enlace declarativo a beans del lado servidor.

• Separación clara de presentación y lógica de negocio vía backing/managed beans.
• Componentes con estado que persisten entre peticiones.
• Validación, conversión y manejo de eventos integrados.
• Internacionalización y renderizado agnóstico de dispositivo.
• Arquitectura extensible que integra librerías de terceros.

Ejemplo: Un formulario con <h:inputText> y <h:commandButton> puede enlazar a una propiedad de bean y disparar un método del lado servidor sin parsing manual.

2) ¿Cómo funciona la arquitectura de JSF (componente, renderizado, evento, validación) por debajo?

• Componentes UI y Árbol de Componentes: Cada vista es un árbol de objetos UIComponent.
• Render Kit y Renderers: Lógica de renderizado separada que traduce componentes a marcado cliente.
• Conversión y Validación: Conversión automática de tipos y validadores integrados ejecutados antes de actualización del modelo.
• Modelo de Eventos y Listeners: Componentes disparan eventos (acción, cambio de valor) manejados por listeners del lado servidor.
• Gestión del Ciclo de Vida: JSF orquesta navegación y fases petición-respuesta.

Este diseño modular mantiene la lógica UI consistente entre páginas mientras permite personalización.

3) ¿Cuáles son las fases del ciclo de vida de JSF y qué ocurre en cada una?

Fase	Descripción
Restore View	Construir o restaurar el árbol de componentes.
Apply Request Values	Poblar componentes con parámetros enviados.
Process Validations	Ejecutar convertidores y validadores; detener si hay errores.
Update Model Values	Transferir datos validados a backing beans.
Invoke Application	Ejecutar lógica de negocio, action listeners, navegación.
Render Response	Generar marcado cliente vía renderers.

Entender el ciclo de vida es crítico para sincronizar validación, navegación y actualizaciones de estado.

4) ¿Qué es un Managed Bean (o Backing Bean) en JSF y cómo se configura?

Un managed bean es un POJO que almacena datos de UI y procesa interacciones del usuario. La configuración puede ser:

• Basada en anotaciones – @ManagedBean + anotaciones de scope.
• Basada en XML – Declaraciones en faces-config.xml.

Los backing beans actúan como modelo y controlador, manteniendo páginas UI limpias y testeables.

5) ¿Qué son Facelets y por qué se prefiere sobre JSP en aplicaciones JSF?

Facelets es la tecnología de vista por defecto en JSF 2.x. Construye el árbol de componentes directamente, soporta plantillas (<ui:include>), componentes compuestos e integra perfectamente con el motor de renderizado JSF.

Comparado con JSP, Facelets elimina conflictos de ciclo de vida, reduce código repetitivo y promueve reutilización.

6) ¿Cómo difiere JSF de aplicaciones web tradicionales basadas en JSP/Servlet o de otros frameworks como Struts?

• Centrado en componentes vs. centrado en página/acción.
• UI con estado y manejo de eventos integrado.
• Conversión/validación automática.
• Plantillas potentes vía Facelets.

Estas distinciones hacen a JSF ideal para interfaces complejas y con estado.

7) ¿Cuáles son los diferentes scopes de bean soportados por JSF y cómo influyen en el comportamiento de la aplicación?

• Request – Vida corta, por petición HTTP.
• View – Persiste entre postbacks dentro de la misma vista.
• Session – Datos específicos de usuario a través de múltiples vistas.
• Application – Compartido entre todos los usuarios.
• None – Beans sin estado para escenarios altamente escalables.

Elegir el scope correcto previene fugas de memoria y asegura gestión de estado correcta.

8) ¿Cómo se renderizan los componentes JSF al cliente (navegador)? Explique el modelo de renderizado.

Cada UIComponent delega renderizado a un Renderer del RenderKit activo. Los renderers convierten el estado del componente en HTML, JavaScript u otros formatos, permitiendo una clara separación entre lógica de componente y presentación.

9) ¿Qué tipos de expresiones soporta Expression Language (EL) de JSF y cuál es la diferencia entre expresiones de valor y de método?

• Expresiones de Valor – #{…} para obtener/establecer propiedades de bean.
• Expresiones de Método – #{…} que invocan métodos de bean, típicamente en manejadores de eventos.

Las expresiones de valor se evalúan durante renderizado y envío, mientras que las de método se disparan por eventos UI específicos.

10) ¿Qué son las librerías de tags estándar de JSF y cómo apoyan el desarrollo UI?

• Core – tags como <f:ajax>, <f:validate…>, <f:metadata>.
• HTML Render Kit – tags para componentes UI: <h:inputText>, <h:commandButton>, <h:dataTable>, etc.

Estas librerías permiten desarrollo UI declarativo e integración con librerías de componentes de terceros.

11) ¿Qué implementaciones JSF existen y cuáles son sus principales diferencias?

Implementación	Descripción	Características Clave
Mojarra	Implementación de referencia por Eclipse/Oracle.	Cumplimiento completo, acceso temprano a features.
Apache MyFaces	Impulsada por comunidad, modular (Core, Tomahawk, Tobago).	Extensibilidad, soporte componentes personalizados.

12) ¿Cómo soporta JSF AJAX y cuáles son las diferentes formas de usarlo?

• Incrustar <f:ajax> en componentes para peticiones asíncronas.
• Usar librerías de terceros (PrimeFaces, RichFaces, ICEfaces) para widgets UI avanzados.
• AjaxBehavior programático para interacciones dinámicas.

AJAX reduce recargas completas de página, mejora capacidad de respuesta y ahorra ancho de banda.

13) ¿Qué son convertidores y validadores en JSF? Explique tipos y uso.

• Convertidores – Transforman strings de UI a objetos de modelo (ej. fecha, número). Integrados y personalizados.
• Validadores – Cumplen restricciones (longitud, rango, regex). Integrados y personalizados vía javax.faces.validator.Validator.

14) ¿Qué son componentes compuestos en JSF y cómo se usan?

Los componentes compuestos permiten a desarrolladores empaquetar fragmentos UI reutilizables en Facelets sin renderers personalizados. Exponen atributos, soportan validación, conversión y AJAX, e integran totalmente con el ciclo de vida JSF.

15) ¿Cómo se maneja la navegación en JSF?

• Navegación implícita – retornar string con nombre de vista.
• Reglas explícitas – entradas navigation-case en faces-config.xml.
• Navegación dinámica – uso programático de NavigationHandler.

16) ¿Cuáles son desventajas comunes de JSF y cómo mitigarlas?

Desventaja	Mitigación
Curva de aprendizaje pronunciada	Usar librerías de componentes modernas (PrimeFaces) y entrenamiento modular.
Estado en lado servidor	Habilitar guardado de estado parcial y vistas sin estado donde sea posible.
Complejidad de depuración	Aprovechar logging JSF, página debug Facelets e integración IDE.
Salida HTML verbosa	Emplear plantillas ligeras y renderizado AJAX.

17) ¿Cómo puede JSF integrarse con otras tecnologías Java EE o Jakarta EE como CDI, EJB y JPA?

• Reemplazar @ManagedBean con beans CDI @Named.
• Inyectar EJBs vía @EJB o CDI.
• Persistir datos con entidades JPA accedidas a través de servicios CDI.

18) ¿Cuál es la diferencia entre @ManagedBean y la anotación @Named de CDI?

Aspecto	@ManagedBean	@Named
Paquete	javax.faces.bean	javax.inject
Scope	Scopes JSF (Request, Session, etc.)	Scopes CDI (Request, Session, View, etc.)
Soporte DI	Limitado	Inyección CDI completa, qualifiers
Preferido desde	JSF 2.0	Jakarta EE 8+

Preferir CDI (@Named) para aplicaciones modernas por gestión de dependencias unificada.

19) ¿Cómo implementar internacionalización (i18n) en aplicaciones JSF?

1. Crear resource bundles (ej. messages_en.properties, messages_fr.properties).
2. Registrar bundles en faces-config.xml.
3. Usar expresiones EL como #{msg.greeting} en Facelets.
4. Cambiar locale dinámicamente vía FacesContext.getCurrentInstance().getViewRoot().setLocale(new Locale("fr")).

20) ¿Cuáles son mejores prácticas para construir aplicaciones JSF seguras y mantenibles?

• Seguir MVC: UI en JSF, lógica de negocio en CDI/EJB, persistencia en JPA.
• Validar entradas en lado servidor; escapar salidas.
• Usar protección CSRF (javax.faces.ViewState) y HTTPS.
• Mantener objetos grandes fuera de scope de sesión.
• Configurar páginas de error personalizadas y manejadores de excepción.

21) ¿Qué es PrimeFaces y cómo mejora aplicaciones JSF?

PrimeFaces es una popular librería open-source de componentes UI que añade más de 100 widgets ricos, AJAX integrado y temas responsivos, reduciendo drásticamente código repetitivo y mejorando experiencia de usuario.

22) ¿Cuál es la diferencia entre PrimeFaces, RichFaces e ICEfaces?

Feature	PrimeFaces	RichFaces	ICEfaces
Mantenimiento	Activo	Descontinuado	Parcial
Soporte AJAX	Integrado <p:ajax>	<a4j:ajax>	Push-based AJAX
Uso Recomendado	UI JSF Moderna	Sistemas Legacy	Apps Tiempo Real

23) ¿Cómo optimizar rendimiento de aplicaciones JSF?

• Habilitar guardado de estado parcial (javax.faces.PARTIAL_STATE_SAVING=true).
• Preferir beans @ViewScoped o @RequestScoped.
• Usar AJAX para actualizaciones parciales.
• Cachear recursos estáticos y consultas BD.
• Evitar anidamiento profundo de componentes.
• Aprovechar carga perezosa para data tables.

24) ¿Cómo personalizar el ciclo de vida JSF para necesidades de procesamiento especiales?

Implementar PhaseListener para engancharse en cualquier fase del ciclo de vida, permitiendo logging, chequeos de seguridad o lógica de navegación personalizada.

25) ¿Cómo puede JSF interactuar con servicios web RESTful?

Usar API Cliente JAX-RS o clientes HTTP externos (ej. HttpClient) para consumir endpoints REST, y exponer servicios REST vía clases anotadas @Path junto a vistas JSF.

26) ¿Cómo asegurar aplicaciones JSF contra vulnerabilidades web comunes?

Amenaza	Mitigación
XSS	Escapado automático EL; evitar HTML crudo.
CSRF	JSF ViewState; establecer STATE_SAVING_METHOD.
Fijación de sesión	Regenerar ID de sesión tras login.
Inyección	Validar entrada; usar consultas parametrizadas JPA.
Clickjacking	Establecer header X-Frame-Options: DENY.

27) ¿Cómo manejar gestión de excepciones y páginas de error en JSF?

• Definir entradas <error-page> en web.xml.
• Implementar ExceptionHandler personalizado para centralizar logging y redirecciones.

28) ¿Cómo integrar JSF con Spring Framework?

• Registrar ContextLoaderListener de Spring.
• Inyectar beans Spring en JSF vía @ManagedProperty o CDI @Autowired.
• Preferir CDI con Spring Boot para configuración más limpia.

29) ¿Qué son los view parameters en JSF y cómo difieren de request parameters?

• f:viewParam enlaza valores de query string a propiedades de bean con conversión y validación automática.
• Los request parameters son parámetros HTTP genéricos requiriendo manejo manual.
• Los view parameters integran con el ciclo de vida JSF, permitiendo gestión de estado consistente.

30) ¿Cuáles son técnicas avanzadas para depurar aplicaciones JSF?

• Habilitar javax.faces.PROJECT_STAGE=Development para salida verbosa.
• Usar PhaseListener para loggear fases del ciclo de vida.
• Aprovechar página debug Facelets (?faces-redirect=true o ?trace=true).
• Poner breakpoints en IDE en managed beans, convertidores o validadores.
• Utilizar add-ons de navegador (PrimeFaces Inspector) y herramientas de profiling de servidor.

31) ¿Cuáles son los cambios mayores en JSF 3.x comparado con JSF 2.x?

Área	JSF 2.x	JSF 3.x (Jakarta Faces)
Namespace	javax.faces.*	jakarta.faces.*
Inyección de Dependencias	ManagedBean + CDI opcional	Integración CDI completa; @ManagedBean deprecado
Seguridad	Libs externas	Jakarta Security integrado

32) ¿Cómo migrar una aplicación JSF 2.x existente a Jakarta Faces 3.x?

1. Actualizar dependencias Maven/Gradle a jakarta.faces-api 3.x.
2. Refactorizar imports de javax.* a jakarta.* (herramientas refactor IDE recomendadas).
3. Reemplazar @ManagedBean con CDI @Named y scopes.
4. Verificar funcionalidad de componente, convertidor, validador y navegación.
5. Desplegar en servidor compatible Jakarta EE (Payara 6, WildFly 27, TomEE 9).

33) ¿Cuál es el rol de CDI en aplicaciones JSF modernas?

• Gestión de ciclo de vida y contexto de bean (scopes, eventos).
• Inyección de servicios, EJBs y recursos.
• Interceptores y decoradores para preocupaciones transversales.
• Comunicación dirigida por eventos vía eventos CDI.

34) ¿Qué son eventos CDI y cómo se usan en aplicaciones JSF?

Los eventos CDI permiten acoplamiento débil: un bean productor dispara un evento, y cualquier bean observador reacciona, permitiendo features modulares como logging de auditoría o notificaciones por email.

35) ¿Cómo adaptar aplicaciones JSF a arquitecturas de microservicios?

• JSF como gateway frontal comunicándose con APIs REST.
• Patrón Backend-for-Front-end (BFF) para UIs específicas por rol.
• Beans @ViewScoped sin estado y back-ends RESTful.
• Integración con Jakarta MicroProfile para configuración y métricas.

36) ¿Cómo desplegar JSF en entorno containerizado (Docker/Kubernetes)?

1. Crear Dockerfile basado en servidor Jakarta EE (ej. Payara 6).
2. Copiar WAR al directorio de despliegue.
3. Construir y ejecutar contenedor; exponer puerto 8080.
4. Desplegar a Kubernetes vía manifiesto Deployment y Service.

37) ¿Cuál es la diferencia entre @ViewScoped de JSF y @ViewScoped de CDI?

Aspecto	javax.faces.bean.ViewScoped	jakarta.faces.view.ViewScoped (CDI)
Introducido En	JSF 2.0	JSF 2.3+
Contexto Base	JSF Managed Beans	Contextos CDI
Requisito Serializable	Opcional	Obligatorio
Soporte Inyección	Limitado	Inyección CDI completa

38) ¿Cómo pueden aplicaciones JSF consumir y exponer endpoints REST?

Usar API Cliente JAX-RS para llamar servicios externos, y exponer endpoints REST internos vía clases anotadas @Path, permitiendo una sola aplicación servir tanto consumidores UI como API.

39) ¿Qué tendencias futuras o alternativas pueden influir en desarrollo JSF?

• Evolución Jakarta Faces con integración CDI más profunda.
• Integración MicroProfile para features cloud-native.
• Front-ends híbridos (JSF + React/Angular).
• Modelos de despliegue serverless.
• Ejecutar JSF en Quarkus con MyFaces Core para arranques de baja memoria.

40) ¿Cuáles son las principales diferencias entre JSF y frameworks web Java más nuevos (ej. Vaadin, Spring MVC, Quarkus)?

Framework	Arquitectura	Modelo Renderizado	Fortalezas	Caso de Uso
JSF (Jakarta Faces)	Basado en componentes, lado servidor	Renderizado HTML vía RenderKit	Maduro, integración CDI, UI empresarial	Apps web complejas con UI rica
Spring MVC	Centrado en acción, MVC	JSP/Thymeleaf	Ligero, friendly para microservicios	Servicios RESTful, apps MVC simples
Vaadin	Basado en componentes, híbrido servidor/cliente	Java + TypeScript	UI moderna, dashboards ricos	Paneles admin, interfaces intensivas en datos
Quarkus + Qute	Reactivo, cloud-native	Basado en plantillas	Arranque rápido, baja memoria	Microservicios, serverless

Top Preguntas de Entrevista JSF con Escenarios Reales y Respuestas Estratégicas

A continuación 10 preguntas realistas de entrevista JSF, cada una incluyendo una respuesta modelo que demuestra pericia, contexto y experiencia práctica. Las frases "En mi rol anterior", "En una posición previa", "En mi trabajo anterior" y "En mi último rol" aparecen solo una vez cada una.

1) ¿Puede explicar el ciclo de vida de petición JSF y por qué entenderlo es importante?

Respuesta: El ciclo de vida —Restore View, Apply Request Values, Process Validations, Update Model Values, Invoke Application, Render Response— dicta cuándo los datos se convierten, validan y renderizan. Conocerlo ayuda a identificar errores de validación, optimizar navegación y depurar manejo de eventos.

2) ¿Cómo gestiona estado en aplicaciones JSF?

Respuesta: Elegir guardado de estado en lado servidor para seguridad y persistencia de sesión, o en lado cliente para escalabilidad. El guardado de estado parcial reduce payload, y vistas sin estado son ideales para diseños RESTful.

3) Describa una situación donde optimizó una página JSF lenta. ¿Qué pasos tomó?

Respuesta: En mi rol anterior, refactoricé una tabla fuertemente anidada, introduje carga perezosa de datos y moví consultas costosas a un EJB en segundo plano. El tiempo de carga de página cayó de 12 s a 3 s.

4) ¿Cómo maneja validación de formularios en JSF?

Respuesta: Uso validadores integrados para chequeos comunes, y creo validadores personalizados para reglas de negocio. Todas las validaciones corren en lado servidor antes de actualización del modelo, asegurando integridad de datos.

5) Cuéntenme sobre un conflicto que encontró trabajando en equipo en un proyecto JSF. ¿Cómo lo resolvió?

Respuesta: En una posición previa, los equipos de front-end y back-end discreparon sobre responsabilidades de componentes. Organicé una revisión conjunta, definí propiedad clara y establecí un documento de diseño compartido, lo que resolvió la fricción.

6) ¿Cuál es el propósito de los managed beans en JSF y cómo afectan los scopes a su comportamiento?

Respuesta: Los managed beans conectan componentes UI a lógica de negocio. Los scopes (Request, View, Session, Application) determinan la vida del bean y afectan uso de memoria y consistencia de estado.

7) Describa cómo migraría una aplicación JSF antigua a una plataforma Java EE o Jakarta EE moderna.

Respuesta: Evaluaría dependencias, actualizaría a namespace Jakarta, reemplazaría @ManagedBean con CDI @Named, ajustaría scopes y testearía cada módulo en el nuevo entorno de servidor.

8) ¿Puede dar un ejemplo de cómo usó Facelets para mejorar mantenibilidad?

Respuesta: En mi trabajo anterior, extraí header, footer y navegación a una plantilla Facelets. Todas las páginas ahora referencian una sola plantilla, reduciendo duplicación y acelerando cambios de UI.

9) ¿Cómo respondería si una aplicación JSF en producción empezara a lanzar errores de view state repentinamente?

Respuesta: Primero verifico el método de guardado de estado, luego examino replicación de sesión e IDs de componente. Analizo logs para identificar causa raíz, y aplico rollback o parche.

10) Cuéntenme sobre una vez que tuvo que aprender una tecnología relacionada con JSF rápido. ¿Cómo lo abordó?

Respuesta: En mi último rol, tuve que dominar PrimeFaces para un nuevo dashboard. Leí la guía oficial, construí un prototipo, experimenté con manejo de eventos y luego entregué un componente listo para producción en semanas.