JSF is the latest offering for the Java web application development. JSF is an MVC framework, similar to Struts. JSF is an enhancement to Struts:

1. The action is now mapped to a method of a bean instead of a servlet. Components can now have events. This is much more like code-behind in ASP.NET. This reduces the number of files one has to work with.
2. More custom tags and richer controls, such as Data Tables.

Here is how JSF compares with ASP.NET 2.0:

1. ASP.NET 2.0 is the mainstream development framework in .net world. JSF is still considered as unproven. Only a quarter or less Java web developer jobs requires JSF.
2. JSF is a specification instead of implementation. Depending on the implementation used, one may get more or less rich components. So evaluating implementation itself is a major task.

In conclusion, projects using ASP.NET 2.0 should expect stable and well behaved frameworks. Developers should find it much easier to develop web applications with richer functionality and to work with AJAX.

Struts is an MVC framework for Java web application development. Struts 1.0 was released in July 2001, roughly a year before ASP.NET 1.0. Currently, 70-80% of Java Web application developer's job requires Struts so it is fair to say that Struts is the current mainstream framework for Java web application.

Struts contains an MVC framework and a set of JSP custom tags. For a simplest application, developers need to provide:

1. An html form in which user can enter data.
2. A Struts bean that serves as model. The inputs in the form is mapped to the properties of the bean.
3. An action servlet which serves as controller.
4. One or more JSP pages that serves as view for the results.

The components are wired together with a configuration file struts-config.xml. Struts framework actually provides a servlet as front-controller in which all actions go to. The front-controller is responsible for instantiate the Struts bean, dispatch the action and route to the approprate view based on the return of the action.

In addition, Struts also supplies custom JSP tags that provides the following functionalities:

1. Preserve the state of input if the view is same as the form.
2. Validation.
3. Layout with Tiles.

Struts provides serveral important functionalities in the framework and significantly reduced the repeatitive tasks in Java web development. ASP.NET does not require a regid MVC pattern like Struts (which could be both pro and con). Besides that, ASP.NET does almost every other things better:

1. Struts still requires coding the same information twice, once in form and the second time in bean. In ASP.NET code-behind, controls are automatically created from form. In additional, ASP.NET supports rich controls, i.e., controls not available in HTML.
2. The modle, view and controller of Struts is scattered in many files. The only place to find them is in the struts-config.xml file. It is inconvenient to work with large number of files. Although the seperation of functionalities into many classes remotes reuse, in reality, the classes are rarely reused.
3. ASP.NET's mechanism to preserve form state is simpler to use.
4. ASP.NET's validation architecture is better and it is transparent to render client-side Javascript depending on the type of clients.
5. ASP.NET's master page and skin is superior to Tiles.

In conclusion, also Struts is a significant improvement over normal JSP/Serlet programming. Struts is still far behind ASP.NET in functionality and productivity. There are tools like AppFuse that would make Struts development easier. It is still nowhere near the experience with Visual Studio 2005 and ASP.NET 2.0.

Perhaps it is time to compare ASP.NET with JSF which is the latest offering in the Java world.

ASP (Active Server Pages) was a revolution to web development when it was released by Microsoft in 1997. Since then, Sun has answered with a better tool in JSP. Microsoft answered to the Java challenge with ASP.NET in 2002. How do they compare to each other? I have done a survey and will anwer the question in a series of posts.

ASP allows server scripts and expression to be embedded in HTML. When it is desirable to seperate the code from the content, one would write the code in a COM object (usually written in VB6) and call the COM object from ASP page.

JSP (JavaServer Pages) has the following advantages over ASP:

• ASP is interpreted while JSP is compiled - better performance.
• In the Java world, one can develop Servlet and Servelet filter. In ASP world, one has to use C++ to write ISAPI Extension and ISAPI filter. ISAPI Extension and filter does not share session state with ASP. While the Servlet functinality is not essential, lack of filter is a limitation for ASP.
• In Java world, one often seperate presentation and code with JSP/Java Bean, like the ASP/COM object combination. One limitation for the Java Bean is that it does not have context while the COM object can access the context. To access the context, one has to write custom JSP Tag. The capability of JSP does make custom components look like HTML.

ASP.Net was Microsoft's answer to JSP. ASP.NET not only has all the capability of JSP, it also represent a major productivity boost:

