Data Persistence

and
Intro to Hibernate
Aaron Zeckoski
azeckoski@gmail.com

Sakai Montreal CRIM Workshop

Creative Commons Attribution-
NonCommercial-ShareAlike 2.5 License Sakai Programmer's Café
 What is persistence?
• The storage of an object on a disk or other
permanent storage device or data that exists
from session to session
– as opposed to transient data
• Persistent data typically implies that it is durable
(i.e. will survive a crash or shutdown of the
process) usually with some guarantee of
integrity
• Persistence generally implies use of a database
– One could use the file system (with suitably careful
procedures)

2
3 ways to persist data to the DB

JDBC
http://java.sun.com/products/jdbc/
Spring JDBC
http://www.springframework.org/docs/refere
nce/jdbc.html
Hibernate
http://www.hibernate.org/

3
 JDBC Info

• Java Database Connectivity

• Industry standard but has some issues:
– The developer needs to deal with lot of plumbing and
infrastructure, such as endless try-catch-finally-try-catch blocks.
– Applications need complex error handling to ensure that
connections are properly closed after they're used, which makes
the code verbose, bloated, and repetitive.
– JDBC uses the rather uninformative SQLException.
– JDBC has no exception hierarchy
• Bottom Line: Don’t use this!

From: http://java.sun.com/products/jdbc/ 4
 Spring JDBC Info
• Abstraction framework for JDBC
– i.e. It does lots of stuff for you!
• Some features of Spring JDBC
– JdbcDaoSupport – superclass, provides JdbcTemplate access
– Spring provides an abstract exception layer, moving verbose
and error-prone exception handling out of application code into
the framework. The framework takes care of all exception
handling; application code can concentrate on using appropriate
SQL.
– Spring provides a significant exception hierarchy for your
application code to work with in place of SQLException.
– For creating instances of oracle.sql.BLOB (binary large object)
and oracle.sql.CLOB(character large object), Spring provides the
class org.springframework.jdbc.support.lob.OracleLobHandler.
• Bottom Line: If you love writing SQL, use this!
From: http://www.springframework.org/docs/reference/jdbc.html 5
 Hibernate Info
• Object / Relational mapping (ORM) and persistence /
query framework
– i.e. It does even more stuff for you!
• Some features of Hibernate
– HibernateDaoSupport – superclass, easy HibernateTemplate access
– Database independence - sits between the database and your java code, easy
database switch without changing any code
– Object / Relational Mapping (ORM) - Allows a developer to treat a database like
a collection of Java objects
– Object oriented query language (HQL) - *Portable* query language, supports
polymorphic queries etc.
– You can also still issue native SQL, and also queries by “Criteria” (specified
using “parse tree” of Java objects)
– Hibernate Mapping - Uses HBM XML files to map value objects (POJOs) to
database tables
– Transparent persistence - Allows easy saves/delete/retrieve for simple value
objects
– Very high performance “in general” due to intelligent (2-level) caching, although
in a few cases hand-written SQL might beat it

From: http://www.hibernate.org/ 6
 More Hibernate Info
• Hibernate basically
sits between the DB
and your code
• Can map persistent
objects to tables
• In Sakai, the
Hibernate
configuration is set
for you already

From: http://www.hibernate.org/hib_docs/v3/reference/en/html/architecture.html 7
 Even more Hibernate Info

• Hibernate 2-tier web

architecture
• Can send data to
JDBC or XML files
• Best to just use it the
way Sakai does
(JDBC)
• Bottom Line: Use this!

From: http://www.hibernate.org/354.html 8
 Hibernate Commentary
• Beyond the hype:
– Hibernate *is* the best ORM persistence framework
• probably in any language
– Not to say it is without numerous issues
• ORM is a tricky problem and general solutions are very difficult
– Many aspects of the Hibernate framework are “over-eager”
• lazy Collections, cascade options, long transactions
– Many aspects of Hibernate are overly rigid
• proxy behaviour, initial configuration sets cannot be changed, poor
cross-ClassLoader behaviour
• Advice
– Use it cautiously! (pay attention to tips)
– Avoid lazy Collections, be conservative with cascade options
– In general just use it on one entity at a time, with explicit
save/load on for each database operation
– In some cases you may still actually want to fall back to SQL
• recommended by the Hibernate team for certain situations

9
 Some database tips

• Always turn on hbm2ddl.auto

<prop key="hibernate.hbm2ddl.auto">update</prop>
• You may want to turn this off for production environments

• HSQLDB works well for development and

for demos
– Caveat: You cannot look at the HSQLDB
database without some serious trickery
• If all else fails, switch to HSQLDB file
storage
10
 More database tips

• MySQL despite being a “production”

