Hibernate - Advance

September 5, 2016
 1. Collection Mapping

2. One to Many Mapping

3. One to One Mapping

4. Many to Many Mapping

5. Hibernate Cache

6. Few more topics

• ColumnTransformer
• @Formula
AGENDA • @Any
• @Temporal
• @Index
• Locking
• Interceptor Interface
• Attribute Convertor
• BasicTypeRegistry
• Explicit BasicTypes
• Transaction Isolation Level / Strategies

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 2

Objectives
Learning Advance hibernate topics including-
 Collection Mapping
 One to Many Mapping
 One to One Mapping
 Many to Many Mapping
 Hibernate Cache

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 3

Collection Mapping
Collection Mapping Problem
 We are working for an on line shopping site (lets suppose Tele Venture Marketing – TVM). For each item,
TVM wants to put one or more images. With respect to JAVA programming, you would like to have a
collection of images in your item POJO. But how this arrangement will be mapped to the database?

Image 1

Image 2

Image 3

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 5

Set Property Mapping
 Set of File name in POJO class
• We have different implementations of set provided in java.util framework. If you were the hibernate designer you
must have the issue of Set type mapping. Different type of sets have different functionality, even you can have user
defined implementation of a set.
• Either you would provide the flexibility to define the set type (which type of set) to the hibernate, or you will restrict
the type of set in hibernate application.
• Hibernate restricts the type of a Set in hibernate application. You can have a Set collection in a POJO by having the
reference of following interfaces:
o A java.util.Set is mapped with a <set> element. Initialize the collection with a java.util.HashSet. The order of its
elements isn’t preserved, and duplicate elements aren’t allowed. This is the most common persistent collection in a
typical Hibernate application.
o A java.util.SortedSet can be mapped with <set>, and the sort attribute can be set to either a comparator or natural
ordering for in-memory sorting. Initialize the collection with a java.util.TreeSet instance.
• If you insert the item POJO first time to the database, you need to have a concrete implementation of Set to add your
images. java.util.HeshSet is used to initialize the Set.
• If you fetch, item entity from the database, hibernate provide its own implementation of set for the image collection.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 7

 Set of File name in Database
• From the point of view of the database, a new database table is maintained for the item images. ITEM_IMAGE table is
a separate entity, a separate table, but Hibernate hides this for you.
• ITEM_IMAGE table maintains an ITEM_ID column referencing ITEM table primary key.
• A set can’t contain duplicate elements, so the primary key of the ITEM_IMAGE collection table is a composite of both
columns in the <set> declaration: ITEM_ID and FILENAME.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 8

Set Mapping Example

Item POJO

Collection table with join column Collection of String

name
Column name for images

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 9

 Exercise

• Create a database BookStoreDB. Create a simple java project named BookStoreApp.

• Create a Hibernate/JPA POJO Book with fields ISBN number, book title and publication date.
• Every book has a set of author names. An author of a book is not an entity in our book store application.
• Map this arrangement in hibernate using set.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 10

Bag Property Mapping
 Bag of File name in POJO class
• An unordered collection that permits duplicate elements is called a bag.
• Java Collections framework doesn’t include a bag implementation. However, the java.util.Collection interface has bag
semantics.
• You can use either java.util.Collection reference or java.util.List reference for a bag mapping. Reference of List
interface for a bag isn’t recommended, because clients using this collection property may think the order of elements
is always preserved, which isn’t the case if it’s mapped as a bag.
• java.util.ArrayList is used to initialize the collection,

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 12

 Bag of File name in Database
• From the point of view of the database, a new database table is maintained for the item images. ITEM_IMAGE table is
a separate entity, a separate table, but Hibernate hides this for you.
• ITEM_IMAGE table maintains an ITEM_ID column referencing ITEM table primary key.
• ITEM_IMAGE table has its own surrogate key in order to allow duplicate values.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 13

Bag Mapping Example

Item POJO

Collection table with join column Collection of String

name
Column name for images

java.util.Collection

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 14

 Exercise

• Create a database BookStoreDB. Create a simple java project named BookStoreApp.

• Create a Hibernate/JPA POJO Book with fields ISBN number, book title and publication date.
• Every book has an unordered list of images.
• Map this arrangement in hibernate using bag.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 15

Indexed List Property Mapping
 Indexed List of File name in POJO class
• An ordered collection that permits duplicate elements is called a indexed List.
• java.util.List reference is used for a indexed list mapping.
• java.util.ArrayList is used to initialize the collection,

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 17

 Indexed List of File name in Database
