| An Introduction to JavaServer Faces JavaServer Faces 1.0 Framework makes it easy to build powerful and dynamic web applications. There are many web user interface frameworks available, but JavaServer Faces Technology stands out for several reasons: it is a Java Community Process standard, it brings JavaBeans component paradigms to Web UI programming, and it was built by taking the best ideas from many existing frameworks. As a standard, many tool vendors can rely on well defined and consistent behavior. JavaServer Faces Technology was designed for use inside of tools from the very beginning. Users can also rely on consistent and specific behavior from one JavaServer Faces Technology implementation to the next. |
| A first look at JavaServer Faces, Part 1 Part of every IT-project includes testing, and Struts projects are no different. If we look at testing "from the bottom up", we start by unit testing the classes and methods we're developing. Extreme programmers actually write their unit test cases before the code they're supposed to test! As the project progresses, we step up through the application architecture to module, integration and system testing. You may use different words for your test phases, but the idea is to start at the very detailed level and finish by letting the end users test the functionality of the system, in order to see that what they get is what was promised to be delivered! |
| A first look at JavaServer Faces, Part 2 In September 2002, the early access (EA) draft of the JavaServer Faces specification was released under Java Specification Request (JSR) 127. JavaServer Faces, with a well-defined request processing lifecycle and a rich component hierarchy, will profoundly affect the development of Java 2 Platform, Enterprise Edition (J2EE) applications. |
| What is JavaServer Faces technology? JavaServer Faces technology is a framework for building user interfaces for web applications. JavaServer Faces technology |
| What are the benefits of JavaServer Faces technology? The primary benefits of JavaServer Faces technology include |
| Who are the intended users of JavaServer Faces technology? Because of the extensibility and ease-of-use that JavaServer Faces technology provides, a wide range of developers and web-page designers can take advantage of the power of JavaServer Faces technology |
| Who is involved in developing the JavaServer Faces specification? A number of important industry players are collaborating with Sun to define the first draft of the JavaServer Faces specification. Please see JSR-127 for a complete list of expert group members. |
| What are the differences between JavaServer Faces technology, Struts, and the Sun ONE Application Framework? The Sun ONE Application Framework (formerly called JATO) and Struts are popular Java web application frameworks. The charter of JSR-127 is to define a user-interface framework for Java web applications, and this does result in some overlap with current Sun ONE Application Framework and Struts functionality |
| How does JavaServer Faces technology relate to the JavaServer Pages Standard Tag Library (JSTL)? JSTL and the JSP tag library that is part of JavaServer Faces technology have been designed to work together. |
| How does JavaServer Faces technology relate to JavaServer Pages (JSP) technology? JavaServer Faces technology, version 1.0 relies on JSP 1.2. Since JSP 2.0 is a superset of JSP 1.2, it is possible to use JavaServer Faces technology, version 1.0 with JSP 2.0. Future versions of the JavaServer Faces specification will be able to take better advantage of JSP 2.0. |
| Using the Custom Component in the Page After you've created your custom component and written all the accompanying code, you are ready to use the component from the page. |
| JavaServer Faces, redux JavaServer Faces (JSF), poised to become the preeminent Java Web application framework, has undergone many changes since it was introduced as an early access (EA) release in September 2002. In this article, JavaServer Faces expert group member David Geary explores JSF's EA4 release (launched in June 2003) and illustrates how JSF has matured since its debut last year |
| Field Validation in JSF For a while, I have been studying Struts quite thoroughly. And frankly, I am still not convinced that it is really superior to a custom controller servlet approach with JSTL as tag library. |
| Field Validation Thoughts Here at my company our business is all about forms. I’m not talking about HTML forms; I’m talking about business forms such as loan applications, tax reporting statements, etc. |
| Page Navigation in JavaServer Faces Page navigation is an important aspect of web programming. The more complex an application is, the harder it is to manage how users navigate from one page to another. JavaServer Faces (JSF) solves this problem by allowing page navigation to be configured in the Application Configuration file. |
| Introducing JavaServer Faces JavaServer Faces (JSF) has been dubbed the next big thing in Java web programming. With JSF, you use web components on your web pages and capture events caused by user actions. In the near future, Java tools will support this technology. Developing web applications will be similar to the way we write Swing applications today: dragging and dropping controls and writing event listeners. |
| Increasing Developer Productivity with Project Rave: AnConversation with Rich Green At the 2003 JavaOne conference, Sun Microsystems, Inc., demonstrated a next generation tool for Java application development. Code named Project Rave, the tool is designed to address three developer needs: increase application development productivity while decreasing deployment time; reduce application development complexity; and deliver solutions based on portable and interoperable Java technology standards. |
| JSF: The good, the bad and the ugly This article has been brought to you by a member of the International Institute of Information Technologists (I3T). The I3T is an international organisation that represents the interests of IT professionals around the world, especially those who are under-appreciated and whose talents have not been recognised |
| Magical Web Interface Development Rapid Application Development (RAD) was a popular term in the pre-Web days. The main goal of RAD was to enable you to build powerful applications with a set of reusable components like text fields, data grids, tree views, panels, buttons, and so on. If you've ever used tools like Visual Basic, PowerBuilder, or Delphi, you know that they were a major leap forward in productivity for application development. For the first time it was easy to develop complex user interfaces and integrate them with data sources. |
| Integrating Struts, Tiles, and JavaServer Faces Would you like the front-end power of JavaServer Faces (JSF), the content-formatting strengths of Tiles, and the flexibility of the Struts controller tier all wrapped up in your J2EE Web application? Enterprise Java experts Srikanth Shenoy and Nithin Mallya show you how to integrate the features of all three. This article demonstrates how to customize the classes in the Struts-Faces integration library to make them work with Tiles and JSF, explains the rationale behind doing this, and details how to use the new set of classes with a working example. |
| Using JSF The JavaServer Faces (JSF) technology provides standard APIs and tag libraries needed by Java developers that build web-based user interfaces. Craig McClanahan, the author of the Apache Struts framework, co-leads the JSF project at Sun. This will ensure an easy migration from the popular Apache project to the JSF standard. Like the Struts framework, JSF defines a set of JSP tags that generate HTML form elements that can be bound to JavaBean properties |
| An introduction to Java Server Faces Web application development in Java has come a long way. We have matured from our yester year implementations using Java Servlets to render HTML code, to Element Construction Set (ECS) to modularize HTML rendering and representation, to using JavaServer Pages (JSP) technology to provide clean separation of business logic and presentation. Lately Model View Controller (MVC) frameworks like STRUTS have gained wide acceptance to rapidly develop complex web applications |
| An introduction to Java Server Faces Web application development in Java has come a long way. We have matured from our yester year implementations using Java Servlets to render HTML code, to Element Construction Set (ECS) to modularize HTML rendering and representation, to using JavaServer Pages (JSP) technology to provide clean separation of business logic and presentation. Lately Model View Controller (MVC) frameworks like STRUTS have gained wide acceptance to rapidly develop complex web applications |
| Why Web Developers Need JavaServer Faces There's been a plethora of articles written recently on one of the Java Specification Requests (JSR) currently making its way through the Java Community Process (JCP). JSR 127 describes a new technology called JavaServer Faces that, if delivered as promised, will help to further deliver on the Java promise of Write Once, Run Anywhere. |
| Developing Web Applications with JavaServer Faces You have lots of choices when building user interfaces for server-side applications. Java developers who use servlets or JavaServer Pages (JSP pages) often rely on HTML user interface components for developing the user interface. This is mainly because HTML user interface components are the lowest common denominator that Web browsers support. The implication, of course, is that such Web applications do not have rich user interfaces, compared with stand-alone fat clients, and therefore less functionality and/or poor usability. While applets can be used to develop rich user interfaces, page authors may not be familiar with (or interested in learning) the Java language. |
| Putting a New Face on Web Interfaces Building user interfaces (UIs) with Java 2 Platform, Enterprise Edition (J2EE) has never been completely satisfactory. Today, most developers using JavaServer Pages (JSP) apply HTML user controls, which represent the lowest common denominator in what browsers can be expected to support. The result is that Web-based UIs have long been known as being less rich than their fat client counterparts. |
| Integrating JSP/JSF and XML/XSLT The long awaited releases of JavaServer Faces TM (JSF) version 1.0 and JavaServer Pages TM (JSP) version 2.0 promise to transform the way J2EE developers build Web applications. Meanwhile, Extensible Stylesheet Language Transformations (XSLT) version 2.0 is in the final stages of specification, and many developers are seriously considering XML-based presentation layers, especially when the applications target multiple devices or require look and feel customization. |
| JavaServer Faces 1.0 Early Access Draft There are some parts of the specification as it stands that need to be addressed. Some issues revolve around performance and others clarity. In this article I'll try to tackle as many as I have space for and those that I've found. I've referenced the section numbers from the EAD so that you can follow along at home, so to speak. I'm also assuming that you have prior knowledge of the specification - although not required, it will help when reading. I spend very little time describing the sections and assume that you have access to them to read, or have read them before and will pick up as we go along. |
| JavaServer Faces 1.0 Early Access Draft There are some parts of the specification as it stands that need to be addressed. Some issues revolve around performance and others clarity. In this article I'll try to tackle as many as I have space for and those that I've found. I've referenced the section numbers from the EAD so that you can follow along at home, so to speak. I'm also assuming that you have prior knowledge of the specification - although not required, it will help when reading. I spend very little time describing the sections and assume that you have access to them to read, or have read them before and will pick up as we go along. |
| Let's face the facts The Java Server Faces Framework has been under development for about a year and a half. Now it is finally available for public review. But was it worth the wait? In fact, we waited so long that we started to develop a framework of our own that is now available for preview. So let's compare the (preliminary) specification with our own and have a closer look at some of the design decisions and development implications that are implied |
| Flex in Relation to DHTML, XUL, SVG, JavaServer Faces, and Flash MX Amid the talk about Macromedia Flex, several questions seem to be recurring. I'll offer quick and unofficial thoughts on five of them: how it relates to DHTML, XUL, SVG, JSF, and our existing Flash MX tool. |
| Welcome to the JavaServer (TM) Faces Implementation Project! People have been requesting that Sun release the source code of its implementation of JavaServer(TM) Faces Technology for several years, and Sun's answer has been that doing so is under review. I won't go into the reasons for the length of the review process, but I'm happy to announce that it's finally complete. We have created an open development project on java.net to host the continuing development of Sun's JavaServer Faces implementation. All previously internal development will be done in this project; there is no private source tree that we really use. In other words, this project is not just for show. Please read the FAQ for answers to such pressing questions as "how do I get and build the source". |