Object/Relational Mapping with Hibernate

1
Object/Relational Mapping with Hibernate

• Practical ORM

2
Who is this guy?

• Gavin King
• gavin_at_hibernate.org

3
Modern ORM Solutions

• Transparent Persistence (POJO/JavaBeans)
• Persistent/transient instances
• Automatic Dirty Checking
• Transitive Persistence
• Lazy Fetching
• Outer Join Fetching
• Runtime SQL Generation
• Three Basic Inheritance Mapping Strategies

4
Why?

• Natural programming model
• Minimize LOC
• Code can be run and/or tested outside the
  container
• Classes may be reused in nonpersistent context
• Minimize database access with smart fetching
  strategies
• Opportunities for aggressive caching
• Structural mapping more robust when object/data
  model changes

5
Entity Beans?

• Transparent Persistence L
• Persistent/transient instances L
• Automatic Dirty Checking J
• Transitive Persistence L
• Lazy Fetching J
• Outer Join Fetching K
• Runtime SQL Generation K
• Three Basic Inheritance Mapping Strategies L

6
What do RDBs do well?

• Work with large amounts of data
• Searching, sorting
• Work with sets of data
• Joining, aggregating
• Sharing
• Concurrency (Transactions)
• Many applications
• Integrity
• Constraints
• Transaction isolation

7
What do RDBs do badly?

• Modeling
• No polymorphism
• Fine grained models are difficult
• Business logic
• Stored procedures kinda suck
• Distribution
• (arguable, I suppose)

8
Data is important

• Even so, the relational model is important
• The data will be around much longer than the Java
  application!

9
The Goal

• Take advantage of those things that relational
  databases do well
• Without leaving the language of objects / classes

10
The Real Goal

• Do less work
• Happy DBA

11
Hibernate

• Opensource (LGPL)
• Mature
• Popular (13 000 downloads/month)
• Custom API
• Will be core of JBoss CMP 2.0 engine

12
Hibernate

• Persistence for JavaBeans
• Support for very fine-grained, richly typed
  object models
• Powerful queries
• Support for detached persistent objects

13
Auction Object Model
14
Persistent Class

• Default constructor
• Get/set pairs
• Collection property is an interface type
• 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)
• _descriptiondesc

15
XML Mapping

• Readable metadata
• Column / table mappings
• Surrogate key generation strategy
• Collection metadata
• Fetching strategies

• ltclass nameAuctionItem tableAUCTION_ITEMgt
• ltid nameid columnITEM_IDgt
• ltgenerator classnative/gt
• lt/idgt
• ltproperty namedescription columnDESCR/gt
• ltmany-to-one namesuccessfulBid columnSUCCESS
  FUL_BID_ID/gt
• ltset namebids
• cascadeall
• lazytruegt
• ltkey columnITEM_ID/gt
• ltone-to-many classBid/gt
• lt/setgt
• lt/classgt

16
Dirty Checking

• 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()

17
Transitive Persistence

• 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()

18
Detachment

• 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()

More on this later!
19
Optimizing Data Access

• Lazy Fetching
• Eager (Outer Join) Fetching
• Batch Fetching

20
Transparent 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 ?

21
Outer Join Fetching

• ltclass nameAuctionItem tableAUCTION_ITEMgt
• ltid nameid columnITEM_IDgt
• ltgenerator classnative/gt
• lt/idgt
• ltproperty namedescription columnDESC/gt
• ltmany-to-one namesuccessfulBid
• outer-jointrue
• columnSUCCESSFUL_BID_ID/gt
• ltset namebids
• cascadeall
• outer-jointruegt
• ltkey columnITEM_ID/gt
• ltone-to-many classBid/gt
• lt/setgt
• lt/classgt

22
Outer Join Fetching

• AuctionItem item (AuctionItem)
  s.get(ActionItem.class, itemId)
• SELECT
• FROM AUCTION_ITEM ITEM
• LEFT OUTER JOIN BID BID1 ON BID1.ITEM_ID
  ITEM.ITEM_ID
• LEFT OUTER JOIN BID BID2 ON BID2.BID_ID
  ITEM.SUCCESSFUL_BID
• WHERE ITEM.ITEM_ID ?

23
Optimizing Data Access

• Minimize row reads
• Minimize database roundtrips
• (Much less important) Minimize column reads

24
Optimizing Data Access

• Minimize row reads
• Use lazy fetching
• Minimize database roundtrips
• Use outer join fetching
• (Much less important) Minimize column reads
• Come back to this one later

25
Optimizing Data Access

• Minimize row reads
• Use lazy fetching
• N1 Selects Problem (too many roundtrips)
• Minimize database roundtrips
• Use outer join fetching
• Cartesian Product Problem (huge result set)

26
Optimizing Data Access

• Solution Runtime Fetch Strategies
• Say what objects you need
• Navigate the object graph

27
Hibernate Query Options

• Hibernate Query Language (HQL)
• Minimal OO dialect of ANSI SQL
• Criteria Queries
• Extensible framework for expressing query
  criteria as objects