• From the point of view of the database, a new database table is maintained for the item images. ITEM_IMAGE table is
a separate entity, a separate table, but Hibernate hides this for you.
• ITEM_IMAGE table maintains an ITEM_ID column referencing ITEM table primary key.
• A list mapping requires the addition of an index column to the collection table. The index column defines the position
of the element in the collection. Thus, Hibernate is able to preserve the ordering of the collection elements.
• The primary key of the collection table is a composite of ITEM_ID and indexed column..

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 18

Indexed List Mapping Example

Item POJO

Collection table with join column Collection of String

name
Column name for images

Indexed Column

java.util.List

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 19

 Exercise

• Create a database BookStoreDB. Create a simple java project named BookStoreApp.

• Create a Hibernate/JPA POJO Book with fields ISBN number, book title and publication date.
• Every book has an ordered index of chapters.
• Map this arrangement in hibernate using indexed list.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 20

Map Property Mapping
 A Map of File name in POJO class

• An unordered collection for key value pair that does not permit duplicate key is called a Map.
• java.util.Map or java.util.SortedMap reference is used for a Map property mapping.
• java.util.HashMap or java.util.TreeMap is used to initialize the collection,

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 22

 A Map of File name in Database
• From the point of view of the database, a new database table is maintained for the item images. ITEM_IMAGE table is
a separate entity, a separate table, but Hibernate hides this for you.
• ITEM_IMAGE table maintains an ITEM_ID column referencing ITEM table primary key.
• A map mapping requires the addition of an map key column to the collection table.
• The primary key of the collection table is a composite of ITEM_ID and map key column. The IMAGENAME column holds
the keys of the map.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 23

A Map property Mapping Example

Item POJO

Collection table with join column

name
Column name for images

Map key Column

java.util.Map

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 24

 Exercise

• Create a database BookStoreDB. Create a simple java project named BookStoreApp.

• Create a Hibernate/JPA POJO Book with fields ISBN number, book title and publication date.
• Every chapters has one or more images.
• Map this arrangement in hibernate using map. Key of the map should be the name of the chapter.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 25

Collection of Components
 Object Collection property in POJO class

• Collection strategies for the collection of object remains same as discussed earlier.
• You can have a collection of embeddable POJO in your container pojo.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 27

 Exercise

• Create a database BookStoreDB. Create a simple java project named BookStoreApp.

• Create a Hibernate/JPA POJO Book with fields ISBN number, book title and publication date.
• Every book has an ordered index of chapters and every chapter is started with an image.
• Map this arrangement in hibernate using indexed list of Chapter objects.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 28

Entity Association
 Database Entity Relationship
• Database entities are related to each other by defining referential integrity. For example, an Item in an on line
shopping can have more that one bids. Item and bids have one to many relationship and this relation ship is
maintained as follows in a relational database:

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 30

 POJO relationship
• With respect to JAVA programming, If an Item has one to many relationship with bid, you would like to have a
collection of bid objects in item object and item object in all bid objects.

• If you were a ORM developer, you will have to define a strategy of mapping between object association and entity
relationship.
• Hibernate, as well as JPA, defines so many techniques for association–relationship mapping.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 31

One to Many Association Mapping
 Problem Statement
• In an on line shopping application, an item has one to many relationship with bids. You need to define this association
of item to bid in POJO and you need to map this association to database entity relationship.

If a bid is added to

?
Item Object

A Bid entity, referring item,

should be created

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 33

Lets have a look on code first

Set of Bids in Item Class

Item in Bid Class
Foreign Key Column
© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 34
 One Item is associated with many bids
• @javax.persistence.OneToMany annotation needs to apply on the set of the bids in Item POJO.
• @javax.persistence.ManyToOne annotation needs to apply on the item property in Bid POJO.
• You need to define @javax.persistence.JoinColumn at item property in Bid POJO (Bid id has ITEM_ID column, a
reference of Item entity).
• Either, you need to @javax.persistence.JoinColumn at set of bids in Item POJO or you need to define mappedBy
attribute of @javax.persistence.OneToMany annotation.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 35

 No Dirty checking for association
• If your application need one to many bidirectional relationship between item and bid, you need to update this
information in both the POJO objects at JVM level i.e. If a bid is added to the item set, item should also be set on the
bid object.
• If you want to add a bid to an item, you should call below method of Bid POJO.

