Show WhatIsFrame2.html syntax highlighted
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<title>What is Frame2?</title>
</head>
<body>
<h1>What is Frame2?</h1>
<p>
Frame2 is a second-generation implementation of the JSP Model 2 web application
architecture.<br>
It builds on the prior art of frameworks such as Struts, WebMacro
and Virtuas Solutions' TurboM2 Framework to present a highly configurable and
modularized tool that supports the development of both web applications and web
services using J2EE.<br>
Frame2 users (that is, developers who build web
applications and services) will use the Frame2 framework to integrate business
assets with web-based user interfaces.<br>
With Frame2, business assets may be
used as-is, with no modification. The user interface components (JSPs, HTML,
images, etc.) are bundled with the framework, configuration information,
and user extensions for deployment in the J2EE servlet container.
</p>
<h2>The Frame2 Development Model</h2>
Frame2 presents a standard layered/n-tier model for development. Each layer
contains code and configuration data specific to its purpose. These layers are
intended to keep application and service development simple, reliable and
sustainable.<br>
The layers in the Frame2 model are as follows:
<ul>
<li>Client Presentation - Presentation code that executes on the client. This
generally corresponds to Javascript placed into the HTML response. Javascript
may be used to perform lightweight validation or to implement dynamic
presentation features.</li>
<li>Server Presentation - Presentation code that executes on the server. This
generally corresponds to JSP and custom tag code. Frame2 provides custom tags
for seamlessly combining HTML with server data.</li>
<li>Application Controller - The controller acts as a mediator between the
presentation layer and the application logic. Because the mapping of requests
to application-specific logic and data lends itself to generic, data-driven
implementations, the application controller is an ideal candidate for framework
design. Packages such as Frame2 and Struts serve this role.</li>
<li>Application Logic - Application code that implements logic for the
navigation and processing of user inputs (i.e. complicated validation or
integrity checks). Application logic pertains to the behavior of the application
with respect to user inputs.</li>
<li>Business Services or Model - Domain oriented data abstractions, services and
models. These are separated from the application logic and have a high potential
for reuse across different applications. They may be hosted in the same
container as the application layers or hosted remotely.</li>
<li>Resource - Resources external to the application such as databases,
messaging services, transaction managers, other remote facilities.</li>
</ul>
<p>
For web services, the layering corresponds to a similar model. The presentation
layer is replaced with programmatic clients, which are often outside the realm
of the service developer. Additionally application-level behaviors are
simplified in comparison to web applications, often reduced to pass-through to
the underlying business service.
</p>
Interposing an application controller between the client and application logic
offers numerous advantages. Foremost is simplifying the work to develop web
applications that have non-trivial navigation and processing rules. Complicated
and rote programming tasks for managing the navigation rules, converting data
from the HTTP requests, and data validation can be avoided through automation
and configuration. Security measures can also be made uniform.
<h2>Configurability</h2>
Model 2 controllers intrinsically manage navigation concerns.<br>
Frame2 provides a rich set of configuration features that combine easily with
user-provided application logic. Through the configuration, users can define
mappings between the client requests and the application components that
process those requests, and between the outcomes of the processing to the views.
<br>Within these configuration elements specification can be given to how to
handle invalid inputs, cancellation requests, and errors generated by the
application code of the framework itself.<br>
In support of co-hosting both web applications and web services in the same
deployment, the configuration information can be segregated between the HTTP
and the XML processing streams.
<h2>Web Application Support</h2>
Frame2 provides a number of features for web application support.<br>
At the server presentation layer it provides custom tags that extend the JSTL
expression language to standard HTML tags as well as allowing
internationalization without the need for learning or understanding new tag
attributes.<br>
At the controller layer, Frame2 gives a simplified programming model for
creating and structuring application data and logic. Frame2 automatically
populates JavaBeans with data from the HTTP request, validates the data, and
then provide the data to the appropriate handlers for execution of the
application logic.<br>
To complement these features Frame2 interoperates with the J2EE security model
to allow configurable role-based security for all requests made through the
framework.
<h2>Web Service Support</h2>
Frame2 can be used with any JAX-RPC SOAP front-end (for example, Apache Axis or
the Sun's JWSDP).<br>
The web service features give the user broad latitude in how the SOAP request
body is structured as well as how the response is generated.<br>
Bodies may be processed as single or batch requests, with unmarshalling into
JavaBeans automatically taken care of through JAXB technologies. Frame2
interoperates with JAXB to allow XML schema definitions to be automatically
converted and validated as JavaBeans.<br>
With a defined schema, developers can code application and business services
without having to understand XML or SOAP; the code to the JavaBean
representations of the SOAP bodies and Frame2 with JAXB manages conversion.
<h2>Simple API</h2>
Frame2 abstracts the transport and protocol layers to minimize the difficulty
with learning and using complex technologies such as J2EE and SOAP.<br>
Most development can be done in the application layer by reading and setting
bean properties and exercising business services. The simple API in combination
with the flexible configuration helps maintain good separation between the
model, view and controller components.
<h2>Struts Differences</h2>
There are numerous feature-based comparisons to be made with Struts, the most
popular open-source framework for building J2EE web applications.<br>
From a framework design point of view, there are several key differences:
<ul>
<li>Frame2 abstracts the J2EE API and HTTP protocol away from the user-provided
application code. Developers do not need detailed knowledge of either to be
productive in the environment.</li>
<li>Frame2 more naturally models the interaction between the user interface or
client and the server elements. Struts treats this as a procedure call, where
the request data is an argument to a requested action. Frame2 unifies the
request intent and data into an event which is sequentially processed by event
handlers. This model is more common to user-oriented applications and more
flexible with respect to developing and configuring reusable application
components.</li>
<li>Frame2 minimizes the amount of wrapping of existing standard Java APIs.
For example, no wrapping is provided for message formatting and resource bundle
management is limited to what is necessary for the framework.</li>
<li>Frame2 places more emphasis on flexibility in the configuration of the
application. Users have more options for setting application strategies through
the configuration, and more options for organizing their application logic to be
reused both within the web application and across applications.</li>
<li>Frame2 supports co-hosting both web applications and web services with reuse
of data and logic components between the two. The web applications are supported
through a traditional J2EE Model 2 architecture with a configurable controller.
The web services are supported through interoperability of the same controller
with SOAP front-ends such as Apache Axis or the Sun implementation of
JAX-RPC.</li>
<li>Frame2 places more emphasis on using emerging technologies such as the
JSTL/EL and JAXB. As such, it lacks compatibility with older developer kits and
J2EE specifications; however, it takes advantage of technologies like the
Expression Language (EL), which makes obsolete the elaborate and framework
specific tag libraries provided by Struts.</li>
</ul>
The differences are all intended to simplify developing a web application by
creating a simple but flexible API.
</body>
</html>
See more files for this project here