JSF Overview

1.1.  What is JSF

JavaServer Faces (JSF) is a UI component based Java Web
framework. JSF is serverbased, e.g. the JSF UI components
and their
are represented on the server with a defined life-cycle
the UI components. JSF is part of
the Java EE standard.

A JSF application run in a
standard web
container, for example
Tomcat or Jetty .

This articles provides an introduction to JSF using only standard JSF
For the usage of special Apache Trinidad features please see
Apache Myfaces Trinidad with Eclipse – Tutorial

1.2.  A JSF application

A JSF application consists of web pages with JSF UI components.
A JSF application requires also some configuration files
(“faces-config.xml” and

The faces-config.xml defines:

  • Managed Bean – the data elements of the JSF
    (managed beans and
    beans) Represents a Java class which will
    be created dynamically
    during runtime of the JSF application. It
    can be defined for which
    scope the bean is valid (Session, Request,
    Application or none).

  • the navigation
    web pages

  • data validators – Used to check the validity of UI input

  • data converters -Used to translate between UI and model

Managed beans are
simple Java objects (POJO’s) which are
and can be used in an JSF application.
For example
you can define a
Java object “Person”. Once you define the
object in
you can use the attributes of Person in your
components, e.g.
by binding the value “firstName” of this object
to an
JSF input

JSF uses the Unified Expression Language (EL) to bind UI
components to object attributes or methods.

1.3. Value and Method Binding

In JSF you can access the values of a managed bean via
binding. For value binding the universal Expression
Language (EL) is
used (to access bean and / or methods). In JSF you
do not need to
specify the get() or set() method but just the
variable name.

Method binding can be used to bind a JSF component, e.g. a
button to an method of a Java class.


Expression Language statements either start with “${” or with
and end with “}”. JSP EL expressions are using the ${…}
These EL expressions are immediately evaluated. JSF EL
are of the type #{…}. These are only evaluated when
needed (and
otherwise stored as strings).

1.4.  Prerequisites to use JSF

To use JSF you need:

  • JSF Implementation (in the form of the JSF jars)

  • The JSTL tags library

  • A Java runtime environment

  • A web-container to use JSF in (for example Tomcat)

1.5.  JSF Main features

JSF has the following main features:

  • JSF is based on the Model-View-Controller concept

  • JSF has a stateful UI component model, e.g. each component is
    aware of its data

  • JSF separates the functionality of a component from the
    display of the component. The renderer is responsible of
    displaying the component for a certain client. This renderer can
    exchanged. The
    renderer for JSF components is the HTML

  • JSF support listeners on UI components

  • JSF support data validation, data binding and data conversion
    between the UI and the model

This entry was posted in JSF 2.0. Bookmark the permalink.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s