• Hibernate doesn’t manage persistent associations. If you want to manipulate an association, you must write exactly
the same code you would write without Hibernate. If an association is bidirectional, both sides of the relationship must
be considered.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 36

 Problem with bidirectional mapping

• In the above code, we have added a bid to an item and item was set to the bid object. At runtime, there are two
different in-memory representations of the same foreign key value: the item property of Bid and an element of the
bids collection held by an Item.
• In persistence context, both (item and bid) objects have been changed. Any change in the persistence context is
propagated to the database.
• In persistence context, Bid object is added and item object is updated. From the point of view of database, it is a single
change.
• Hibernate doesn’t transparently detect the fact that the two changes refer to the same database column. Hibernate
find that 2 objects in persistence context has been updated.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 37

 Hey Hibernate! It’s a single database change.
• By specifying mappedBy attribute, you explicitly tell Hibernate which end of the link it should not synchronize with the
database. In above example, you tell Hibernate that it should propagate changes made at the Bid end of the
association to the database, ignoring changes made only to the bids collection.

Item property in Bid POJO

• @ManyToOne annotation does not have mappedBy attribute. So for one to many relationship, you can stop the
change made at the item end to be propagated to the database.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 38

Cascading Object State
 Would you like to persist all bids individually???
• In our online shopping application, if you want to add two bids to an item, you will have to write below piece of code

You have to persist each bid

individually

• Don’t you think that every bid should not be persisted programmatically? If we add bids to a persisted item, bids
should be persisted automatically.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 40

 Persistence By Reachability
• Hibernate support PERSIST and MERGE cascade type at association relationship. If you define PARSIST cascade type on
set of bids, all the bids of an item are persisted when the item is persisted.

Cascade Operation at One to

Many end

No Need to persist individual bids

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 41

 Cascade Delete
• In our online shopping application, if an item is deleted from the database, all the bids should also be deleted from the
database. Either you delete all related bids one by one (You are responsible ) from the database or you can set the
cascade attribute to delete (Hibernate is responsible).

If Item is deleted,
All bids are deleted

• Hibernate delete all the bids by executing delete statements. Hibernate does not use database cascade functionality.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 42

 Orphan Removal
• If you delete a bid, not item, the bid object should be removed from the set of bids in item object. Either you will
remove the deleted bid programmatically or you can set orphanRemoval attribute value to true.

If you delete a bid, bid will also be

removed from list

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 43

Fetching strategies
 Fetching Issue
• If you fetch an item entity from database, bids on this items should also be fetched from the database otherwise
getBids() method of Item class will return a null value or empty collection.
• If you were a hibernate developer, would you like to leave this responsibility for the java programmer to fetch child
entities programmatically? Of course No.
• If a hibernate user fetch item entity from the database, he/she should not be worried about fetching bids of the item.
Bids should be fetched by the hibernate framework either at the time of fetching item or lazily.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 45

 Lazy Fetching
• Hibernate defaults to a lazy fetching strategy for all entities and collections. This means that Hibernate by default loads
only the objects you’re querying for. Dependent entities are loaded when they are used lazily.

List of bids will be fetched lazily.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 46

Lazy Fetching in Practice

List of bids is fetched at this point

lazily.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 47

 Eager Fetching
• you often want to specify that a particular entity association or collection should always be loaded. You want the
guarantee that this data is available in memory without an additional database hit. You can define the fetching strategy
as eager.

List of bids will be fetched eagerly.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 48

Eager Fetching in Practice

List of bids is fetched at this point

eagerly.

Left Outer Join.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 49
 Exercise

• Create a POJO class BookOrder that has a one to many relationship with
Book class. It stores other information like order date, price, order state
and set of books ordered.
• Implement this association relationship by Hibernate/JPA.
• Use cascading operation while persist.
• Try it with different fetching strategies.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 50

One to Many Association Using Map
 Map in place of set
• In our on line shopping application, an item can have more than one images. For bidirectional relationship, we wants
to have a map (<String, Image>) in Item class.
• We define @MapKey annotation on image map. Map key is stored in image table.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 52

 Set image type to the key of map

Map Key is stored in Image table

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 53

 Exercise

• Create a POJO class BookOrder that has a one to many relationship with
Book class. It stores other information like order date, price, order state
and set of books ordered.
• Implement this association relationship by Hibernate/JPA using book
name as the map key.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 54

One to Many
Unidirectional Indexed Association
 Maintain index order of bid
