Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchWindows Errors? Fix Them Before They Spread
Repair common Windows errors and clear accumulated junk for a smoother, more stable PC - no reinstall needed.Free scan · no reinstallJavaServer Faces (JSF) is a server-side, component-based Java web UI framework. DZone’s JavaServer Faces Refcard #021 by Cay Horstmann is a free PDF quick reference covering the development process, standard tags, Expression Language (EL), faces-config.xml, the request lifecycle and web.xml. The related JavaServer Faces 2.0 Refcard #058 adds Facelets, resources, tables and Ajax examples. Modern documentation calls the continuing standard Jakarta Faces; “JSF” remains common when discussing older Java EE applications.
What JavaServer Faces is
JSF builds web pages from a server-side component tree rather than treating each request as an isolated form submission. A view combines JSF component tags with HTML and CSS. Components hold submitted values, validation state and events, while EL expressions connect them to managed beans. Those beans can coordinate presentation logic with business and persistence layers.
This model supplies predefined input, output, form, command, table and navigation components, an event-driven programming model, extensibility points and tooling support. The browser ultimately receives HTML (or XHTML), but the server retains and processes the component model across requests.
JSF terminology and the Jakarta name
“JavaServer Faces” is the historical Java EE name. The current standard is Jakarta Faces, documented by the Jakarta EE project. Namespace packages, runtime versions, servlet configuration and bean conventions can differ between a legacy JSF deployment and a current Jakarta Faces deployment, so follow the specification and API documentation for the version you deploy. The core ideas in the DZone refcards—components, Facelets, EL and the lifecycle—remain useful for maintaining older applications.
Do these 3 things before closing this tab:
1Repair Windows errors before they cause bigger problems2Scan for outdated or missing drivers - takes under a minute3Clear out junk files and repair common Windows errors#1 Best Overall
How Facelets and JSF work together
Facelets is the lightweight page-declaration language normally used to define Faces views. A Facelets page contains component tags and templates; the JSF runtime turns that declaration into a component tree. On an initial request, the runtime creates the view, applies the Facelets definition, renders the response and saves the view state for subsequent requests. Later requests restore that state before processing the submitted data.
A page might bind an input and a command to a bean like this:
Rank #2
<h:form>
<h:inputText value="#{profile.name}" />
<h:commandButton value="Save" action="#{profile.save}" />
</h:form>Here #{profile.name} is an EL value expression. JSF reads the property during rendering and writes a converted, validated value back to it during request processing. The action method can perform application work and return a navigation outcome.
The JSF request lifecycle
The lifecycle manages processing for an entire Faces request. Jakarta documentation presents it as two broad stages: Execute and Render.
Rank #3
Execute: build or restore and process the view
- Build or restore the view. The first request builds a component tree from the Facelets page; a postback restores the saved view.
- Apply request values. Components receive submitted parameters from the HTTP request.
- Convert and validate. Submitted strings are converted to target types and checked against required rules and validators. Conversion or validation errors stop the normal progression and return to rendering with messages.
- Update model values. Successfully converted and validated values are written to the properties referenced by EL.
- Invoke application logic. Action methods, listeners and navigation decisions run after model updates.
Render: produce the response
JSF renders the component tree as HTML or XHTML, including validation messages and any updated values. It then saves the state needed for a later request. Ajax requests can render only selected portions of the tree rather than replacing the entire document.
Why lifecycle knowledge matters
- An action method may not run when validation fails, because the lifecycle returns to rendering with messages.
- A bean property is not updated until conversion and validation succeed.
- Component state explains why a postback can behave differently from a first page load.
FacesServlet and URL mapping
FacesServlet is the Jakarta Servlet that manages the Faces request-processing lifecycle. Requests must reach this servlet for JSF components and phases to execute. Depending on runtime discovery and configuration, automatic mappings can include /faces/*, *.jsf, *.faces and *.xhtml. Do not assume every mapping is enabled: inspect the deployed runtime and explicit application configuration.
The mapping determines the public URL, not the component model. A project may expose /faces/profile.xhtml or use an extension such as profile.jsf while Facelets remains the view declaration language.
What belongs in faces-config.xml and web.xml
faces-config.xml
The Faces configuration file can define application-level behavior such as navigation rules, resource bundles, converters, validators, component or renderer registrations and other runtime settings. Modern applications often use annotations and convention for some of these concerns, but legacy projects commonly centralize them in this file. The exact schema and namespace must match the JSF or Jakarta Faces version in use.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Best Value
web.xml
The servlet deployment descriptor configures the web application at the servlet-container level. It can declare and map FacesServlet, set startup or application parameters and define related web behavior. A project using automatic discovery may need less explicit servlet configuration, but an existing mapping in web.xml takes precedence over assumptions about defaults.
Tags, EL and common features covered by the refcards
| Area | What it does | Typical use |
|---|---|---|
| Core tags | Provide behavior such as actions, listeners, validation and conversion. | Attach a validator or listener to an input or command. |
| HTML tags | Represent UI components that render HTML controls and containers. | Forms, inputs, outputs, links, buttons and messages. |
| Expression Language | Reads and writes bean properties and invokes methods. | #{bean.property} or #{bean.save}. |
| Navigation | Chooses the next view after an action. | Return an outcome or configure a navigation rule. |
| Resource bundles | Externalize labels and messages. | Localized text and validation messages. |
| Data tables | Render repeated data from a collection. | Display records with columns and row actions. |
| Ajax | Submit and render selected components without a full-page replacement. | Refresh a dependent field, table or message area. |
| Resources | Manage stylesheets, scripts and other static assets. | Include CSS and JavaScript through the Faces resource mechanism. |
A practical way to read the DZone refcards
- Start with the lifecycle. It explains when values are read, validated, stored and acted upon.
- Learn the Facelets page structure. Identify the view root, forms, naming containers and component nesting.
- Trace an EL binding. Find the bean property or method behind each input and command.
- Check configuration. Review
faces-config.xml,web.xml, annotations and the runtime’s version-specific namespaces. - Add behavior deliberately. Choose converters, validators, messages, navigation and Ajax render targets based on the lifecycle rather than trial and error.
What the refcards do not establish
The DZone PDFs are educational quick references, not version specifications. They do not establish current Jakarta Faces namespace details, implementation support windows, adoption levels, performance figures or market share. For normative behavior, consult the Jakarta Faces specification and API documentation that match your deployed version. When upgrading a Java EE JSF application, verify package names, servlet mappings, bean management and configuration schemas instead of assuming that a historical example is drop-in compatible.
JSF compared with another server-side UI framework
Use these questions when evaluating JSF against an alternative:
Quick Recap
- Component and state model: Does the framework keep a server-side component tree and view state, or rely on stateless templates?
- Lifecycle and validation: Where do conversion, validation and model updates occur, and in what order?
- View language: How do Facelets templates, composition and tag libraries compare with the other framework’s templates?
- Bean integration: How are view-scoped state, dependency injection and business services connected?
- Ajax and partial rendering: Can interactions update selected components, and how are events routed?
- Configuration and URLs: How are servlet entry points, navigation and resources configured?
- Maintenance: Which Jakarta or Java EE version, implementation and namespace does the application require?
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
