Roger Kitain's Blog

JavaServer Faces 2.0 Early Draft Review 2 And JavaScript?

The JavaScript public API is the beginnings of the client side portion of the JavaServer Faces / Ajax standard. The JavaServer Faces 2.0 Expert Group includes members representing other JavaServer Faces / Ajax frameworks such as RichFaces, ADF Faces (Trinidad) and ICEfaces.

We're definitely exploring new territory here, as this is the first time that a public JavaScript API has been introduced with JavaServer Faces to the JCP. It may be the first time a public JavaScript API has been introduced to the JCP, period.

Back To Basics With JSF and Ajax

This demo uses the Dynamic Faces library (with JSF) to illustrate a stock lookup service. To simplify things for the demo, there are only three artifacts used in the demo:

One JSP page
One small JavaScript file
One Managed Bean

First, let's take a look at the UI:

The UI is pretty basic. You enter one or more space delimited stock symbols in the "Symbols" text field and press the "Search" button. You can enter proxy information if you are behind a firewall. The most interesting feature of the demo is the "Streaming" option. If "Streaming" is set to "On", the client will poll the server, firing Ajax transactions every 10 seconds (or a specified time interval). The "Remote/Local" option allows you to switch the demo to use local data, if a network connection is not available. If the "Remote" option is used, the Yahoo Stock Quoting service is used to get the stock data. The table of stock data will dynamically change size depending on the number of symbols that are used in the query. Let's take a look at the artifacts used in this demo.

JSP

Here's a snippet of the JSP page for the demo, showing the relevant parts:

...
...










                onclick="DynaFaces.fireAjaxTransaction(this, {});return false;"
                actionListener="#{bean.getStockInfo}" />






                onchange="toggleStreaming()">











        styleClass="panel-data-border" rendered="false">

Here is an explanation of the "blue" sections in the code snippet:

is the standard tag to include for Dynamic Faces applications, and it includes the Dynamic Faces JavaScript library.
The include_js('javascripts/stock-faces.js'); line is just a utility function that loads the application's JavaScript file stock-faces.js (which we will discuss next).
The h:commandButton tag has an onclick JavaScript event handler attached to it - DynaFaces.fireAjaxTransaction, which will send an Ajax request to the server when the button is pressed. The actionListener specified by #{bean.getStockInfo} will get executed on the server as usual. But the key is that any view or JSF component manipulation done on the server will happen over Ajax.
The "streaming" option is just a h:selectOneMenu component that has an onchange JavaScript event handler.
Next is the "placeholder" for our dynamic table of stock data. The attribute rendered is set to false, but this will be set to true from the application code when there is stock data to return.

Get the entire source of this file here.

Application JavaScript

stock-faces.js

var pollId;

/** Delay between requests to the server when polling. */
var pollDelay = 10000;

/** Start polling the server */
function start() {
    pollId = setInterval(poll, pollDelay);
}

/** Stop polling the server */
function stop() {
    clearInterval(pollId);
}

function poll() {
    queueEvent();
    DynaFaces.fireAjaxTransaction(null, {});
}

function queueEvent() {
    var actionEvent =
        new DynaFaces.ActionEvent("search",
        DynaFaces.PhaseId.INVOKE_APPLICATION);
    DynaFaces.queueFacesEvent(actionEvent);
    return false;
}

function toggleStreaming() {
    var menu = document.getElementById("streaming");
    var idx = menu.selectedIndex;
    var streaming = menu[idx].value;
    if (streaming == "Off") {
        stop();
    } else if (streaming == "On") {
        start();
    }
}