• In our on line shopping application, an item can have more than one bids. For unidirectional relationship, we can have
an indexed list of bids in Item class as follows:

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 56

One to Many
Bidirectional Indexed Association
 Maintain index order of bid
• In our on line shopping application, an item can have more than one bids. For bidirectional relationship, we can have
an indexed list of bids in Item class as follows:

No mappedBy attribute. Collection

information is required to update
the index

Equivalent to mappedBy,
Updatable and insertable attributes
are false.
© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 58
One to One Association Using Same
Primary Key
 One User has one shipping address
• In our on line shopping application, a user can be mapped to a single shipping address. We can have bidirectional one
to one mapping between user and address.
• We will have a one to one relation if Address table primary key references User table primary key.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 60

 @OneToOne

Optional must be true

Foreign Key
Generator

@OneToOne @PrimaryKeyJoinColumn
© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 61
 Exercise

• Create a POJO class Book that has a one to one relationship with cover
image class.
• Implement this association relationship by Hibernate/JPA same primary
key approach.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 62

One to One Association Using
Unique Foreign Key
 One User has one shipping address
• Instead of sharing a primary key, two rows can have a foreign key relationship. One table has a unique foreign key
column that references the primary key of the associated table.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 64

 @OneToOne

Address key is unique

mappedBy at
Address end

@OneToOne
© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 65
 Exercise

• Create a POJO class Book that has a one to one relationship with cover
image class.
• Implement this association relationship by Hibernate/JPA same unique
foreign key approach.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 66

Many to Many Unidirectional
Association
 Many to Many relationship of Item and Category
• In our on line shopping application, an item can be categorized in more than one category and a category can have
more than one item.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 68

 Many to Many relationship in database
• Many to many relationship is maintained with the help of a join table. The join table (or link table, as some developers
call it) has two columns: the foreign keys of the CATEGORY and ITEM tables. The primary key is a composite of both
columns.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 69

Many to Many Unidirectional POJO mapping

Join table with many to many

relationship

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 70

Many to Many Indexed Collection

Join table with many to many

relationship

Order Column

Join table with category id and item index

as primary key © 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 71
 Exercise

• Create a POJO class Book that has a many to many relationship with
Book Categories. We can fetch books of one category but we can not
fetch categories of a book.
• Implement this association relationship by Hibernate/JPA.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 72

Many to Many Bidirectional
Association
Many to Many Bidirectional POJO mapping

Join table with many to many

relationship

mappedBy Attribute is required at

other side

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 74

 Exercise

• Create a POJO class Book that has a many to many relationship with
Book Categories. We can fetch books of one category and vice-versa.
• Implement this association relationship by Hibernate/JPA.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 75

 The object-retrieval options
• At this point, we have enough knowledge to store a JVM POJO to the database. Saving some data to the database is of
no use if we do not fetch it. Database provide SQL queries to fetch database tables.
• With respect to hibernate, we should have some mechanism to fetch the data from the database. Retrieving persistent
objects from the database is one of the most interesting parts of working with Hibernate.
• Hibernate provides the following ways to get objects out of the database:
o Navigating the object graph
o Retrieval by identifier
o The Hibernate Criteria interface
o The Hibernate Query Language / JPA Query Language
o Native SQL queries
• Navigating the object graph, starting from already loaded objects. If an object is in the persistence context, its
associations also fetched in the persistence context. For example, if you fetch an item object in a persistence context,
all it’s bids are also fetched in the same persistence context.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 76

Retrieval By Identifier
 Different Strategies for ID retrieval
• Let us suppose we have a person entity in a database and we want to fetch a person object by providing identifier
value. To retrieve a person entity by the identifier, we can call either of the two JPA method:

Hibernate get method is called

Hibernate load method is called.

• If getReference() can’t find the object in the cache or database, an unchecked exception EntityNotFoundException is
thrown. The getReference() method never returns null. The find() method returns null if the object can’t be found.

• The getReference() method may return a proxy instead of a real persistent instance. A proxy is a placeholder that
triggers the loading of the real object when it’s accessed for the first time. On the other hand, find() never returns a
proxy. find() method either hit the database or take the object from cache.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 78

 Understanding Proxies
• Look at the below code snippet

• We have used getReference() method to have the reference of an item entity with item_id 1. When we execute above
program, no select query is executed. Hibernate generates a proxy of item object (Usually a subclass of Item
overriding access methods) at runtime.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 79

 Proxy Initialization with real entity
