Shale Framework

Shale Framework
Shale is a modern web application framework, fundamentally based on JavaServer Faces. Architecturally, Shale is a set of loosely coupled services that can be combined as needed to meet particular application requirements. Shale provides additional functionality such as application event callbacks, dialogs with conversation-scoped state, a view technology called Clay, annotation-based functionality to reduce configuration requirements and support for remoting. Shale also provides integration links for other frameworks, to ease development when combinations of technologies are required.
Shale Features
The major features of the Shale Framework are described in the following detail sections:
View Controller - Convenient mechanism to associate a "backing" Java class with each JavaServer Faces view in an application, with predefined event handers for events significant to an application developer.
Dialog Manager - Mechanism to define a "conversation" with a user that requires multiple HTTP requests to implement, modeled as a state diagram.
Application Manager - Traditional application wide front controller features that should be applied to every request.
Validation - Integration with the Jakarta Commons Validator Framework, supporting both client side and server side validations based on a single set of configured validation rules.
Remoting - Server side support for applications that employ AJAX (Asynchronous JavaScript and XML) style interactions.
Spring Integration - Integration with the Spring Framework, allowing the use of Spring's dependency injection framework to create JavaServer Faces managed beans.
Clay - An alternative to JSP where you define views in pure HTML, in a fashion similar to Tapestry and Facelets. An innovative sub-framework for supporting the configuration of reusable subtrees of JavaServer Faces components for customizable reuse.
Test Framework - Set of mock objects and JUnit test case base classes suitable for testing both the framework classes themselves, as well as application components built on top of the framework.
Tiger Extensions - Optional add-on library that adds additional ease-of-use features for Shale applications that run on Java Standard Edition 5 (popularly known by its code name during development, "tiger").
Clay
Every JavaServer Faces (JSF) view is represented on the server as a tree of components. Shale's Clay lets you graft a component subtree onto an existing component tree.
At first blush, this may not seem like much; after all, you can accomplish the same thing with JSF's standard f:subview tag. However, Clay builds upon this fundamental feature to give you the following killer capabilities:
HTML Views
Similar to Tapestry and Facelets, you define your views in HTML. For dynamic content, you tie HTML elements to JSF components with a jsfid attribute--when Clay renders your view, it replaces static HTML elements that have jsfid attributes with their component counterpart. When Clay creates the components, it transmits HTML style attributes from the HTML tag to the component; therefore, graphic designers can implement a look and feel with mockup HTML and that look and feel is absorbed by the component that replaces the mockup HTML.
Meta-data Inheritance and Tiles-like Composition
You can define a component as an extension of an existing component and then override or add attributes. This mechanism is similar to the inheritance mechanism built into the popular Tiles framework for composing web pages from discrete JSP fragments, known as tiles. In fact, Clay's features are sophisticated enough that Clay can give you much of the same benefits that Tiles users enjoy.
Symbols
You can map managed beans to symbols, which you can use as though they were the actual managed bean. This aliasing facility, much like MyFaces t:aliasBean tag--lets you reuse a view for many different managed beans.
http://shale.apache.org/
http://shale.apache.org/shale-clay/index.html