| 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. |
| JavaServer Faces (JSF) vs Struts My JSF article series and Meet the Experts appearance on IBM developerWorks received a lot of feedback. I would have to say, the most common question or feedback came along the lines of comparing Struts to JSF. |
| Q&A: JavaServer Faces Sun engineers Mimi Hills, Tony Ng, and Ed Burns talk about the importance of JavaServer Faces in today's programming environment and how developers can best utilize it. Hills and Ng are software engineering managers in Sun's Java Web services group. Ng is also the manager of the JavaServer Faces team. Burns leads the team developing the specification for the JavaServer Faces project. |
| How To Use ADF Faces With JDeveloper 10g ADF Faces is the Oracle Application Development Framework (ADF) view technology based on JavaServer Faces (JSF). Although JDeveloper 10g's complete and enhanced support for ADF Faces development will be provided in post 10g releases, it is still possible to productively do ADF Faces development in JDeveloper 10g. This document describes how to install and work with ADF Faces Early Access Release in JDeveloper 10g. |
| Handling Events in JavaServer Faces, Part 1 When the user clicks a button or link, changes a value in a field, or makes a selection in a list, the application may need to react. JSF user interface components signal user actions by firing an event handled by application code that has registered itself to be notified of the event. It's a model borrowed from traditional GUI frameworks, making it easy to develop and maintain the code for each specific user action in a separate code module. You can even use multiple event handling modules for different aspects of the processing, such as one that logs the action and another that acts on it. |
| Handling Events in JavaServer Faces, Part 2 When the user clicks a button or a link, chances are good that backend code should be asked to do something, like adding a report entry to the current report when the Add button is clicked in the sample application. Occasionally, though, an event affects only the user interface. For instance, clicking a button or changing the value of an input control may expose additional options or display more information. |
| Developing JavaServer Faces portlets using WebSphere Studio and the IBM Portal Toolkit -- Part 1 This three-part article series shows how the latest JavaServer™ Faces and portlet specifications can be used together to rapidly build and assemble Web sites to help achieve your business objectives. Part 1 explains how to build an EJB™ client portlet, and how to package an EJB client JAR file inside your portlet WAR files. |
| Developing JavaServer Faces portlets using WebSphere Studio and the IBM Portal Toolkit -- Part 2 This three-part article series shows how the latest JavaServer™ Faces and portlet specifications can be used together to rapidly build and assemble Web sites to help achieve your business objectives. Part 1 explained how to build an EJB™ client portlet, and how to package an EJB client JAR file inside your portlet WAR files. Part 2 uses the JSF Web service component to build a Web service client portlet. |
| eXo platform, Reloaded A lot of work has been done since our last article was published in December 2003. We released the eXo Platform 1.0 beta 5 in March, with many new features, including WSRP and support for JSF 1.0. Today's design is still based on the service oriented architecture that was described in our very first article. By simply adding new services it was very easy to manage a quickly growing code base and still keep it mainta |
| JavaServer Faces, Web Applications Made Easier The Java Community Process (JCP), in an effort to keep Java in the forefront of Web Applications, has come up with a specification called JavaServer Faces (JSF), which attempts to standardize the way we develop Java Web applications and provides a set of rich ready-to-use UI components. In this article, I'll try to discuss the JSF technology, what's wrong, what's right and why it's necessary. |
| Developing JSF Applications using WebSphere Studio V5.1.1 -- Part 1 Part 1 of this 5-part series begins a series of hands-on exercises with Java Server Faces (JSF), an exciting new feature for visually developing J2EE Web applications. |
| Developing JSF Applications using WebSphere Studio V5.1.1 -- Part 2 Part 2 of this 5-part series on Java Server Faces builds upon Part 1, continuing with the creation of JSF submission forms, and showing some of the dynamic controls that can be used for visually developing J2EE Web applications. |
| Developing JSF applications using WebSphere Studio V5.1.1 -- Part 3 In Part 2 of this 5-part series, we built Java Server Faces forms using Rapid Application Development (RAD) JSF components. In Part 3, we will see how JSF can work with data using Web Data Object (WDO) (soon to be Service Data Object) technology. |
| Developing JSF applications using WebSphere Studio V5.1.1 -- Part 4 In prior installments of this 5-part series, we built Java Server Faces forms using Rapid Application Development (RAD) JSF components and saw how JSF works with data using Web Data Object (WDO) or Service Data Object (SDO) technology. In Part 4, we demonstrate how JSF can work with existing J2EE technology. |
| Developing JSF applications using WebSphere Studio V5.1.1 -- Part 5 In prior installments of this 5-part series, we built Java™ Server Faces forms using Rapid Application Development (RAD) JSF components, and saw how JSF works with Web Data Object/Service Data Object technology, and even with existing J2EE technology. In this final installment, we will use the JSF Web service component to invoke a Web service. |
| Roland Barcia on using JMS and JSF This question and answer article features WebSphere expert Roland Barcia who answers questions on using Java Messaging Service (JMS) with WebSphere Application Server and WebSphere MQ, developing Java Server Faces (JSF) applications with WebSphere Studio Application Developer, and building and deploying applications to WebSphere Application Server. |
| Generating Java using EGL and JSF with WebSphere Studio Site Developer V5.1.2 This article describes how to use JSF and WebSphere Studio Site Developer V5.1.2 to deploy EGL applications to WebSphere Application Server V5.1. It shows you how to code, test, generate, and deploy a three-tier application consisting of a Web interface, WebSphere Application Server, and a server program that accesses DB2. |
| Developing Web applications using RAD tools, IBM extended JSF components, and WebSphere Studio V.5.1.2 This article describes the Fileupload/Download features of the IBM Extended JavaServer Faces components that are integrated into WebSphere Studio V5.1.2. You can use these components and complementary rapid application development (RAD) tools.to build a Web application that uploads content and then displays it. The article shows how the Faces components work with data using Websphere Service Data Object (SDO) technology. |
| 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. |
| UI development with JavaServer Faces This tutorial provides an overview of JavaServer Faces (JSF) and walks you through the basics for developing Web applications using the technology. With Java developer and consultant Jackwind Li Guojie as your guide, examine the JSF life cycle, input validation, event handling, page navigation, and internationalization -- all of which are illustrated through a sample application. |
| Creating Web-based user interfaces: Using WebSphere Studio V5.1.2 to develop JavaServer Faces applications JavaServer™ Faces (JSF) technology is one of the most exciting technologies for Web application developers who are using J2EE. The WebSphere Studio family of tools allows you to build JSF technology-based Web applications, and provides a set of powerful visual tools to help simplify the process. Using a simple messaging center example, this tutorial teaches you how to use JavaServer Faces technology to build Web applications using WebSphere Studio V5.1.2. |
| Developing Web Applications with JavaServer Faces JavaServer Faces (JSF) is a standardized specification for building User Interfaces (UI) for server-side applications. Before JavaServer Faces, developers who built web applications often relied on building HTML user interface components with servlets or JavaServer Pages (JSP pages). 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 standalone fat clients, and therefore less functionality and/or poor usability. While applets can be used to develop rich user interfaces, web application developers don't always know what clients will be accessing the application and/or they may have no access to the client device. |
| Developing Web Applications with JavaServer Faces JavaServer Faces (JSF) is a standardized specification for building User Interfaces (UI) for server-side applications. Before JavaServer Faces, developers who built web applications often relied on building HTML user interface components with servlets or JavaServer Pages (JSP pages). 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 standalone fat clients, and therefore less functionality and/or poor usability. While applets can be used to develop rich user interfaces, web application developers don't always know what clients will be accessing the application and/or they may have no access to the client device. |
| Java Server Explained |
| Put JSF to work Building a real-world Web application using JavaServer Faces is not a trivial task. This article shows you how to integrate JSF, the Spring Framework, and Hibernate, and describes best practices and design guidelines for building a real-world Web application using these technologies. |
| JSF: Did Sun Mess Up (Again)? In March 2004, Sun released the final version of the JavaServer Faces (JSF) 1.0 specification (JSR 127). If you were completely naďve (which I know you are not!) and read the final JSF specification (or any of its earlier draft versions) along with Sun’s marketing spin on it (JSF), you would probably think that JSF is the best thing since sliced bread. You would probably wonder how the Java community ever survived without JSF. Sun obviously seems to think so and to that end has even made JSF part of J2EE 1.4. |
| Pictorial of the Creator: Touring JSF on Java Studio Creator The ongoing debate on Java Server Faces in the Java blogger community has been on interesting topic to follow. But I think it is missing the point to complain that JSF is "heavy weight" or fails to follow the POJO fad or is otherwise too complex to use. JSF is *not* designed to simplify the work for developers who manually code everything. |
| 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. |
| A first look at JavaServer Faces, Part 1 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. In Part 1 of this two-part series, David Geary introduces JavaServer Faces and explores its fundamental concepts |
| 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. In Part 1 of this two-part series, David Geary introduced JavaServer Faces and explored its fundamental concepts. In Part 2, he examines more advanced concepts such as custom validation, internationalization, and custom component implementation. |
| Creating JSF Custom Components This article illustrates how to build custom components for use in web applications based on JavaServer Faces (JSF). While JSF comes with a standard set of components, one of the most-publicized features is the easy addition of new components. In this article, you will see just how easy it is to create new components that are fully functional and integrated into your web applications. Specifically, this article will show how to develop a component that allows users to enter valid credit card numbers. |
| Take a Tour of Web Tier Technologies The Web tier has existed in Web-based applications since the introduction of the thin client. The move from the fat-client, two-tier enterprise application models (traditional client/server architecture) to Web-browser-based, thin-client n-tier application models required the introduction of a tier to handle the Web-based presentation logic distinct from the business logic in the middle tier. |
| Guidelines for Designing Reusable Custom Components Using JavaServer Faces Technology JavaServer Faces technology is a user interface component framework for building Java Web applications. It is designed to significantly ease the burden of writing and maintaining applications that run on a Java application server and render their UIs back to a target client. A JavaServer Faces user interface component is the basic building block for creating user interfaces. If a component uses no proprietary API's, it can be reused over and over again in a number of applications, making it much easier to develop applications and improve developer productivity. |
| 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. |
| Improving JavaServer Faces by Dumping JSP After a long wait and high expectations, JavaServer Faces (JSF) 1.0 was finally released on March 11, 2004. JSF introduces an event-driven component model for web application development, similar in spirit and function to the model used for standalone GUI applications for many years. |
| JavaServer Faces vs. ASP.NET WebForms Every year, the Microsoft and Java development communities have been attempting to develop methods to enhance developer productivity. Whether you are using the Microsoft Application Blocks for .NET or a number of the Jakarta frameworks like Struts and Ant, they have been designed to increase productivity and decrease the rate of development. |
| Mixing JSTL and JSF in Web Applications Even though the JavaServer Pages Standard Tag Library (JSTL) and the newer JavaServer Faces (JSF) technology are very different, they're not totally incompatible. Find out how and when you might want to consider mixing the two to achieve a blend that's smoother than either one alone. |
| Introduction to JavaServer Faces This article is meant to acquaint the reader with JavaServer Faces, commonly known as JSF. JSF technology simplifies building the user interface for web applications. It does this by providing a higher-level framework for working with your web app, representing the page as event-aware components rather than raw markup. |
| Design Considerations Using JavaServer Faces Java Server Faces (JSF) is a standardized framework for building user interfaces for web applications. It is positioned to be the "Swing for server-side applications". This paper is an attempt to identify the appropriate use of this technology. Some of the specific issues discussed in here are related to Sun's implementation of the JSF specification only. |
| INTRODUCING JAVASERVER FACES TECHNOLOGY Applications that are based on JSP pages, and that follow what's termed a "Model 1 architecture," can typically be developed easily and in a short amount of time. A Model 1 architecture is a good choice if page navigation and business logic are simple, and if the application is unlikely to change significantly. But as discussed in the tip "Improving Designs with the MVC Design Pattern," an application composed entirely of JSP pages can quickly become difficult to manage. |
| Introduction to JavaServer Faces, Part 1 This chapter gently introduces the JavaServer Faces technology. More importantly, it teaches you how to write your first JSF application to get a feel for how this great technology works. In addition to the sample chapters, this chapter prepares you for the next chapters by introducing the JSF Application Programming Interface (API) and the Application Configuration file. This excerpt comes from chapter two of JavaServer Faces Programming, by Budi Kurniawan |
| Introduction to JavaServer Faces Part 2 We continue with part two of Chapter 2 of Introduction JavaServer Faces Programming, by Budi Kurniawan (McGraw-Hill/Osborne, ISBN 0-07-222983-7, 2004). This section deals with the ActionListener and Component Tree, as well as validation and navigation for your JSP pages. This chapter prepares you for the next chapters by introducing the JSF Application Programming Interface (API) and the Application Configuration file. |
| Introduction to JavaServer Faces Part 3 This chapter has been leading us gently through the JavaServer Faces technology. More importantly, in it, Budi teaches ushow to write an online survey application to get a feel for how this great technology works. This chapter prepares you for the next chapters by introducing the JSF Application Programming Interface (API) and the Application Configuration file. This excerpt comes from chapter two of JavaServer Faces Programming, by Budi Kurniawan |
| JSF: The Ultimate in Flexibility? Or Complexity? I have a love/hate relationship with J2EE. I love the idea of standards that we can all use in our development to improve interoperability, ease integration issues, create a pool of skilled developers, etc. I hate the idea that I have to wait years for the standards to evolve and become usable. |
| J2EE Core Patterns and JSF This article explains and shows how well JSF fits into the J2EE architecture using Core J2EE Patterns. It also explains how JSF Backing Beans correlate with J2EE Transfer Objects and Enterprise Beans. The example in this article is the demo application ('Drill Down Grid') which is connected to a business service through a J2EE Business Delegate. |
| Facing Forward with JSF JavaServer Faces (JSF) is a new technology for rapidly building Web applications using Java technologies. JSF expedites the development process by providing the following features: standard and extensible user interface (UI) components, easily configurable page navigation, components for input validation, automatic bean management, event-handling, easy error handling, and embedded support for internationalization. |
| UI frameworks and JavaServer Faces While JSF provides a powerful foundation for building user-interface components, it is a new standard, only just now being fully defined. Many other articles discuss what JSF is, and how it works, and the upcoming book "JSF in Action", by author Kito Mann (Manning publications), gives a comprehensive description of how to put it to use effectively. Most web applications already in use today make use of a UI framework of some sort already, and many of these frameworks are highly capable in their own right. |
| JSF Navigation by Examples The JavaServer Faces (JSF) Navigation Framework provides navigation rules that allow you to define navigation from view to view (mostly JSP pages) in a Web application. These navigation rules are defined in JSF configuration files along with other definitions for a JSF application. Usually, this file is named faces-config.xml. However, you can assign any other name and even use more than one file to store JSF configuration data. |
| The Many Faces of JavaServer Faces (JSF) No doubt the name at least is familiar: JavaServer Faces has been talked about a lot, and much anticipated, with good reason. For years there have been an ever-expanding choice of ways to take your web application's output and get it on a page (or on some other kind of display). |
| Developing Web Interfaces with JSF JavaServer Faces offers a competitive alternative to visual Web development tools and promotes a teamwork approach to application development |
| 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. This is one of the features that will make JSF the first choice of web application development in Java in the future. |
| Magical Web Interface Development JavaServer Faces gives you server-based power and flexibility for building Web-based interfaces that keep components in sync with your business objects |
| 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. |
| 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. |
| 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 |
| http://www.jsfcentral.com/archives/Full%20JCP%20CORNER%20article%20by%20Bart%20Leeten%20and%20Kris%20Meukens.pdf This article will not only provide you with an overview of what JavaServer Faces is about, but also with the arguments why we believe JavaServer Faces really presents a significant step forward for the J2EE Web Tier. As JSF is still work in progress, not cast in stone yet, we will limit ourselves to describing the overall features and goals, and will not overwhelm you with lower level Application Programming Interface (API) details. |
| Developing Web Applications with JavaServer Faces JavaServer Faces (JSF) is a standardized specification for building User Interfaces (UI) for server-side applications. Before JavaServer Faces, developers who built web applications often relied on building HTML user interface components with servlets or JavaServer Pages (JSP pages). 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 standalone fat clients, and therefore less functionality and/or poor usability. While applets can be used to develop rich user interfaces, web application developers don't always know what clients will be accessing the application and/or they may have no access to the client device. |
| Putting a New Face on Web Interfaces The JavaServer Faces technology takes the next step in separating presentation from business logic |
| Putting a New Face on Web Interfaces 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 Although some will claim that the Java Server Faces (JSF) 1.0 Specification Early Access Draft (EAD) release is simply not suitable for web development, there are those, including the companies that voted yes on the specification, that believe that it has merit. I won't go into detail about what camp I'm in, but I will say that JSF is definitely a step in the right direction for HTML over HTTP based application development. |
| 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. |
| Proxy Id for a JSF Custom Component The JavaServerTM Faces custom components have a dynamic id. This can create problems when trying to access these components from JavaScript code on the client side. This tiny library contains a custom component that allows you to get the dynamic id for any of the other JSF components. |
| How To Create Your Own JSF Components JavaServerTM Faces is a technology that helps to build a user interface based on the components approach. Using UI Components as building blocks simplifies the development, slashes the number of code lines, and allows reusing the same components from one project to the next. |
| How to use Tiles with JSF Applications This short example shows how use JSF together with Tiles. All you have to do is add struts.jar from the Struts1.1 distributive to your classpath. Including struts.jar does not mean that Struts itself is required to use with Tiles. Tiles packages are distributed inside the struts.jar. No other funclionality of the Struts Framework will be involved. |
| JavaServer Faces 1.0 Part I JavaServer Faces is a new framework for building J2EE base web applications. JSF was developed through the Java Community Process under JSR-127. JSF is a model-driven web component application framework whose event model has been compared to that of Swing. |
| JSF good! I used AppFuse and Spring together extensibly on two projects earlier this year with a lot of success. I added Spring support before it was part of the AppFuse core (for my projects). I have a lot of respect for Matt Railble's opinions. Matt is an awesome, dedicated technologist. I don't agree with him about JSF. |
| Introducing Jayashri Visvanathan After leading the JavaServer Faces implementation team through our 1.0 release I deciced to spend more time on developing the specification itself, and have handed the leadership over to the ever-so-capable Jayashri Visvanathan. Jayashri was a key contributor to the project during 1.0, and has lead the team through the 1.1 and subsequent releases. I'm devoting this blog to giving the community a chance to get to know Jayashri better, and to give her a chance to share her vision for the future of the JavaServer Faces project. |
| Pictorial of the Creator: Touring JSF on Java Studio Creator The ongoing debate on Java Server Faces in the Java blogger community has been on interesting topic to follow. But I think it is missing the point to complain that JSF is "heavy weight" or fails to follow the POJO fad or is otherwise too complex to use. JSF is *not* designed to simplify the work for developers who manually code everything. It is designed to be used with tools. The component model and event callback model are all designed to facilitate drag-and-drop "visual" development that is appealing to "corporate developers" currently using VB and ASP.Net. So, the really relevant question is: Would JSF-enabled tools make life easier for Java web developers? Well, Sun answers this question with their Java Studio Creator IDE (based on the NetBeans platform). |
| Let's learn about ourfaces The ourfaces project is intended to be a casual, yet very useful repository of JavaServer Faces components. I say casual because we want have a low barrier to entry for adding new components to the repository. The project leader, Matthias Unverzagt, has made it very easy to get started as a contributor, in four simple steps. Of course, if it's easy to be a contributor, it's even easier to be a user. |
| Geospatially spending my time There've been no updates for a while due in part to this event. In addition to putting together a demo that the demo gods decided to strike me down for on Saturday (8/7), I had 2-3 other demos to prep for at the Sun booth on the exhibition floor. I spent a lot of time talking with customers doing things in the GIS space with Sun technology, be it hardware, software or both. |
| A reply to Matt Raible's article "My JSF Experience" Although I am a member of the JSF Expert Group, I do not speak for the group in this weblog. |
| My JSF Experience Category: Java Of all the MVC Frameworks I've developed with in the last few weeks (Struts, Spring MVC, WebWork and Tapestry) - JSF was by far the worst. And it's not the implementations that are the problem, it's the spec itself (as far as I can tell). Plain and simple, it does not simplify web development. |
| Improve JSF by Decoupling Form Rules from Presentation Components The conceptual goal of this article is to convince component developers that the rules that govern form validation should be embedded in the form definition rather then spread between business and presentation logic. This approach (which I have advocated before) simplifies the mapping between requirements and implementation, and leads to code that is easier to maintain. |
| More on Tapestry and JSF A recent article at OnJava, Improving JSF by Dumping JSP has been the source of some interesting discussions. The author, Hans Bergsten, is on the JSF expert group and is quite aware of Tapestry ... he even modified the Hangman example from chapter two of Tapestry in Action for this article. |
| Book Review - JavaServer Faces Programming by Budi Kurniawan The book has the following chapters: Overview Of Java Web Technologies; Introduction To JavaServer Faces; Objects For Request Processing; The User Interface Component Model; JSF Simple Components; JSF Advanced Components; JSF Event Handling; Page Navigation; Validators; Converters; Internationalization And Localization; Renderers; Custom User Interface Components; Online Store Application; The Application Configuration File; Summing Up: How JSF Works; The JSP 2.0 Expression Language; The JSP Standard Tag Library; Installing And Configuring Tomcat 5; The Web Application Deployment Descriptor |
| ASP.NET and JavaServer Faces Although ASP.NET is a very loose implementation of the model-view-controller design pattern, it does follow several design patterns which make for an extremely productive environment. For example, ASP.NET implements the Page controller pattern with its code-behind concept. |
| Rave/JSCreator hits EA - Review/Notes I went to a Sun developer briefing yesterday @ Sun's campus in Broomfield on what has become of Project Rave. Its renamed to JSCreator for one thing and is finally in EA. You can download a copy |
| Java Studio Creator: First Thoughts I had to restart the installation process after it hung at 24%. Aparenlty the installer needs me to turn off the firewall at this point, but had timed out by the time I got around to taking care of it. I restarted the installation with my firewall off and it installed perfectly. I'm not sure if the installer said anything before I started the install process (I rarely pay attention to such things), but that's something that should be made clear before the process begins. |
| My Review of Java Studio Creator (a.k.a. Rave) Category: Java I attended a Rave Demo at Sun in Broomfield today. The meeting actually had two parts - the first hour was a marketing schpeel about Sun's Enterprise Java System and the second hour was a demo of Java Studio Creator. The first hour was boring and very marketing esque - they did have an interesting price point though - $100 per employee. This is small business friendly, which is nice to see. |
| My Review of Java Studio Creator (a.k.a. Rave) Category: Java I attended a Rave Demo at Sun in Broomfield today. The meeting actually had two parts - the first hour was a marketing schpeel about Sun's Enterprise Java System and the second hour was a demo of Java Studio Creator. The first hour was boring and very marketing esque - they did have an interesting price point though - $100 per employee. This is small business friendly, which is nice to see. |
| JSF: a regular expression validator Continuing my example from a few days back, this example shows how to create a JSF validator tag which checks agains a regular expression. |
| Getting started with JSF (on oc4j) |
| Role Based Rendering of UIComponents This example will show you how to conditionally render a UIComponent based on the users role. |
| JSF: UIComponent.getAttributes() -- good, bad or ugly? Back in September Allen Holub said that accessors are evil, there was also a long thread on TSS about Allen's article. Then very recently Cedric Beust posted that he thought accessors are here to stay and that Allen Holub was all wrong (I tend to agree with Cedric on accessors but Allen did make a couple of good points). Which all seem to have very little to do with JSF I know but... |
| JavaServer Faces and Orion Application Server Out of curiosity I tried to run the JSF 1.0 Beta Guess Number demo on Orion Application Server 2.0.2. I have listed the tweaks and fixes that I did. |
| Tapestry vs JSF Howard noted my parting mail to tapestry-dev in his blog. For the record, it was immediately followed with spelling corrections :-). I typed it in a frenzy of list unsubscriptions. Tapestry was unique among them as it was far less of a retreat than a glorious success. Ultimately, I hope to see Howard in the JBoss world more often. He's an awfully independent thinker which is evident in Tapestry and would fit in well with our group. Unfortunately, I will never have the opportunity to sheppard another project with a great guy like Howard into Apache ever again. That is a story for another day. |
| JSF EA4 and JSF 1.0 Beta changes - Action to MethodBinding Well this is the first of hopefully many installments on how to convert to the new JSF |
| JSF 1.0 PFD & 1.0 Beta RI finally here! Well the spec finally shipped a week after the first posting said it would. |
| 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. |
| JavaServer Faces 1.0 has been released, but why does it matter? Today marks the release of JavaServer Faces (JSF) 1.0 specification. It's been over two years in the making, and whether you're a skeptic or a supporter, there's no doubt this day has been highly anticipated. |
| A Proposal for Design-Time Metadata for Java Server Faces Components This document is a starting point for a community discussion that will hopefully result in a standard mechanism for associating design-time metadata with Java Server Faces components. Existing sources of grammar and metadata information are examined, and a strategy for providing additional design-time metadata is proposed. |
| JavaServer Faces Is Here It took more than two years, but JavaServer Faces (JSF), aka JSR 127, is finally available. In theory, JSF will help new developers build JavaServer-based Web applications quickly by assembling reusable user interface (UI) components in a page, connecting components to an application data source, and wiring client-generated events to server-side event handlers. Essentially, JSF provides a single application programming interface (API) set for creating interoperable components for application servers and component libraries. |
| 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". |