• A proxy object is initialized with real entity when it is accessed for first time.
• If identifier has not been mapped with the field access, as long as you access only the database identifier property, no
initialization of the proxy is necessary.

• When you define a collection for lazily fetched, a proxy of collection is created at runtime. A collection is initialized if
you start iterating through its elements or if youhere
Entity is fetched call ifany of the iscollection-management
identifier operations,
Entity is fetched such as is
here if identifier size() and
contains(). field accessed not field accessed

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 80

 Need of a Proxy
• In our on line shopping application, lets suppose that you want to just add a bid to the existing item and closing the
persistence context.

Need
No to have
need to the
addreference of Item
bids to item.
Transaction is over.

• Do you agree that item object should be fetched from the database while only bid entity is to be persisted to the
database? Required item id for bid association has been given to the getReference() method.
• We should have only one insert statement:

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 81

Problem with Proxy
 Un necessary database fetch
• Let us suppose that shipping address of user is lazily fetched from the database. An application administrator wants to
fetch a list of all users and then send a letter to corresponding shipping address.

• Hibernate lazily fetch address object for each item in a separate database call.
• Hibernate offers an optimization named: Batch Fetching or blind-guess-optimization.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 83

 Fill a batch of proxies
• If one proxy of address must be initialized, let hibernate initialize more than one address proxies in a single select.

JPA do not provide batch

optimization

• You are telling hibernate to pre-fetch up to 10 uninitialized proxies in a single SQL select, if a single proxy is initialized.
• The resulting query is looks like below:
Select a.* from AddressFKA a where a.id in (?,?,?)

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 84

Questions
 What is difference between sorted collection and ordered collection, which one is better?
 What are the collection types in Hibernate?
 How to implement Joins in Hibernate?
 How do you implement one to one relationship in Hibernate with XML mapping?
 How do you implement one to one relationship in Hibernate with java annotation?
 How does Hibernate useful in mapping object and its relations?
 What are the inheritance mapping strategies?
 What are the different fetching strategy in Hibernate?
 What is Hibernate proxy?
 What is lazy loading in hibernate?
 What is automatic dirty checking in hibernate?

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 85

More Questions
 Why we should not make Entity Class final?

 How can Hibernate be configured to access an instance variable directly and not through a setter method
?
 Is it possible to perform collection mapping with One-to-One and Many-to-One?

 How to make a immutable class in hibernate?

 Why it's important to provide no argument constructor in Hibernate Entities?

 Can we make a Hibernate Entity Class final?

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 86

Hibernate Cache
Caching is all about application performance optimization and it sits between your application and the database
to avoid the number of database hits as many as possible to give a better performance for performance critical
applications.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 88

First level cache - L1 Cache
 The first-level cache is the Session cache and is a mandatory cache through which all requests must pass.
The Session object keeps an object under its own power before committing it to the database.

 The L1 cache is connected directly to the Hibernate Session, ie the L1 cache runs throughout the lifecycle of
the Session object, thus "born" and "die" with him. Because the L1 cache is internal to a Session object, it
can not be accessed from other Sessions created by the Session Factory.

Read more: http://mrbool.com/understanding-the-hibernate-cache-l1-and-l2-in-detail/33437#ixzz4JMixHlSM

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 89

Second level cache – L2 Cache
 Second level cache is an optional cache and first-level cache will always be consulted before any attempt is
made to locate an object in the second-level cache. The second-level cache can be configured on a per-class
and per-collection basis and mainly responsible for caching objects across sessions.
 Second level cache is created in session factory scope and is available to be used in all sessions which are
created using that particular session factory.
It also means that once session factory is closed, all cache associated with it die and cache manager also
closed down.

Note-
 Fist level cache Is is enabled by default and works in session scope.
 Second level cache is apart from first level cache which is available to be used globally in session factory
scope.

Read more: http://howtodoinjava.com/hibernate/how-hibernate-second-level-cache-works/

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 90

Configuring L2 Cache

1.) Add the mapping element required to tell Hibernate to

cache Employee instances using READ_ONLY strategy.

Different strategies-
• Read Only: This caching strategy should be used for
persistent objects that will always
read but never updated.
• Read Write: It’s good for persistent objects that can be
updated by the hibernate application.
• Nonrestricted Read Write: If the application only
occasionally needs to update data and strict transaction
isolation is not required, a nonstrict-read-write cache
might be appropriate.
• Transactional: The transactional cache strategy provides
support for fully transactional cache providers such as
JBoss TreeCache.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 91

