Skip to main content

Making a simple JSF application

Here's how we build a simple JSF application:

  1. Configure web.xml for FacesServlvet
  2. Create faces-context.xml (This is the file from where FacesServlet reads navigation rules, details of managed beans and other JSF specific configuration details)
  3. Create a controller or controllers for the application. Here is where JSF differs from Struts. Struts had a front controller, the ActioServlet which delegated requests to Action classes. JSF does not have the notion of a front controller. A JSF application uses an event model. The UI is tied to the backend with events. Controller classes (also known as backing beans in JSF) accept these events and also hold properties that accept user supplied values from a form. These properties will also be used to display data on pages. For example if we have a simple application that allows employees to put in a leave request, a backing bean will have properties that will be populated with the request that the user enters on the form. The same backing bean may also be responsible for displaying the leave status to the user. Essentially we will have one backing bean class for a related set of UI views. The view pages for adding, editing, viewing, and deleting "leave requests" will be mnaged by the same backing bean class. A JSF application can have many backing beans, thus resulting in many controllers. Even though we can code business logic in these backing beans, we should desist from doing so. The business logic must in other application classes which are invoked from the backing bean. This way the backing bean acts as a glue between the view and the model (which is what a controller should be doing anyways).
  4. Create the view (JSP) files.
    1. All the JSF tags should be put within an f:view tag. Components placed within this tag are managed by the JSF system. If we not use f:view, then the JSF system will remain oblivious of the components.
    2. Fields in a JSF form can be associated with beacking bean properties using JSF - EL. For example #{BeanName.PropertyName}. JSF-EL is similar to JSTL-EL, however, it directly associates a field (within which it is used) with a backing bean property (or a properties property). These properties are used to hold values submitted by users as well as hold values that will be displayed to the user on a form.
    3. We can associate commandButtons to methods in the backing beans, using JSF-EL. I believe we can associate them with events, in which case appropriate event handlers will be invoked[verify this].
    4. The JSF system can also run simple validations on the form fields automatically. Things like required fields, or fields that represent numbers can be validated automatically. More complex validations can be defined in custom validators.
Labels:

Comments

Post a Comment

Popular posts from this blog

Commenting your code

Comments are an integral part of any program, even though they do not contribute to the logic. Appropriate comments add to the maintainability of a software. I have heard developers complain about not remembering the logic of some code they wrote a few months back. Can you imagine how difficult it can be to understand programs written by others, when we sometimes find it hard to understand our own code. It is a nightmare to maintain programs that are not appropriately commented. Java classes should contain comments at various levels. There are two types of comments; implementation comments and documentation comments. Implementation comments usually explain design desicisions, or a particularly intricate peice of code. If you find the need to make a lot of implementation comments, then it may signal overly complex code. Documentation comments usually describe the API of a program, they are meant for developers who are going to use your classes. All classes, methods and variables ...
Post a Comment
Read more

Inheritance vs. composition depending on how much is same and how much differs

I am reading the excellent Django book right now. In the 4th chapter on Django templates , there is an example of includes and inheritance in Django templates. Without going into details about Django templates, the include is very similar to composition where we can include the text of another template for evaluation. Inheritance in Django templates works in a way similar to object inheritance. Django templates can specify certain blocks which can be redefined in subtemplates. The subtemplates use the rest of the parent template as is. Now we have all learned that inheritance is used when we have a is-a relationship between classes, and composition is used when we have a contains-a relationship. This is absolutely right, but while reading about Django templates, I just realized another pattern in these relationships. This is really simple and perhaps many of you may have already have had this insight... We use inheritance when we want to allow reuse of the bulk of one object in other ...
3 comments
Read more

Planning a User Guide - Part 3/5 - Co-ordinate the Team

Photo by  Helloquence  on  Unsplash This is the third post in a series of five posts on how to plan a user guide. In the first post , I wrote about how to conduct an audience analysis and the second post discussed how to define the overall scope of the manual. Once the overall scope of the user guide is defined, the next step is to coordinate the team that will work on creating the manual. A typical team will consist of the following roles. Many of these roles will be fulfilled by freelancers since they are one-off or intermittent work engagements. At the end of the article, I have provided a list of websites where you can find good freelancers. Creative Artist You'll need to work with a creative artist to design the cover page and any other images for the user guide. Most small to mid-sized companies don't have a dedicated creative artist on their rolls. But that's not a problem. There are several freelancing websites where you can work with great creative ...
Post a Comment
Read more