The JDK is an essential toolkit provided for Java application development. You can go to http://java.sun.com/j2se/1.5.0/download.jsp to download JDK 5.0. Install it into a folder such as C:jdk1.5.0.

Eclipse is an IDE for developing Java applications. The latest version is Galileo. You can install it from the following URL: www.eclipse.org/downloads/download.php?file=/technology/epp/downloads/release/galileo/SR1/eclipse-jee-galileo-SR1-win32.zip.

Derby is an open source SQL relational database engine written in Java. You can go to http://db.apache.org/derby/derby_downloads.html and download the latest version. Derby also provides plug-ins for Eclipse. The plug-in gives you the required jar files for development and also provides a command prompt (ij) in Eclipse to execute Data Definition Language (DDL) and Data Manipulation Language (DML) statements.

connect 'jdbc:derby://localhost:1527/BookShopDB;create=true;
user=book;password=book';

Creating the Tables (Relational Model)

These solutions use the example of a bookshop. Books are published by a publisher, and the contents of a book are defined by the chapters. The entities Book, Publisher, and Chapter are stored in the database; you can perform various operations such as reading, updating, and deleting.

Because an ORM is a mapping between an object model and a relational model, you first create the relational model by executing the DDL statements to create the tables/entities in the database. You later see the object model in Java and finally the mapping between the relational and the object models.

Create the tables for the online bookshop using the following SQL statements:

CREATE TABLE  PUBLISHER (
       CODE VARCHAR(4) NOT NULL ,
       PUBLISHER_NAME VARCHAR(100) NOT NULL,        ADDRESS VARCHAR(200),  PRIMARY KEY (CODE)
);
CREATE TABLE  BOOK
   (ISBN VARCHAR(50) NOT NULL,
    BOOK_NAME VARCHAR(100) NOT NULL,
    PUBLISHER_CODE VARCHAR(4),     PUBLISH_DATE DATE,
    PRICE  integer,
    PRIMARY KEY (ISBN),     FOREIGN KEY (PUBLISHER_CODE)
    REFERENCES  PUBLISHER (CODE)
   );

CREATE TABLE  CHAPTER
   (BOOK_ISBN VARCHAR(50) NOT NULL,
     IDX integer NOT NULL,
     TITLE VARCHAR(100) NOT NULL,
     NUM_OF_PAGES integer,
     PRIMARY KEY (BOOK_ISBN, IDX),
     FOREIGN KEY (BOOK_ISBN)
     REFERENCES  BOOK (ISBN)
   );

Figure 1-3 shows the entity model for the sample table structure.

Figure 1-3. Relational model diagram for the bookshop

Next, let's input some data for these tables using |the following SQL statements:

insert into PUBLISHER(code, publisher_name, address)
values ('001', 'Apress', 'New York ,New York'),
insert into PUBLISHER(code, publisher_name, address)
values ('002', 'Manning', 'San Francisco', 'CA')
insert into book(isbn, book_name, publisher_code, publish_date, price)
values ('PBN123', 'Spring Recipes', '001', DATE('2008-02-02'), 30)
insert into book(isbn, book_name, publisher_code, publish_date, price)
values ('PBN456', 'Hibernate Recipes', '002', DATE('2008-11-02'), 40)

To begin developing your Java application, you create a bookshop project in Eclipse. To set up the Derby database, you can install the core and UI plug-ins or download the Derby jar files and add them to your Eclipse project classpath.

To install the Derby plug-ins for Eclipse, do the following:

You must load the JDBC driver and create a connection to that database before you can execute any SQL statements. The JDBC driver for Derby is in the derby.jar file that was added to your project's build path during Derby's installation. Be careful: you must remember to close that connection (whether an exception is raised or not). Connections are a costly resource—if they aren't closed after use, the application will run out of them and stop working:

Class.forName("org.apache.derby.jdbc.EmbeddedDriver");
Connection connection = DriverManager.getConnection(
"jdbc:derby://localhost:1527/BookShopDB", "book", "book");
try {
// Using the connection to query or update database
} finally {
connection.close();
}

For demonstration purpose, let's query for a book whose ISBN is 1932394419. Here's the JDBC code for this task:

PreparedStatement stmt = connection.prepareStatement
("SELECT * FROM BOOK WHERE ISBN = ?");
stmt.setString(1, "1932394419");
ResultSet rs = stmt.executeQuery();
while (rs.next())
{
       System.out.println("ISBN : " + rs.getString("ISBN"));
       System.out.println("Book Name : " + rs.getString("BOOK_NAME"));
       System.out.println("Publisher Code : " +                     rs.getString("PUBLISHER_CODE"));
       System.out.println("Publish Date : " +           rs.getDate("PUBLISH_DATE"));
       System.out.println("Price : " + rs.getInt("PRICE"));
       System.out.println();
}
rs.close();
stmt.close();