2.) Add provider class in hibernate configuration file-

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 92

3.) Create xml file called ehcache.xml and store in at class path location
[ no confusions, the place where you have mapping and configuration XML’s ] in web application.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 93

Questions

 What are different types of cache hibernate supports ?

 What are the different caching strategies?

 What is query cache in Hibernate?

 What is Second-level Cache in Hibernate?

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 94

Few More Topics
ColumnTransformer Annotation
Annotation org.hibernate.annotations.ColumnTransformer can be used to specify custom SQL during a
write/update operation.

Suppose there is a requirement to have two columns - created_date and updated_date in Persontable.
 created_date should be filled automatically whenever a new record is inserted into table.
 updated_date should be updated automatically whenever the corresponding row is modified.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 96

The above example prints the below SQL when run-

Note-
 Coalesce (...) is similar to Oracle's nvl() function and supported by all major DBs.
It returns the first non-null argument.

 Current_Timestamp is similar to Oracle's sysdate() function and supported by all major DBs.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 97

 Hibernate Filters -@ Filter
Filtering in hibernate is like creating a view in database. We need to create filter definition using @FilterDef
annotation where we define a name and parameters. Using this filter definition name, we enable filter by Session
enableFilter() method and disable it by disableFilter() method. To apply filter on entity load we use @Filter and on
collection load we need to use @FilterJoinTable on association. Hibernate filter is created and used by below
annotations and methods.

@FilterDef: Defines filter definition name and parameters to set values while enabling filter.
@Filter: Adds filter to an entity or a target entity.
@Filters: To define more than one @Filter, use @Filters.
@FilterJoinTable: Use it to filter join table.
Session.enableFilter(): Finally filter is enabled using this method. We need to pass filter definition name.
Session.disableFilter(): Pass filter definition name to disable filter.
deduceAliasInjectionPoints: This is the attribute of @Filter annotation which has Boolean value that controls
explicit aliasing.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 98

Using @FilterDef, @Filters and @Filter to Load Entity-

Use Session enableFilter() and disableFilter()-

While using filter, we need to use session method as Session.enableFilter() passing filter definition name. It
returnsorg.hibernate.Filter instance. To set parameter values, filter provides setParameter() method. Finally if
we want to disable filter, we just use Session.disableFilter() passing filter definition name.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 99

Using @FilterDef and @FilterJoinTable to Load Collection-

To filter collection load in hibernate association, we need to use @FilterJoinTable annotation. This annotation is
applied at association level within entity.

@FilterJoinTable is used with @JoinTable. When entity is loaded, collection will be filtered according to
@FilterJoinTable definition.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 100

@Formula Annotation
If we want to apply a virtual property in your entity to get a calculated value, we can use @Formula annotation to set the
formula. This formula can be as complex as we want. In this example we are showing area of a Dimension entity.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 101

Below code will show how @Formula is useful-

Output-

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 102

@Any Annotation
Sometimes we need to map an association property to different types of entities that don't have a common
ancestor entity - so a plain polymorphic association doesn't do the work.
The @Any annotation defines a polymorphic association to classes from multiple tables.

In Any relationship, the table holding the relationship would have two columns for relationship management.
One to identify the primary key value of record being associated and another to identify the table to which the
associated record belongs.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 103

In this case, the developer has defined that SaleTransaction would be managing the relationship using
vehicleType and vehicleId columns in database. If the transaction is of bus sale then vehicleType column in
SaleTransaction table would be ‘bus’ and vehicleId would be the value of primary key of corresponding bus. In
the same way, if the transaction is of Truck sale then the vehicleType column in SaleTransaction would be
‘truck’ and vehicleId would be the value of primary key of corresponding truck.
Read More: http://javabeat.net/polymorphic-association-mapping-relationship-hibernate/

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 104

@Temporal Annotation
@Temporal is used in hibernate entity with a entity variable. @Temporal defines the TemporalType.

TemporalType can be like TemporalType.TIMESTAMP, emporalType.DATE and TemporalType.TIME. In below

example we have used TemporalType.TIMESTAMP.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 105

Below code will show how @Formula is useful-

Result-

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 106

@Index Annotation
@Index applies the index at property level. If the property of an entity is annotated with @Index, an index with
the given name will be applied on the column.

The above @Index code is equivalent to below SQL code-

