Project description

The life cycle of software applications in general is very short and with extreme volatile requirements. Within these conditions programmers need development tools and techniques with an extreme level of productivity. We consider the code reuse as the most prominent approach to solve that problem. Our proposal uses the advantages provided by the Aspect-Oriented Programming (Kiczales et al, 1997) in order to build a reusable framework capable to turn both programmer and application oblivious as far as data persistence is concerned, thus avoiding the need to write any line of code about that concern. Besides the benefits to productivity, the software quality increases.

The objective of this project is to build a complete and totally reusable framework for Orthogonal Persistence (Atkinson & Morrison, 1995) in concurrent environments with support for transactions. The current version already is capable of freeing the programmer of implementing any read or writes data operations. This prototype is supported by an object oriented database and, in the future, will also use a relational database and have support for transactions.

Others projects (Atkinson et al, 1996)(Liskov et al, 1996)(Marquez et al, 2001)(Perez-Schofield et al, 2008) already have implemented Orthogonal Persistence in the past. Some (Soares et al, 2002)(Rashid & Chitchyan, 2003) are Aspect-Oriented but require that the data object implement special classes or interfaces.

System architecture

The framework architecture is organized as three main components/layers:

• Main module;
• Aspects;
• Database.

The former element provides an Application Programming Interface (API), as well as others important subsystems such as: object and meta-object cache; the default instance adaptation mechanism; schema manager; database garbage collector; database weaver; and database classloader.

The aspects are organized in two categories: application and framework. The application level aspects provide applications with persistence and data integrity. These application aspects, and the framework's API, are the "glue" that seamlessly attaches the framework to applications. The framework concerns are modularized as five aspects: (1) instance adaptation; (2) database integrity; (3) object storing; (4) system internal statistics; and (5) debugging. Concerning to the instance adaptation aspect, in framework scope just the default behaviour is implemented. This aspect can be extended with user-defined behaviour, which is reified as a special meta-object.

At the lowest level there is the object database. This database holds objects and meta-objets.

This framework prototype uses intensively the Java Reflection API to know the internal structure of the object and it fields. This is crucial to for the object data hierarchy drilldown until the object primitive data types. The prototype provides support to object arrays. This particular type of object needs a specialized treatment since it must be disaggregated in all individuals objects of one or more types. This procedure isn't need in an object database, like the one used, it was an option made to achieve a normalized mechanism in the object persistence aspect to enable a system future evolution to a relational databases, and for cache performance issues allowing a granularity until the elementary object.

In order to the object persistence aspect distinguish between two objects, of a same class, to know which one is persistent or is transient, that is done by a search on the system cache and also on all related objects. An instantiated object that is referred in cache has an Object Id, so it is long-lived. This solution avoids any preparation at type, code or object level (Al-Mansari et al, 2007). By this way, the prototype meets the Persistence independence and Type Orthogonality principles (Atkinson & Morrison, 1995).

The use of the framework it is very simple. The application objects source code it is needed for the woven and compiling process. To write an application, just add the framework package and start write code with any hurry about persistence. To achieve final binary code, the process it is very simple and completely automated by the IDE.

Demo

The following demo shows how the framework can be used. Just add the needed includes to an Aspect Project, in your favourite IDE, and start write code without any hurry about persistence.
In this example, we demonstrate how simply is to create, update, delete and read object from the database in eight different programs (program01 to program08). Those programs have dependences so you must run it sequentially.

The data objects are available on download.

Publications