• ASP.NET's HttpHandler and httpModule is equivalent to Servlet and servlet filter.
• ASP.NET support custom controls, like the custom JSP tags.
• ASP.NET supports a code behind model. This is a productivity boost compare to JSP/Java Bean. With JSP/Java Bean, one has to code the inputs once in the form and then again in the bean. One only create the controls once in ASP.NET pages and they are automatically accesible in code-behind.
• ASP.NET support rich components (none-HTML, such as Grid and TreeView. These are usually DHTML controls manipulated by JavaScript with states saved in a hidden input control. ASP.NET has the viewstate framework for store and retrieve the property of controls. These rich controls can be accessed in the code-behind page transparently like any other control. JSP/Java bean are limisted simple HTML inputs. Therefore, it is much easier to develop feature rich page with ASP.NET than the JSP/Java bean approach.

In conclusion,  JSP is about half way between ASP and ASP.NET. It is perhaps not fair to compare ASP.NET and JSP since they are not really in the same generation. A better comparison to ASP.NET might be JSP/Struts or JSF.

For .net programmers, we used to work in a single System.DateTime structure. In Java, unfortunately, we often need to work with several classes:

• java.util.Date

java.util.Date internally store the date/time as number of milliseconds after Jan. 1, 1970 using long. There are 86,400,000 millilseconds a day. The default constructor represents the date/time that the object is constructed. The main advantage of using Date class is that it is possible to parse a String to Date or format a Date to String using DateFormat class.

• java.text.DateFormat, java.text.SimpleDateFormat

These two classes can convert a String to/from to Date. One can use one of the overloaded DateFormat.getDateInstance() methods to get a localized format. For custom format, it is better to create an instance SimpleDateFormat using the format string in the constructor.

• java.util.GregorianCalendar

We need this class in order to work with parts of a date or construct a date from parts. It also allow us to add a range to a date. We can convert between Date and GregorianCalendar by using the setTime() and getTime() method of teh GregorianCalendar class.

There is a nice article on Javaworld that contains many useful examples. 

1. Add jar files to WEB-INF/lib
• commons-beanutils.jar
• commons-collections.jar
• commons-digester.jar
• commons-fileupload.jar
• commons-lang.jar
• commons-logging.jar
• commons-validator.jar
• jakarta-oro.jar
• struts.jar
2. Add tld files to WEB-INF
• struts-bean.tld
• structs-html.tld
• structs-logic.tld
• structs-nested.tld
• structs-template.tld
• structs-tiles.tld
3. Add XML files
• structs-config.xml
• validation.xml
• validator-rules.xml
4. Add the following to web.xml:

<servlet>

<servlet-name>action</servlet-name>

<servlet-class>

org.apache.struts.action.ActionServlet</servlet-class>

<init-param>

<param-name>config</param-name>

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<init-param>

<param-name>debug</param-name>

<param-value>5</param-value>

</init-param>

<init-param>

<param-name>detail</param-name>

<param-value>2</param-value>

</init-param>

<init-param>

<param-name>validate</param-name>

<param-value>true</param-value>

</init-param>

<load-on-startup>2</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

• J2SE 1.4
• J2EE 1.4
• Servlet 2.4
• JSP 2.0
• JSTL 1.1
• JSF 1.1
• Struts 1.1

The problem

When I worked at ESRI, I worked on the .net version of ArcGIS Server Manager, which is a web-based front-end for ESRI’s ArcGIS Server products. The Java team also has a Java version of the product based on the same UI spec. I was the only .net developer on the .net version while the Java team had 2 ½ developers on the Java version, but I was constantly ahead in features. I was proudly thinking that I am a much better developer than my peers on the Java team.

However, a recent project changed my thinking. My current employer is migrating some VB6 based projects to Java. I developed a web service in Java. At the end of project, I have some time left. So I decide to develop a few simple CRUD pages for the configuration table. The idea is fairly simple: I want to develop a page that lists the records in the table. It has a single form at the end of the page that allows me to insert a new record, as seen in the picture below:

When I try to edit the record, the page will enter the edit mode. The row that I try to edit would contain some textboxes. The edit/delete link would change to update and cancel. The insert form would be hiden, as seen in the picture below:

This is a fairly standard feature in asp.net. I can develop a page like this in a few clicks in less than an hour. However, in Java/JSP, I search the Google with words like “Java and RAD” but could not find any rapid application development solution that is simple to use.

The solution

I did a survey on how Java developers do similar things with JSP. JSP allows scriptlets, like ASP developers embed script inside the ASP page. However, it is not good practice to embed lots of code in the contents page. Servlet is a good place for code. You cannot embed Servlet in an JSP page. A typical pattern is that people will have a page post to a Servlet (controller) to do all the processing. The servlet will then forward/redirect to a JSP page (View) to display the result. That is a good practice except the view could need lots of scriptlets if there are lots of conditional rendering. It is possible to embed Java Bean in JSP. However, Java Bean does not have access to Http context. To gain access to the Http context, one would have to develop custom Jsp tags.

Since my goal is to develop a CRUD page that allows me to edit an simple table, here is the design approach that I take. I have one JSP page and 3 servlets. The 3 servlets are used for handling insert, delete and update. The JSP is reponsible for displaying the data. It also contains scriplets to switch between normal and edit mode:

1. Normal mode: Display the table normally. Show the insert form.
2. Edit mode: Display the row being edited as textboxes. Display the button of the row as Update and Cancel. Hide the insert form.

Here is the code:

boolean editMode = (request.getParameter("kc") != null);

if (editMode) {

    action = "updateConfig?kc=" + request.getParameter("kc") + "&kk=" + request.getParameter("kk");

} else {

    action = "addConfig";

}

<form action="<%= action %>" method="post">

    <table>

        <tr>

            <th>Configurationth>

            <th>Keyth>

            <th>Valueth>

            <th>th>

        tr>

<%

while(rs.next()) {

%>

<% if (editMode && rs.getString("CONFIG_NAME").equals(request.getParameter("kc")) && rs.getString("KEY").equals(request.getParameter("kk"))) {%>

        <tr>

            <td><%= rs.getString("CONFIG_NAME") %>td>

            <td><INPUT type="text" name="key" size="20" maxlength="64" value='<%= rs.getString("KEY") %>'>td>

            <td><INPUT type="text" name="value" size="20" maxlength="254" value='<%= rs.getString("VALUE") %>'>td>

            <td><INPUT type="submit" value="update"><a href='config.jsp'>cancela>td>

        tr>

<% } else { %>

        <tr>

             <td><%= rs.getString("CONFIG_NAME") %>td>

             <td><%= rs.getString("KEY") %>td>

             <td><%= rs.getString("VALUE") %>td>

             <td>

                 <a href='config.jsp?kc=<%= rs.getString("CONFIG_NAME") %>&kk=<%= rs.getString("KEY") %>'>edita>

                 <a href='deleteConfig?kc=<%= rs.getString("CONFIG_NAME") %>&kk=<%= rs.getString("KEY") %>'>deletea>

             td>

         tr>

<% }

}

%>

<% if (!editMode) {%>

         <tr>

             <td><INPUT type="text" name="configName" size="20" maxlength="64">td>

             <td><INPUT type="text" name="key" size="20" maxlength="64">td>

             <td><INPUT type="text" name="value" size="20" maxlength="254">td>

             <td><INPUT type="submit" value="insert">td>

          tr>

<% } %>

      table>

form>

I felt that I go back 10 years in time and become an asp programmer again. So here is what I think why at ESRI my peers on the Java team are so much slower than me:

1. JSP does not have an efficient method like code-behind in asp.net that allows close interaction between code and view.
2. The MVC frameworks like Struts that is main stream in Java community tend to product large number of classes for simply thing. Also the MVC promotes separation of responsibility and reuse at the first glance. However, in real life, only a small number of classes are actually reused; most of classes are only used once. The large number of classes create problems in both naming and finding things. In ASP.NET, it is far more easier to work with things and find code.
3. JSP lacks a component model to work with non-HTML controls. Here the non-HTML control means a sophiscated control like Tree that is composed of html, images, css. Its behavior is manipulated by Javascript and DHTML and states often saved in a hidden control. JSP and MVC framework like Struts can only handle native HTML controls. The rich components are handled outside of framework. Therefore, I would say that JSP is about half way between asp and asp.net. For an asp.net developer to work on JSP, it is like going back to stone page.
4. I hope JSF will provide a rich component model that rivals that of ASP.NET. Unfortunately, both the development and the adoption have been so slow. It does not help that our company is still standardized on J2EE 1.4.

The following steps are only required for the first time deployment to the server:

1. Configure Environment Variables for DB2 Universal JDBC Drivers. From Admin Console, client Environment/WebSphere Variables. Make sure that the correct node is selected. Configure the following environment variables:

DB2UNIVERSAL_JDBC_DRIVER_PATH

UNIVERSAL_JDBC_DRIVER_PATH

2. Configure JDBC Providers: Click Resources/JDBC Providers. Make sure that the correct node is selected. If DB2 Universal JDBC Driver Provider is not already created, click New. From database type, select DB2. From provider type, select DB2 Universal JDBC Driver Provider. From implementation type, select “Connection Pool Datasource”. Click Next. Accept the default for Class Path and Native Library path. If the class name is not populated, enter “com.ibm.db2.jcc.DB2ConnectionPoolDataSource”.
3. Create J2C Authentication data: Click Security/Global security. Expand JAAS Configuration under Authentication on the right-hand-side. Click J2C Authentication data. Click new to create a new entry and set the follow parameters:

Alias:

Description:

User ID:

Password :

4. Create Data sources: From DB2 Universal JDBC Driver Provider screen, click “Data sources” under “Additional Properties”. Click New to create a new Datasource:

Name:

JNDI Name:

Component-managed authentication alias:

Fill the DB2 Universal data source properties with the information from prerequisite 3. Accept default for the rest of parameters.

Save the configuration. Click test connection to ensure that the DB2 connection is successful.

5. Deploy the enterprise application: Click Applications/Enterprise Applications. Click Install. Browse to the ear file and leave context root empty. Click Next. On override, select “Do not override existing bindings”. On Virtual Host, select “Use default virtual host name for web modules”. Enter the host name from prerequisite 1. Click Next. From installation options, do not pre-compile JSP. Select Distribute Application. Accept the default for the rest and click Next.
6. Map resource reference to Resources: The web service contains resource reference jdbc/Q2WSDatasourceReference. Clip MapResource reference to resources. Select the module, select the resource JNDI name from step 4, select user default method and select alias in step 2 in the authentication data entry.

My web project connects to a database. WebSphere server can provide pooled connection as datasource. In my application, I just simply get the connection by lookup through the context:

   InitialContext ctx = new InitialContext();
   DataSource ds = (DataSource)ctx.lookup(dataSourceUri);
   con = ds.getConnection();

Using this way, I can let container manages the connection and security. I just simply retrieve the connection from my code. Direct resource lookup is deprecated in WebSphere 6 for security reasons. Now we have to look up the datasource through resouce reference (i.e., indirect lookup). Application will specify the resource reference that the application will lookup in the deployment descriptor. The container can link the resource reference to resource by confiugration. This way, a data source is not exposed to any application.

We have to let application tell which resource reference it is going to lookup first. To do this, cllick the Deployment Descriptor in the web project and click the References tab. Add a new resource reference. For data resources, set type to javax.sql.DataSource. Set authentication to container. To make it easier to work with local testing environment, we can set the JNDI name tha the resource reference should bind to under WebSphere Bidings. Set JNDI Login Configuration to None.

In the next part, we will specify how to configure the resouce reference in the admin console.

I created a dynamdic web project using Rational Application Developer (RAD) 6.0. The wizard automatically created an EAR project. The EAR project is for creating the Enterprise Archieve (EAR file). I can right click on my EAR project and select export. I can then deploy the single EAR file to my WebSphere server.

The web project uses some third party jar files such as log4j. These utility jars must be deployed with the web application. So I dropped those jar files in my EAR project. From the web project, I right clicked on the web project, select properties.../ Then I select Java Build Path, click on the Libraries tab and then click “Add JARs...”. I can then select any JAR file that is in my workspace. The project file will use relative path to reference the Jar file so that the workspace is portable from one developer to another.

I have some Java code that can be reused in other projects so that I do not want to place them in my web project. I create seperate projects for the code. The projects need to be compiled into Jar files and then packaged into my EAR file. With RAD, there is an easy way to do it. Just click on the Deployment Descriptor of my EAR project, clicke on the Module tab, under Project Utility JARs, click Add to add all my library projects. When I export my EAR file, RAD will automatically create JAR files from my projects and include them in the EAR file.