create index nameIndex on Person(name);
Other way:

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 107

Locking
Locking refers to actions taken to prevent data in a relational database from changing between the time it is
read and the time that it is used.
Locking strategy can be either optimistic or pessimistic.

Optimistic locking assumes that multiple transactions can complete without affecting each other, and that
therefore transactions can proceed without locking the data resources that they affect. Before committing, each
transaction verifies that no other transaction has modified its data. If the check reveals conflicting modifications,
the committing transaction rolls back. Hibernate provides two different mechanisms for storing versioning
information, a dedicated version number or a timestamp.
 Version number
 Timestamp

Pessimistic locking assumes that concurrent transactions will conflict with each other, and requires resources
to be locked after they are read and only unlocked after the application has finished using the data.

Read More: https://docs.jboss.org/hibernate/orm/4.0/devguide/en-US/html/ch05.html

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 108

Interceptors
An object passes through different stages in its life cycle and Interceptor Interface provides methods which
can be called at different stages to perform some required tasks. These methods are callbacks from the
session to the application, allowing the application to inspect and/or manipulate properties of a persistent object
before it is saved, updated, deleted or loaded.
Following is the list of all the methods available within the Interceptor interface:

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 109

Creating a Interceptors:

To build an interceptor you can either

implement Interceptor class directly
or extend EmptyInterceptor class.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 110

Enabling the interceptor:

You can enable the interceptor by pass it as an argument to openSession(interceptor)

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 111

Attribute Converter
If you are using Hibernate, and want a customized type is supported in your Entity class, you could have to
write a custom Hibernate Type.

JPA 2.1 brings a new feature named attribute converter, which can help you convert your custom class type to
JPA supported type.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 112

Create an attribute converter:

In this example, we try to store the tags property into one column instead of an external table.
Create an attribute converter, it should be annotated with @Converter and
implementsAttributeConverter interface.

It is easy to understand, the tags property will be converted into a comma based string when it is stored into
database, and tags field value of Person table will be converted into a List when it is fetched from database.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 113

Apply Converter:

You can use the autoApply attribute of the Converter to apply the converter to any supported type.

It is dangerous in a real world project when there are some List you do not want to be converted. Alternatively,
you can apply it on the property via a @Convert annotation.

You can also place it on class.

An extra attributeName must be specified. You can declare several Converters for properties on an Entity class.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 114

BasicTypeRegistry
Hibernate type is not a Java type, nor a SQL type, but that it understands both and performs the marshalling
between them.

Hibernate has a service org.hibernate.type.BasicTypeRegistry, which essentially maintains a map

of org.hibernate.type.BasicType that helps hiibernate to map aatributes.

As an example, take a String attribute if there isno explicit type mapping, Hibernate looks to the
BasicTypeRegistry to find the registered mapping forjava.lang.String.

As a baseline within BasicTypeRegistry, Hibernate follows the recommended mappings of JDBC for Java types.
JDBC recommends mapping Strings to VARCHAR, which is the exact mapping that StringType handles. So
that is the baseline mapping within BasicTypeRegistry for Strings.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 115

Explicit BasicTypes
Sometimes you want a particular attribute to be handled differently. Occasionally Hibernate will implicitly pick a
BasicType that you do not want (and for some reason you do not want to adjust the BasicTypeRegistry).

In these cases you must explicitly tell Hibernate the BasicType to use, via
theorg.hibernate.annotations.Type annotation.

Read More: https://docs.jboss.org/hibernate/orm/5.0/mappingGuide/en-US/html/ch03.html#basic-registry

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 116

Transaction Isolation Level / Strategies
Isolation does not have 0 or 1 state instead there can be different isolation levels. Also, increasing the isolation
level will impact the performance.
There are four transaction isolation levels.
• Read Uncommitted- One transaction can view uncommitted data of another transaction and dirty read,
phantom read, unrepeatable reads are allowed. This is the loosest isolation level and is not recommended.
• Read Committed – Dirty Reads (Uncommitted Read) are not allowed in this isolation level, but unrepeatable
reads and phantom reads are permitted. This approach uses shared read lock and exclusive write lock in
which read lock is acquired and released immediately where as write lock is released at the end of the
transaction.
• Repeatable Read- Dirty Read and Unrepeatable Read is not allowed in this isolation level but phantom
reads are allowed. In this isolation level, reading transaction will block all other writing transactions ( but
allows other reading transactions ) and any writing transaction will block all other transactions. This will have
some scalability issues.
• Serializable- This is the strictest isolation level and will have scalability issues. This prevents dirty read,
phantom reads , unrepeatable read etc. Transactions are executed serially (one after another) and acquires
read and write locks on the entire set of affected data.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 117

