Study On Component-based Object Persistence Layer Architecture

The maturation of Object-Oriented (OO) technology in recent years provides us a brand new approach of software development, while, in the data storage market, the traditional relational databases are still in dominion. Relational database is based on a widely different theory from object-oriented techniques which raises many problems such as the impedance mismatch. Combination of the advanced OO mechanism and methods with database techniques are the result of the development of OO technology and database. There are three major strategies to make this combination. The first one is to design a whole new object-oriented database (OODBMS); the second is to expand traditional database to ORDBMS with object-oriented specialties; and the third, is to build a standalone object persistence layer between application and database. At present, the OODBMS technique is not mature, presents many problems and limitations. It lacks of the support of the solid mathematical theories and feasible standards, and, its poor performance, reliability and portability makes it difficult to be accepted by the information process market. The ORDBMS takes the advantages of both OO techniques and the matured relational database, but due to the lack of standards, each vender design and development the products in its own way, which makes the compatibility between different products are unacceptable. Therefore, the object persistence layer strategy seems to be a feasible approach in current situation. Researches on object persistence techniques emerges with the birth of OO technology and it application to data process field. Nowadays, software industry has made encouraging achievements on mapping object pattern to relational database schema and the object persistence layer architecture. Nevertheless, present researches usually regard the persistence layer as a part of the application, and attempting to make persistence layer to perform the full functions of a database kernel, which results in a super-complex, high level coupling design, makes it very difficult to implement such a persistence layer. Furthermore, such an implementation is not easy to be used, because of its highly concentrative functions and complex framework. This paper brings forward a component-based; four layer architecture of object persistence layer. The Component-based design ensures the architecture the trait of simpleness and agility. In this architecture, the first layer (layer 0) performs base persistence job such as storage management and caching; the second layer (layer 1) provides reliable support to the persistence layer; the third layer (layer 2) extends the persistence by adding transaction support; the fourth layer (layer 3) provides flexible mapping configuration through mapping management components. Persistence layer based on this design can be treated as a fine-grained integration of a few self-contained components. In this framework, each component provides single function, such as logging, storage management and mapping management, etc. these components have the advantage of high cohesion, low coupling, and the entire persistence layer can be easily implement and customized. This paper systematically discussed the strategies of mapping object patterns to relational database patterns. Focused on performance, space consumption and flexibility/maintainability, etc., and made an in-depth research on integrality and restricts of relations of these mapping strategies. Based on the research on object persistence techniques, using UML (Unified Modeling Language) and Java programming language, we made a basic reference implementation of the architecture. And bring forth its high and middle level class diagrams of the implementation. In a practical work, the implementation based on this architecture proves to be efficiency in reducing the coupling between persistence layer and application, which provides the application a high flexible and reusable characteristic.