The polling delay (or the time interval between calls to the server is 10 seconds.
The start() function kicks off the server polling.
The stop() function stops server polling.
The poll() function does two things:
1. It queues up a server side JSF action event.
3. Fires an Ajax request to the server using the Dynamic Faces library.
The queueEvent() function queues up a server side <>JSF action event using the Dynamic Faces library. This action event will get processed during the standard JSF lifecycle processing as the Ajax request flows through.
The toggleStreaming() function just toggles the value of the "streaming" menu control.

Get the entire source for this file here.

JSF Managed Bean

Bean.java (how original...)

/**
* This bean has methods to retrieve stock information from
* the Yahoo quote service.
*/
public class Bean {

    private static final String SERVICE_URL =
            "http://quote.yahoo.com/d/quotes.csv";

    /**
     * Action method that is used to retrieve stock information.
     * This method uses two helper methods - one to get the
     * stock information, and the other to dynamically build
     * the "data" components for the UI.
     */
    public void getStockInfo(ActionEvent ae) {
...
...
                        stockData = getStockData(symbols);
                        buildUI(stockData);
...
    }

    /**
     * Helper method to get the stock data (remotely).
     */
    private String[] getStockData(String[] symbols)
        throws IOException, MalformedURLException {
        String[] data = new String[symbols.length];
        for (int i=0; i             StringBuffer sb = new StringBuffer(SERVICE_URL);
            sb.append("?s=");
            sb.append(symbols[i]);
            sb.append("&f=snol1cp2v=.csv");
            String url = sb.toString();
            URLConnection urlConn = null;
            InputStreamReader inputReader = null;
            BufferedReader buff = null;
            try {
                urlConn = new URL(url).openConnection();
                inputReader = new InputStreamReader(
                    urlConn.getInputStream());
                buff = new BufferedReader(inputReader);
                data[i] = buff.readLine();
                data[i] = data[i].replace( "\"", "" );
...
...
        }
        return data;
    }

    /**
     * Helper method to dynamically add JSF components to display
     * the data.
     */
    private void buildUI(String[] stockData) {
        FacesContext context = FacesContext.getCurrentInstance();
        UIForm form = (UIForm)context.getViewRoot().findComponent("form");
        UIPanel dataPanel = (UIPanel)form.findComponent("stockdata");
        String buffer = null;
        dataPanel.getChildren().clear();
        for (int i=0; i             String[] data = stockData[i].split("\\,");
            UIOutput outputComponent = null;
            UIGraphic imageComponent = null;
...
...
            // Create and add components wth data values

            // Symbol

            outputComponent = new UIOutput();
            outputComponent.setValue(data[0]);
            dataPanel.getChildren().add(outputComponent);

            // Name

            outputComponent = new UIOutput();
            outputComponent.setValue(data[1]);
            dataPanel.getChildren().add(outputComponent);

            // Open Price (if any)

            outputComponent = new UIOutput();
            try {
                openPrice = new Double(data[2]).doubleValue();
            } catch (NumberFormatException nfe) {
                openPriceAvailable = false;
            }
            outputComponent.setValue(data[2]);
            dataPanel.getChildren().add(outputComponent);
...
...
        }
        dataPanel.setRendered(true);
    }

This JSF Managed Bean has an action method getStockInfo that does two things:

It uses a helper method getStockData to contact the Yahoo Stock Quote service (as defined by SERVICE_URL) to retrieve stock data for all the symbols.
It uses a helper method buildUI to build JSF components (from the stock data) and it adds the JSF components to the JSF component view. After all components have been created and added, then it sets the rendered attribute to true on the "stockdata" JSF component.

The action method, getStockInfo is called on two seperate occasions:

It is called when the "Search" button is pressed.
It is also called as the result of an Ajax "poll" request. This is because each client poll queues an action event tied to this event handler. Refer to the queueEvent method in the stock-faces.js JavaScript file.

Get the entire source of this file here.

Summary

We've seen how we can combine the power of JSF component building with Ajax to produce dynamic applications. This application illustrated the use of two features from Dynamic Faces:

fireAjaxTransaction
Remote JSF event queueing from JavaScript

This application is included as one of the samples applications in the jsf-extensions project. Please refer to the jsf-extensions FAQ for getting and building the source code.

Resources

jsf-extensions
GlassFish
javaserverfaces

MobileFaces, Mobile JSF Kit and GlassFish

The core MobileFaces library is currently based on the JSF 1.1 specification. The library not only makes it easier to develop mobile web applications, but it also utilizes a key extensible piece of the JSF architecture - RenderKits and Renderers. This allows the same underlying component model to render not only in HTML, but markup that is suitable for mobile devices (such as WML). Here, we'll take a look at how we can get one of the sample Mobile JSF Kit applications up and running on the GlassFish application server.

Prerequisites:

A working build environment with ant, at least JDK 5, and GlassFish. I've recently run MobileFaces and the Mobile JSF Kit on the GlassFish v2 B52 Promoted Build.

Setup:

Download and unpack the Mobile Faces Source to some directory, say MobileFaces.
Go to the MobileFaces directory. Get the build.xml script and the associated build.properties file for GlassFish from here and unpack it in the MobileFaces directory. Edit the glassfish.home property in the build.properties.glassfish file to refer to your GlassFish top level directory.
Build MobileFaces from source: ant -f build.xml.glassfish build
Download and unpack the Mobile JSF Kit. After you unpack it you will see a samples directory.
Go to the HelloMobile directory under the samples directry - this will be the sample application we'll be running. Currently, the build scripts are set up to work with Tomcat. Get the build.xml script and the associated build.properties file for GlassFish from here and unpack it in the HelloMobile directory. Edit the glassfish.home property in the build.properties.glassfish file to refer to your GlassFish top level directory. Edit the mobilfaces.home property in the build.properties.glassfish file to refer to your MobileFaces directory.
Build the HelloMobile application: ant -f build.xml.glassfish build
Start the GlassFish application server (if it's not already started) and deploy the application to the GlassFish application server. The helloMobile_R1A.war file will be under the HelloMobile/dist directory. The application will be deployed as: helloMobile_R1A

Running the Application:

To test your mobile web application you can use a phone simulator with a mobile browser. Here, we will use the Openwave Phone Simulator with the Openwave Mobile Browser. The simulator uses the same browser that is embedded in real mobile phones. I believe this simulator only works on Windows - but they may have a Linux version available as well.

Download and install the Openwave Phone Simulator from here.
Start up the phone simulator. In addition to the phone simulator you will see a console window for the simulator.

Configure the phone simulator to your environment. Under Settings select Server Profiles. There you can set your network settings. I used http-direct with no proxy.
Configure the phone simulator with the appropriate User-Agent. To test the WML rendering capabilities of MobileFaces, go to Settings, then Device Settings, and change the User Agent field to: OPWV-SDK-WML.
Enter the URL http://localhost:8080/helloMobile_R1A in the phone simulator URL field and press "enter".

Now you should see the application loaded into the simulator. You can also see the page content sent in the response in the simulator console window:

Under The Hood:

The MobileFaces architecture includes a servlet filter that examines the user-agent information on the incoming request. The architecture also extends the JSF RenderKitFactory to load up RenderKits for xhtmL-MP and WML in addition to the Standard HTML RenderKit. The extensibility of the JSF architecture allows you to create additional RenderKits. Based on the user-agent it will create the appropriate RenderKit that will render the markup in the JSF Render Response Phase. MobileFaces also includes a small library of custom tags to use in your pages and these can be used along with the Standard HTML JSF tags.

Resources:

GlassFish Application Server
MobileFaces
Mobile JSF Kit
JavaServer Faces

It's also worth noting that there is a Mobile JSF Kit Netbeans plugin available for download at the Mobile JSF site. But that's a topic for discussion on another day..

Seam 1.1.0.GA On GlassFish

To get prior releases of Seam running on GlassFish, you had to patch some Seam application modules. With this release, there is no patchwork necessary - the folks at JBoss (RedHat) have done a great job of streamlining the process. In fact, after you download and unpack the Seam 1.1.0.GA release from here, you will see a GlassFish sample application (which is essentially the booking application) under the "jboss-seam-1.1.0.GA\examples\glassfish" directory. In this entry, we will outline the steps to get this release of Seam running on GlassFish with Java Persistence.

Prerequisites:

A working build environment with ant, at least JDK 5, and GlassFish. I've run this version of Seam successfully on the GlassFish v1 FCS (v1_ur1-p01-b02) and GlassFish v2 (Build 30) builds.

Seam Setup:

Download and install the Seam 1.1.0GA release from here. You should see a jboss-seam-1.1.0.GA directory.
Go to the jboss-seam-1.1.0.GA/examples/glassfish directory.
Build the sample application using the "toplink" build target:
- ant clean; ant toplink
The "toplink" target builds the EAR file using toplink as the JPA provider.

Deploy the application:

Start up GlassFish: /bin/asadmin start-domain domain1
Start the database: /bin/asadmin start-database
Deploy jboss-seam-1.1.0.GA/examples/glassfish/build/jboss-seam-glassfish.ear

Note that deploying the application will create the necessary application database tables, and undeploying the application will remove the application database tables.

Load the database:

Get the sql script that will be used to load the database from here and unpack it to some directory. You should see the script: import.sql
Go to the directory that contains the import.sql script.
Set your CLASSPATH to include:
- /javadb/lib/derbyclient.jar
- /javadb/lib/derbytools.jar
- /javadb/lib/derby.jar
Get into the "ij" utility: java org.apache.derby.tools.ij
At the "ij>" prompt:
- ij> DRIVER 'org.apache.derby.jdbc.ClientDriver';
- ij> CONNECT 'jdbc:derby://localhost:1527/sun-appserv-samples';
- ij> run 'import.sql';

Now the Seam application tables should be loaded.

Run the application:

visit localhost:8080/jboss-seam-glassfish

Seam (FCS) On GlassFish

So far we've seen how we can get Seam running on GlassFish with Hibernate Persistence and Java Persistence. Modifications were needed to the Seam core classes as well as the application classes. Fortunately, JBoss has made the modifications to their core classes in time for their Seam FCS release. In this entry we'll outline the steps to get the Seam FCS release up and running on GlassFish with Java Persistence.

Prerequisites:

A working build environment with ant, at least JDK 5, and GlassFish (build 43 or later).
You'll need to use some of the Hibernate libraries that the Seam framework depends on:

Download and install Hibernate3 3.2cr1.
Download and install Hibernate EntityManager 3.1 beta7 . Note that hibernate-entitymanager.jar is not required because we'll be using Java Persistence. However, hibernate-annotations.jar is still required, because the Seam framework uses classes from the Hibernate validator package.
Copy the required hibernate jars into Glassfish lib dir. The script here contains the list of jars.
Edit the script to make sure it references your Glassfish and Hibernate install directories.
Execute the script.

Seam Setup:

Download and install the Seam 1.0.1.GA release from here. You should see a jboss-seam-1.0.1.GA directory.
Get the zip file: seam-1.0.1.GA-booking-patch.zip .
Go to the jboss-seam-1.0.1.GA directory and unzip seam-1.0.1.GA-booking-patch.zip.

Compilation Procedure:

Copy jboss-seam-1.0.1.GA/lib/thirdparty-all.jar to /lib
Compile Seam core classes - this will compile the HtmlLink class in the ui package.

Go to the jboss-seam-1.0.1.GA directory
ant

Compile Seam Booking Application:

Go to the jboss-seam-1.0.1.GA/examples/booking directory
ant

Deploy the application:

Start up Glassfish.
Start the database: /bin/asadmin start-database
Deploy jboss-seam-1.0.1.GA/examples/booking/build/jboss-seam-booking.ear

Load the database:

Go to jboss-seam-1.0.1.GA/examples/booking/resources
set your CLASSPATH so that it is:

CLASSPATH=/javadb/lib/derbyclient.jar:/javadb/lib/derbytools.jar:/javadb/lib/derby.jar:.

java -Dij.driver='org.apache.derby.jdbc.ClientDriver' org.apache.derby.tools.ij
At the Derby ij prompt connect to the default database:

connect 'jdbc:derby://localhost:1527///bin/sun-appserv-samples';

For example: connect 'jdbc:derby://localhost:1527///home/work/glassfish/bin/sun-appserv-samples';

run 'import.sql';

Now the Seam application tables should be loaded.

Run the application:

visit localhost:8080/seam-booking

Code Change Summary

The following changes apply to the Seam Booking application:

./examples/booking/resources/import.sql
----> Added trailing semicolons to each sql statement
./examples/booking/resources/META-INF/persistence.xml
----> Updated for application with GlassFish and Java Persistence
./examples/booking/resources/META-INF/ejb-jar.xml
----> Updated per EJB 3 schema: added schema namespace and element
./examples/booking/resources/WEB-INF/web.xml
----> Added schema namespace
---->Updated JNDI lookup pattern
---->Disabled MyFaces StartupServletContextListener - we're using JSF 1.2
---->Added

elements for EJB applicaton actions
./examples/booking/src/org/jboss/seam/example/booking/RegisterAction.java
./examples/booking/src/org/jboss/seam/example/booking/HotelSearchingAction.java
./examples/booking/src/org/jboss/seam/example/booking/BookingListAction.java
./examples/booking/src/org/jboss/seam/example/booking/LoginAction.java
----> Updated sql statements passed to EntityManager.createQuery
./examples/booking/src/org/jboss/seam/example/booking/User.java
---->Refer to table name 'Users'
./examples/booking/view/conversations.xhtml
---->Added element

The following change is to a Seam (JSF) custom component:

./src/ui/org/jboss/seam/ui/HtmlLink.java
---->Added encodeEnd method to properly end either an HTML input element or an HTML hyperlink element

All of these entries are in the seam-1.0.1.GA-booking-patch.zip file and can be reviewed.

JavaServer Faces In The Real World

Often when you are "heads down" developing a technology, you forget about who might be using that technology. And in the course of giving a presentation about the technology, you may hear a question or two like "yeah... great.... but who is using this out there in the real world?".. Well.. we've compiled an initial list of companies/sites out there that use JSF.... That list can be found here. Enjoy!

Announce: JSF 1.2 Specification Errata

A list of clarifications and corrections to the JSF 1.2 (JSR 252) specification has now been made available. The list can be found here. There may be additions to this list of errata items, so check back.

Seam On GlassFish With Java Persistence

Seam-GlassFish In Java EE SDK Runs Seam I outlined some steps for getting Seam (the JBoss application framework that unifies JSF and EJB 3.0) to run on GlassFish with Hibernate as the persistence layer. Now, we'll see how we can have Seam running on GlassFish with the Java Persistence API as the persistence layer. For completeness, I'll go over the prerequisites and setup as described in Java EE SDK Runs Seam because their are some subtle differences along the way.

Prerequisites:

A working build environment with ant, at least JDK 5, and GlassFish (build 43 or later).
You'll need to use some of the Hibernate libraries that the Seam framework depends on:

Download and install Hibernate3 3.2cr1.
Download and install Hibernate EntityManager 3.1 beta7 . Note that hibernate-entitymanager.jar is not required because we'll be using Java Persistence. However, hibernate-annotations.jar is still required, because the Seam framework uses classes from the Hibernate validator package.
Copy the required hibernate jars into Glassfish lib dir. The script here contains the list of jars.
Edit the script to make sure it references your Glassfish and Hibernate install directories.
Execute the script.

Seam Setup:

Download and install the Seam 1.0beta2 release from here. You should see a jboss-seam-1.0beta2 directory.
Get the zip files: seam-core-patch.zip and seam-booking-jpersist-patch.zip .
Go to the jboss-seam-1.0beta2 directory and unzip seam-core-patch.zip and seam-booking-jpersist-patch.zip.

Compilation Procedure:

Copy /lib/javaee.jar to jboss-seam-1.0beta2/lib directory.
Copy jboss-seam-1.0beta2/lib/jboss-common.jar /lib (needed for JBoss Logger)
Compile Seam core classes:

Create an empty jboss-seam-1.0beta2/src/test directory (the build file is looking for this directory that is not there from the seam zip file).

Go to jboss-seam-1.0beta2 directory; ant;

Compile Seam Booking Application:

Copy jboss-seam-1.0beta2/jboss-seam-ui.jar to jboss-seam-1.0beta2/examples/booking/resources/WEB-INF/lib
Go to jboss-seam-1.0beta2/examples/booking
ant

Deploy the application:

Start up Glassfish.
Start the database: /bin/asadmin start-database
Deploy jboss-seam-1.0beta2/examples/booking/build/jboss-seam-booking.ear

Load the database:

Go to jboss-seam-1.0beta2/examples/booking/resources
set your CLASSPATH so that it is:

CLASSPATH=/javadb/lib/derbyclient.jar:/javadb/lib/derbytools.jar:/javadb/lib/derby.jar:.

java -Dij.driver='org.apache.derby.jdbc.ClientDriver' org.apache.derby.tools.ij
At the Derby ij prompt connect to the default database:

connect 'jdbc:derby://localhost:1527///bin/sun-appserv-samples';

For example: connect 'jdbc:derby://localhost:1527///home/work/glassfish/bin/sun-appserv-samples';

run 'import.sql';

Now the Seam application tables should be loaded.

Run the application:

visit localhost:8080/seam-booking

You can refer to Java EE SDK Runs Seam for an explanation of the Seam core modules and the Seam Booking application modules that required modification. Those modifications are essentially the same with the exception of the following modifications to some Booking application modules:

    examples/booking/resources/META-INF/persistence.xml
            ----> updated for application with GlassFish and Java Persistence
    examples/booking/src/org/jboss/seam/example/booking/BookingListAction.java
    examples/booking/src/org/jboss/seam/example/booking/HotelBookingAction.java
    examples/booking/src/org/jboss/seam/example/booking/LoginAction.java
    examples/booking/src/org/jboss/seam/example/booking/RegisterAction.java
           ----> made SQL queries complete for Java Persistence.

Java EE SDK Runs Seam

Seam-GlassFish I am happy to report that Seam (the JBoss application framework that unifies JSF and EJB 3.0) runs on GlassFish, the Open Source Application Server from which the Java EE SDK is built. This required some modifications and rebuilding of Seam source code, mainly because of the repackaging of EJB classes in accordance to the latest EJB specification implementation. JBoss is making the required changes, but for those of you who can't wait, I'll describe those changes and setup necessary to get a Seam application up and running on GlassFish. Also, I'd like to point out, that these instructions are for the Seam 1.0beta2 release. Recently JBoss has released a later version, but the interceptor related packaging changes are not there. First, let's install the patches and get the Seam Booking application up and running.

Prerequisites:

A working build environment with ant, at least JDK 5, and GlassFish (build 43 or later).
For this application, you will also need to make sure you have the compatable Hibernate libraries with GlassFish:

Download and install Hibernate3 3.2cr1 or later.
Download and install Hibernate EntityManager 3.1 beta7 or later.
Copy the required hibernate jars into Glassfish lib dir. The script here contains the list of jars.
Edit the script to make sure it references your Glassfish and Hibernate install directories.
Execute the script.

Seam Setup:

Download and install the Seam 1.0beta2 release from here. You should see a jboss-seam-1.0beta2 directory.
Get the zip files: seam-core-patch.zip and seam-booking-patch.zip .
Go to the jboss-seam-1.0beta2 directory and unzip seam-core-patch.zip and seam-booking-patch.zip.

Compilation Procedure:

Copy /lib/javaee.jar to jboss-seam-1.0beta2/lib directory.
Copy jboss-seam-1.0beta2/lib/jboss-common.jar /lib (needed for JBoss Logger)
Compile Seam core classes:

Create an empty jboss-seam-1.0beta2/src/test directory (the build file is looking for this directory that is not there from the seam zip file).

Go to jboss-seam-1.0beta2 directory; ant;

Compile Seam Booking Application:

Copy jboss-seam-1.0beta2/jboss-seam-ui.jar to jboss-seam-1.0beta2/examples/booking/resources/WEB-INF/lib
Go to jboss-seam-1.0beta2/examples/booking
ant

Deploy and run the application:

Start up Glassfish.
Start the database: /bin/asadmin start-database
Deploy jboss-seam-1.0beta2/examples/booking/build/jboss-seam-booking.ear
Visit localhost:8080/seam-booking

Now, here is an explanation of changed modules. The current JBoss Seam codebase is not up to date with the latest EJB specification (and implementation - as in GlassFish). Seam classes still reference EJB interceptor related classes in the javax.ejb package, but these now exist in the javax.interceptor package. JBoss will be updating their source, but I am not clear on when that will happen.

Core classes:
    src/main/org/jboss/seam/Component.java
    src/main/org/jboss/seam/ejb/SeamInterceptor.java
    src/main/org/jboss/seam/interceptors/BijectionInterceptor.java
    src/main/org/jboss/seam/interceptors/BusinessProcessInterceptor.java
    src/main/org/jboss/seam/interceptors/ConversationInterceptor.java
    src/main/org/jboss/seam/interceptors/Interceptor.java
    src/main/org/jboss/seam/interceptors/JavaBeanInterceptor.java
    src/main/org/jboss/seam/interceptors/OutcomeInterceptor.java
    src/main/org/jboss/seam/interceptors/RemoveInterceptor.java
    src/main/org/jboss/seam/interceptors/RollbackInterceptor.java
    src/main/org/jboss/seam/interceptors/SeamInvocationContext.java
    src/main/org/jboss/seam/interceptors/ValidationInterceptor.java
           ----> interceptor package changes described above
    src/main/org/jboss/seam/jsf/SeamPhaseListener.java
           ----> moved initilialization of SeamVariableResolver, SeamNavigationHandler, SeamStateManager to
   faces-config.xml, so they get created at startup.
    src/main/org/jboss/seam/jsf/SeamStateManager.java
           ----> new class taken from StateManagerInterceptor class in SeamPhaseListener
    src/main/META-INF/faces-config.xml
           ----> defines SeamVariableResolver, SeamNavigationHandler, SeamStateManager
           ----> modified component definition for HtmlQueryTable
    src/main/org/jboss/seam/mock/MockServletContext.java
           ----> stubbed in public String getContextPath() method

Booking Application Modules:
    examples/booking/resources/import.sql
    examples/booking/resources/META-INF/persistence.xml
            ----> updated for application with GlassFish
    examples/booking/resources/WEB-INF/web.xml
            ----> reference 2.5 schema, etc..
            ----> modified JNDI name pattern for EJB lookups
            ----> disabled MyFaces StartupServletContextListener (not compatable with JSF 1.2)
            ----> added elements for EJB modules
    examples/booking/src/org/jboss/seam/example/booking/BookingListAction.java
    examples/booking/src/org/jboss/seam/example/booking/ChangePasswordAction.java
    examples/booking/src/org/jboss/seam/example/booking/HotelBookingAction.java
    examples/booking/src/org/jboss/seam/example/booking/LoggedInInterceptor.java
    examples/booking/src/org/jboss/seam/example/booking/LoggedIn.java
    examples/booking/src/org/jboss/seam/example/booking/LoginAction.java
    examples/booking/src/org/jboss/seam/example/booking/LogoutAction.java
    examples/booking/src/org/jboss/seam/example/booking/RegisterAction.java
           ----> interceptor package changes described above
    examples/booking/src/org/jboss/seam/example/booking/User.java
           ----> create "Users" table and reference it as "user" (User is reserved in javaee5)
    examples/booking/view/main.xhtml
    examples/booking/view/template.xhtml
           ----> added missing JSF "form" tags

Open JavaServer Faces

In its continuing open-source effort, Sun has made the source code of its implementation of JavaServer Faces available under the OSI approved Common Development and Distribution License (CDDL). More information about that license can be found here. JavaServer Faces has had external contributions, and this open-source strategy will make it easier to get contributions into the technology. The news comes just as JavaServer Faces is ramping up for the start of its 2.0 release - a release that promises exciting new features. So, you are certainly encouraged to get involved. Want to get involved? You can start here.

Ajaxian JavaOne 2005 ?

Well.. It's the last day at JavaOne 2005. I attended some good web-tier sessions, and yes, I admit it - I too was caught up in the AJAX hype. The web-tier sessions in general, get good attendance, but, sprinkle a little AJAX in there, and you have electricity in the air! Javascript has been around forever, and folks have been adding interactivity (DHTML..) to their web pages for years. But I think the commonality of XMLHttpRequest across more browsers, coupled with a new buzzword - AJAX - has generated "renewed" excitement in this area. So... it may have been AJAX that left a mark at this year's JavaOne. What about next year?