option is actually really easy to set up for
development
– Allows you to look at the database through its
console to see if things are working
– Works well on most platforms and tends to get
into a lock state somewhat easily which helps
you find transaction problems

11
 One last database tip

• You can turn on verbose Hibernate

logging to see every SQL statement that it
runs
– Change the following from false to true
<prop key="hibernate.show_sql">false</prop>
• Note: You do NOT want to leave this on in a
production environment

12
 Hibernate Development
• 4 methods of development using Hibernate
• Top down (good for existing code)
– implement a Java (JavaBeans) object model
– write a mapping document by hand, or generate it from XDoclet tags
– export the database tables using the Hibernate Tools
• Bottom up (good for existing database or code conversion)
– start with an existing data model
– use the Hibernate Tools to generate the mapping documents
– use the Hibernate Tools to generate skeletal Java code
– fill in the business logic by hand
• Middle out (good for new development)
– express your conceptual object model directly as a mapping document
– use the Hibernate Tools to generate skeletal Java code
– fill in the business logic by hand
– export the database tables using the Hibernate Tools
• Meet in the middle (good for existing JDBC to Hibernate switch)
– start with an existing data model and existing Java classes
– write a mapping document to adapt between the two models

From: http://www.hibernate.org/355.html 13
 Hibernate Tips -
Avoid primitives
• Don’t use primitives for properties on
persistent objects
– This works fine in general but it does not
work if you are doing a findByExample
• If you do decide to use primitives, you cannot
leave them null/unset when doing a
findByExample or they will be set to the default
value for that primitive
– Things seem to work better when not using
primitives sometimes (e.g. Boolean)

14
 Hibernate Tips -
don’t preset values
• Don’t set the values of persistent
objects in the POJO
– This can cause problems with frameworks
that expect to be able to instantiate the
POJO with all properties unset
– It may be more work to set the properties
for all non-null attributes but it is worth it

15
 Hibernate Tips -
save dependent objects first
• If you have any dependent entities as
properties of a persistent object you
*must* save them before saving the
parent class
– Hibernate has numerous “cascade” options
that claim to do this automatically, but it is
best to start simple
– The same thing goes for deleting

16
 Hibernate Tips -
non-primitive generated ids
• Use non-primitive generated ids for the
primary key of persistent objects
– It is more efficient and is a good idea in
most databases anyway
– Use java.lang.Long or java.lang.String for
best results
• More best practices here:
http://www.hibernate.org/hib_docs/reference/en/html/best-practices.html

17
 Hibernate Tools
• Hibernate provides a set of Eclipse tools
http://www.hibernate.org/255.html
– Mapping Editor: An editor for Hibernate XML mapping files,
supporting auto-completion and syntax highlighting
– Console: a view in Eclipse. Provides a tree overview of console
configurations and interactive view of persistent classes and
relationships. Also allows the execution of HQL queries against
your database and browsing of results in Eclipse.
– Development Wizards: Includes the Hibernate configuration
(cfg.xml) files wizard and reverse engineering wizard for turning
an existing database schema into POJO source files and HBM
files.

From: http://www.hibernate.org/255.html 18
 Using hibernate in your app

• Create a Hibernate SessionFactory

using config settings in your app
– You should only create one Session
Factory per database
• You can create another one when connecting
to an external database
– More info on session configuration:
http://www.hibernate.org/hib_docs/reference/en/html/session-configuration.html

19
Use the Generic Dao package

• The GenericDao is an abstraction layer that

will allow you to use Hibernate with your
persistent objects without needing to write a
DAO at all
• It has usage information in the Javadocs
• Highly configurable and extendable
• Has no Hibernate dependencies in the
interfaces (*any* DAO should be like this)

URL: http://bugs.sakaiproject.org/confluence/display/BOOT/Generic+DAO+package 20
 More on GenericDao

• Get the code and javadocs from the VT

Maven repository:
– http://source.edtech.vt.edu/maven/generic-dao/
• Usage (Sakai related) is demonstrated
in the tasklist code here:
– https://source.sakaiproject.org/contrib/programmer
scafe/trunk/tasklist/

21
 Let’s look at some code!

• Let’s see what it takes to use Hibernate

– Hibernate and Spring packages
– Hibernate mapping file(s)
– Hibernate properties file
– Hibernate related Spring beans
– DAO beans

22
 Hibernate and Spring packages

• Download the Hibernate Core from:

http://www.hibernate.org/6.html
– Get at least version 3.1.3
• Download the Spring framework here:
http://www.springframework.org/download
– Get version 1.2.8 for now
– Version 2.0 is risky, wait for patches

23
 Hibernate Mapping Files

• Hibernate uses an XML file to map Java

objects onto database columns
• We will create our mapping file from a
simple template attached to the
persistence page
• For applications with many tables, use a
tool to help generate the HBM files