• Includes query by example
• Native SQL Queries

28
Hibernate Query Language

• Make SQL be object oriented
• Classes and properties instead of tables and
  columns
• Polymorphism
• Associations
• Much less verbose than SQL
• Full support for relational operations
• Inner/outer/full joins, cartesian products
• Projection
• Aggregation (max, avg) and grouping
• Ordering
• Subqueries
• SQL function calls

29
Hibernate Query Language

• HQL is a language for talking about sets of
  objects
• It unifies relational operations with object
  models

30
Hibernate Query Language

• Simplest HQL Query
• from AuctionItem
• i.e. get all the AuctionItems
• List allAuctions session.createQuery(from
  AuctionItem)
• .list()

31
Hibernate Query Language

• More realistic example
• select item
• from AuctionItem item
• join item.bids bid
• where item.description like hib
• and bid.amount gt 100
• i.e. get all the AuctionItems with a Bid worth gt
  100 and description that begins with hib

32
Hibernate Query Language

• Projection
• select item.description, bid.amount
• from AuctionItem item
• join item.bids bid
• where bid.amount gt 100
• order by bid.amount desc
• i.e. get the description and amount for all the
  AuctionItems with a Bid worth gt 100

33
Hibernate Query Language

• Aggregation
• select max(bid.amount), count(bid)
• from AuctionItem item
• left join item.bids bid
• group by item.type
• order by max(bid.amount)

34
Hibernate Query Language

• Runtime fetch strategies
• from AuctionItem item
• left join fetch item.bids
• join fetch item.successfulBid
• where item.id 12
• AuctionItem item session.createQuery()
• .uniqueResult() //associations already fetched
• item.getBids().iterator()
• item.getSuccessfulBid().getAmount()

35
Criteria Queries

• List auctionItems
• session.createCriteria(AuctionItem.class)
• .setFetchMode(bids, FetchMode.EAGER)
• .add( Expression.like(description,
  description) )
• .createCriteria(successfulBid)
• .add( Expression.gt(amount, minAmount) )
• .list()
• Equivalent HQL
• from AuctionItem item
• left join fetch item.bids
• where item.description like description
• and item.successfulbid.amount gt minAmount

36
Example Queries

• AuctionItem item new AuctionItem()
• item.setDescription(hib)
• Bid bid new Bid()
• bid.setAmount(1.0)
• List auctionItems
• session.createCriteria(AuctionItem.class)
• .add( Example.create(item).enableLike(MatchMode.
  START) )
• .createCriteria(bids)
• .add( Example.create(bid) )
• .list()
• Equivalent HQL
• from AuctionItem item
• join item.bids bid
• where item.description like hib
• and bid.amount gt 1.0

37
Fine-grained Persistence

• More classes than tables
• Fine-grained object models are good
• Greater code reuse
• More typesafe
• Better encapsulation

38
Components

• Address class
• street, city, postCode properties
• STREET, CITY, POST_CODE columns of the PERSON and
  ORGANIZATION tables
• Mutable class

39
Components

• ltclass namePerson tablePERSONgt
• ltcomponent nameaddressgt
• ltproperty namestreet columnSTREET/gt
• ltproperty namecity columnCITY/gt
• ltproperty namepostCode columnPOST_CODE/gt
• lt/componentgt
• lt/classgt

40
Custom Types

• MonetoryAmount class
• Used by lots of other classes
• Maps to XXX_AMOUNT and XXX_CURRENCY columns
• Performs currency conversions (behaviour!)
• Might be mutable or immutable

41
Custom Types

• ltclass nameBid tableBIDgt
• ltproperty nameamount typeMonetoryAmountUserT
  ypegt
• ltcolumn nameAMOUNT/gt
• ltcolumn nameCURRENCY/gt
• lt/propertygt
• lt/classgt
• We still have to write the MonetoryAmountUserType
  class!

42
DTOs are Evil

• Useless extra LOC
• Not objects (no behavior)
• Parallel class hierarchies smell
• Shotgun change smell
• Solution detached object support

43
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)

44
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)
• .setParameter(itemType, itemType)
• .list()

45
Detached Object Support

• Step 2 Collect user input in a servlet/action
• item.setDescription(newDescription)

46
Detached Object Support

• Step 3 Make the changes persistent, back in the
  session bean
• public void updateItem(AuctionItem item) throws
  
• getSession().update(item)

47
Detached Object Support

• Even 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()

48
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?

49
The Big Problem (solution)

1. Version property (if there is one)
2. Identifier value e.g. unsaved-value0 (only
   works for generated surrogate keys, not for
   natural keys in legacy data)
3. Write your own strategy, implement
   Interceptor.isUnsaved()

50
Hibernate Info

• http//hibernate.org
• Hibernate in Action (Manning, 2004)
• Tool support
• http//xdoclet.sf.net
• http//boss.bekk.no/boss/middlegen
• http//www.andromda.org/