Technology Discussion (2nd round)

So far we decided to go on with a "webservice"-like approach. However, there are still some options which should be discussed:

Server-side technologies supporting a "webservice"-like approach:

• JAX-WS 2.x
• XML-RPC
• REST

Relevant client-side technologies:

• ExtJS/Ext GWT (>= 2.1)
• Sproutcore

Following we're discussing different scenarios to decide for one of each technologies.

ExtJS and RESTful webservices

Scenario:

1. expose Magnolia's functionality through a REST conforming API (that is leveraging HTTP methods to retrieve/update/create new data in Magnolia)
   1. implement a facade to Magnolia in terms of POJOs
   2. leverage the standardized JSR-311 API (RESTful Services with Java) to implement the mapping between POJOs and HTTP requests
2. implement the client-side part completely in Java using Ext GWT
   1. at runtime all the client gets is a statically served HTML page including the Ext GWT generated JavaScript code to render the complete UI
   2. use the predefined Ext.Ajax class to implement communication between client and server
3. supported communication styles (for both client- and server-side) in this scenario are either JSON or plain XML

More information:

• http://extjs.com/learn/Manual:RESTful_Web_Services
• http://extjs.com/blog/2008/04/21/ext-js-21-and-ext-gwt-10-released-preview-of-ext-js-30/

  First-Class REST Support:
  Developers using a RESTful architecture will be excited to know that Ext JS now has full support for all HTTP verbs (no longer just POST and GET). We've also added support for passing in additional header information to ease integration with server-side platforms.

Technology Discussion (1st round)

If we don't decide for either of both approaches at first, we could follow a strategy that may support the JSF as well as the Webservice approach. This scenario is outlined in the Common Architecture attachment. Basically the idea is, to define the exposed services of Magnolia as simple POJOs and annotate them with both JSF (aka JBoss Seam) annotations and with Webservice (aka JSR-181) annotations. With those annotations in place we can use those POJOs as managed beans (in the case of JSF) or alternatively as published webservices, in both cases without any additional (per bean) configuration.

Comparison of both scenarios

• see the JSF Rendering Scenario attachment
• see the Webservice Rendering Scenario attachment

stars describe status, 1 is minimum, 5 is highest

JSF related

JSF RI

URL: https://javaserverfaces.dev.java.net/
Documentation: (Specification is very good documentation source)
Community:
Release Cycle: (well, it's standardized and passes TCK)

Apache MyFaces

TODO, but not an options since still not JSF 1.2

JBoss Richfaces / Ajax4JSF

Component library with built-in AJAX support.

URL: http://labs.jboss.com/jbossrichfaces/
Documentation:
Community:
Release Cycle:

Webservices related

CXF (aka Celtic/XFire)

Complete webservice stack. Supports JSR-181 (Webservice Annotations) and early support for the not yet finalized JSR-311 (RESTful Webservices).

URL: http://incubator.apache.org/cxf/
Documentation:
Community:
Release Cycle:

Axis2

URL: http://ws.apache.org/axis2/
Documentation:
Community:
Release Cycle:

Cons:
does not support JSR-181 (Webservice Annotations) which greatly simplifies development

Client-side related

Please also see the Javascript Tools discussion page. 

ExtJS

JavaScript UI Component library (extracted from YUI project), includes very performant AJAX layer.

URL: http://www.extjs.com/
Documentation:
Community:
Release Cycle:

JQuery

Library that provides AJAX functionalities and simplified DOM access. Interesting since good score (see below) and it is compatible with ExtJS (means, ExtJS can simply use JQuery as AJAX layer).

URL: http://www.jquery.com/
Documentation:
Community:
Release Cycle:

Mootools

TODO

Scriptaculous

TODO

Prototype

TODO