Setting a Isolation Level
Every database has default isolation level (either Read Committed or Repeatable Read) and we can override
the isolation level using hibernate.connection.isolation property in hibernate.cfg.xml file.
• Read uncommitted isolation - 1
• Read committed isolation- 2
• Repeatable read isolation- 4
• Serializable isolation – 8

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 118

Questions

 How to implement Optimistic locking in Database?

 What are the uses of interceptors in hibernate and how it is configured?

 How transaction management works in Hibernate?

 What are best practices to follow with Hibernate framework?

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 119

More Questions

 Can Hibernate filters be used with criteria queries?

 How to enable hibernate filter for sessionFactory.getCurrentSession()?

 How to append conditional query dynamically in Hibernate Filter?

 How to log hibernate generated sql queries in log files?

 Why is onFlushDirty called after onSave?

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 120

Exercise
Design the JPA/Hibernate POJO for Portfolio Management

• Create a website for BullishBears India which will manage the shares portfolio for their clients. The website would
have the following layout
• Login Page
The initial page that will open and it will have the following layout

o The password field will show only *s.

o A validation needs to be added for empty username or password fields.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 122

Portfolio Management System/Home Page

• The Layout of the Site would be divided in 3 sections -

o Header - This will contain the LOGO of the company, a small welcome string or welcome note suffixed by User name and a Logout link. This part of
the Site will remain fixed for all the pages.
o The Left navigation pane – This will contain the Links to the other pages on the site, clicking on any of the link will open that page. This part of the
Site will remain fixed for all the pages.
o The Right Pane – This part of the page will contain the content which will be rendered by the link which was clicked.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 123

Portfolio Management System/Sell Stock Page

The right hand pane for sell stock page would look like this –

Stock Name Quantity Mkt Price Amount

ABC 200 45.40 9080
FICT 300 78 23400
… … … …
… … … …

The stock name would be a hyperlink and clicking on it would show the following Sell Stock Order page(in the same
pane).

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 124

Portfolio Management System/Buy Stock Page

The right hand pane for buy stock page would look like this –
Stock Name Buy Quantity Mkt Price Amount
ABC 45.4

FICT 78

FRAD 63

DICT 98

BUY Reset

When the client presses the BUY button after specifying the quantity. A backend validation would be required to
check if the client has enough money for the order to be processed.

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 125

Portfolio Management System/User Details Page

• This page would show the user details – Initially (read only)
o Client name
o Contact details (address, contact number, email id)
o Account balance
• The user will be given an option to update his details, where he would be able to update his address, phone, email id
(not his name).

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 126

Portfolio Management System/Transaction History Page

• This page would show the transaction history of the client, it will show in a tabular format the transactions he has
made (All of the transactions)

Date Stock Name Quantity Price Amount Transaction Type

10/2/2011 ABC 200 12 2400 BUY

… … … … … …
… … … … … …
… … … … … …

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 127

What to do

• Find entities in portfolio management System and create JPA/Hibernate POJO.

• Create DAO classes for each POJO having CRUD operations.
• Write JPA QL Queries for below:
o Select All users having non negative account balance.
o Select buy transactions of a user
o Select users having no transaction.
o Select the investment of a buyer. (Sum of amount of buy transactions)

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 128

Recap
 Collection Mapping
 One to Many Mapping
 One to One Mapping
 Many to Many Mapping
 Hibernate Cache
 Few more topics
• ColumnTransformer
• @Formula
• @Any
• @Temporal
• @Index
• Locking
• Interceptor Interface
• Attribute Convertor
• BasicTypeRegistry
• Explicit BasicTypes
• Transaction Isolation Level / Strategies

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 129

References
 http://www.tutorialspoint.com/hibernate/
 https://docs.oracle.com/cd/E13224_01/wlw/docs103/guide/ormworkbench/hibernate-
tutorial/tutHibernate1.html
 http://javabeginnerstutorial.com/hibernate/hibernate-framework-basic/
 https://docs.jboss.org/hibernate/orm/3.3/reference/en/html/tutorial.html

© 2016 SAPIENT GLOBAL MARKETS | CONFIDENTIAL 130

THANK YOU