Since with Hibernate, you're typically mapping to a relational database, complex objects may need to be persisted to multiple tables, adding some complexity to the implementation.

To save you the effort of annotating everything, Hibernate provides many default behaviors. For example, Hibernate by default will map your class to a Table of the same name so you don't have to use the @Table annotation unless the class name and table name differ. The same goes for class properties. They will be mapped to columns of the same name in the Table. If you want to override this behavior, use the @Basic annotation. This type of intelligent behavior minimizes the work you have to do to persist a class. For our Person class example, this means that it will be persisted to the database Table named "Person," which will have three columns (id, firstName, and lastName) and the id column will be the primary key. Hibernate provides excellent control over how the primary key is assigned, but that's beyond the scope of this article.

An example of a minimally annotated POJO:

import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Person{
     @Id
     public Integer id;
     public String firstName;
     public String lastName;
}

An example of how a one-to-many relationship is defined:

   // In the Department class -
   @OneToMany(cascade=ALL,mappedBy = "department_id")
   // Requires the foreign key "department_id" in the Person class
   public ArrayList<Person> getEmployees(){
   // Method to return all employees
       return employees;
   }

   // In the Person class
   @ManyToOne
   @JoinColumn(name = "department_id")
   public Department getDepartment(){
   // Method to return the department
       return department;
   }

As a final time and labor saver, you can now use Hibernate's hbm2ddl tool to generate the database schema for you. While you may be splitting objects to save them in multiple tables, which is not required for the object databases, you do get very good control over the mapping process. And as we'll see later, there are also circumstances where the relational approach has advantages over a pure object approach.

DB4O
Implementing persistence with DB4O is dead easy. You don't need to create a database ahead of time or prep your Java Classes at all. Simply call Db4o.openFile() and provide the path to your database file as the parameter. If the database doesn't exist, it will be created for you. Then instantiate an Object and call db.Save(object) to persist it. It doesn't get any simpler.

ObjectContainer db=Db4o.openFile("C:\db4o\test.yapp");
try {
     Person person = new Person("James","Hogan");
     db.set(person); // It's now saved!
}
finally {
db.close();
}

Since you're storing actual Java objects, there' no mapping required. There's also no need to annotate relationships, but you must provide properties in the objects on both sides of a relationship if you want to be able to traverse the object tree bidirectionally.

   // In the Department class
   public ArrayList<Person> employees;

   // In the Person class
   public Department department;

Caché
Setting up persistence with Caché and Jalapeño falls between Hibernate and DB4O in complexity. No mapping is required, however, as InterSystems correctly points out in their Jalapeño documentation: "Databases define concepts such as constraints, relationships (with referential integrity), and indices, which have no equivalent within a Java class definition." To address and support these concepts, InterSystems' Jalapeño provides database operation-specific annotations for use in your Java Classes, much as Hibernate does. However, they are only used by the Jalapeño SchemaBuilder to create the Object Storage in the Caché database, and aren't required (other than for documentation purposes) after the Object Storage has been created.

The minimal steps for preparing to persist your objects with Jalapeño/Caché are as follows:
1)  Create a Namespace and Empty Database using the Caché System Management Portal
2)  Run the Jalapeño SchemaBuilder to create the Object Storage in the database

An example of a minimally annotated POJO that can be persisted using Jalapeño/Caché:

public class Person{
     public String firstName;
     public String lastName;
}

Like DB4O, since Caché stores objects, there's a one-to-one relationship between your POJOs and the Caché Object Classes defined in the database - so no mapping is required.