An Introduction to Hibernate
By Mr.Subrahmanyabharathi Pendyala Tata Consultancy Services Ltd Hyderabad.
Agenda
What is Hibernate
Overview Features Benefits Examples Important Concepts Best Practices
Spring Integration
Benefits Example
What is Hibernate?
Popular Open Source Object/Relational Mapping (ORM) tool Transparent persistence for POJOs (Plain Old Java Objects) Core of JBoss CMP 2.0 impl.
Features
Mapping from Java classes to database tables (and from Java data types to SQL data types). Data query and retrieval facilities. Generates the SQL calls and relieves the developer from manual result set handling and object conversion Portable to all data bases Provides persistence for Plain Old Java Objects(POJO)
Features
Support for detached persistent objects Powerful yet Simple queries using HQL.
Why should you use it
EJB (2.x)
Developer has to write EJB QL for CMP or native SQL for BMP. Database dependent Doesnt support OO mapping concepts Developer may not able to write optimal query, less performance
Hibernate
Hibernate generates query called HQL Data base independent Supports OO concepts like, Inheritance and Polymorphic mappings HQL is gives optimal query and gives more performance
Why should you use it
EJB(2.x)
y EJB container is required to
Hibernate
y No specific container needed y Hibernate components are
run the EJB s y EJB s are distributed components y EJB s can be invoked remotely
not distributed y Can't be invoked remotely
Why Hibernate?
Retains natural object model (transparent) Minimizes Code Does not require a container Model is not tied to persistence implementation
What to do RDBs do well Work with large amounts of data
Work with sets of data
Searching, sorting
Sharing
Joining, aggregating Concurrency (Transactions) Many applications Constraints Transaction isolation
Integrity
What to do RDBs do badly
Modeling
No polymorphism Fine grained models are difficult Stored procedures. (arguable, I suppose)
Business logic
Distribution
Data is important
Even so, the relational model is important The data will be around much longer than the Java application
The Goal
Take advantage of those things that relational databases do well Without leaving the language of objects / classes
The Real Goal
Do less work Happy DBA
Sample OR Mapping file
<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernatemapping-3.0.dtd"> <hibernate-mapping>
<class name="events.Event" table="EVENTS"> <id name="id" column="EVENT_ID"> <generator class="native"/> </id> <property name="date" type="timestamp" column="EVENT_DATE"/> <property name="title"/> </class>
</hibernate-mapping>
How does it handle Database Connectivity
Hibernate configuration XML file <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernateconfiguration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- Database connection settings --> <property name="connection.driver_class">org.hsqldb.j dbcDriver</property> <property
How does it handle database connectivity
<!-- SQL dialect --> <property name="dialect">org.hibernate.dialect.HSQLD ialect</property> <!-- Enable Hibernate's automatic session context management --> <property name="current_session_context_class">thre ad</property> <!-- Disable the second-level cache --> <property name="cache.provider_class">org.hibernate. cache.NoCacheProvider</property> <!-- Echo all executed SQL to stdout -->
Object/Relational Mapping
JavaObject
int id; String name; String getName() int getId() void setName(String) void setId(int)
SQL Table id [int] primary key, name [varchar(50)]
Magic Happens Here (O/R Mapper i.e. Hibernate)
Other ORM Solutions
Open
iBatis SQL Maps JDO
Commercial
TopLink
Hibernate's Goal
Remove 95% of common data persistence problems
Person.java
Hibernate Component Mapping Example
person.hbm l .xm
person table
Nam e.java
Hibernate Collection M apping w ith recursion and subclassing
Cat.java cat.hbm.xml
cats
table
OR Mapping Made easy
Visualize the object model in terms of relationships. Write the Java classes for each object in the model. Add relevant Xdoclet tag to the code at the appropriate places. Use the relevant ant targets in the ant script to generate the mapping XML files for OR mapping. If the script is intelligent enough, you can also create database schema
How to Relationships of Object Model
Microsoft Word Document
Sample Build Script
XML Document
How do you use it?
Act on your data model Query in SQL and/or HQL ... or using your object model
Auction Object Model
Persistent Class
Default Constructor Getters/Setters Collections use interface types Identifier property
public class AuctionItem { private Long _id; private Set _bids; private Bid _successfulBid private String _description; public Long getId() { return _id; } private void setId(Long id) { _id = id; } public String getDescription() { return _description; } public void setDescription(String desc) { _description=desc; } }
XML Mapping
<class name=AuctionItem table=AUCTION_ITEM> <id name=id column=ITEM_ID> <generator class=native/> </id> <property name=description column=DESCR/> <many-to-one name=successfulBid column=SUCCESSFUL_BID_ID/> <set name=bids cascade=all lazy=true> <key column=ITEM_ID/> <one-to-many class=Bid/> </set> </class>
Readable metadata Column/Table map Key Generation Collections Fetching Strategies
Working with Data
Retrieve an AuctionItem and change description
Session session = sessionFactory.openSession(); Transaction tx = s.beginTransaction(); AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); item.setDescription(newDescription); tx.commit(); session.close();
Working with Data
Retrieve an AuctionItem and create a new persistent Bid
Bid bid = new Bid(); bid.setAmount(bidAmount); Session session = sf.openSession(); Transaction tx = session.beginTransaction(); AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); bid.setItem(item); item.getBids().add(bid); tx.commit(); session.close();
Hibernate in code
Retrieve an AuctionItem and create a new persistent Bid
Bid bid = new Bid(); bid.setAmount(bidAmount); Session session = sf.openSession(); Transaction tx = session.beginTransaction(); AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); bid.setItem(item); item.getBids().add(bid); tx.commit(); session.close();
Working with detached objects.
Retrieve an AuctionItem and create a new persistent Bid
Session session = sf.openSession(); Transaction tx = session.beginTransaction(); AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); tx.commit(); session.close(); item.setDescription(newDescription); Session session2 = sf.openSession(); Transaction tx = session2.beginTransaction(); session2.update(item); tx.commit(); session2.close();
Lazy Fetching
AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); SELECT FROM AUCTION_ITEM ITEM WHERE ITEM.ITEM_ID = ? Iterator iter = item.getBids().iterate(); SELECT FROM BID BID WHERE BID.ITEM_ID = ? item.getSuccessfulBid().getAmount(); SELECT FROM BID BID WHERE BID.BID_ID = ?
DTOs are Evil
Useless extra LOC Not objects (no behavior) Parallel class hierarchies smell Shotgun change smell Solution: detached object support
Detached Object Support
For applications using servlets + session beans You dont need to select a row when you only want to update it! You dont need DTOs anymore! You may serialize objects to the web tier, then serialize them back to the EJB tier in the next request Hibernate lets you selectively reassociate a subgraph! (essential for performance)
Detached Object Support
Step 1: Retrieve some objects in a session bean:
public List getItems() throws { return getSession() .createQuery(from AuctionItem item where item.type = :itemType)
Detached Object Support
Step 2: Collect user input in a servlet/action:
item.setDescription(newDescription);
Detached Object Support
Step 3: Make the changes persistent, back in the session bean:
public void updateItem(AuctionItem item) throws { getSession().update(item); }
Transitive Persistence
Session session = sf.openSession(); Transaction tx = session.beginTransaction(); AuctionItem item = (AuctionItem) session.get(ActionItem.class, itemId); tx.commit(); session.close(); Bid bid = new Bid(); bid.setAmount(bidAmount); bid.setItem(item); item.getBids().add(bid); Session session2 = sf.openSession(); Transaction tx = session2.beginTransaction(); session2.update(item); tx.commit(); session2.close();
The Big Problem
Detached objects + Transitive persistence! How do we distinguish between newly instantiated objects and detached objects that are already persistent in the database?
The Big Problem (solution)
1.
Version property (if there is one) Identifier value e.g. unsaved-value=0 (only works for generated surrogate keys, not for natural keys in legacy data) Write your own strategy, implement Interceptor.isUnsaved()
2.
3.
Benefits
Metadata controlled persistence Transparent - working with the model, not the data access technology Pooling, Caching, Transactions can all be handled outside of our code
Integrating Spring and Hibernate
Spring and Hibernate
Benefits Examples
Benefits
Resource Management
IoC / AOP Session Management
Extended Transaction Support
JTA and/or JDBC Flexible Transaction Demarcation
Programmatic Declarative (Spring's XML config)
HibernateTemplate
Simplifies Hibernate API
Spring IoC
Session
setSession()
DAO
save()
POJO
Spring Interceptors (AOP)
Business Logic
getCatById()
Interceptor
DAO
save(Cat)
Session
Spring Framework
Springs HibernateTemplate
Hibernate Only:
public User getUserByEmailAddress(final String email) { try { Session session = sessionFactory.openSession(); List list = session.find( "from User user where user.email=?", email, Hibernate.STRING); return (User) list.get(0); } finally { session.close(); } }
HibernateTemplate:
public User getUserByEmailAddress(final String email) { List list = getHibernateTemplate().find( "from User user where user.email=?", email, Hibernate.STRING); return (User) list.get(0); }
Some Important Concepts
Lazy Loading --Getting the objects when needed
Eager Loading Getting it the first time when you hit the database Difference between load and get methods Load() --- Retrieves the objects from the Persistence Context , only if not available, database will be hit. Get() Retrieves from database. Fetch Strategies Inheritance strategies Separate tables (implicit polymorphism) Ideally not preferred. Redundancy creeps in. Table Per class hierarchy (with discriminator column) Use it when data size is small Normalized tables ( Good when working with large data)
Some Important Concepts
Transient Persistence (Persistence works similarly for transient , detached , attached objects) Detached Object support Optimistic locking ( through version fields preferably integers) Pessimistic locking ( using session.lock() method) Batch operations and best practices Sub selects ,Pre defined batch size Persistence Context ( Maintains cache of retrieved objects) SessionFactory( Thread safe) & Session (Not thread safe)
Object states and lifecycle Transient, Persistent, Detached, Removed
Important Links
http://www.hibernate.org http://www.springframework.org
Parts of this presentation come from documentation and presentations on the hibernate.org website:
http://www.hibernate.org/hib_docs/reference/en/pdf/hibernate_reference.pdf - Manual http://www.hibernate.org/hib_docs/online/jaoo_presentation/HibernateJAOO.ppt - Presentation by Gavin King http://www.hibernate.org/200.html - Road Map
Tutorials: http://raibledesigns.com/wiki/Wiki.jsp?page=CreateDAO http://raibledesigns.com/wiki/Wiki.jsp?page=AppFuseQuickStart
THANK YOU
