Jakarta Faces

Developments

Facelets (which was designed specifically for Java Server Faces) was adopted as the official view technology for JSF 2.0. This eliminates the life-cycle conflicts that existed with JSP, forcing workarounds by Java developers.^[7]

The new JSF developments also provide wide accessibility to Java annotations such as @ManagedBean, @ManagedProperty and @FacesComponent that removes the need for faces-config.xml, in all cases except framework extension. Navigation is also simplified, removing the need for faces-config.xml navigation cases. Page transitions can be invoked simply by passing the name of the desired View or Facelet.^{[citation needed]}

The addition of Partial State Saving and Document Object Model (DOM) updates are part of the built-in standardized AJAX support.^{[citation needed]}

The latest JSF release has built-in support for handling resources like images, CSS and Javascript, allowing artifacts to be included with component libraries, separated into JAR files, or simply co-located into a consistent place within the Web application. This includes logical naming and versioning of resources.^{[citation needed]}

JSF 2.0 also includes a number of other changes like adding support for events, separate development, staging, and production modes, similar to RAILS_ENV in Ruby on Rails, and significantly expanding the standard set of components.^{[citation needed]}

Update history

• JSF 4.1^[8] (2025-07-01) – Jakarta EE 11– Aligned Update: Removes remaining SecurityManager references, improves CDI alignment, modernizes APIs with missing generics, adds UUIDConverter and flow injection support, enhances lifecycle events for built-in scopes, and includes multiple spec clarifications and small functional enhancements.
• JSF 4.0 (2022-05-15) – Major features: Deleted some deprecated things (native managed beans, native EL references), no extended view by default, added ClientWindowScoped
• JSF 3.0.0 (2020-10-28) – Package name changed from Javax to Jakarta.
• JSF 2.3 (2019-09-10) – The first release of the Jakarta Server Pages API for Jakarta EE.Neither the API nor the behavior has changed.
• JSF 2.3 (2017-03-28) – Major features: search Expressions, extensionless URLs, bean validation for complete classes, push communication using WebSocket, enhanced integration with CDI.^[9]
• JSF 2.2 (2013-05-21) – Introduced new concepts like stateless views, page flow and the ability to create portable resource contracts.^[10]
• JSF 2.1 (2010-11-22) – Maintenance release 2 of JSF 2.0. Only a very minor number of specification changes.^[11][12]
• JSF 2.0 (2009-07-01) – Major release for ease of use, enhanced functionality, and performance. Coincides with Java EE 6.
• JSF 1.2 (2006-05-11) – Many improvements to core systems and APIs. Coincides with Java EE 5. Initial adoption into Java EE.
• JSF 1.1 (2004-05-27) – Bug-fix release. No specification changes.
• JSF 1.0 (2004-03-11) – Initial specification released.

JSF and AJAX

Mojarra
Other names	JSF RI
Original author	Sun Microsystems
Developer	Eclipse Foundation
Release	March 3, 2004; 22 years ago (2004-03-03)
Stable release	4.1.16[13]  / 5 September 2026; 3 days ago (5 September 2026)
Written in	Java
Platform	Jakarta EE
Type	web framework
License	EPL-2.0
Website	eclipse-ee4j.github.io/mojarra/
Repository	github.com/eclipse-ee4j/mojarra

JSF is often used together with AJAX, a Rich Internet application development technique. AJAX is a combination of web development techniques and technologies that make it possible to create rich user interfaces. The user interface components in Mojarra (the JSF reference implementation^[14]) and Apache MyFaces were originally developed for HTML only, and AJAX had to be added via JavaScript. This has changed, however:

Because JSF supports multiple output formats, AJAX-enabled components can easily be added to improve user interfaces created with JSF. The JSF 2.0 specification provides built-in support for AJAX by standardizing the AJAX request lifecycle and providing simple development interfaces to AJAX events. The specification allows an event triggered by the client to go through validation, conversion, and method invocation, before returning the result to the browser via an XML DOM update.^{[citation needed]}

JSF 2 includes support for graceful degradation when JavaScript is disabled in the browser.^{[citation needed]}

ThoughtWorks, 2014

In their January 2014 Technology Radar publication, ThoughtWorks wrote:^[15]

We continue to see teams run into trouble using JSF – JavaServer Faces – and are recommending you avoid this technology. Teams seem to choose JSF because it is a JEE standard without really evaluating whether the programming model suits them. We think JSF is flawed because it tries to abstract away HTML, CSS and HTTP, exactly the reverse of what modern web frameworks do. JSF, like ASP.NET webforms, attempts to create statefulness on top of the stateless protocol HTTP and ends up causing a whole host of problems involving shared server-side state. We are aware of the improvements in JSF 2.0, but think the model is fundamentally broken. We recommend teams use simple frameworks and embrace and understand web technologies including HTTP, HTML and CSS.

DZone, 2014

In the article published November 2014 in the DZone website, titled "Why You Should Avoid JSF", Jens Schauder wrote:^[17]

Facelets, the preferred presentation technology of JSF looks at first sight like an ordinary templating technology like the good old JSP or Thymeleaf. But if you look closer the horror becomes obvious. In the same place where you structure your HTML, you also place the logic what parts of the UI should get updated on an action. A clear violation of the separation of concerns principle in my book. Even better is the immediate attribute which changes the server side life cycle! And if this isn't enough it does it in different ways depending on what tag you use it on. You can't make stuff like this up.

TheServerSide, 2016

In February 2016, the enterprise Java community website TheServerSide published an article recommending against the use of JSF, whose use could compromise the quality of the final product. The article ellaborated on five reasons:^[18]

1. Simple tasks become difficult;
2. JSF lacks flexibility;
3. The learning curve is steep;
4. Incompatibility with standard Java technologies; and
5. Primitive AJAX support.