Atif Khan’s Blog

POX (Plain Old XML) JAX-WS service using CXF and Spring Configuration

By Atif Khan ( January 1, 2008 at 8:22 pm) · Filed under Software, Programming, Java, Web Service

The new and upcoming Apache CXF framework is quickly gaining steam and rightfully so. It’s very intuitive, simple to use and functional. Some of it comes from the fact the its roots are in popular XFire and Celtix frameworks. It’s still in the incubation stage at Apache but the current releases are pretty stable. The documentation is not complete right now, but it’s improving as well.

One of the cases where I found the document and example lacking is the POX (Plain Old XML) service using JAX-WS Provider model and configuring it using Spring. The examples are mainly focussed towards configuring and starting the service from Java code. So, I created this simple EchoService example that shows step by step how to do it.

First step is to create the service Java class that will echo the incoming XML message back to the requester. We will also annotate this class using the JAX-WS annotation to mark it as a web service provider and the message type to be the payload. So, the CXF implementation knows that it should only deliver the message payload to the service class. The CXF binding layer processes any binding level wrappers and headers.

In the above class we specified that we want to receive the incoming XML message as DOM. You can change it to use any concrete subclass of the Source interface (e.g. SAXSource).

Next step is to create the Spring configuration. For simplicity sake, let’s keep the name of this file to applicationContext.xml. Here is an example:

<jaxws:endpoint id="echoService" implementor="test.jws.provider.EchoService"
 address="/echo" bindingUri="http://www.w3.org/2004/08/wsdl/http">
 <jaxws:serviceFactory>
 <bean class="org.apache.cxf.jaxws.support.JaxWsServiceFactoryBean">
 <property name="wrapped" value="true" />
 </bean>
 </jaxws:serviceFactory>
 </jaxws:endpoint>
 
</beans>

The key things to notice in the above XML are:

Address of the service (/echo).
Binding URI (http://www.w3.org/2004/08/wsdl/http). This is really important. This is what tells CXF that this service is going to be simple XML over HTTP.
Declaration of service factor where we indicate that the messages are going to be of wrapped nature

All that’s remaining is to declare the Spring context listener in your web.xml for the web application that this service is going to be a part of. Here is an example of the web.xml: <web-app xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" version="2.4"> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <servlet> <display-name>CXF Servlet</display-name> <servlet-name>CXFServlet</servlet-name> <servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>CXFServlet</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> </web-app>

As you can see that there is nothing special here at all. It’s all standard Spring configuration using the context loader listener. Also, we are declaring the CXF servlet here and mapping it to /* to make all the requests to this web application go through the CXF servlet.

Now all you have to do is to package this web application and deploy it in your favorite application server. You should be able to access the Echo Service we wrote at http://localhost:8080/AppName/echo (you will have to adjust the port and application name in the URL). Now HTTP post a XML to this URL and you should get the request echoed back to you.

Maven POM
I think it’s more useful to also specify the Maven POM that contains all the dependencies as well to build the run this example. Please keep in mind that some of the dependencies here may not be required anymore as I was playing around with a lot of CXF functionalities. < ?xml version="1.0" encoding="UTF-8"?> <project> <modelversion>4.0.0</modelversion> <groupid>CXFTest</groupid> <artifactid>CXFTest</artifactid> <packaging>war</packaging> <version>0.0.1</version> <repositories> <repository> <id>apache.incubating.releases</id> <name> Apache Incubating Release Distribution Repository </name> <url> http://people.apache.org/repo/m2-incubating-repository </url> </repository> </repositories> <properties> <spring .version>2.0.7</spring> <cxf .version>2.0.3-incubator</cxf> </properties> <dependencies>  <dependency> <groupid>org.springframework</groupid> <artifactid>spring-core</artifactid> <version>${spring.version}</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-beans</artifactid> <version>${spring.version}</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-context</artifactid> <version>${spring.version}</version> </dependency> <dependency> <groupid>org.springframework</groupid> <artifactid>spring-web</artifactid> <version>${spring.version}</version> </dependency> <dependency> <groupid>log4j</groupid> <artifactid>log4j</artifactid> <version>1.2.14</version> </dependency>  <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-core</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-frontend-simple</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-frontend-jaxws</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-databinding-aegis</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-transports-local</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-transports-http</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-transports-http-jetty</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-transports-jms</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-management</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-common-utilities</artifactid> <version>${cxf.version}</version> </dependency> <dependency> <groupid>org.mortbay.jetty</groupid> <artifactid>jetty</artifactid> <version>6.1.5</version> </dependency> <dependency> <groupid>junit</groupid> <artifactid>junit</artifactid> <version>3.8.2</version> <scope>test</scope> </dependency> <dependency> <groupid>org.apache.cxf</groupid> <artifactid>cxf-rt-bindings-http</artifactid> <version>${cxf.version}</version> </dependency> </dependencies> <build> <plugins> <plugin> <artifactid>maven-compiler-plugin</artifactid> <configuration> <source>1.6</source> <target>1.6</target> </configuration> </plugin> </plugins> </build> </project>

Here is a list of all the jar files that ended up being in the war file from the build using above Maven POM. Again, some of the jars here may not be needed. XmlSchema-1.3.2.jar jaxb-impl-2.0.5.jar aopalliance-1.0.jar jaxb-xjc-2.0.jar avalon-framework-4.1.3.jar jaxen-1.1.jar commons-lang-2.1.jar jaxws-api-2.0.jar commons-logging-1.1.jar jdom-1.0.jar cxf-api-2.0.3-incubator.jar jetty-6.1.5.jar cxf-common-schemas-2.0.3-incubator.jar jetty-util-6.1.5.jar cxf-common-utilities-2.0.3-incubator.jar jra-1.0-alpha-4.jar cxf-rt-bindings-http-2.0.3-incubator.jar log4j-1.2.14.jar cxf-rt-bindings-soap-2.0.3-incubator.jar logkit-1.0.1.jar cxf-rt-bindings-xml-2.0.3-incubator.jar neethi-2.0.2.jar cxf-rt-core-2.0.3-incubator.jar saaj-api-1.3.jar cxf-rt-databinding-aegis-2.0.3-incubator.jar saaj-impl-1.3.jar cxf-rt-databinding-jaxb-2.0.3-incubator.jar servlet-api-2.3.jar cxf-rt-frontend-jaxws-2.0.3-incubator.jar servlet-api-2.5-6.1.5.jar cxf-rt-frontend-simple-2.0.3-incubator.jar slf4j-api-1.3.1.jar cxf-rt-management-2.0.3-incubator.jar slf4j-jdk14-1.3.1.jar cxf-rt-transports-http-2.0.3-incubator.jar spring-beans-2.0.7.jar cxf-rt-transports-http-jetty-2.0.3-incubator.jar spring-context-2.0.7.jar cxf-rt-transports-jms-2.0.3-incubator.jar spring-core-2.0.7.jar cxf-rt-transports-local-2.0.3-incubator.jar spring-web-2.0.7.jar cxf-tools-common-2.0.3-incubator.jar stax-api-1.0.1.jar geronimo-activation_1.1_spec-1.0-M1.jar stax-utils-20060502.jar geronimo-annotation_1.0_spec-1.1.jar velocity-1.4.jar geronimo-javamail_1.4_spec-1.0-M1.jar velocity-dep-1.4.jar geronimo-jms_1.1_spec-1.1.jar wsdl4j-1.6.1.jar geronimo-servlet_2.5_spec-1.1-M1.jar wstx-asl-3.2.1.jar geronimo-ws-metadata_2.0_spec-1.1.1.jar xml-apis-1.3.02.jar jaxb-api-2.0.jar xml-resolver-1.2.jar

Share and Enjoy:
These icons link to social bookmarking sites where readers can share and discover new web pages.

Permalink Comments (2)

Multi-valued Reversible enum in Java

By Atif Khan ( April 16, 2007 at 6:46 pm) · Filed under Software, Programming, Java

Sometime back I proposed a reversible enum pattern in my post. One thing missing from that implementation was the ability to successfully lookup the enum constants in cases where enum constants can have multiple values. To accomplish this, I utilized another feature introduced in Java 5, namely varargs or variable argument support. This way while building the key for the map, we utilize all the values for a constant and use the varargs in the reverse() method of the enum.

Let’s look at the interface MultiValueReversibleEnum that denotes an enum as reversible and that an enum should implement.

The things to notice in this interface are:

getAllCode() method - It returns an array of all the possible values for an enum constant
reverse( E ... code ) method - You can see the usage of varargs here. You basically give all the possible values for the enum constant you want to lookup in the right order

Next we need to look at the map MultiValueReverseEnumMap that will store the enum constants and their value mappings.

import java.util.HashMap;
import java.util.Map;

/**
 * 
 * A utility class that provides a reverse map of the {@link Enum} that is keyed
 * by the values of the {@link Enum} constant. This map implementation
 * should be used with the enums implementing the
 * {@link MultiValueReversibleEnum} interface.
 * 
 * @author Atif Khan
 * @param <K>
 * The class type of the values of the enum constant
 * @param <V>
 * The Enum for which the map is being created
 * @since Mar 26, 2007
 */
public class MultiValueReverseEnumMap<K, V extends MultiValueReversibleEnum<K, V>>
{
 private final Map<String, V> mReverseMap = new HashMap<String, V>();

/**
 * 
 * Create a new instance of ReverseEnumMap.
 * 
 * @param valueType
 */
 public MultiValueReverseEnumMap( final Class<V> valueType )
 {
 for( final V v : valueType.getEnumConstants() ) {
 mReverseMap.put( buildKey( v.getAllCodes() ), v );
 }
 }

/**
 * 
 * Perform the reverse lookup for the given enum values and return the enum
 * constant.
 * 
 * @param enumValues
 * @return enum constant
 */
 public V get( final K ... enumValues )
 {
 return mReverseMap.get( buildKey( enumValues ) );
 }

/**
 * 
 * Build the key for the entry in the map using the array of values supplied.
 * 
 * @param values
 * @return key for the entry
 */
 private String buildKey( final K[] values )
 {
 final StringBuilder valueBuff = new StringBuilder( values.length * 5 );
 for( final K value : values ) {
 valueBuff.append( value.hashCode() );
 }

return valueBuff.toString();
  }
}

As you can see, the getAllCodes() defined in the interface is used to build the key for the map. Also, the get( final K ... enumValues ) method that looks up the value in map uses varargs.

Now it’s time to glue everything together and see how to use the interface and map to build a multi-valued reversible enum. We will write a test class MultiValuedEnumTest.

import com.ihg.dec.framework.commons.utils.enums.MultiValueReverseEnumMap;
import com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum;

/**
 * 
 * A test class for multi-values enum that implements the
 * <code>MultiValueReversibleEnum</code> interface and uses the
 * <code>MultiValueReverseEnumMap</code>.
 * 
 * @author Atif Khan
 * @since Apr 16, 2007
 */
public class MultiValuedEnumTest
{
 enum TestEnum
 implements MultiValueReversibleEnum<Integer, TestEnum>
 {

ONE(1, 11),
    TWO(2, 22);

private int mCode1;
    private int mCode2;

private static final MultiValueReverseEnumMap<Integer, TestEnum> mMap = new MultiValueReverseEnumMap<Integer, TestEnum>(
 TestEnum.class );

/**
 * Create a new instance of TestEnum. 
 * @param code1
 * @param code2
 */
 private TestEnum( final int code1, final int code2 )
 {
 mCode1 = code1;
 mCode2 = code2;
 }

/**
 * Get the value of <code>code1</code>. 
 * @return Returns the code1.
 */
 public int getCode1()
 {
 return mCode1;
 }

/**
 * Get the value of <code>code2</code>. 
 * @return Returns the code2.
 */
 public int getCode2()
 {
 return mCode2;
 }

/**
     * Get an instance of TestEnum
     * @return TestEnum constant
     */
    public static TestEnum getInstance()
    {
      return TestEnum.ONE;
    }

/**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#getAllCodes()
     */
    public Integer[] getAllCodes()
    {
      return new Integer[] {
        getCode1(), getCode2()
      };
    }

/**
     * @see com.ihg.dec.framework.commons.utils.enums.MultiValueReversibleEnum#reverse(E[])
     */
    public TestEnum reverse( final Integer ... code )
    {
      return mMap.get( code );
    }
  }

/**
 * 
 * The main method to execute this class.
 * 
 * @param args
 */
 public static void main( final String[] args )
 {
 System.out.println("Reverse for [1, 11]: " + TestMultiValueEnum.getInstance().reverse( 1, 11 ) );
 System.out.println("Reverse for [2, 22]: " + TestMultiValueEnum.getInstance().reverse( 2, 22 ) );
 }

}

If you run this class, you should see following getting printed:

Reverse for [1, 11]: ONE
Reverse for [2, 22]: TWO

It’s all very simple and straightforward. If you have any suggestions or feedback to improve this, please leave me a comment.

Share and Enjoy:
These icons link to social bookmarking sites where readers can share and discover new web pages.

Permalink Comments (1)

Impression of RIFE Web Framework

By Atif Khan ( April 10, 2007 at 3:05 pm) · Filed under Software, Programming, Java, Web

I have been spending time on and off looking at various web frameworks available for a little more than a year. A lot of this has to do with keeping track of what’s going on in the web framework arena and keep in sync with the technologies. Another focus of mine is to see how the new (at least for me) frameworks affect the productivity of a developer.

I first looked at RIFE last year and I have been very impressed by the concepts.The developers of RIFE, Geert Bevin and others have been very helpful when I had some questions. I was even able to get answers on the IRC channel for RIFE. It was not until recently that I tried to write an application using RIFE that I really got a feel of it.

Here are some of the good and bad that I encountered:

Pros

A complete framework. It includes basic web framework, ORM, Content Management, Validations, Templates etc.
Good support from developers
A nice quick start application to get you running quickly
Good support for constraints for adding validations
Continuations - ability to pause, rewind, jump through transaction steps

Cons

Templates are really weird to work with. The syntax for the templates really did me. It is not really designer friendly like Tapestry or Wicket
The concept of flowlink and datalink is just too verbose and not clear
Using annotation didn’t do me any good as well for defining the flow and data links. There isn’t enough documentation for annotations
The only way for form validations I could find was to define the a MetaData class equivalent to the domain object representing the form and define the validations in there. This just seems like way too much of work for simple validations.
I could not figure out how to customize the error messages for form validations

In the end, I feel that it’s the lack of documentation that prevented me from really exploring it. I know Geert is a very sharp guy and if he ever gets to read my blog, I welcome his comments. I think the learning curve is too much for RIFE and lack of documentation adds to it and I am not sure if the return is proportional to the effort compared to other frameworks.

Share and Enjoy:
These icons link to social bookmarking sites where readers can share and discover new web pages.

Permalink Comments (4)

A simple file based Ruby Database - KirbyBase

By Atif Khan ( March 27, 2007 at 4:50 pm) · Filed under Software, Programming, Ruby

Have you ever been in a situation where you wanted to write a simple application for internal use that should be portable and completely self contained (including the database)? I am pretty sure you have. I had to do this recently for one of the simple reporting applications and I didn’t really want to create a dependency on external database like MySQL or PostgreSQL. This application needed only 4 tables and the data in these table is never going to be large enough to warrant an extensive database system. I thought about putting the data in flat files and write the code to access it. But, then I found this really neat gem called KirbyBase that does exactly the same and little more.

KirbyBase has some neat features that mirror the traditional RDBMS while still sticking to it’s simple roots:

Pure Ruby code
Data is kept in simple delimited files, allowing the modification in any text editor
It’s not an in-memory DB. The data is actually stored on the disk
Allows various data types like String, Integer, Float, Boolean, Time, Date, DateTime, Memo, Blob, and YAML
Allows creating indexes on fields
Query results can be sorted
Allows to define one-many links between tables similar to joins in RDBMS
The columns can be defined with a formula, so the value will be calculated during insertion
Automatic lookup fields can be defined to lookup the related values from another table

To give a simple example on how all this works, let’s consider a scenario of Department and Employees. The simple requirements can be laid out as each employee has personal information and belongs to a department. Also, each department has a name and identifier and can contain multiple employees. Following is how the code going to look using KirbyBase. Please keep in mind that I have tried to write a reusable DAO, hence the code may look a little verbose. You can very well short circuit the whole thing and write very concise code.

#!/usr/bin/ruby -w

require 'rubygems'
require 'kirbybase'

class DAO
  attr_accessor(:employee_tbl, :department_tbl)

#Initialize the KirbyBase engine
  def initialize
    db = KirbyBase.new(:local, nil, nil, '.')

#Get/Create the Department table
    begin
      self.department_tbl = db.get_table(:department)
    rescue
      self.department_tbl = db.create_table(:department, :dept_name, {:DataType=>:String, :Key=>true, :Index=>1}, :employee, {:DataType=>:ResultSet, :Link_many=>[:recno, :employee, :dept_id]}) do |t|
        t.record_class = Department
      end
    end

#Get/Create the Employee table
    begin
      self.employee_tbl = db.get_table(:employee)
    rescue
      self.employee_tbl = db.create_table(:employee, :dept_id, {:DataType=>:Integer, :Key=>true, :Index=>1}, :name, {:DataType=>:String, :Key=>true, :Index=>1}) do |t|
        t.record_class = Employee
      end
    end
  end

#Get the department by name or if it does not exist, insert it 
  def get_department(name)
    dept = self.department_tbl.select_by_dept_name_index { |r| r.dept_name == name  }.first
    unless dept
      dept = Department.new do |x|
        x.dept_name = name
      end
      self.department_tbl.insert(dept)
      dept = self.department_tbl.select_by_dept_name_index { |r| r.dept_name == name  }.first
    end
    return dept
  end

#Insert a new employee in table
  def insert_employee(dept, employee)
    employee_rs = self.employee_tbl.select_by_dept_id_name_index { |r| r.dept_id == dept.recno and r.name == employee.name }.first

if employee_rs
     self.employee_tbl.update(employee) { |r| r.dept_id == dept.recno and r.name == employee.name }
    else
      employee_obj = Employee.new do |x|
        x.dept_id = dept.recno
        x.name = employee.name
      end
      self.employee_tbl.insert(employee_obj)
    end
    
  end

#Get all employees for a department
  def get_all_employees(dept)
    employee_rs = self.employee_tbl.select_by_dept_id_name_index { |r| r.dept_id == dept.recno }.sort(:name)
  end
  
end

# The Department class
class Department
  attr_accessor(:recno, :dept_name, :employee)

def Department.kb_create(recno, dept_name, employee)
    Department.new do |x|
      x.recno = recno
      x.dept_name = dept_name
      x.employee = employee
    end
  end

def initialize(&block)
    instance_eval(&block)
  end
end

# The Employee class
class Employee
  attr_accessor(:recno, :dept_id, :name)

def Employee.kb_create(recno, dept_id, name)
    Employee.new do |x|
      x.recno = recno
      x.dept_id = dept_id
      x.name = name
    end
  end

def initialize(&block)
    instance_eval(&block)
  end
end

#Test everything now
dao = DAO.new
dept = dao.get_department("IT")

emp1 = Employee.new { |x| 
  x.name = "John"
}
dao.insert_employee(dept, emp1)

emp2 = Employee.new { |x|
  x.name = "Doe"
}
dao.insert_employee(dept, emp2)

#Get all empoyees in IT department and print
#Let's use the get_all_employees function first
puts "Employee in #{dept.dept_name} department"
dao.get_all_employees(dept).each { |x|
  puts x.name
}

#Alternatively we could use the dept.employee to get all employees
#Refresh the dept object
dept = dao.get_department("IT")
puts "Employee in #{dept.dept_name} department"
dept.employee.each { |x|
  puts x.name
}

The output after execution will look like this:

Employee in IT department
Doe
John

Employee in IT department
John
Doe

This should also generate 2 files in your current directory, department.tbl and employee.tbl. Let’s look at content of these files now.

department.tbl

000001|000000|Department|recno:Integer|dept_name:String:Key->true:Index->1|employee:ResultSet:Link_many->recno=employee.dept_id
1|IT|kb_nil

employee.tbl

000002|000000|Employee|recno:Integer|dept_id:Integer:Key->true:Index->1|name:String:Key->true:Index->1
1|1|John
2|1|Doe

That’s all there to it. It is very powerful and easy to work with library.

Share and Enjoy:
These icons link to social bookmarking sites where readers can share and discover new web pages.

Permalink Comments (4)

Rich Web UI, Flash and DHTML - Bridge the gap

By Atif Khan ( January 15, 2007 at 8:37 pm) · Filed under Software, Programming, Java, OpenLaszlo

As the Web 2.0 grows in popularity, so does the urge for a lot of organizations to revamp their legacy applications and make them web based. Their are obvious benefits to this as the application becomes more accessible and requires less effort to deploy and maintain as there is single point of deployment and maintenance, the application server. What gets lost in all this excitement is the functionality that may have been available in the existing applications with rich user interfaces can not be easily replicated in the web application replicating it. By using the readily available javascript libraries and AJAX techniques some of this pain can be alleviated. It’s not necessary that web applications may always lose the usability of functionality of the original application. In fact they can actually simplify some of the transactions if the user experience is considered from beginning during the rewrite process.

I have been playing with OpenLaszlo recently and it seems like a viable alternative for replacing the standalone applications with rich user interface. The most important feature of OpenLaszlo is the ability to write the user interface in XML based LZX language and export it to either Flash (.sfw) bytecode or DHTML. This functionality is only available with the upcoming Project Legals release of OpenLaszlo, which is already in beta.

It has a rich set of components and event model that can all be used and programmed to using the LZX language. You can also write your own components using the LZX markup. The important thing to keep in mind is that OpenLaszlo is strictly a UI technology. You still need to get your data to display from the backend whether it being database of another middleware. This is where OpenLaszo excels. At the core it can interact with a back end system using the RPC. Various RPC options include:

Java RPC
SOAP
XML RPC
XMLHttpRequest for Ajax

So, you can pretty much have you back end written in Java, PHP, Ruby or whatever you like as long as it supports either RPC, SOAP or XMLHttpRequest. If you are wondering about what do you need on your server to run OpenLaszlo, it is basically a Java Servlet based web application. So, you do need the Java servlet container on your server to run OpenLaszlo. That shouldn’t be an issue at all if you already use Java.

If you do use Java on the server side and you have been trying to decide between various web application frameworks available and there are a ton of them , OpenLaszlo can make your life a little simpler as you don’t have to worry about the components or the component state management (JSF, Wicket, Tapestry etc). All you need is a solid framework that can preferably produce XML output and serve some data (Struts, WebWork, Spring MVC, RIFE) or any other similar framework and leave the UI aspect to OpenLaszlo. OpenLaszlo may not be suitable in all the cases, but it is worth a look if you want a web application with the look and feel and usability of a desktop application.