Java Ajax Frameworks - Ajax Patterns

Java Ajax Frameworks

From Ajax Patterns

See also Multi-Language_Ajax_Frameworks and Ajax_Frameworks.


Ajax tags for JSP : SweetDEV RIA

SweetDEV RIA provides Ajax tags for your JSP / Struts applications.

The library gives all the components required for a Web application, such as :

  • Datagrid,
   - Drag and drop columns resizing and organizing
   - Automatic datagrid resizing (horizontal & vertical scrol bar)
   - Columns multisorting (like Excel)
   - Line expand / collapse
   - Excel export
   - Preferences 
   - Each cell of the datagrid can include a tag (calendar, combo, etc.)
   - automatic paging
  • Combobox (mono/multiselect, autosuggest)
  • Window (modal or not)
  • Calendar (simple month, multi months,special dates,...)
  • Tab panel (horizontal and vertical),
  • Expand/Collapse
  • Excel export
  • Treeview
  • Menu (bar, contextual, right clik)
  • Accordeon,
  • Editable text,
  • File upload,
  • Listener,
  • Clik to open,
  • Spliter layout,
  • Modal panel,
  • Windows docking (portlet style)


SweetDEV RIA Demo Download SweetDEV RIA

Developers can continue to use JSP/servlet and frameworks like Struts, because SweetDEV RIA Ajax tags can plug into JSP pages. JavaScript expertise if not necessary; Pick the SweetDEV RIA tags you need and that's it!

SweetDEV RIA is available under Open Source Apache 2 License. Professional services available through Ideo Technologies and partners.

SweetDEV RIA by Ideo Technologies

ADF Faces Rich Client Components

Oracle ADF Faces Rich Client Components

A set of over 150 JSF components with built-in Ajax capabilities. Part of the Oracle Application Development Framework. The components provide:

  • Extensive data visualization components
  • JSF 1.2 Support
  • Complete JavaScript API
  • Drag and Drop Framework
  • Dialog and Popup Framework
  • Navigation Menu Framework
  • Declarative Partial Page Rendering
  • Support for Skinning
  • Support for Page templates, reusable page regions, and declarative components
  • Internationalization and Accessiblity support
  • Integration with ADFc to support TaskFlows and bookmarking
  • Integration with ADFm to support data bindings.
  • Oracle ADF Security Support

ADL(AJAX Dev Library) and AJAX tool In JoyiStar

AJAX Dev Library ADL Pack series is the extension package for Joyistar WebShop with more powerful function and beautiful UI. And also it's the standard AJAX library.

AjaxAnywhere (from September 2005)

