Helping ordinary people create extraordinary websites!
| |
Helping ordinary people create extraordinary websites! |
JSF for Nonbelievers: The JSF Application LifecycleBy Rick Hightower2005-05-05 
The JSF Lifecycle: an Overview
The six phases of the JSF application lifecycle are as follows (note the event processing at each phase): 1. Restore view 2. Apply request values; process events 3. Process validations; process events 4. Update model values; process events 5. Invoke application; process events 6. Render response The six phases show the order in which JSF typically processes a form GUI. The list shows the phases in their likely order of execution with event processing at each phase, but the JSF lifecycle is hardly set in stone. You can change the order of execution by skipping phases or leaving the lifecycle altogether. For example, if an invalid request value were copied to a component, the current view would be redisplayed, and some of the phases might not execute. In this case, you could issue a FacesContext.responseComplete method invocation to redirect the user to a different page, then use the request dispatcher (retrieved from the request object in the FacesContext) to forward to an appropriate Web resource. Alternately, you could call FacesContext.renderResponse to re-render the original view. (See the sample application below for details.) The point is to let the lifecycle structure your development efforts without feeling completely tied to it. You can alter the lifecycle when needed without fear of breaking your application. In most cases, you'll find that the JSF lifecycle is worth adhering to because it's quite logical. Forms have to be validated before any application logic can be executed, and field data has to be converted before being validated. Sticking to the lifecycle frees you up to think about the details of validation and conversion, rather than the phases of the request process itself. It's also important to note that other Web frameworks have similar lifecycles; they just don't tend to be as well advertised. Focusing your efforts Some developers using JSF may never write a component or extend the framework, while others may focus on just those tasks. While the JSF lifecycle will be the same for almost any project, you'll likely tap into it at different stages based on your role in the project. If you're concentrating more on the overall application development, you'll likely be concerned with the middle phases of the request processing lifecycle: * Apply requests values * Process validations * Update model values * Invoke application If you're concentrating on JSF component development, you'll probably focus on the first and last phases of the lifecycle: * Restore view * Render response In the sections that follow, I'll walk you through every phase of the JSF request processing lifecycle, including event handling and validation. Once you have a basic understanding of each phase, I'll introduce a sample application that shows how they all come together. Before we get started, take a look at Figure 1, a diagram of the JSF lifecycle. Figure 1. The JSF lifecycle 
About this series This four-part series is dedicated to dispelling fear, uncertainty, and doubt (FUD) about JavaServer Faces (JSF) technology, mainly by giving you a chance to get to know it for yourself in a step-by-step, easy-to-follow format. Over the course of four articles, I'll provide a series of examples to introduce you to the basic architecture, features, and functionality of JSF. Once you're familiar with the JSF way of doing things, I think you'll find it hard to go back to Struts Model 2-style development. After all, who would want to revisit XML configuration Hades after experiencing the JSF event-driven, GUI component model? To get the most out of this series, you should be familiar with Java programming, JavaBeans (namely, event model and properties), JavaServer Pages (JSP), the JSP Standard Tag Library Expression Language, and all basic Web development concepts. Tutorial Pages: » Walk Through the 6 Phases of JSF's Request Processing Lifecycle » The JSF Lifecycle: an Overview » Phase 1: Restore View » Phase 2: Apply Request Values » Phase 3: Process Validation » Phase 4: Update Model Values » Phase 5: Invoke application » Phase 6: Render Response » A Working Example » Let's Code it » Use Case 1: Add a New CD » Use Case 2: Edit a CD » Use Case 3: Sort CDs » Immediate Event Handling » Conclusion » Resources First published by IBM DeveloperWorks
|
 |