Let's update the title of the book whose ISBN is 1932394419. Here's the JDBC code:

PreparedStatement stmt = connection.prepareStatement(
"UPDATE BOOK SET BOOK_NAME = ? WHERE ISBN = ?");
stmt.setString(1, "Hibernate Quickly 2nd Edition");
stmt.setString(2, "1932394419");
int count = stmt.executeUpdate();
System.out.println("Updated count : " + count);
stmt.close();

You use normal JavaBeans to build your object/domain model. These JavaBeans are called Plain Old Java Objects (POJOs). This term is used to distinguish them from Enterprise JavaBeans (EJBs). EJBs are Java objects that implement one of the javax.ejb interfaces and that need to be deployed in an EJB container. Note that each of these POJOs must have a no-argument constructor:

public class Publisher {
       private String code;
       private String name;
       private String address;
       // Getters and Setters
}
public class Book {
       private String isbn;
       private String name;
       private Publisher publisher;
       private Date publishDate;
       private int price;
       private List chapters;
       // Getters and Setters
}
public class Chapter {
       private int index;
       private String title;
       private int numOfPages;
       // Getters and Setters
}

You use a foreign key to reference PUBLISHER from the BOOK table, but it's a many-to-one association represented with a list of chapters in the Book class. You use a foreign key to reference BOOK from the CHAPTER table, but there's nothing referencing the Book class from the Chapter class. In contrast, a Book object has a list of Chapter objects (one-to-many association). This is a case of an object-relational mismatch, which focuses on the association between two classes or tables in their corresponding model. To handle the incompatibility of these models, you need to do some conversion/translation when you retrieve and save your object model. This is called object/relational mapping (O/R Mapping or ORM).

Let's say your Bookshop sells audio and video discs. In the object-oriented model, this can be represented by using a Disc superclass and two subclasses called AudioDisc and VideoDisc (see Figure 1-4). On the relational database side, you don't have a way to map this inheritance relationship. This is a major object-relational system mismatch.

You may also want to use a polymorphic query that refers to the Disc class and have the query return its subclasses. SQL doesn't support this kind of requirement—this is another object-relational system mismatch.

Figure 1-4. Inheritance in the object model

You can see that there are differences between an object model and a relational model. The object model is based on the analysis of the business domain, and therefore this forms the domain model. The relational model or tables are defined based on how the data is organized in rows and columns. ORM frameworks like Hibernate provide strategies to overcome the association mismatch, inheritance mismatch, and the polymorphic mismatch.

Suppose you have a web page in your application that shows a book's details (including ISBN, book name, publisher name, publisher address, publish date, and all the chapters in the book). You can use the following JDBC code fragment to get the result set:

PreparedStatement stmt = connection.prepareStatement(
"SELECT * FROM BOOK, PUBLISHER WHERE BOOK.PUBLISHER_CODE = PUBLISHER.CODE
AND BOOK.ISBN = ?");
stmt.setString(1, isbn);
ResultSet rs = stmt.executeQuery();
Book book = new Book();
if (rs.next())
{
       book.setIsbn(rs.getString("ISBN"));
       book.setName(rs.getString("BOOK_NAME"));
       book.setPublishDate(rs.getDate("PUBLISH_DATE"));
       book.setPrice(rs.getInt("PRICE"));

       Publisher publisher = new Publisher();
       publisher.setCode(rs.getString("PUBLISHER_CODE"));
       publisher.setName(rs.getString("PUBLISHER_NAME"));
       publisher.setAddress(rs.getString("ADDRESS"));
       book.setPublisher(publisher);
}
rs.close();
stmt.close();

List chapters = new ArrayList();
stmt = connection.prepareStatement("SELECT * FROM CHAPTER WHERE BOOK_ISBN = ?");
stmt.setString(1, isbn);
rs = stmt.executeQuery();
while (rs.next()) {
       Chapter chapter = new Chapter();
       chapter.setIndex(rs.getInt("IDX"));
       chapter.setTitle(rs.getString("TITLE"));
       chapter.setNumOfPages(rs.getInt("NUM_OF_PAGES"));
       chapters.add(chapter);
}
book.setChapters(chapters);
rs.close();
stmt.close();
return book;

The result set must be iterated through to create book and publisher objects. To retrieve the chapters, you have to execute another SQL statement based on the book's ISBN property. A group of objects with such an association is called an object graph.

Suppose you want to provide a web page where users can input a book's information, including the publisher and chapters. When the user is finished, the entire object graph is saved to the database:

PreparedStatement stmt = connection.prepareStatement(
"INSERT INTO PUBLISHER (CODE, PUBLISHER_NAME, ADDRESS) VALUES (?, ?, ?)");
stmt.setString(1, book.getPublisher().getCode());
stmt.setString(2, book.getPublisher().getName());
stmt.setString(3, book.getPublisher().getAddress());
stmt.executeUpdate();
stmt.close();

stmt = connection.prepareStatement(
"INSERT INTO BOOK (ISBN, BOOK_NAME, PUBLISHER_CODE, PUBLISH_DATE, PRICE)
VALUES (?, ?, ?, ?, ?)");
stmt.setString(1, book.getIsbn());
stmt.setString(2, book.getName());
stmt.setString(3, book.getPublisher().getCode());

stmt.setDate(4, new java.sql.Date(book.getPublishDate().getTime()));
stmt.setInt(5, book.getPrice());
stmt.executeUpdate();
stmt.close();

stmt = connection.prepareStatement(
"INSERT INTO CHAPTER (BOOK_ISBN, IDX, TITLE, NUM_OF_PAGES) VALUES (?, ?, ?, ?)");
for (Iterator iter = book.getChapters().iterator(); iter.hasNext();)
{
       Chapter chapter = (Chapter) iter.next();

stmt.setString(1, book.getIsbn());
       stmt.setInt(2, chapter.getIndex());
       stmt.setString(3, chapter.getTitle());
       stmt.setInt(4, chapter.getNumOfPages());
       stmt.executeUpdate();
}
stmt.close();

Using JDBC means you can execute any kind of SQL statements. For a simple task, you have to code many SELECT, INSERT, UPDATE, and DELETE statements repeatedly. This results in the following issues:

You can go to www.hibernate.org/ and download Hibernate Core 3.3.2. After you download the compressed Hibernate distribution, extract it to a directory such as C:hibernate. In Eclipse, go to Windows

${Hibernate_Install_Dir}/hibernate3.jar
${Hibernate_Install_Dir}/lib/antlr.jar
${Hibernate_Install_Dir}/lib/asm.jar
${Hibernate_Install_Dir}/lib/asm-attrs.jars
${Hibernate_Install_Dir}/lib/cglib.jar
${Hibernate_Install_Dir}/lib/commons-collections.jar
${Hibernate_Install_Dir}/lib/commons-logging.jar
${Hibernate_Install_Dir}/lib/dom4j.jar
${Hibernate_Install_Dir}/lib/ehcache.jar
${Hibernate_Install_Dir}/lib/jta.jar
${Hibernate_Install_Dir}/lib/log4j.jar

Defining a custom library this way makes it easy to reuse in another project. If you have another project that uses Hibernate, you can import this user library into that project. Follow these steps to add this user library to a project's build path:

The custom library is now configured to your project's build path.

First, you ask Hibernate to retrieve and persist the book objects for you. For simplicity, let's ignore the publisher and chapters at this moment. You create an XML file Book.hbm.xml in the same package as the Book class. This file is called the mapping definition for the Book class. The Book objects are called persistent objects or entities because they can be persisted in a database and represent the real-world entities:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.metaarchit.bookshop">
       <class name="Book" table="BOOK">
       <id name="isbn" type="string" column="ISBN" />
       <property name="name" type="string" column="BOOK_NAME" />
       <property name="publishDate" type="date" column="PUBLISH_DATE"/>

<property name="price" type="int" column="PRICE" />
       </class>
</hibernate-mapping>

Each persistent object must have an identifier. It's used by Hibernate to identify that object uniquely. Here, you use the ISBN as the identifier for a Book object.

Before Hibernate can retrieve and persist objects for you, you need to tell it your application's settings. For example, which kind of objects are persistent objects? What kind of database are you using? How do you connect to the database? You can configure Hibernate three ways:

This solution introduces only the first two approaches (programmatic and XML configuration). The properties file configuration is much like XML configuration.

The following code loads the configuration programmatically. The Configuration class provides the API to load the hbm files, to specify the driver to be used for the database connection, and to provide other connection details:

Configuration configuration = new Configuration()
.addResource("com/metaarchit/bookshop/Book.hbm.xml")
.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyDialect")
.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")
.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")
.setProperty("hibernate.connection.username", "book")
.setProperty("hibernate.connection.password", "book");
SessionFactory factory = configuration.buildSessionFactory();

Instead of using addResource() to add the mapping files, you can also use addClass() to add a persistent class and let Hibernate load the mapping definition for this class:

Configuration configuration = new Configuration()
.addClass(com.metaarchit.bookshop.Book.class)
.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyDialect")
.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")
.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")
.setProperty("hibernate.connection.username", "book")

.setProperty("hibernate.connection.password", "book");
SessionFactory factory = configuration.buildSessionFactory();

If your application has hundreds of mapping definitions, you can pack it in a jar file and add it to the Hibernate configuration. This jar file must be found in your application's classpath:

Configuration configuration = new Configuration()
.addJar(new File("mapping.jar"))
.setProperty("hibernate.dialect", "org.hibernate.dialect.DerbyDialect")
.setProperty("hibernate.connection.driver_class", "org.apache.derby.jdbc.EmbeddedDriver")
.setProperty("hibernate.connection.url", "jdbc:derby://localhost:1527/BookShopDB")
.setProperty("hibernate.connection.username", "book")
.setProperty("hibernate.connection.password", "book");
SessionFactory factory = configuration.buildSessionFactory();

SessionFactory factory = configuration.buildSessionFactory();

Another way to configure Hibernate is to use an XML file. You create the file hibernate.cfg.xml in the source directory, so Eclipse copies it to the root of your classpath:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="connection.driver_class">
   org.apache.derby.jdbc.EmbeddedDriver
</property>
<property name="connection.url">jdbc:derby://localhost:1527/BookShopDB</property>
<property name="connection.username">book</property>
<property name="connection.password">book</property>
<property name="dialect">org.hibernate.dialect.DerbyDialect</property>
<mapping resource="com/metaarchit/bookshop/Book.hbm.xml" />
</session-factory>
</hibernate-configuration>

Now, the code fragment to build up a session factory can be simplified. The configuration loads your hibernate.cfg.xml file from the root of the classpath:

Configuration configuration = new Configuration().configure();

This method loads the default hibernate.cfg.xml from the root class path. The new Configuration() loads the hibernate.properties file, and the configure() method loads hibernate.cfg.xml if hibernate.properties isn't found. If you need to load another configuration file located elsewhere (not in the root classpath), you can use the following code:

new Configuration().configure("/config/recipes.cfg.xml")

This code looks for recipes.cfg.xml in the config subdirectory of your classpath.

A Hibernate Session object represent a unit of work and is bound to the current thread. It represents a transaction in a database. A session begins when getCurrentSession() is first called on the current thread. The Session object is then bound to the current thread. When the transaction ends with a commit or rollback, Hibernate unbinds the session from the thread and closes it.

Just as when you use JDBC, you need to do some initial cleanup for Hibernate. First, you ask the session factory to open a new session for you. After you finishing your work, you must remember to close the session:

Session session = factory.openSession();
try {
       // Using the session to retrieve objects
}catch(Exception e)
{

       e.printStackTrace();
} finally {
       session.close();

}

Given the ID (an ISBN, in this case) of a book, you can retrieve the unique Book object from the database. There are two ways to do that:

Book book = (Book) session.load(Book.class, isbn);

and

Book book = (Book) session.get(Book.class, isbn);

What's the difference between load() and get()? First, when the given ID can't be found, load() throws an exception org.hibernate.ObjectNotFoundException, whereas get() returns a null object. Second, load() just returns a proxy by default; the database isn't hit until the proxy is first invoked. get() hits the database immediately. The load method is useful when you only need a proxy and don't need to make a database call. You just need a proxy, when in a given session you need to associate an entity before persisting.

Just as you can use SQL to query a database, you can use Hibernate to query objects, using Hibernate Query Language (HQL). For example, the following codes queries for all the Book objects:

Query query = session.createQuery("from Book");
List books = query.list();

If you're sure only one object will match, you can use the uniqueResult() method to retrieve the unique result object:

Query query = session.createQuery("from Book where isbn = ?");
query.setString(0, isbn);
Book book = (Book) query.uniqueResult();

Opening a session is similar to doing so in Hibernate in general, except you use AnnotationConfiguration to build the session factory:

public class SessionManager {

       private static final SessionFactory sessionFactory = buildSessionFactory();

       private static SessionFactory buildSessionFactory() {
               try {
                   // Create the SessionFactory from hibernate.cfg.xml
                   return new                                                                          AnnotationConfiguration()
        .configure().buildSessionFactory();
               }
               catch (Throwable ex) {
                   // Make sure you log the exception, as it might be swallowed                     ex.printStackTrace();

                   throw new ExceptionInInitializerError(ex);
               }
           }

           public static SessionFactory getSessionFactory() {
               return sessionFactory;
           }
}

If the configuration file name isn't hibernate.cfg.xml (in this case, it's named annotation.cfg.xml), build the session factory the using the following statement:

new  AnnotationConfiguration()
.configure("annotation.cfg.xml")
.buildSessionFactory();

There are other overloaded configure() methods that you can use appropriately.

This section uses a Data Access Object (DAO) for database operations. The DAO is a design pattern used to abstract and encapsulate all access to the data source. For this example, it contains code to create the SessionFactory and a Session object and to fetch and update data in the database:

public class BookDAO {

       /**
        * To query all details of a book
        * @return
        */
       public List<Book> readAll() {

             Session session = SessionManager.getSessionFactory().getCurrentSession();
              session.beginTransaction();
              List<Book> booksList = session.createQuery("from Book").list();

session.getTransaction().commit();
              return booksList;
       }

       /**
        * To create a book
        * @return
        */
       public void create(Book bookObj) {

              Session session=SessionManager.getSessionFactory().getCurrentSession();
              session.beginTransaction();
              session.saveOrUpdate(bookObj);
              session.getTransaction().commit();

       }

}

The readAll method queries all data from the BOOK table that's mapped in hibernate.cfg.xml. The create method inserts a new row into the BOOK table.

Hibernate generates SQL statements that let you access the database behind the scene. You can set the show_sql property to true in the hibernate.cfg.xml XML configuration file to print the SQL statements to stdout:

<property name="show_sql">true</property>

Hibernate can also use the log4j logging library to log SQL statements and parameters. Make sure the log4j.jar file is included in your project's classpath. Create a properties file named log4j.properties in the source root folder; this file is used to configure the log4j library:

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n
### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %5p %c{1}:%L - %m%n
log4j.rootLogger=error, stdout
log4j.logger.org.hibernate.SQL=debug
log4j.logger.org.hibernate.type=debug

You can enable live statistics by setting the property hibernate.generate_statistics in the configuration file:

<property name="hibernate.generate_statistics">true</property>

You can also enable live statistics programmatically by using the Statistics Interface:

Statistics stats = sessionFactory.getStatistics();
stats.setStatisticsEnabled(true);
Transaction tx = session.beginTransaction();
List<Book> books = session.createQuery("from Book").list();
for(Book bo : books)
{
       System.out.println(bo);
}
stats.getSessionOpenCount();
stats.logSummary();
session.close();

You use Apache Ant to define the building process. (For more information about Ant, see http://ant.apache.org/.) Create the following build.xml file in the project root:

<project name="BookShop" default="schemaexport">
<property name="build.dir" value="bin" />
<property name="hibernate.home" value="c:/hibernate-3.1" />
<property name="derby.home" value="c:/derby" />
<path id="hibernate-Classpath">
<fileset dir="${hibernate.home}">
<include name="**/*.jar" />
</fileset>
<fileset dir="${derby.home}">
<include name="lib/*.jar" />
</fileset>

<pathelement path="${build.dir}" />
</path>
<!-- Defining Ant targets -->
</project>

You use the schemaexport task provided by Hibernate to generate the SQL statements to create a database schema. It reads the dialect property from the Hibernate configuration file (hibernate.cfg.xml) to determine which brand of database you're using:

<target name="schemaexport">
<taskdef name="schemaexport"
classname="org.hibernate.tool.hbm2ddl.SchemaExportTask"
Classpathref="hibernate-Classpath" />
<schemaexport config="${build.dir}/hibernate.cfg.xml"
output="BookShop.sql" />
</target>

During the development cycle, you may change your object model frequently. It isn't efficient to destroy and rebuild the schema every time. The schemaupdate task updates an existing database schema:

<target name="schemaupdate">
<taskdef name="schemaupdate"
classname="org.hibernate.tool.hbm2ddl.SchemaUpdateTask"
Classpathref="hibernate-Classpath" />
<schemaupdate config="${build.dir}/hibernate.cfg.xml" text="no"/>
</target>

In the previous mapping example, you discarded some table details, such as column length and the not-null constraint. If you generate a database schema from this mapping, you must provide these kinds of details:

<hibernate-mapping package="com.hibernaterecipes.bookshop">
<class name="Book" table="BOOK">
<id name="isbn" type="string">
<column name="ISBN" length="50" />
</id>
<property name="name" type="string">
<column name="BOOK_NAME" length="100" not-null="true" />
</property>
<property name="publishDate" type="date" column="PUBLISH_DATE" />
<property name="price" type="int" column="PRICE" />

</class>
</hibernate-mapping>