AjaxAnywhere turns any set of existing JSP/JSF/Struts/Spring/etc.. components into AJAX-aware components without a complexe JavaScript coding. (Quick Start Demo).

  • Does not break existing server-side MVC architecture.
  • Less JavaScript to develop and to maintain. Absence of commonly accepted naming convention, formatting rules, patterns makes JavaScript code messier then Java/JSP. It is extremely difficult to debug and unit-test it in multi-browser environment. Get rid of all those complexities by using AjaxAnywhere.
  • Easy to integrate. AjaxAnywhere does not require changing the underlying application code.
  • Graceful degradation. Switch whenever you need between AJAX and traditional (refresh-all-page) behaviour of your web application. Your application can also support both behaviors.
  • Open-source license zs3(

AJAX JSP Tag Library

The AJAX JSP Tag Library is a set of JSP tags that simplify the use of Asynchronous JavaScript and XML (AJAX) technology in JavaServer Pages. This tag library eases development by not forcing J2EE developers to write the necessary JavaScript to implement an AJAX-capable web form.

  • Autocomplete: Retrieves a list of values that matches the string entered in a text form field as the user types.
  • Callout: Displays a callout or popup balloon, anchored to an HTML element with an onclick event.
  • HTML Content Replace: Builds the JavaScript required to hook a content area (e.g., DIV tag) to a link, image, or other HTML element's onclick event.
  • Portlet: Portlet-style capability from a AJAX-enabled JSP tag.
  • Select/dropdown: Based on a selection within a dropdown field, a second select field will be populated.
  • Tab Panel: Enable an AJAX-based set of property pages.
  • Toggle: Uses images to create either a single on/off toggle or a sequential rating system.
  • Update Field: Updates one or more form field values based on response to text entered in another field.
  • Area and Anchor: Shows how to AJAX-enable any area of your page
  • Ajax DisplayTag: Shows how to AJAX-enable DisplayTag
  • Open-source license by multiple contributors.

= AjaxTags (a subcomponent of tags) 23:52, 25 February 2008 (EST)Insert non-formatted text hereMedia:Example.ogg

Java Web Parts

The AjaxTags component of the Java Web Parts project is a taglib that allows for very easy, purely declarative AJAX functions to be attached to any element on a page.

It is nice because it does not require you to change anything about your existing page, you can add AJAX features after the fact very easily. The taglib consists of two common tags, and two others that are less frequently used, which have one or two attributes apiece. Very simple! All you do is drop a tag directly after the element on the page you wish to AJAX-enable, configure an entry in an XML config file describing the AJAX event, and you're done!

AjaxTags comes with a number of request and response "handlers" which provide common AJAX functions (e.g. construct XML from a form and submit it, update a div with the servers' response, execute returned populate a select, transform returned XML via XSLT, etc). It also has tremendous flexibility for you to create your own handlers to do other things, like transfrom the server's response via XSLT using Sarissa (this was a contributed custom handler which is now standard in AjaxTags).

AjaxTags does not provide pre-made AJAX widgets as other libraries do, but it does provide the foundation to very easily and quickly build these (see the cookbook example of building Google Suggests with AjaxTags). AjaxTags also provides timed AJAX events, so you can continually refresh an iFrame for instance. AjaxTags is, in short, an exceedingly simple, powerful and flexible way to introduce AJAX into your applications without having to write ANY code yourself!

Ajax reusable GUI Classes and “loosely coupled” component based Framework

Raju’s GUI-API Ajax reusable GUI Classes are based on “patent pending” inventions, which let developers build easy to use and more flexible reusable GUI Classes than possible for traditional GUI Platforms such as Java/Swing or Windows/VC++.

To build superior online GUI applications than possible on the traditional GUI platforms, one needs superior GUI-API. Raju’s GUI framework offers simple and complete solution to build superior online applications. Raju's GUI-API will contain very lightweight and highly scalable GUI Classes. For example, fine-grained java-classes can be quickly composed to build GUI classes for larger components.

Although, component based processes are controversial, pioneer-soft strongly believes it invented a viable component oriented programming. The following web pages briefly summarizes the process:

The basic proof is not complex: If the product-makers (e.g. computers and cars) were also cannot build interchangeable components and literally assemble them to create ‘hierarchies of loosely-coupled components’, they would also face crisis, similar to the software makers. These technologies are still needs to be peer-reviewed and accepted by other researchers, so the technologies not yet commercial.

Apache Struts 2

Struts is a MVC library that (since version 2) includes complex AJAX-tags (by integrating DOJO-toolkit)

Apache Trinidad


Based on a donation from the Oracle company to the Apache foundation, this is a graphical framework based on JSF model. You will have access to over a 100 components and other feature like validators, partial page rendering, skining and more.

Apache Wicket


With proper mark-up/logic separation, a POJO data model, and a refreshing lack of XML, Apache Wicket makes developing web-apps simple and enjoyable again. Swap the boilerplate, complex debugging and brittle code for powerful, reusable, Ajax-enabled components written with plain Java and HTML.


Authenteo provides client centric programming model for RIA development

  • Built in WCM with browser-based WYSIWYG editing, version control, security
  • Client domain model approach for client centric programming model with persisted objects in JavaScript
  • Directly writing Ajax is not necessary as communication is dynamically transparently handled with persisted object access.
  • Utilizes powerful multi-generational inheritance for persisted objects
  • Support for continuations through Narrative JavaScript, greatly simplifies programming requests, animations, and sequenced user interactions

BACKBASE - Java Enterprise Ajax Framework (from 2003)

BACKBASE is a comprehensive Enterprise AJAX Framework with cross browser support that deeply integrates with the Java platform (e.g. JSP Struts, JSF, Spring, SOA, Portals JSR 168 and WSRP). Backbase Enterprise Ajax includes of full set of development tools designed to increase developers’ productivity.

  • Free Community Edition Download here...
  • Over 250 Widgets and Functions Go to: Backbase Explorer
  • Cross Browser support: IE, Firefox, Safari, Opera, Netscape and Mozilla.
  • Advanced Ajax Debugger (cross browser - including IE).
  • Visual Ajax Builder, the first wysiwyg visual Ajax editor, based on Eclipse See: Demo Visual Ajax Builder
  • Java Server-side Integration for JSP, Struts, Spring, etcetera
  • JSF Server-side UI components (Java Server Faces)
  • Java Portal (JSR 168, WSRP) Integration
  • Web Services Connector (SOAP, WSDL)
  • Push (DWR & Comet)
  • JSON and XML support
  • WAI / Section 508 support
  • Optimized Ajax Security (many large banks use Backbase)
  • 3rd Party Widget Integration (e.g. ExtJS, YUI, Google Gadgets)
  • Pre-build Rich Apps: Rich Dashboard, Rich Forms, Co-Browse, In-page Analytics
  • Pre-build Composite Widgets: SuperGrid (similar to Google Spreadsheet)
  • Active AJAX developer community Go to: Backbase Developer Network

Cross-Browser Core Engine

The Backbase Core Engine provides a cross-browser Ajax-UI runtime (IE, Firefox, Safari, Opera, Netscape and Mozilla). The core includes a DOM Abstraction layer that shields developers from cross-browser incompatibility issues and it provides a dual programming API: JavaScript and XML (to enable developers to use Ajax tag libraries). Ansar

Comprehensive Widget Library : 250+ widgets & functions

The Backbase offers a very complete UI widget library with over 250 pre-built widgets and functions. The widgets are built in XHTML, CSS, JavaScript and XML, and can be plugged-in anywhere on the page. Backbase allows you to change widgets to fit your needs. The source code of all pre-built widgets is included and Backbase encourages customers to modify and adapt the controls to suit their needs. Custom widgets can be created by adjusting pre-built widgets or by building widgets from scratch. With Backbase you are not stuck with rigid single purpose widgets; rather, you can create any UI control you need. Go to: Backbase Explorer

Cross Browser Ajax Debugger

The Backbase Ajax Debugger allows interactive, real-time debugging of the complete Ajax user interface. The developer loads the debugger inside the browser, on top of the interface being debugged. Once loaded, the debugger gives the developer a 360-degree view of the interface. For each element currently used in the Ajax interface, the developer can easily inspect the XML data, the DOM node, the computed style, the behaviors and also the variables. The tool is fully integrated with the tracer and command execution. Following the trace, the developer can identify UI elements that have caused execution errors, and fix those. The debugger works in all major Browsers (including IE). See: Demo of Debugger

Visual Ajax Builder (Eclipse Based)

Backbase offers a unique WYSIWYG visual Ajax development environment, specifically designed for Rapid Application Development of Ajax based applications. The builder is an Eclipse plug-in, is intended for professional and enterprise developers, and includes all the development tools and features necessary to cover the full Ajax based RIA application development lifecycle – from development to deployment. See: Demo Visual Ajax Builder

Java Server-side Integration Framework : JSP, Struts, Spring, JSF, JSR 168, WSRP

Backbase JSP / Struts / Spring Connector: add Ajax features to existing JSP, Struts, spring and HTML code, while making only minimal changes to your existing code base ("ajaxify" your existing java applications).

Backbase Portal Connector: enables you to create JSR-168 compliant portlets that do not require your portal page to re-render all portlets after each operation and also offers over 250 Ajax widgets and functions that simplify the development of your “ajaxified” portlets. The concept of the Portal Connector is that we want to avoid as many page refreshes as possible when interacting with a portlet. We’re using the WSRP protocol and JSR-168. To avoid page refreshes, we avoid rerunning the portlet class, because that would cause the entire portal page to refresh. So the main thing we do in an Ajax portlet is to dispatch to a view. When you need other functionality such as editing portlet preferences, you can define other JSR168 defined methods (like processAction) to take care of this.

Backbase JSF Edition: is a JavaServer Faces (JSF) implementation that takes advantage of the client runtime and Eclipse-based development tools. The Backbase JSF runtime performs the Ajax component rendering in the JSF presentation framework. It extends the JSF request lifecycle to work in a Single Page Interface environment, it synchronizes client-server state and facilitates data binding. Backbase Ajax JSF Components are pre-built and accelerate application development. Over 50 customizable UI components are included, and developers can also create their own components. Besides the ajaxified flavours of the standard JSF components, the JSF Edition delivers rich Ajax JSF components that combine rich client side and server side behavior such as the listGrid. Image:Example.jpgMedia:Example.ogg

Pre-build Rich Applications

Backbase delivers a comprehensive Suite of Rich Applications that brings customer facing web applications to the next level. These Rich Apps helps companies create, manage, and deliver online applications more effectively, so they can truly interact and connect with their customers. Backbase Rich Applications are built on top of the leading world class Enterprise Ajax Framework, are fully based on open industry standards, and consist of the following functional rich applications.

    • Rich Dashboard
    • Rich Forms
    • Co-Browse & Chat
    • In-Page Analytics



BindowsFaces is a components library that enables programmers create powerful Ajax web applications using Java through JSF.

Who should consider using BindowsFaces?

  • Developers creating enterprise strength web applications.
  • Java developers that do not want to engage in JavaScript "hacking".
  • Bindows programmers that want to expand into and leverage JSF technologies.

Why use BindowsFaces

  • Most JSF based frameworks in the market provide the client side components as an afterthought - their client side is quite weak.
  • BindowsFaces provides Java developers with a market leading client-side component model, built from the ground up with TRUE object-oriented Ajax.
  • Bindows is famous for being full, rich and mature (probably the richest Ajax framework). Bindows also provides the best in market support for developing Section-508 accessible web applications.


  • BindowsFaces shields the developer from the complexities of JavaScipt cross-browser programming.
  • BindowsFaces enables you to create full fledged Bindows applications using only JSF.
  • The Bindows legacy provides you with access to the most robust, mature and rich Ajax components (the richest components library) on the market.
  • You (the developer) have full control of how to distribute execution loads between the client and the server. Let the client do 99% of the work - drastically reduce server load and bandwidth utilization.
  • Creation of the client application can be fully automated by the use of XML.
  • Utilize industry standard Java development tools featuring code completion, unit testing etc.
  • The underlying Ajax library is object oriented - very similar to Java and Swing which should make the transition swift and painless for a large portion of the developer community around the world.
  • Cross-browser compatibility and zero-foorprint.
  • Enables an application flow on the client side with actions and events. No need to send an entire HTML page just to change one pice of data.
  • Bindows uses true Ajax! No hidden frames...

BZByte EZAjax - Ajax, no javascript, no nonsense

[1] BZByte EZAjax is an open-source Ajax Web framework that enables rich UI for Web applications with no JavaScript or other nonsense


  • The event-driven model brings the intuitive desktop programming model to Web developers.
  • Firefox & IE supported.
    • Drag-and-drop
  • Server centric processing. Visual representation and content are synchronized automatically between clients and servers.
  • Simple yet powerful threading model. No prerequisite of handling threading and concurrent accesses. True server-side modal dialogs. Suspend and resume your application freely without blocking users.
    • GPL

Direct Web Remoting (DWR) (2005)

Direct Web Remoting is a framework for calling Java methods directly from Javascript code.

  • Like SAJAX, can pass calls from Javascript into Java methods and back out to Javascript callbacks.
  • Can be used with any web framework - Struts, Tapestry, etc.
  • Follows Spring-like KISS/POJO/orthogonality philosophy.
  • Being incorporated into next WebWork release.
  • Open-source license (Apache). By Joe Walker.

bharadwaj n

Echo 2 (from March 2005)

Echo 2 allows you to code Ajax apps in pure Java (Demo).

  • Automatically generates HTML and Javascript.
  • Co-ordinates messages between browser and server. Messaging in XML.
  • Can hand-write custom Javascript components if desired.
  • Open-source license (Mozilla Public License or GNU LGPL) by Next App, Inc..


Flexjson is a lightweight library for serializing Java objects into JSON using jsp framework. What's different about Flexjson is it's control over what gets serialized allowing both deep and shallow copies of objects. It also handles cycles in your object graph gracefully so you don't have to maintain parrallel object models, and translate between them.


Guise provides an elegant server-side component architecture that doesn't require developers to write HTML or JavaScript (Demo).

  • A true application framework, written completely in Java.
  • Allows developers to think in terms of component and events instead of HTML generation and DOM programming.
  • Provides controls, modal dialogs, flyovers, and more.
  • XHTML compliant.
  • Flexible commercial license, with free full-featured development version available for immediate download. By Global Mentor Inc.

Google Web Toolkit

GWT Google Web Toolkit (GWT) is a Java software development framework that makes writing AJAX applications like Google Maps and Gmail easy for developers who don't speak browser quirks as a second language.

  • You write your front end in the Java programming language, and the GWT compiler converts your Java classes to browser-compliant JavaScript and HTML.
  • UI components are open-source, Java-to-JavaScript compiler is open-source too since december 2006.
  • Dynamic, reusable UI components
  • Really simple RPC
  • Browser history management
  • Real debugging
  • Interoperability and fine-grained control

A cool extension is GWT-ext which is a library that helps tie together the functionality of the Google Web Toolkit and the widgets available in the ExtJS javascript library.

Other inetersting thing is Web Desktop Manager - something like Windows Explorer or Linux Gnome, but made with GWT

IBM JSF Widget Library

IBM's Rational Developer Tools include a standards-compliant extension to JavaServer Faces (JSF) for building and deploying rich AJAX applications. These is a mature library, which first shipped as a non-AJAX version in 2003, and has been enhanced to include AJAX in 2006.

  • Supports external AJAX updates as well as AJAX from the JSF lifecycle
  • Works in application server and portal server
  • Drag & drop support with visual design tools in IBM's Rational tools
  • Can apply AJAX patterns to existing JSPs containing non-AJAX components
  • Source included in Rational Application Developer


ICEfaces is a standards-compliant extension to JavaServer Faces (JSF) for building and deploying rich AJAX applications

  • Smooth, incremental page updates with in-place editing and no full page refresh.
  • User context preservation during page update, including scrollbar positioning and user focus.
  • Asynchronous page updates driven from the application in real time.
  • Fine-grained user interaction during form entry that augments the standard submit/response loop.
  • Community and Commercial version by ICEsoft.

ItsNat, Natural AJAX

ItsNat is an innovative open source (LGPL v3 or alternative license) Java AJAX Component based Web Framework. It offers a natural approach to the modern Web 2.0 development focused on SEO friendly Single Page Interface web sites/apps.

ItsNat simulates a Universal W3C Java Browser in the server; the server mimics the behavior of a web browser, containing a W3C DOM Level 2 node tree and receiving W3C DOM Events using AJAX. Every DOM server change is automatically sent to the client and updated the client DOM accordingly. Consequences: pure (X)HTML templates and pure Java W3C DOM for the view logic. No JSP, no custom tags, no XML meta-programming, no expression languages, no black boxed components. The developer has the full control of the view.

ItsNat includes features like web-continuations (continue events), user defined events, timers, long running server tasks, COMET, DOM utils (to simplify DOM manipulation), resolution of ${} based variables in markup, ElementCSSInlineStyle support in the server, automatic page remote/view control of other users/sessions, XML generation, non-HTML namepaces support (like SVG in XHTML, pure SVG and XUL), JavaScript generation utilities, events fired by the server sent to the client simulating user actions for instance to test the view from the server (server driven functional testing), custom pretty URLs, previous/forward document navigation (pull and push referrers) with back/forward button support using AJAX, degraded modes (AJAX disabled and JavaScript disabled modes) etc.

ItsNat provides an, optional, event based (AJAX) Component System, inspired in Swing and reusing Swing as far as possible such as data and selection models, where every DOM element or element group can be easily a component.

Web site (downloads, docs, forums etc)

Online Demo (examples with source code)

JavAjax : Java & Ajax Web Framework

JavAjax is a light and fast web framework that will help you to develop dynamic java web applications in Java, integrated with a strong support for Ajax. It can easily be integrated in an already developed application/website: on the server side, you just need to configure a new filter and you are ready to call the actions, on the client side it works with your HTML code transparently, no graphical tags are needed, putting in your hand a strong tool to work in Ajax.

It's key features are:

  • Strong support for Ajax: write your Action and call its methods via Ajax or in page navigation mode trasparently through a generated Javascript Action API
  • Strong, multi-level data validation performed at method level - data type, regular expression matching, min/max length/value, compulsoriness
  • Automatic Request parameters/method parameters mapping
  • Automatic Bean population with parameters from request
  • Bean pre-population strategy: instantiate or pre-load the Bean you want to be populated
  • Bean post-population validation through expressions
  • Minimal jsp tags use, pure html form and elements: no need of framework dependent graphical tags
  • Support for Action and Method level security, basic security is based on roles as defined by J2EE standards, or you can easily implement your own
  • Automatic error reporting with field highlighting, both with Ajax and page navigation methods
  • Easy localization support through a multi-level resource bundle strategy
  • Javascript based on prototype.js or jquery assures the same behaviour with the most diffused browsers.
  • Support for Action call chaining

And much more...

Jaxcent : Just-Java Framework and API for AJAX


Jaxcent is an open-source Java-only Framework and API for AJAX. No JavaScript programming is required. Only a single JavaScript include statement needs to be added to HTML content. JavaScript can be taken advantage of, if desired. Note that this is not a JavaScript code-generator - all flow of control is Java driven. When Java classes are recompiled, the behavior of the page changes immediately at the next refresh. Jaxcent is a server-side Java framework.

Light Portal

Light is an Ajax and Java based Open Source Portal framework which can be seamless plugged in to any Java Web Application or as an independent Portal application. One of its unique features is that it can be turned on when users need to access their personalized portal and turned off when users want to do regular business processes.

  • Supports JSR 168 Portlet API programming model.
  • supports multiple theme, also support custom theme.
  • Each Portlet can be configured to refresh independently, auto refresh independently and refresh other portlets in the same tab page.
  • Supports Role based Authorization.
  • Easy to be configured and managed.

Java2Script Pacemaker

j2s Java2Script (J2S) Pacemaker provides an Eclipse Java to JavaScript/HTML/CSS compiler plugin and an implementation of JavaScript version of Eclipse Standard Widget Toolkit (SWT) with other common utilities, such as java.lang.* and java.util.*. You can convert your SWT-base Rich Client Platform (RCP) into Rich Internet Application (RIA) by Java2Script Pacemaker.

  • Totally open source including core compiler (Eclipse Public License 1.0)
  • Well-integrated with Eclipse Platform (JDT)
  • Support AJAX for Java besides JavaScript
  • Creating 2 GUI with one step (SWT and Web)
  • Providing JavaScript version of SWT
  • JavaScript version of JUnit tests supported
  • Using Dynamic JavaScript Loading (Loading JavaScript on demands)
  • Java reflection supported (early implemenation)
  • I18N supported (Through java.util.ResourceBundle)

Java Web Objects (May 2001)

JWO is a technology for building highly interactive web applications. It's a pre XMLHttp technology based on an extension of HTTP.

  • Hosted by the Firestorm Web Server
  • Client has to support the WSAP protocol (KWSAP is a WSAP extension for KDE)
  • A JWO can expose its methods through SOAP
  • A JWO generates its own HTML interface
  • Transparent remote invocations from JavaScript to the server-side web object (synchronous)
  • Server side generated events (asynchronous)
  • The project has been inactive since 2002

JayJax (March 2007)

[2] is an integration project for current AJAX libraries (prototype, scriptaculous etc.) enhanced by a Model-Presenter-Layer.

  • The goal is to allow various communication policies between client and server.
  • The server side is currently Java only.
  • Implements the Model View Presenter pattern.
  • Uses Java annotations.

jMaki (May 2006)

[3] is a technology for providing a Java wrapper around JavaScript libraries whether they be created by you or are existing libraries such as Dojo, Yahoo UI Widgets, Scriptaculous, or SPRY.

  • jMaki is provided as a JSP (2.0) tag or JSF (1.1) Component.
  • jMaki contains over 30 prewrapped widgets.
  • jMaki also contains a generic Java based proxy for accessing XML based services such as those provided by Yahoo, Flickr, and Google and providing the content as JSON.
  • Hosted live at [4].
  • Netbeans and Eclipse Plugin available for drag and drop construction of applications.
  • Open Source License (BSD)

JSON-RPC-Java (April 2004)

JSON-RPC-Java is an AJAX RPC middleware that allows JavaScript DHTML web applications to call remote methods in a J2EE Application Server.

  • Transparently maps Java objects to and from JavaScript objects using Java reflection.
  • Handles marshalling/unmarshalling of arbitrarily complex nested data structures.
  • Lightweight protocol similar to XML-RPC.
  • Leverages J2EE security model with session specific exporting of objects.
  • Open-source license (LGPL) by Michael Clark and others.

JSP Controls Tag Library (December 2005)

JSP Controls Tag Library provides the lifecycle for portlet-like JSP components. The Library does not require a portal engine or other central controller. The components built with the Library can be used in any JSP-based application.

  • Supports dual-mode components (non-Ajax and Ajax) therefore works even with Netscape 4.
  • In non-Ajax mode components utilize synchronous HTTP request/response cycle via Redirect-After-Post pattern.
  • In Ajax mode components are updated in-place.
  • Component reload in non-Ajax mode is completely automatic and transparent.
  • Transition between Ajax and non-Ajax mode is undetectable when Javascript turned on or off.
  • Demo
  • Open-source license (Apache 2.0) by Michael Jouravlev.

bharadwaj n


jWic is a java-based development framework for developing dynamic web applications with the convenience and familiarity of 'rich client' style programming.

  • Component-based, event-driven programming model
  • Controls are rendered using templates (i.e. Velocity)
  • Dynamically updates a control using AJAX mechanisms
  • Open-source licence (Apache Licence, Version 2.0) by Florian Lippisch an Jens Bornemann.


Nitobi Software makes enterprise-class Ajax controls, as well as an Ajax toolkit. Components are available for Java, ASP.NET, PHP, Classic ASP, and Coldfusion MX.

Nitobi's Ajax components include:

  • Grid -- A cross-browser spreadsheet with Excel "copy/paste", LiveScrolling, and more.
  • TreeGrid - A new, hierarchical grid component.
  • ComboBox -- A drop-down menu with autocomplete functionality, similar to Google Suggest.
  • Calendar -- A high-performance calendar picker that can be used with Nitobi Grid or in standalone web applications.
  • Callout -- A rich, skinnable tool-tip that prompts users with real-time feedback and helpful instructions as they navigate through an application.
  • Fisheye -- A tool bar menu featuring fisheye magnification, similar to Apple OS X tool bar.
  • Spotlight -- A tool for creating stylish guided tours of websites and applications.
  • Tabstrip -- Folder tabs for navigating to different sections of a web application via Ajax or iFrame requests.
  • Tree -- A hierarchical data view, similar to the folder view in Windows Explorer.
  • Ajax Toolkit -- A library of fully-documented tools used in Nitobi components that can be re-used in your own applications, or to build your own components.


Restlet is a lightweight REST framework for Java


  • REST concepts have equivalent Java classes (resource, representation, connector, etc.)
  • Suitable for both client and server Web applications
  • Automatic server-side content negotiation based on media type and language preferences
  • Static file serving and editing with metadata association based on file extensions
  • Support for representations like JSON, XML (DOM or SAX), FreeMarker templates (alternative to JSP)
  • Server connectors for HTTP, HTTPS and AJP (for Apache or IIS) protocols
  • Client connectors for HTTP, HTTPS, SMTP, JDBC and FILE protocols
  • Routers support the concept of URIs as UI with advanced pattern matching features
  • Filters support features such as authorization, browser tunnelling and extraction of call attributes
  • Support of HTTP Basic and Amazon Web Services authentication schemes
  • Deployment as native services using Java Service Wrapper
  • Supports blocking and non-blocking NIO modes
  • Clean Restlet API as a full alternative to the Servlet API
  • Noelios Restlet Engine (NRE) is the Reference Implementation (provided by Noelios Consulting)


  • "Restlet API" and "Noelios Restlet Engine" are distributed under the CDDL license (similar to Mozilla Public License).
  • Commercial licenses can be discussed for trademark usage and alternative usage models.

Simple Remoting

Web Site Simple Remoting is an alternative open source SOA library which uses JSON instead of XML as its messaging format. Converting popular java object types like POJO, Spring and EJB to services can be done within minutes without any code change on existing classes.Javascript & Java Clients are core parts of the framework.Services are also reachable through direct HTTP GET/POST methods.

Software AG’s Crossvision Application Designer

Commercial Link


An open source AJAX framework to create database applications for the WEB.

The target of this framework is to give the user the possibility to create a lot of formulars in a kind of a simulated MDI-interface. The user can switch between the web-formulars which were opened by himself using the window menu. With this the user can navigate through a large of data very easy because it is possible for him to keep the formulars open he is interested in. The framework supports tables with vertical and horizontal scrollbars and the user can change the width of the columns. Two look and feels exists currently. It is also possible to create your own look and feel. Unfortunately the tutorial is in german language but the documentation of the API is in english language.


An open source business-applications oriented Ajax framework with support for JPA/EJB3

Our approach to Ajax is quite different from other solutions (as far as we know), we builded a system able to track, on the server side, changes to the page displayed on the browser and, through a small javascript runtime, to refresh only changed parts (it is comparable to the paint event mechanism of desktop user interfaces). It is completely transparent to the programmer which has to deal only with a new jsp tag library. This is the view side of our MVC model, but work has been done also on the controller and model side. The controller side is based around the concept of Flow (yes, it is very similar as concept only to the one of Spring Web Flow but powerful, for us at least) which lets the programmer design the interaction with the user as finite state-machines. Each flow can be in turn nested in another flow and became a state of it (sub-flow), used in modal interaction with the user or as a component of another flow (the main difference with a sub-flow is that a component is active concurrently with other components and can interact with them in a way similar to portlets).

We provided also an implementation thinked to be binded via interfaces to the application model.

As an optional package, it is included our implementation of the application model, complete of a data validation architecture (with an interface to "Hibernate Validator"), complex model such as tables, trees, view on tables, etc... If used with a JPA provider such as Hibernate it includes lookup validator, direct loading and storing from/to the data model, optimistic lock handling, etc...

Many other functionalities are provided for the programmer, but, by the way, the real think that makes the solution appetible is the final result in terms of usability.

Vaadin (IT Mill Toolkit)

Vaadin is a Ajax framework for developing web applications for with Java language at server-side. It provides a library of user interface components and defines clean framework for creating your own components using GWT (Google Web Toolkit) - no XML declarations or JavaScript programming is needed. Vaadin is the only framework that combines security and easiness of server-side Java-programming model with extensibility by adding new widgets completely in Java. The toolkit has been used in production applications since year 2001 and it is suitable for building compatible Rich Internet Applications (RIAs) on Java EE (or J2EE) platforms.


ZK is an Open Source Ajax Java framework without JavaScript. With Server+client fusion, 200+ Ajax components and markup languages, developing Ajax/RIA as simple as desktop apps and HTML/XUL pages.


  • 200+ XUL/HTML-complaint Ajax components offer UI designers a variety of feature rich components to meet the demands of enterprise Ajax applications.
  • ZUML makes the design of rich user interfaces similar to authoring HTML pages. ZUML is a variant of XUL inheriting all features available to XML, and separates the UI definition from the run-time logic.

Support for Model-View-Controller (MVC) decoupling View, Model and Controller for easy to develop and maintain. Support for Model-View-Presenter and Model-View-ViewModel (MVVM) decoupling the controller furthermore to minimize the code required and to maximize the maintainability.

  • Comet server push, drag-and-drop, animation, context menu, and so on
  • Strong IDE support, full feature free to use currently. ZK Studio
  • ZK 5 CE is distributed under the Lesser General Public License (LGPL), while ZK 3 and prior versions are distributed under GPL.