There are a lot of frameworks for J2EE development that are based on the MVC. Below, 11 (very different) frameworks are shortly presented.
Orbeon Presentation Server
OpenLaszlo
Cocoon
Spring
Beehive
Hivemind
Tapestry
Struts
Java Server Faces
Shale
WebWork
(texts sometimes taken from the web sites of the products) Frameworks based on XML
Orbeon Presentation Server
Orbeon PresentationServer (OPS) 3.0 is an open source J2EE-based platform for XML-centric web applications. OPS is built around server-side XForms, XHTML, XSLT, XML pipelines, and Web Services, which makes it ideal for applications that capture, process and present XML data.
Unlike other popular web application frameworks like Struts or WebWork that are based on Java objects and JSP, OPS is based on XML documents and XML technologies. This leads to an architecture better suited for the tasks of capturing, processing, and presenting information in XML format, and often does not require writing any Java code at all to implement your presentation layer.
OPS is built around Orbeon's optimized XPL engine, a mature, high-performance XML pipeline engine for processing XML data. XML pipeline engine implementing the XPL language provides a service-oriented, declarative approach to XML processing.
The latest version (3.0) provides full server-side XForms with AJAX support.
While similar to Apache Cocoon, OPS benefits from standards-based forms processing using XForms, richer controller semantics, and full-featured XML pipelines described with XPL, the XML Pipeline Language.
License: LGPL
OpenLaszlo
The OpenLaszlo 3.1 platform allows developers to create applications with the rich user interface capabilities of desktop client software and the instantaneous Web deployment of HTML. These applications run on all leading Web browsers on all leading desktop operating systems from a single XML code base (Flash player needed).
OpenLaszlo applications are written in XML and JavaScript just like DHTML, but portable across browsers.
A compiler transforms the XML data into Flash. It is the ideal tool for rich web-based applications.
License: IBM's CPL
Apache Cocoon
Cocoon is a web development framework built around the concepts of separation of concerns and component-based web development.
Cocoon implements these concepts around the notion of 'component pipelines', each component on the pipeline specializing on a particular operation. This makes it possible to use a Lego(tm)-like approach in building web solutions, hooking together components into pipelines without any required programming.
Cocoon is "web glue for your web application development needs". It is a glue that keeps concerns separate and allows parallel evolution of all aspects of a web application, improving development pace and reducing the chance of conflicts.
"pure" J2EE Frameworks
Spring Framework
Spring 1.2.5 is a middleware for J2EE. Spring's main aim is to make J2EE easier to use and promote good programming practice. It does this by enabling a POJO-based programming model that is applicable in a wide range of environments.
Spring is essentially a technology dedicated to enabling you to build applications using POJOs. This desirable goal requires a sophisticated framework, which conceals much complexity from the developer.
Beehive
Apache Beehive's goal is to make J2EE programming easier by building a simple object model on J2EE and Struts. Using the new JSR-175 annotations, Beehive reduces the coding necessary for J2EE. The initial Beehive project has three pieces.
NetUI: An annotation-driven web application programming framework that is built atop Struts.
Controls: A lightweight, metadata-driven component framework for building that reduces the complexity of being a client of enterprise resources.
Web Service Metadata (WSM): An implementation of JSR 181 which standardizes a simplified, annotation-driven model for building Java web services.
In addition, Beehive includes a set of system controls that are abstractions for low-level J2EE resource APIs such as EJB, JMS, JDBC, and web services.
Hivemind
HiveMind (Apache Jakarta project) is a services and configuration microkernel.
Services: HiveMind services are POJOs (Plain Old Java Objects) that can be easily accessed and combined.
Configuration: HiveMind allows you to provide complex configuration data to your services in a format you define. HiveMind will integrate the contributions of such data from multiple modules and convert it all into data objects for you.
Microkernel: HiveMind is a framework for creating applications, not an application, or even an application server, itself.
In HiveMind, a service is an implementation of a Java interface. Unlike other SOAs (Service Oriented Architectures, such as a SOAP, or EJBs), HiveMind is explicitly about combining Java code within a single JVM. HiveMind uses a descriptor to describe different services, their lifecycles, and how they are combined. HiveMind takes care of thread-safe, just-in-time creation of singleton service objects so your code doesn't have to.
HiveMind sits between your application code and the underlying J2EE or other APIs
Tapestry
Tapestry 4.0 (Apache Jakarta project) is an open-source framework for creating dynamic, robust, highly scalable web applications in Java. Tapestry complements and builds upon the standard Java Servlet API, and so it works in any servlet container or application server.
Tapestry divides a web application into a set of pages, each constructed from components. This provides a consistent structure, allowing the Tapestry framework to assume responsibility for key concerns such as URL construction and dispatch, persistent state storage on the client or on the server, user input validation, localization/internationalization, and exception reporting. Developing Tapestry applications involves creating HTML templates using plain HTML, and combining the templates with small amounts of Java code using (optional) XML descriptor files. In Tapestry, you create your application in terms of objects, and the methods and properties of those objects -- and specifically not in terms of URLs and query parameters. Tapestry brings true object oriented development to Java web applications.
Tapestry is specifically designed to make creating new components very easy, as this is a routine approach when building applications. The distribution includes over fifty components, ranging from simple output components all the way up to complex data grids and tree navigators.
Tapestry easily integrates with any kind of backend, including J2EE, HiveMind and Spring
Apache Struts Action Framework
Apache Struts Action Framework (formerly under the Apache Jakarta project, Struts is now a top level project) is an open-source framework for developing J2EE web applications. It uses and extends the Java Servlet API to encourage developers to adopt an MVC architecture. It was originally created by Craig McClanahan and donated to the Apache Foundation in May, 2000.
This framework enables design and implementation of large web applications to be handled by different groups of people. In other words, page designers, component developers and other developers can handle their own bit of the project all in tandem and in a decoupled manner. It features I18N (internationalization), a powerful custom tag library, tiled displays and form validation. It also supports for a variety of presentation layers, including JSP, XML/XSLT, JavaServer Faces (JSF), and Velocity, as well as a variety of model layers, including JavaBeans and EJB.
Tiles
Tiles is a part of struts and allows to organize your page in different pieces (like a puzzle).
Java Server Faces
With the simple, well-defined programming model that JavaServer Faces technology provides, developers of varying skill levels can quickly and easily build Web applications by: assembling reusable UI components in a page, connecting these components to an application data source, and wiring client-generated events to server-side event handlers. With the power of JavaServer Faces technology, these web applications handle all of the complexity of managing the user interface on the server, allowing the application developer to focus on their application code.
Shale Framework
The Shale Framework Successor of Struts (based on java server faces)
Shale is a proposal for a modern web application framework, fundamentaly based on JavaServer Faces, and focused on improving ease of use for developers adopting JSF as a foundational technology in their own development environments. At the same time, the architecture of Shale is a set of fine grained services (and service options) that can be combined as needed to meet particular application requirements. In addition, integration links for other frameworks and framework components are provided, to ease development when combinations of technologies are required.
WebWork
WebWork (from OpensSymphony) is a Java web-application development framework. It is built specifically with developer productivity and code simplicity in mind, providing robust support for building reusable UI templates, such as form controls, UI themes, internationalization, dynamic form parameter mapping to JavaBeans, robust client and server side validation, and much more.
WebWork will be merged into Struts.
|
Blog 
