The J2EE standard includes Servlet and JSP specifications to facilitate Web application construction and rollout. Although these specifications provide the basic infrastructure for creating Web applications, they do not establish the application design.
Creating the application execution architecture goes beyond creating a collection of common application services, such as data access, e-mail delivery or queue management objects. It must provide the base architecture for the applications, defining the tier structure and design templates used in each of them.
The best practices and design templates that have come out of the Java community facilitate the creation of quality application architectures on which to develop the applications. However, developing an application architecture from scratch, based on templates, is costly, repetitive and more open to errors that starting with an existing one.
That is why openTrends implements the framework openFrame, service-oriented architecture (SOA), with its clients who have specific development needs, especially in critical, large-volume and multi-provider environments.
openTrends' J2EE development framework is the result of:
- Years of experience by openTrends staff in the development and implementation of corporate applications in business settings.
- The experience in architecture design
- The application of commonly accepted standards as part of an open architecture (Model View Controller, use of design templates and J2EE-Blue Prints)
- Integration of OpenSource solutions that have been proven and certified by the framework development team (low cost of the solutions with the reliability and features of the commercial suites)
The development framework is designed taking into account the need to constantly upgrade and adapt a platform of this type. The openFrame development team, together with the clients where it is implemented, is currently upgrading this technology in order to improve:
- The productivity of developments with plugins or tools designed specifically to support development
- The quality of the software, with the inclusion of code quality management (Junit, Jmeter, Maven) and continuous integration (Cruise Control) methodologies
- The management and reuse of projects and components (openForge, CVS)
openFrame provides a service-oriented architecture, based on open source software components, de facto standards in professional development, that make it possible to create business-critical applications, reducing the design, development and maintenance costs of the applications.
The three main openFrame modules are Struts, Spring and Hibernate.
Struts provides the following utilities:
- A main Controller already implemented (Front Controller pattern with Dispatcher View)
- Automatic form management with refreshing between screens and optional validation
- Error management, displaying them in the viewer
- Application internationalization (multi-language)
- Tag library for use in the views
- Allows process filters to be added (Decorating Filter pattern)
- A single configuration file that links the controllers with application forms, clearly showing their interaction and lifetime
Spring provides the following utilities, among others:
- A centralized container for objects and services, fully configurable with XML files
- By using control inversion, especially the injection of dependencies, it allows the configuration of objects outside of the application code (the container manages the instances), in a non-intrusive way (the objects configured are not linked to Spring, nor is it necessary to know their classes).
- Reduces the application code dedicated to configuring and localizing resources (JNDI, JTA, etc.), as this is done by the framework. The application code is thus more legible, since it contains primarily application logic.
- It promotes best practices, such as programming against interfaces instead of against classes
- This helps to detach services (think of the application objects as services, which express their functionality as interfaces and separate their configuration details from the programmer view, facilitating the change from one specific implementation to another).
- Structuring the application logic into services based only on POJOs and interfaces facilitates individual tests (the EJB container is not needed for the tests and the services are easy to emulate with MockObjects)
- Transaction management without the use of specific APIs, using Aspect-Oriented Programming (AOP can also be used in other services, such as the management of logs, security or exceptions)
Hibernate, as a data access layer, provides the following utilities:
- Flexible object-relational mapping (table per class, multiple objects per record, multiple tables per object, all types of relationships 1-n, n-m, etc.)
- Transparent object persistence (non-intrusive, without imposing interfaces or foreign classes, just standard Java arrays and collections)
- Query language independent of the DB (HQL)
- Possibility of conventional native access (T-SQL, PL-SQL, etc.) and logic calls in the DB (stored procedures, packages)
- The entire configuration (mapping, HQL queries, native queries, etc.) can be defined in XML configuration files, not hard-coded in the Java code.
- Cache (multi-layer, threadsafe, non-blocking, clusterable)
- Other optimizations (lazy initialization, subselect fetching, etc.)
- J2EE integration (EJB 3.0, JMX, JTA, etc.)
- Extendible (new SQL dialects, own-key generators, etc.)
- Supports multiple DBs (Oracle, DB2, Sybase, MS SQL Server, PostgreSQL, MySQL, HypersonicSQL, SAP DB, Interbase, Ingres, Informix)
The openTrends J2EE application development framework uses these three modules as its base and extends it by adding a set of additional services and patterns, selected from among the best open source initiatives in each area (log4j, tiles, hibernate, quartz, digester, tiles, validator, xerces, cocoon, jasper, openJMS, etc.), making them work together and offering the developer a single, consistent view of how the platform is used.
