Webwarp Framework - Architecture
Maven Build Settings and Utility Projects
Webwarp Framework is organized in different layers. At the lowest level
(webwarp-common) there are base projects controlling the maven build
and reporting setup. Following there is a pom layer (webwarp-pom) which
only encapsulates the dependencies for the different technologies used
throughout the framework (e.g. Apache commons libraries, spring
framework, hibernate O/R mapper and more). Based on the pom layer
several utility libraries are build (webwarp-util) which contain
several projects that are as much as independent from each other as
is the webwarp base layer (webwarp-base) which realizes some very
common functionaliy usd throughout application development, like
pluggable bean configurations (based on spring), pluggable menus, an
installer snd setup manager and multi language support. Dependency and
version management on the base layer is made with the help of an
additinoal abstraction layer (webwarp-base-pom).
Modules Layer and Reporting Framework
webwarp modules layer (webwarp-modules) then contains several
components for different areas of application development that we
encountered during our work within tha last years. The modules layer is
extended by a reporting module that was separated from the other
modules because of its complexity (webwarp-reports).
on the layers described so far, several UI component libraries can be
build. Currently only a JSF/Apache MyFaces/Trinidad based web
application interfaces is implemented and available. The UI projects
allow the pluggable setup and configuration/extension of web based
applications based on simple dependency inclusion in the projects POM.
As a build system the Webwarp Framework heavily
relies on Apache maven.
Basically you can also collect and organize things with other build
tools. But we strongly recommend using maven for several reasons:
Webwarp Framework heavily uses the transitive dependency declaration
und resolution of maven. If you omit maven you will have to organize
yourself to get the right libraries connected together.
Webwarp Framework provides a base pom layer which defines a running
combination of the tools used, both for building the framework as well
as running the implemented applications.
- The Trinidad UI Framework uses war-merging for extension and
setup of new web applications and web modules.
what could you do with the framework? As a quick start we want to give
you a short overview of the modules currently available:
Based Build Infrastructure: You
get a complete maven based configuration and build-setup usable also
for automated builds, including automated testing, testing code
coverage and other static code analysis (webwarp-common-build-setup,
- Library Version Management:
The POM Layers (webwarp-pom, webwarp-base-pom) provide you a persistent
and testedversion set of current available technologies on the market.
- DAO Framework: Base
Classes for entites with creation and mutation timestamps, base DAO
implementations that allows you to write a DAO by ony extending the
base classes (webwarp-util-hibernate). Dynamic loading of object trees
is supported by allowing the specification of a detailed preload
settings when issuing queries to the database.
- Historization and Change
(webwarp-util-history-api) and a corresponding implemtation
(webwarp-modules-history) for marking objects and corresponding
properties to be historized and automatically let the history
manager track the changes. The object state can be restored on request
in a flexible way. Additional converters added can also support the
mapping of complex types, e.g. collection types. Both unitemporal and
bitemporal historization is supported.
- The Reporting Framework
multiple rendering engines and provides data abstractions for
decoupling data creation from rendering. Additionally asynchronous
report rendering is supported.
- Extended internationalization
(webwarp-util-i18n, webwarp-base-i18n) which allows you to store and
retrieve internationalized messages in multiple factes, e.g. from
classpath ressources, databases or both.
- File Monitoring Component
(webwarp-util-file): This component allows the monitoring of arbitrary
directories and notifies you on according changes. The observer's state
thereby can be stored in a persistent and recoverable way.
- Excel Manipulation (webwarp-util-excel):
Typically tasks when working with HSSF/Excel are encapsulated
through some Helperclasses.
- Open Office Manipulation
(webwarp-util-openoffice) allows several manipulations on open
office and/or MS Office XML formatted Files.
- SQL Data Extraction and Insertion
(webwarp-util-sql): The library allows the extraction and (re)insertion
of arbitrary data from/into JDBC connected databases.
- XML Configuration Readers
(webwarp-util-xml) allows you to simply checking and reading of XML
configuration data out from a JDOM or DOM tree. Code gets much simpler
by directly setting any default values or throwing exception when
required configuration items are missing.
- Setup Manager
(webwarp-base-setup) for handling required and optional setup
components and their corresponding installer state and compatibility.
- Extendable Spring Context
for automated setup, especially in web applications which allows OSGI
like building up of web applications fully compatible with current UI
technologies, especially JSF.
- User and User Group Management
(webwarp-modules-user): Acegi based and extendible user and user group
- Partner Management Module
(webwarp-modules-partner): Business component that allows definition of
arbitrary persons, groups, organisations and the corresponding
relationships between each other. This module can be used for
implementing partner systems as they are used by insurance companies.
- Configurable Permissioning System
(webwarp-modules-permission): This module allows you to define a
normative permissioning configuration based on subject types, object
types, rights and possible right assigments and object/subject
combinations. On this basis concrete subject, objects and permissions
can be instantiated and managed. Easy permission checking is supported
through corresponding access methods.
- Base UI Framework
is a JSF/Apache Trinidad/Facelets based application development
framework for rapid web application development. It supports multiple
skins, designs and dynamic menu management. Most available modules have
corresponding UI modules that realize the UI functionality. In most
cases inclusion of the dependencies in the POM is sufficient for
successfully incorporating a module into an application.
The Webwarp subversion repository is organiszed according to the layers
defined above and the corresponding UI technology:
- common contains the
Webwarp build settings and parent POMs for projects, web projects and
- pom contains the Webwarp
pom layer which controles the main dependencies from used libraries
- base contains the
webwarp base layer projects
- base-pom handles the
version management for the basic framework layer projects.
- modules contains all
modules currently available
- reports contains the non
UI specific part of the reporting module
- ui contains all UI
- ui/trinidad contains
the MyFaces Trinidad based UI framework.
contains the UI modules for the Webwarp Base Projects
- ui/trinidad/modules contains
the UI modules for the Webwarp Modules Projects
According to the architecture the repository /
projects are layouted as follows:
Base Module. This module does
not contain any UI dependend code. Example: webwarp-base-user
welche die entsprechenden Benutzerschnittstellenmodule realiseren.
Für verschiedene Schnittstellentechnologien
(z.B. Struts, JSF MyFaces,
Eclipse RCP, Swing) müssen auch unterschiedliche UI-Module
realisiert sein. Im Falle von Web-UI unterteilen sich diese
mit dem gesamten JAVA-basierten UI-abhängigen Code
mit dem Code für die HTML-Darstellung (JSPs, Ressourcen etc.)
Webwarp unterstützt in der aktuellen Version nur JSF
mit MyFaces/MyFaces Trinidad.
Version and Release Management
Basically all subprojects are managed as single
projects with their own lifecycle. Corresponding parent projects are
planned to be defined for simplifying the dependency inclusion when
using the Webwarp framework for application development. Another
advantage is that minor bugfixes in submodules can be fixed and
included fast and independent from the overall versioning of the whole