| See also: |
| ||
| View: | [ 2009 | 2008 | 2007 | 2006 | 2005 | 2004 | 2003 | 2002 | 2001 ] |
| Articles Books Examples Interview Transcripts | Links Presentations Tips Tutorials |
- Struts, JavaServer Faces, and Java Studio Creator: The Evolution of Web Application Frameworks by Janice J. Heiss - [Clicks: 284]
Sun Microsystems', Craig McClanahan, the creator of the Apache Struts Framework, co-specification lead for JavaServer Faces 1.0, and prime architect for Sun Java Studio Creator's new release, explains all three.
http://java.sun.com/developer/technicalArticles/Interviews/jsf_mcClanahan.html - Dec, 2004 - Developing a catalog style Web site using Websphere Studio by Dan O’Connor - [Clicks: 226]
The JavaServer Faces technology in WebSphere Studio simplifies the building of user interfaces for JavaServer applications. This article shows how to quickly develop a realtor’s Web site, including data on properties, local information, and mortgage rates. The same basic approach can be used to create Web applications for other industries.
[Includes source code]
http://www-106.ibm.com/developerworks/websphere/library/techarticles/0412_oconnor/0412_oconnor.html - Dec, 2004 - Getting around JSF: The role of JSP by Kito D. Mann - [Clicks: 171]
In this excerpt from JSF in Action (Manning, October 2004), author Kito Mann explains how JavaServer Pages fits with JavaServer Faces.
http://www.javaworld.com/javaworld/jw-12-2004/jw-1213-jsf.html - Dec, 2004 - FacesClient Components, Part 1: Portlet programming with FacesClient Components by Rod Henderson, Yongcheng Li, Thomas McElroy - [Clicks: 198]
Web applications developed using the thin client computing model exhibit performance gaps and user interface limitations. As an alternative, the IBM FacesClient Components (formerly called the Odyssey Browser Framework) provides a more effective model for developing Web applications. FacesClient Components work inside a portlet programming environment to deliver exceptional value to users in the form of richer user interfaces and improved application performance. In this article, three software engineers explore the fundamentals of FacesClient Components and its uses for building portlet applications.
http://www-106.ibm.com/developerworks/web/library/wa-facescomp1/ - Nov, 2004 - Creating a Pet Store Application ...with JavaServer Faces, Spring, and Hibernate by Derek Yang Shen - [Clicks: 1186]
JavaServer Faces (JSF) technology is a new user interface framework for J2EE applications. This article uses the familiar Pet Store application to demonstrate how to build a real-world Web application using JSF, the Spring Framework, and Hibernate. Since JSF is a new technology, this article will concentrate on the use of JSF. It presents several advanced features in JSF development, including Tiles integration and business logic-tier integration.
[Includes source code]
http://www.sys-con.com/story/?storyid=46977&DE=1 - Nov, 2004 - Developing JavaServer Faces portlets using WebSphere Studio and the IBM Portal Toolkit -- Part 3 by Roland Barcia, Sapna Mahwal - [Clicks: 289]
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, Part 2 used the JSF Web service component to build a Web service client portlet, and this conclusion shows how to deploy both portlets on the same page using WebSphere Portal.
[Includes a sample JSF portlet application]
http://www-106.ibm.com/developerworks/websphere/techjournal/0410_barcia/0410_barcia.html - Oct, 2004 - Globalizing Web applications with JSF and WebSphere Studio by Peng De Hua - [Clicks: 173]
Many application frameworks provide globalization features for the On Demand business environment. JavaServer Faces (JSF), the user interface framework for J2EE applications based on the Model-View-Controller (MVC) architecture, also provides globalization features. This paper will show you how to use them to develop a globalized Web application using JSF and WebSphere Studio Application Developer V5.1.2.
http://www-106.ibm.com/developerworks/websphere/library/techarticles/0410_peng/0410_peng.html - Oct, 2004 - JavaServer Faces (JSF) vs Struts by Roland Barcia - [Clicks: 256]
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.
http://www.sys-con.com/story/?storyid=46516&DE=1 - Sep, 2004 - Q&A: JavaServer Faces by Mimi Hills, Tony Ng, Ed Burns - [Clicks: 77]
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.
http://www.javaworld.com/javaworld/jw-09-2004/jw-0927-jsf.html - Sep, 2004 - JavaServer Faces, Web Applications Made Easier by Mike Houghton - [Clicks: 131]
JavaServer Faces (JSF) attempts to standardize the way we develop Java Web applications and provides a set of rich ready-to-use UI components. In this article, Mike Houghton will discuss the JSF technology, what's right, what's wrong and why it's necessary.
http://javaboutique.internet.com/articles/JSF/ - Sep, 2004 - Developing Web applications using RAD tools, IBM extended JSF components, and WebSphere Studio V.5.1.2 by Eugene Konstantinov - [Clicks: 250]
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.
http://www-106.ibm.com/developerworks/websphere/library/techarticles/0409_konstantinov/0409_konstantinov.html - Sep, 2004 - Understanding JavaServer Faces by Jeffrey Liu Helen Wong - [Clicks: 166]
This article examines JSF technology in both the business and technical horizons. You will be presented with the benefits of JSF and a scenario demonstrating the JSF support in the IBM WebSphere Studio Application Developer product.
http://www.sys-con.com/story/?storyid=46159&DE=1 - Aug, 2004 - Handling Events in JavaServer Faces, Part 2 by Hans Bergsten - [Clicks: 100]
Editor's note: The JSF model has the same look and feel as the event model used for standalone applications, but because user actions in JSF take place in a client separated from the server, delays occur in the delivery of some types of events until a new connection is established. In last week's part one of this two-part excerpt from JavaServer Faces, author Hans Bergsten provided examples to show how JSF deals with this difference, by using a strict request processing lifecycle. Here in part two, Hans implements event handling for parts of the sample application discussed in part one.
[O'Reilly Book Excerpts: JavaServer Faces]
http://www.onjava.com/pub/a/onjava/excerpt/JSF_chap8/index1.html - Aug, 2004 - Handling Events in JavaServer Faces, Part 1 by Hans Bergsten - [Clicks: 123]
Editor's note: O'Reilly's JavaServer Faces offers developers a guide to learning how to use the JSF framework to build web applications. In this excerpt from the book, author Hans Bergsten looks at the JSF event model, using examples to help explain what's going on "under the hood." Next week, in part two of this excerpt, Hans implements event handling for parts of the sample application discussed here.
[O'Reilly Book Excerpts: JavaServer Faces]
http://www.onjava.com/pub/a/onjava/excerpt/JSF_chap8/index.html - Aug, 2004 - Developing Web Applications with JavaServer Faces by Qusay H. Mahmoud - [Clicks: 153]
If you want to build web applications with rich user interfaces, come read about the nuts-and-bolts of JavaServer Faces -- a user interface framework that runs on the server side and renders the user interface back to the client! Plenty of code samples to sink your teeth into.
http://java.sun.com/developer/technicalArticles/GUI/JavaServerFaces/index.html - Aug, 2004 - Put JSF to work: Build a real-world Web application with JavaServer Faces, the Spring Framework, and Hibernate by Derek Yang Shen - [Clicks: 520]
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.
[Includes source code]
http://www.javaworld.com/javaworld/jw-07-2004/jw-0719-jsf.html - Jul, 2004 - Creating JSF Custom Components by Bill Dudney - [Clicks: 111]
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.
[Includes source code]
http://today.java.net/pub/a/today/2004/07/16/jsfcustom.html - Jul, 2004 - Delve Into Web Tier Components by Paul Philion - [Clicks: 37]
In my article, "Take a Tour of Web Tier Technologies," I outline J2EE Web tier technologies and discuss how you can use them to build robust Web applications. Those J2EE Web tier technologies are the subject of many JavaOne sessions this week, so in this article, I'll drill down further into the specific Web tier components.
http://www.ftponline.com/reports/javaone/2004/philion2/ - Jun, 2004 - An Introduction to JavaServer Faces by Ed Burns, Justyna Horwat - [Clicks: 73]
This article will give an overview and examples of some of these JavaServer Faces Technology features. For more details on these features and the other features offered by JavaServer Faces Technology, refer to the JavaServer Faces Technology chapters (Chapters 17-21) of the J2EE tutorial.
http://java.sun.com/j2ee/javaserverfaces/jsfintro.html - Jun, 2004 - Guidelines for Designing Reusable Custom Components Using JavaServer Faces Technology - [Clicks: 60]
… In the JavaServer Faces programming model applications can be constructed by simply assembling the user interface components for a particular request or response. Java Server Faces technology provides a number of concrete user interface component implementation classes that cover most of the common requirements. Component writers, application developers, tool providers and implementors of JavaServer Faces technology can create reusable components by extending the standard component API. This article gives you some basic guidelines for designing custom components using ChartComponent as an example.
[Includes sample code]
http://java.sun.com/j2ee/javaserverfaces/customcomponents.html - Jun, 2004 - Developing JavaServer Faces portlets using WebSphere Studio and the IBM Portal Toolkit - Part 1 by Roland Barcia, Sapna Mahwal - [Clicks: 102]
This three-part article series shows how the latest JavaServer(tm) 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(tm) client portlet, and how to package an EJB client JAR file inside your portlet WAR files.
[Includes source code]
http://www-106.ibm.com/developerworks/websphere/techjournal/0406_barcia/0406_barcia.html - Jun, 2004 - Developing Faces by Chris Schalk - [Clicks: 51]
… Oracle JDeveloper 10g is Oracle's integrated development environment for Java, Web services, XML, PL/SQL, and more. This article describes how to work with JSF in Oracle JDeveloper 10g.
http://otn.oracle.com/oramag/oracle/04-jul/o44dev_ojdev.html - Jun, 2004 - Making Faces by John Kirkley - [Clicks: 26]
… Clearly, a better solution is needed. Adam Winer, an architect at Oracle on the Application Developer Framework (ADF) View Technologies team, explains why: "Existing standards do not define how GUI elements get moved around in a common, standard way. When using JSP or Struts, developers wind up inventing a lot of code—either writing it themselves or duplicating something someone else has written. And everyone does it his or her own way."
http://otn.oracle.com/oramag/oracle/04-jul/o44tech_industry.html - Jun, 2004 - Improving JSF by Dumping JSP by Hans Bergsten - [Clicks: 83]
JSF is a great technology for complex web application interfaces. But Hans Bergsten urges you not to give up on JSF just because the JSP layer is flawed; using a custom ViewHandler resolves all of the issues.
http://www.onjava.com/pub/a/onjava/2004/06/09/jsf.html - Jun, 2004 - Mixing JSTL and JSF in Web Applications by Subbu Ramanathan - [Clicks: 52]
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.
[Includes source code]
http://www.devx.com/Java/Article/21020 - May, 2004 - Developing JSF applications using WebSphere Studio V5.1.1 -- Part 5 by Roland Barcia - [Clicks: 111]
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.
[Includes source code]
http://www-106.ibm.com/developerworks/websphere/techjournal/0405_barcia/0405_barcia.html - May, 2004 - Spinning Your Code with XSLT and JSF in Cocoon by Michael Nash - [Clicks: 81]
Explore the combination of the XML processing language XSL with the newly released JavaServer Faces (JSF) standard API, using the Apache Cocoon framework as an enabler for both.
http://www.developer.com/java/other/article.php/3348311 - May, 2004 - Developing JSF applications using WebSphere Studio V5.1.1 -- Part 4 by Roland Barcia - [Clicks: 95]
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.
[Includes sample code]
http://www-106.ibm.com/developerworks/websphere/techjournal/0404_barcia/0404_barcia.html - Apr, 2004 - Introduction to JavaServer Faces by Alexander Prohorenko - [Clicks: 60]
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.
http://www.onjava.com/pub/a/onjava/2004/04/07/jsf.html - Apr, 2004 - J2EE Core Patterns and JSF - [Clicks: 213]
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.
http://www.eccodynamics.com/tiles/en/articles--demos.jsp - Mar, 2004 - (PDF) - Introduction to JavaServer Faces, Part 3 by Budi Kurniawan - [Clicks: 99]
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 (McGraw-Hill/Osborne, ISBN 0-07-222983-7, 2004).
http://www.devshed.com/c/a/Java/Intro-to-JavaServer-Faces-3/ - Mar, 2004 - Developing JSF applications using WebSphere Studio V5.1.1 - Part 3 by Roland Barcia - [Clicks: 51]
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.
[Includes source code]
http://www-106.ibm.com/developerworks/websphere/techjournal/0403_barcia/0403_barcia.html - Mar, 2004 - Introduction to JavaServer Faces Part 2 by Budi Kurniawan - [Clicks: 134]
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.
http://www.devshed.com/c/a/Java/Introduction-to-JavaServer-Faces-Part-2/ - Mar, 2004 - Introduction to JavaServer Faces, Part 1 by Budi Kurniawan - [Clicks: 86]
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 (McGraw-Hill/Osborne, ISBN 0-07-222983-7, 2004).
http://www.devshed.com/c/a/Java/Introduction-to-JavaServer-Faces-1/ - Mar, 2004 - Facing Forward with JSF by Budi Kurniawan - [Clicks: 90]
This article demonstrates how to build an online pizza ordering system using JSF.
[Includes source code]
http://otn.oracle.com/oramag/oracle/04-mar/o24dev_jsf.html - Feb, 2004 - UI frameworks and JavaServer Faces by Michael Nash - [Clicks: 66]
The arrival of JSF should not cause you to abandon existing UI frameworks. The good news is that JSF is perfectly capable of working in conjunction with these frameworks, and has in fact been designed with easy integration in mind. Take a look at how JSF can be used in conjunction with existing frameworks, as an enhancement, not a potential replacement.
[Struts, Cocoon, Velocity, Tapestry]
http://www.developer.com/java/other/article.php/3314971 - Feb, 2004 - Developing JSF Applications using WebSphere Studio V5.1.1 -- Part 2 by Roland Barcia - [Clicks: 41]
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.
[Includes sample code]
http://www-106.ibm.com/developerworks/websphere/techjournal/0402_barcia/0402_barcia.html - Feb, 2004 - JSF Navigation by Examples by Sergey Smirnov - [Clicks: 97]
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.
http://forum.exadel.com/viewtopic.php?t=579 - Feb, 2004 - Developing JSF Applications using WebSphere Studio V5.1.1 -- Part 1 by Roland Barcia - [Clicks: 55]
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.
http://www-106.ibm.com/developerworks/websphere/techjournal/0401_barcia/barcia.html - Jan, 2004 - The Many Faces of JavaServer Faces (JSF) by Michael Nash - [Clicks: 52]
Determine if JavaServer Faces will help you build effective user interfaces.
http://www.developer.com/java/other/article.php/3294951 - Jan, 2004
- JavaServer Faces in Action
by Kito D. Mann - [Clicks: 213]
JavaServer Faces helps streamline your web development through the use of UI components and events (instead of HTTP requests and responses). JSF components—buttons, text boxes, checkboxes, data grids, etc.—live between user requests, which eliminates the hassle of maintaining state. JSF also synchronizes user input with application objects, automating another tedious aspect of web development. JavaServer Faces in Action is an introduction, a tutorial, and a handy reference. With the help of many examples, the book explains what JSF is, how it works, and how it relates to other frameworks and technologies like Struts, Servlets, Portlets, JSP, and JSTL. It provides detailed coverage of standard components, renderers, converters, and validators, and how to use them to create solid applications. This book will help you start building JSF solutions today.
Manning Publications, Paperback - Oct, 2004 - Mastering JavaServer Faces
by Bill Dudney, Jonathan Lehr, Bill Willis, LeRoy Mattingly - [Clicks: 138]
This innovative book arms you with the tools to utilize JavaServer Faces (JSF), a new standard that will make building user interfaces for J2EE applications a lot easier. The authors begin by painting the architectural big picture–covering everything from the Patterns that are used in the implementation to the typical JSF Request/Response lifecycle. Next, you’ll learn how to use JSF in the real world by uncovering the various pieces of the JSF component model, such as UI components, events and validation. The authors then explain how to apply JSF, including how to integrate JSF user interfaces with the Business Tier and how to render your own user interface components. By following this approach, you’ll be able to confidently create and validate your own custom applications that meet the needs of your company.
Wiley, Paperback - Jun, 2004 - Core JavaServer Faces
by David Geary, Cay S. Horstmann - [Clicks: 113]
JavaServer Faces promises to bring rapid user-interface development to server-side Java. It allows developers to painlessly write server-side applications without worrying about the complexities of dealing with browsers and Web servers. It also automates low-level, boring details like control flow and moving code between web forms and business logic. JavaServer Faces was designed to support drag and drop development of server-side applications," but you can also think of it as a conceptual layer on top of servlets and JavaServer Pages (JSP). Experienced JSP developers will find that JavaServer Faces provides much of the plumbing that they currently have to implement by hand. If you already use a server-side framework such as Struts, you will find that JavaServers Faces uses a similar architecture, but is more flexible and extensible. JavaServer Faces also comes with server-side components and an event model, which are fundamentally similar to the same concepts in Swing.
Prentice Hall PTR, Paperback - Jun, 2004 - JavaServer Faces
by Hans Bergsten - [Clicks: 82]
In JavaServer Faces, developers learn how to use the new JavaServer Faces framework to build real-world web applications. The book contains everything you'll need: how to construct the HTML on the front end; how to create the user interface components that connect the front end to your business objects; how to write a back-end that's JSF-friendly; and how to create the deployment descriptors that tie everything together. This book is a complete guide to the crucial new JSF technology.
O'Reilly Media, Inc., Paperback - Apr, 2004
- Using JavaServer Faces (JSF) Navigation Handler Decorator by Sergey Smirnov - [Clicks: 701]
This short example shows how to use the Javaserver Faces Navigation Handler decorator to extend the standard navigation mechanism used in the JSF. The application has a login page and two pages that allow to show and edit user profile data. The profile pages are available only if user logged in. If not, the login page is shown. After login page, user will be redirected to the page selected previously. Note: This is only a prototype that shows how you can use navigation handler decorator. For the simplicity reason, many aspects you can meet in the real projects are omitted.
http://www.jsftutorials.net/jsfNavigation/jsf-login-navigation-redirect.html - Dec, 2004 - How to use Tiles with JSF Applications by Sergey Smirnov - [Clicks: 577]
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.
http://forum.exadel.com/viewtopic.php?t=968 - Apr, 2004 - Drill-Down Grid - [Clicks: 741]
This is a complete 'drill-down grid' example implemented with JSF 1.0 Technology. The user interface is connected to the Backend through a Java BusinessDelegate. See also the article 'J2EE Core Patterns and JSF' above for inside details.
http://www.eccodynamics.com/tiles/en/articles--demos.jsp - Mar, 2004 - JSF: a regular expression validator by Andrej Koelewijn - [Clicks: 286]
Continuing my example from a few days back, this example shows how to create a JSF validator tag which checks agains a regular expression. Step 5: custom validator tag;
http://andrej.racchvs.com/archive/2004/03/25/jsf_a_regular_expression_validator.html - Mar, 2004 - Getting started with JSF (on oc4j) by Andrej Koelewijn - [Clicks: 559]
Step 1: Hello World!; Step 2: a registration form; Step 3: simple validation; Step 4: custom validation.
http://andrej.racchvs.com/archive/2004/03/21/getting_started_with_jsf_on_oc4j.html - Mar, 2004 - Role Based Rendering of UIComponents by Bill Dudney - [Clicks: 276]
This example will show you how to conditionally render a UIComponent based on the users role.
http://bill.dudney.net/roller/page/bill/20040310#role_based_rendering_of_uicomponents - Mar, 2004 - Using Popup Windows in JavaServer Faces Applications by Sergey Smirnov - [Clicks: 710]
This example shows how to use a client-side script to control a form field rendered by JSF, how to launch a popup window and return a result back to the main window, and how to use the standard JSF Navigation Framework for navigation in a multiple-windows interface environment.
http://forum.exadel.com/viewtopic.php?t=559 - Feb, 2004 - Template for simple JSF application under Eclipse by Sergey Smirnov - [Clicks: 388]
This template can be used as a good starting point to play with JSF under Eclipse. … It's a ready-to-deploy Eclipse project contains simple "Hello, World"-style application.
http://forum.exadel.com/viewtopic.php?p=1930 - Jan, 2004
- JavaServer Faces (JSF) by Kito D. Mann - [Clicks: 38]
In this interview, Kito compares UI-oriented and foundation-oriented frameworks, and what JavaServer Faces (JSF) will mean to users of frameworks such as Struts, Webwork and Tapestry. He talks about what's new in the beta release, the state of vendor tool support for JSF, and lists various tools and apps making use of JSF today. He compares JSF to ASP.NET WebForms and outlines the challenges for industry-wide adoption of JSF.
http://www.theserverside.com/talks/library.jsp#mann - Jan, 2004
- Core JavaServer Faces by David Geary, Cay S. Horstmann - [Clicks: 37]
This web site contains a sneak preview of the upcoming Sun Microsystems Press book Core JavaServer Faces.
http://horstmann.com/corejsf/
- About Faces: The JavaServer Faces API and how it relates to Struts by Ed Burns - [Clicks: 287]
Presentation Goals: Demonstrate how JavaServer Faces makes it easier for you to develop Java web applications that are both usable and scalable. Cover some differences, similarities, and an integration strategy with Struts.
https://javaserverfaces.dev.java.net/presentations/20040729-OJUG.pdf - Jul, 2004 - (PDF - 363 Kb) - Developing Advanced Graphics Components Using JavaServer(TM) Faces Technology by Christophe Jolif - [Clicks: 180]
This session describes how to develop JavaServer(TM) Faces components to easily deploy advanced 2D graphics views, such as network diagrams and charts, on the Web from a Java(TM) Web server. Following the path of writing a concrete example, the session describes in detail the necessary steps to build such a component and render it on the client, either with regular DHTML or leveraging the advanced possibilities of the Scalable Vector Graphics (SVG) format. Learn about JavaServer Faces and SVG technologies and how to write your own JavaServer Faces components.
[JavaOne 2004]
http://www.javaone04.com/session-html/TS-1936.html - Jul, 2004 - Advanced Real-World JavaServer(TM) Faces Technology-Based Application Development by Carl Quinn, Octavian Tanase, Tor Norbye - [Clicks: 109]
JavaServer(TM) Faces technology is a rich and flexible application framework that enables a broad range of application development models. This session gives a brief overview of JavaServer Faces software, and then digs in to explore more advanced areas. It then presents a number of practical approaches and design patterns to leverage the power of JavaServer Faces technology while managing its complexity. Concrete application examples are shown, built using Sun Java(TM) Studio Creator application development tool, and then dissected to illustrate how they leverage JavaServer Faces technology.
[JavaOne 2004]
http://www.javaone04.com/session-html/TS-1580.html - Jun, 2004 - Creating a Component Community for JavaServer(TM) Faces Technology by Adam Winer, Brian Albers, Jeffrey Stephenson - [Clicks: 57]
… This session presents proposals, tips and tricks, and demonstrations of ways to enhance the JavaServer Faces software interface for the next generation of Web applications. The goal is to foster development of a component community based on the JavaServer Faces platform, similar to those for Swing and Visual Basic, which will evolve the Web user interface. Specific topics covered include: tips on developing components richer than basic HTML; proposals for metadata that improve tooling and design time; look-and-feel customization of components; declarative component development; and packaging and sharing of JavaServer Faces component libraries. Demonstrations of multiple tools and JavaServer Faces extensions are included.
[JavaOne 2004]
http://www.javaone04.com/session-html/TS-1103.html - Jun, 2004 - Putting Faces on Your Portlets: Exploiting JavaServer Faces Technology in Portlet Applications by Brendan Murray - [Clicks: 229]
A popular, new technology has recently emerged from the Java Community Process (JCP) as JSR 127. JavaServer Faces technology, providing an application framework that sophisticated Web-based applications are being created with. Another technology increasing in popularity, and also recently graduated from the JCP process as JSR 168, is portlets. This session is designed for experienced Web developers who wish to expand their usage of JavaServer Pages technology to create better portlet applications using JavaServer Faces technology, showing in-depth examples of how to to produce reliable and robust applications that exploit the application support of JavaServer Faces technology to deliver applications that will run on a portal server.
[JavaOne 2004]
http://javaoneonline.mentorware.net/servlet/mware.servlets.StudentServlet?mt=1094979941819&mwaction=showDescr&class_id=28142&fromtopic=By%20Topic&subsysid=2000&topic=technical&avail_frames=true - Jun, 2004 - Building Real World Apps with JSF by Bill Dudney - [Clicks: 192]
JSF Overview: - What is JSF and how does it work; - What is MVC for the Web (WMVC). Architecture of JSF Applications: - Views, Controllers and Models.
[Includes source code]
http://bill.dudney.net/roller/page/bill/20040309#arch_of_jsf_apps_presentation - Mar, 2004 - Open Source Java Server Faces by Edwin Mol, Dimitry D'Hondt - [Clicks: 109]
After an introduction to JavaServer Faces (JSF), illustrated with a demo application, the open source JSF implementation 'Smile' will be covered in this presentation. A comparison to other web frameworks, and more in particular Struts, will also be given.
[The Belgian Java User Group Workshop: Java Web Development]
http://smile.sourceforge.net/files/smile@bejug.pdf - Mar, 2004 - (PDF - 177 Kb)
- Custom Components With JavaServer Faces Technology by Robert Eckstein - [Clicks: 68]
In this tip, you'll learn how to create custom components using JSF technology. More specifically, you'll learn how to create a custom JSF technology component that represents a simple stock display. Through an accompanying JavaServer Pages (JSP) page, a user can enter a stock symbol into a input text field and then press the Submit button. In response, the custom component displays a table below the text field. The table contains the stock's symbol, the current price of the stock, and the daily change in the stock price.
[Includes sample code]
http://java.sun.com/developer/EJTechTips/2004/tt1123.html#2 - Nov, 2004 - Value and Method Binding Expressions in JavaServer Faces Technology by N. Alex Rupp - [Clicks: 70]
One of the aims of JavaServer Faces technology is to support a role-based workflow for application development. The technology is designed to address the unique concerns and needs of page authors, user interface component designers, and business model developers. As such, there are several ways that a developer can approach the technology. This tip focuses on the role of the page author, for whom binding expressions provide a way to access the data model.
[Includes sample code]
http://java.sun.com/developer/EJTechTips/2004/tt0923.html#1 - Sep, 2004 - Introducing JavaServer Faces Technology by Mark Johnson - [Clicks: 64]
JSF's scope is ambitious. It provides the following tools to application designers and developers: - A standard GUI component framework for tool integration; - Simple, lightweight classes to represent input events and stateful, server-side GUI components; - A set of HTML form input elements that represent the server-side GUI components; - A JavaBeans model for translating input events to server-side behavior; - Validation APIs for both the client side and server side; - Internationalization and localization; - Automatic view presentation, customized to client type (for example, browser or media type); - Integrated support for accessibility.
[Includes sample code]
http://java.sun.com/developer/EJTechTips/2004/tt0324.html#2 - Mar, 2004
- FacesClient Components Developer's Guide by Laurent Hasson - [Clicks: 255]
Based on JSF technology, FacesClient Components (formerly called the Odyssey Browser Framework) can simplify the development of interactive Web pages and improve their usability and performance by reducing the number of round-trip interactions with the server. The result for the end user is faster response times and increased freedom to interact with the page. This comprehensive Developer's Guide describes the different FacesClient Components, and shows you how to use them with WebSphere Studio to build Web and portlet applications.
http://www-106.ibm.com/developerworks/websphere/library/techarticles/0411_hasson/0411_hasson.html - Nov, 2004 - (PDF - 3800 Kb) - WebSphere Studio 5.1.2 JavaServer Faces and Service Data Objects by Ueli Wahli, Gabriel Cohen, Matthew Perrins, Luis Sanchez Acera, Mads Zandersen - [Clicks: 183]
This redbook covers all of the core features of JSF Web development and the tools that are available in WebSphere Studio Application Developer 5.1.2 to design, develop, deploy, and test JSF Web applications.
[Formats: PDF, HTML]
http://publib-b.boulder.ibm.com/Redbooks.nsf/RedpieceAbstracts/sg246361.html?Open - Aug, 2004 - How To Create Your Own JSF Components - [Clicks: 390]
The tutorial consists of seven separate steps for building up an example application. Each step adds new code to the previous example. The tutorial includes code representing the result of each step. If you are lost, you can compare these target results with your results. Also, you might want to add some extra feature to the code to test how it works. If this messes things up, you can just replace your code with the included code to go on to the next step.
[Formats: HTML, PDF]
http://www.exadel.com/tutorial/jsf/jsftutorial-customcomponents.html - Jun, 2004 - Creating Web-based user interfaces: Using WebSphere Studio V5.1.2 to develop JavaServer Faces applications by Ron Ben-Natan - [Clicks: 248]
JavaServer(tm) 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.
[Formats: HTML, PDF, Zip]
http://www-106.ibm.com/developerworks/edu/i-dw-wes-wesjsf-i.html - Jun, 2004 - JavaServer Faces 1.0 Part I by Gregg Bolinger - [Clicks: 372]
JavaServer Faces future remains to be seen. But as you can see from this tutorial, it's not that difficult of a framework. In fact, I found it easier to get a grasp of than Struts. The tools that become available for JSF are going to be the key to its dexterity and from what I have been reading, a lot of tools are on the way. In Part 2 of my JSF tutorial series I will demonstrate how to perform custom validation and we will look at how we can easily bind data to form elements like select lists.
http://www.javaranch.com/newsletter/200404/JSF_Part1.html - Apr, 2004 - A JSF-Based GuessNumber Application (Showing Standard Validation and Backing Bean Methods) - [Clicks: 150]
In this tutorial, we will try to use as many aspects of JSF as possible. This example uses the standard validation in JSF. We will also show how to use backing bean methods to help with navigation.
[Includes source code]
http://www.exadel.com/tutorial/jsf/jsftutorial-guessnumber.html - Mar, 2004 - The J2EE 1.4 Tutorial by Eric Armstrong, Jennifer Ball, Stephanie Bodoff, Debbie Bode Carson, Ian Evans, Dale Green, Kim Haase, Eric Jendrock - [Clicks: 123]
The J2EE 1.4 Tutorial is for programmers interested in developing and deploying J2EE applications on the J2EE 1.4 SDK. The tutorial describes how to develop JavaServer Faces applications for the J2EE 1.4 SDK, how to use Web services technologies, and how to write applications using the new versions of J2EE platform technologies (Servlet 2.4, JSP 2.0, EJB 2.1, JMS 1.1, J2EE Connector 1.5).
http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html - Mar, 2004 - JavaServer Faces HTML Tags - [Clicks: 300]
This is a handy reference table of the HTML-related JSF tags showing examples of HTML output and rendered output.
http://www.exadel.com/tutorial/jsf/jsftags-guide.html - Mar, 2004 - JSF KickStart - A Simple JavaServer Faces Application - [Clicks: 350]
We won't dwell on the theory behind JSF here. There are plenty of sites and planned books that will do that for you. Instead, we will show you an example that we hope can form the basis for you to start developing more advanced applications.
[Includes a project structure skeleton]
http://www.exadel.com/tutorial/jsf/jsftutorial-kickstart.html - Mar, 2004 - Creating Web-based user interfaces: Using WebSphere Studio V5.1.1 to develop JavaServer Faces applications by Ron Ben-Natan - [Clicks: 115]
... The tutorial teaches you how to use Java Server Faces technology for building Web applications using WebSphere Studio 5.1.1. Using a simple application example of a messaging center, the tutorial shows you how to use JSF tools in WebSphere Studio 5.1.1 to build the various parts of the Web application.
[Formats: HTML, PDF, Zip]
http://www-106.ibm.com/developerworks/edu/i-dw-wes-wesjsf-i.html - Feb, 2004