24
 Basic HBM template
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>
<class name="org.sakaiproject.toolname.model.MyObject "
table="TOOLNAME_MYOBJECT">
<id name="id" type="long">
<generator class="native">
<param name="sequence">MYOBJECT_ID_SEQ</param>
</generator>
</id>
<property name="myProperty" type="string"
length="255" not-null="true”/>
</class>
</hibernate-mapping>

25
 Template customization

• Change the class name and table name

– edu.vt.group.toolname.model.MyObject
• Change the id sequence name
• Copy and paste the property block to add the
properties from your persistent object
– owner
– title
– creationDate
• Etc…

26
Creating a DAO for Hibernate

• Create a new class which implements

your DAO interface
– Write a DAO interface if you do not have one
• Extend HibernateDaoSupport
– part of Spring-Hibernate
• Add import for HibernateDaoSupport
– Make sure you use the one for hibernate 3
• Or use Generic DAO package!

27
 DAO sample code
Make an interface for your DAO
public interface MyAppDAO {
}

Make an implementation of the DAO interface

public class MyAppDAOImpl
extends HibernateDaoSupport
implements MyAppDAO {
}

Note that it Extends HibernateDaoSupport

28
 Spring configuration

• Now we need to tie everything together

with Spring
• First we will tell hibernate about our
MyObject.hbm.xml mapping file
• Next we will give the hibernate stuff to
our DAO implementation
• Finally we will tie the new DAO to the
rest of the webapp

29
 Create a Data Source
<bean id=“myLocalDataSource"
class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>oracle.jdbc.driver.OracleDriver</value>
</property>
<property name="url">
<value>jdbc:oracle:thin:@myDB.host.com:1521:SCHEMA</value>
</property>
<property name="username">
<value>USERNAME</value>
</property>
<property name="password">
<value>PASSWORD</value>
</property>
</bean>

• Setup the connection settings for the

database
30
 Create a SessionFactory
(part 1)
<bean id=“myAppSessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref local=“myLocalDataSource" />
</property>
<property name="mappingResources">
<list>
<value>
com/group/myapp/impl/hbm/MyObject.hbm.xml
</value>
</list>
</property>
...

• This ties our persistent objects with the

newly created SessionFactory bean
31
 Create a SessionFactory
(part 2)
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.Oracle9Dialect</prop>
<prop key="hibernate.show_sql">false</prop>
<prop key="hibernate.cache.provider_class">
org.hibernate.cache.EhCacheProvider</prop>
<prop key="hibernate.query.substitutions">true 1, false 0</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
<!-- create, update, create-drop (wipe and create), or blank -->
</props>
</property>
</bean>

• This sets up the various properties

(could also come from a props file)
32
 Create a transaction manager
<bean id=“myAppTransactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local=“myAppSessionFactory" />
</property>
</bean>

• Creates a spring transaction manager

– We need this in order to manage
transactions in a reasonable way later
– You can manage them manually, but why?

33
 Create a DAO bean
<bean id=“com.group.myapp.dao.target.MyAppDAO"
class=“com.group.myapp.dao.impl.MyAppDAOImpl"
init-method="init">
<property name="sessionFactory">
<ref local=“myAppSessionFactory" />
</property>
</bean>

• Create a DAO bean using the data access

object class that we have created
• This injects the SessionFactory into that class
bean

34
 Define a declarative
transaction interceptor
<bean id=“com.group.myapp.dao.MyAppDAO"
class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="target">
<ref local=“com.group.myapp.dao.target.MyAppDAO"/>
</property>
<property name="transactionManager">
<ref bean=“myAppTransactionManager" />
</property>
<property name="transactionAttributes">
<props>
<prop key="*">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

• This involves much less work than opening and closing

transactions in code, and is more reliable
– Note that this is what we will access, not the actual DAO bean (the
use of the name of the interface is a convention, not a requirement)

35
 Use Hibernate in code

• Access the persistent objects just like you

would any normal java POJO
• Use the dao operations (save, delete, etc.)
to control the lifetimes of objects
• Take advantage of the Hibernate tools

36
 Example App revisit
• Same basic structure Alpha
– Alpha is the main class
– Bravo handles user
Bravo
interaction
– Charlie handles
application logic Charlie
UserString
– Delta handles data (hbm and class)
access
• New implementation of
DeltaHibernate Delta
the Delta interface
– UserString model
class and hbm A B = A depends on B

37
 Changes to Example App

• Implemented Delta interface using

Spring HibernateDaoSupport
• Adjusted bean definitions to point to the
new implementation
• Created hbm file and model class
• Added bean definitions for Hibernate
Programmers Cafe - Example App Spring Hibernate

38
 Any questions?

• Hibernate: http://www.hibernate.org/
• Spring ORM
http://www.springframework.org/docs/reference/orm.html

39