In object oriented systems,we represent entities as objects and classes and use database to persist those objects. Most of the data-driven applications today,are written using object oriented technologies. The idea of representing entities as set of classes is to re-use the classes and objects once written.

To understand the scenario,consider a web application that collects users personal information and stores them to the database. Also there could be a page that displays all the saved users. When implementing this kind of solution,  we may store the data by getting the request parameters and simply putting it into SQL insert statements. Similarly when displaying,we can select the desired record from the database,and display them on dynamic web page by iterating through the result set. But wait...does it sound good to have persistent related code scattered everywhere on the web page? What if we need to modify the design of our database after we have developed few pages? Or even if we want to replace our low-cost development database with an enterprise-class production database that have entirely different SQL syntax? Do we need to change the SQL queries everywhere in our code?

To overcome this problem,we may want to develop JavaBeans representing the entities in the database. We can develop a Persistence Manager that can operate on the given JavaBean and perform several persistent operations like fetch,store,update,search etc. so that we don't need to write persistence related code in our core area of application. Advantage of using this technique is that we can pass on this simple JavaBean to any of the different layers of the application like a web layer,an EJB layer or any other layer we may have in our application.

We have isolated our persistence related code so that whenever there is a change in the design,or we change the database environment we can change our persistence code. Or we can have several copies of the Persistence Manager to work with different databases so that based on some configuration parameter,we can choose the right Persistence Manager instance. But this is still very difficult as we might ignore some database specific settings while writing so many Persistence Managers for different applications.

Here the concept of Object Relational mapping comes. By Object Relational mapping (O/R mapping) we mean the one-to-one mapping of class attributes with the columns of a database entity. Mapping includes the name of the attribute versus database field,the data type,and relation with other entities or classes. So if we write a framework that can take the object to relation mapping and provide persistence facilities on the given JavaBeans,we can use it for different applications and different databases. So,if anyone want to configure the application on a database that was not known at the time of writing the framework,he can simply write a mapping file and the application will start working on that environment.

Thanks to the open source community! we don't need to write such frameworks anymore. We have Hibernate which allows Object/Relation mapping and provides persistence to the abject with the help of simple APIs where we can specify the operations and the operands (JavaBeans).

• Printer Friendly
• Email to a friend
• Add to my Favourites
• Download PDF version
• Report Bad Submissions
• Submit Feedback