Hibernate in Nutshell

Hibernate 3.6
© Onkar Deshpande

Table of Contents
Module Title Page
1 Introduction to Hibernate 3
2 Getting started 13
3 Hibernate API for CRUD 21
4 Some mapping clauses 29
5 More mapping concepts 40
6 The Association relations 55
7 Hibernate Transaction Support 64
8 Queries in Hibernate 82
9 Advanced queries 92
10 More on hibernate 102
© Onkar Deshpande

Module 1. Introduction to Hibernate
 Overview
 Database layer tools-Wrappers and ORM
 What is hibernate?
 OOPs and RDBMS paradigm mismatch
 The ORM solutions
 Hibernate Vs. JPA
 Hibernate architecture
© Onkar Deshpande

Database layer tools
OOPS
Business Layer
Service Layer
Presentation Layer
JDBC Layer
JDBC Wrapper
Spring JDBC
JPA
Hibernate
iBatis
Database
© Onkar Deshpande

5
Hibernate Clients
Desktop application
Console/Swing
Spring
application
EJB Container
Web application
Struts/WebWork/TabeStray
Hibernate Database
© Onkar Deshpande

What is Hibernate?
 What is hibernate?
 A powerful ORM tool to design data base access layer.
 Fills gaps of mismatches between OOPs and RDBMS
paradigm. Also maintains adequate ultra performance of
database access.
 An automated, configurable persistence of java objects with
tables in data base.
 May not be a good solution for data-centric application
which uses only stored procedures to implement business
logic in the database.
© Onkar Deshpande

Hibernate versions
 Hibernate 3.2
 Most commonly used production version.
 Full support for JPA 1.0.
 Hibernate 3.5
 Full support for JPA 2.0.
 Hibernate 3.6
 Full support of JEE 5.
 Hibernate 4.1
 Full Support to JEE 6
 Hibernate 4.3
 Full Support to JEE 7
© Onkar Deshpande

Paradigm mismatch
 Problem of Granularity.
 Problem of subtypes.
 Problem of identity.
 Problems relating to association.
 Problem of object graph navigation.
© Onkar Deshpande

The ORM solutions
 Wrapper for basic CRUD operations.
 Language or API for specifying queries that refers to
Objects and their properties.
 Facility for specifying mapping metadata.
 Techniques to match the mismatches between OOPs
and Databases.
 Dirty checking, lazy fetching, and other optimization
functions.
© Onkar Deshpande

Hibernate Vs. JPA
 JPA is set of specifications of which implementation is
provided in Toplink, hibernate 3.0 etc.
 JPA is a standard while hibernate is not.
 JPA ‘s some of the implementations have been blamed
as slow.
 EntityManager and EntityManagerFactory are thin
wrappers around Session and SessionFactory etc.
© Onkar Deshpande

Hibernate Architecture
Overview of Hibernate in layered architecture
Business Layer
Persistent Layer
Persistence
Classes
Session Query User Types Interceptors
Session Factory Configuration Transaction
© Onkar Deshpande

Module 2. Getting started
 Overview
 Hibernate Configuration- XML and properties
 Mapping tables with beans
 Hibernate SessionFactory and Session
 Mapping using annotations
 Object states.
© Onkar Deshpande

Configuration using XML
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">oracle.jdbc.OracleDriver</property>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:ORCL</property>
<property name="hibernate.connection.username">scott</property>
<property name="hibernate.connection.password">tiger</property>
<property name="hibernate.connection.pool_size">10</property>
<property name="show_sql">true</property>
<property name="hibernate.use_sql_comments">true</property>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<mapping resource="comhibernatepack10_beginempBean.hbm.xml"/>
</session-factory>
</hibernate-configuration>
© Onkar Deshpande

Mapping tables with beans
Mapping metadata…
<hibernate-mapping>
<class name="com.hibernate.pack10_begin.EmpBean" table="EMP">
<id name="empNo" type="int" column="EMPNO" >
<generator class="native"/>
</id>
<property name="ename">
<column name="ENAME" />
</property>
<property name="sal">
<column name="EMPSAL"/>
</property>
</class>
</hibernate-mapping>
public class EmpBean {
private int empNo;
private String empNm;
private Float empSal;
public void setEmpNo(int empNo) {
this.empNo = empNo;
}
public void setEname(String empNm) {
this.empNm = empNm;
}
public void setSal(Float empSal) {
this.empSal = empSal;
}}
© Onkar Deshpande

SessionFactory and Session
 Booting steps...
 Create configuration object.
Configuration config = new Configuration();
config.configure(“pack10_beginhibernate_begin.cfg.xml”);
 Build session factory.
SessionFactory sessions = config.buildSessionFactory();
 Open session
Session session = sessions.openSession();
 Start transaction
Transaction transaction = session.beginTransaction();
 Handle session
session.save(), session.update() etc.
 Conclude transaction
transaction.commit(), transaction.rollback()
 Close session.
 session.close()
© Onkar Deshpande

Mapping using annotations.
@ Entity
@ Table (name="emp")
public class EmpBean {
private int empNo;
private String empNm;
private Float empSal;
@ Id
@ Column(name="EMPNO")
public int getEmpNo() {
return empNo;
}
}
Configuration in xml…
<mapping class=“hiber10annot.EmpBean"/>
© Onkar Deshpande

Object States
 Transient
 Persistent
 Detached
© Onkar Deshpande

Transient Object states
JVM
Database
Persistence Heap Stack
Context
Scott
21
1000
2-01-12
Reference
Session
© Onkar Deshpande

Persistent Object states
JVM
Database
Context
Scott
21
1000
2-1-12
Reference
Session
Name Age Salary DOJ
Scott 21 1000 2-1-12
Reference
© Onkar Deshpande

Detached Object states
JVM
Database
Context
Scott
21
1000
2-1-12
Reference
Session
Name Age Salary DOJ
Scott 21 1000 2-1-12
Reference
© Onkar Deshpande

Module 3. Hibernate API for CRUD
 Overview
 The CRUD operations using beans
 The CRUD operations using XML
 The CRUD operations using Maps
© Onkar Deshpande

Object Retrieving
 Navigating object graph
 Using get()/load() method.
 Using HQL.
© Onkar Deshpande

Object Retrieving
 Using Criteria queries.
 Using Query by example.
 Using native queries.
© Onkar Deshpande

Insert a record
Inserts a persistent object into table at the time of commit(). Throws exception on violation of
any constraint at DB.
save() persist()
Hibernate specific Standard as per JSR 220.
Returns auto generated primary key Does not return any value.
Update a record
Dirty check is default feature for persistent object. But for transient object, update or merge
does update at DB side and makes object as persistent.
update() merge()
Hibernate specific Standard as per JSR 220.
Update the record in DB. Makes an
trans.or detached object persistent.
Copies content of transient object into persistent
object. If there is no persistent object in session, it is
loaded.
CRUD operations
© Onkar Deshpande

Delete a record
Delete a given record from table provided it exists. Otherwise thros exception. Converts
persistent object into transient state.
delete()
Retrieve a record
Returns persistent object of the given class and given record it.
get() load()
Standard as per JSR 220. Hibernate specific
Returns initialized instance only if record is
existing.
Returns proxy assuming instance is existing.
Returns null if record is missing. Throws exception later if record is missing.
Use to get instance or to check existence of
a record.
Old version. Use to get instance if record
surely exists.
CRUD operations
© Onkar Deshpande

Data formats for CRUD operations
 Using plain old java objects: Exchanging DB data with
OOPs paradigm.
 Using Maps: Facilitate dynamic change in structure of
data.
 Using XML: For exchanging DB data with XML data
source.
© Onkar Deshpande

Map format for CRUD operations
Mapping….
<class entity-name="message" table="MESSAGES" >
<id name="id" column="MESSAGE_ID" type="long">
<generator class="increment"/>
</id>
<property name="text" column="MESSAGE_TEXT" type="string"/>
<property name="nextMessage" column="NEXT_MESSAGE_ID" type="long"/>
</class>
CRUD Operations…
Map<String, Object> msg3 = new HashMap<String, Object>();
msg3.put("id", 1l);
msg3.put("text", "Meeting canceled.");
session.persist(msg3);
© Onkar Deshpande

Xml format for CRUD operations
Mapping….
<class entity-name="employee" table="Emp" node="employee">
<id name="empId" type="int" column="EMPNO" node="empId">
</id>
<property name="name" type="string" node="name">
<column name="ENAME"/>
</property>
<property name="salary" type="float" node="salary">
<column name="SAL"/>
</property>
</class>
CRUD Operations…
Session dom4jSession = session.getSession(EntityMode.DOM4J);
Element emp = (Element)dom4jSession.load("Employee", 7499);
System.out.print(emp.elementText("empId"));
System.out.print("t" + emp.elementText("name"));
System.out.println("t" + emp.elementText("salary"));
© Onkar Deshpande

Module 4. Some mapping clauses
 Overview
 The paradigm mismatch- OOPs Vs. RDBMS
 Hibernate built-in data types
 Bypassing properties
 Formula field
 Making field-class immutable
 Making field not-null
 The object identity
 Key auto-generation
 Composite keys.
© Onkar Deshpande

Built-in mapping types.
Mapping type Java type Standard SQL type
integer int or java.lang.integer INTEGER
long long. Or java.lang.Long BIGINT
short short or java.lang.Short SMALLINT
float float or java.lang.Float FLOAT
double double or java.lang.Double DOUBLE
big-decimal java.math.BigDecimal NUMERIC
character java.lang.String CHAR
string java.lang.String VARCHAR
byte byte or java.lang.Byte TINYINT
boolean boolean or java.lang.Boolean BIT
yes_no boolean or java.lang.Boolean CHAR(1)
true_false boolean or java.lang.Boolean CHAR(1)
© Onkar Deshpande

Built-in mapping types.
Mapping type Java type Standard SQL type
date java.util.Date or java.sql.Date DATE
time java.util.Date or java.sql.Time TIME
timeStamp java.util.Date or java.sql.TimeStamp TIMESTAMP
calendar java.util.Calendar TIMESTAMP
calendar_date java.util.Calendar DATE
binary byte[] VARBINAR OR BLOB
text java.lang.String CLOB
Serializable Any serializable class VARBINAR OR BLOB
Clob java.sql.Clob CLOB
blob java.sql.Blob BLOB
© Onkar Deshpande

Mapping metadata
Mapping…
<class name="com.hibernate.pack50_moremappings.Emp" table="EMP" mutable="true"
dynamic-update="true">
<id name="empNo" column="EMPNO" access="field">
<generator class="assigned"/>
</id>
<property name="eName" column="ENAME" access="field" not-null="true" />
<property name="sal" column="SAL" access="field" />
<property name="job" column="JOB" access="field" />
<property name="comm" column="COMM" access="field" />
<property name="deptNo" column="DEPTNO" access="field" />
<property name="totalSal" type="float" formula="SAL+COMM"/>
</class>
© Onkar Deshpande

Mapping metadata
<class name=“pack50_moremappings.Emp" table="EMP“ >
<id name="empNo" column="EMPNO" >
</id>
<property name="eName" column="ENAME" access="field" not-null="true" />
<property name="sal" column="SAL" insert="false" update="false"/>
<property name="job" column="JOB" />
<property name="comm" column="COMM" />
<property name="totalSal" type="float“ formula="SAL + COMM" />
</class>
© Onkar Deshpande

Mapping metadata (Contd...)
 Bypassing setter method for populating field with value.
 <property name="eName" access="field“/> <!-- default is
access=“property”->
 Accessing derived properties.
 <property name="totalSal" type="float“ formula="SAL + COMM" />
 Avoiding trip to database if not-null field value is null.
 <property name=" eName” not-null=“true” />
 Controlling insertion and updation of a field.
 <property name="sal" column="SAL" insert="false" update="false"/>
© Onkar Deshpande

Mapping metadata
 Importing package for all beans.
 <hibernate-mapping package=“pack50_moremappings”>
 Making a class immutable
 <class name=“Emp" table="EMP" mutable=“false”>
 To prevent unmodified property value in SQL-insert.
 <class name=“Emp" table="EMP" dynamic-insert="true”/>
 To prevent unmodified property value in SQL-update
 <class name=“Emp" table="EMP" dynamic-update="true”/>
© Onkar Deshpande

Identifier generators
Generator Description
native Picks active identity generators depending upon the database.
increment Hibernates auto-generation policy.
assigned User given key value.
identity Supports identity column.
sequence Uses sequence policy of data base.
hilo Uses high/low algorithm policy of data base.
Declaration in mapping file…
<id name="empNo" column="EMPNO" type="integer">
</id>
© Onkar Deshpande

<class name="Books" table="Books">
<composite-id name="compoKey" class="CompositeId">
<key-property name="bookId">
<column name="BookId" not-null="true" />
</key-property>
<key-property name="titleId">
<column name="TitleId" not-null="true" />
</key-property>
</composite-id>
<property name="cost" />
</class>
public static class CompositeId implements Serializable
{
private int bookId;
private String titleId;
public CompositeIdBooks(){}
public String getTitleId() { …}
public void setTitleId(String titleId) { … }
public int getBookId() {… }
public void setBookId(int bookId) { …}
}
Composite key
The composite key Embedable
© Onkar Deshpande

Composite key (Contd...)
The entity bean
@ Entity
public class Books {
@Id
@ EmbeddedId
private CompositeIdBooks compoKey;
private float cost;
public Books(CompositeIdBooks compoKey, float cost){
this.compoKey = compoKey;
this.cost = cost;
}
}
Accessing entity using composite key…
Books.CompositeIdBooks bookKey1 = new Books.CompositeIdBooks(3, "AB124");
Books book1 = new Books(bookKey1, 1236.00f);
session.save(book1);
© Onkar Deshpande

Key equality.
 Emp emp2 = (Emp) session.load( Emp.class, 7499 );
 Emp emp3 = (Emp) session.load( Emp.class, 7499 );
System.out.println("Returning cached
object:"+emp2.hashCode()+" "+emp3.hashCode());
 System.out.println(session.getIdentifier(emp2));
 System.out.println(session.getIdentifier(emp3));
© Onkar Deshpande

Module 5. More mapping concepts
 Overview
 The paradigm mismatch- Granularity OOPs Vs. RDBMS
 Matching fine-granularity
 Matching objects’ inheritance structure with tables
 Mapping collections of value type
© Onkar Deshpande

Granularity matching
public class User {
private int userId;
private String userName;
private Address billingAddress;
private Address homeAddress;
………….
}
public class Address {
private String street;
private String city;
private String pin;
private User user;
……………
}
Table structure:
USER_ID number(5) not null,
USERNAME varchar2(15) not null,
HOME_STREET varchar2(10),
HOME_CITY varchar2(10),
HOME_PIN varchar2(6),
BILLING_STREET varchar2(10),
BILLING_CITY varchar2(10),
BILLING_PIN varchar2(6)
© Onkar Deshpande

Granularity matching (Contd...)
Mapping…
<class name="User" table="USERS">
<id name="id" column="USER_ID" type="integer">
</id>
<property name="userName" column="USERNAME" />
<component name="homeAddress" class="Address">
<parent name="user"/> // For bi-directional navigation.
<property name="street“ column="HOME_STREET" />
<property name="city" column="HOME_CITY" />
<property name="pin“ column="HOME_PIN" />
</component>
……
</class>
Loading of object…
User user = (User) session.load( User.class, 1 );
Navigation from User to Address to user:
user.getBillingAddress().getUser().getUserName());
© Onkar Deshpande

Mapping inheritance
 Approaches to represent inheritance hierarchy…
 Table per concrete class : Discards inheritance hierarchy and
polymorphism
 Table per class hierarchy: Enable polymorphism by de-normalizing
relational model.
 Table per sub class: Represents inheritance as a foreign key
relationship.
© Onkar Deshpande

The inheritance hierarchy
BankAccount
-accNo : int
-accNM : String
-accBal : float
SavingsAcc
-isSalAcc : boolean
CurrentAcc
-crLimit : float
© Onkar Deshpande

Table per
concrete class.
BankAcc
SavingsAcc CurrentAcc
Table: CCSavings
ACCNO number(4),
ACC_NM varchar2(15),
ACC_BAL number(8,2),
IS_SALACC number(1),
CONSTRAINT pk_accno_ccsavings PRIMARY KEY (ACCNO)
Table: CCCurrent
ACCNO number(4),
CR_LIMIT number(8),
CONSTRAINT pk_accno_cccurrent PRIMARY KEY (ACCNO)
<class name="SavingsAcc" table="CCSavings">
<id name="accNo" column="ACCNO" type="integer">
……
<property name="accNm" column="ACC_NM" type="string" />
…….
</class>
<class name="CurrentAcc" table="CCCurrent">
……
…….
</class>
© Onkar Deshpande

One table with
discriminator.
BankAcc
Table: CHAccounts
ACCNO number(4),
ACCTYPE varchar2(2),
CR_LIMIT number(8)
CONSTRAINT pk_accno_CHAccounts PRIMARY KEY (ACCNO)
<class name=“BankAcc" table="CHAccounts">
……
<discriminator column="ACCTYPE" type="string" not-null="true"/>
…….
<subclass name="SavingsAcc" discriminator-value="SA">
<property name="salAcc" column="IS_SALACC" type="boolean“/>
</subclass>
<subclass name="CurrentAcc" discriminator-value="CA">
<property name="crLimit" column = "CR_LIMIT" type="long”/>
</subclass>
© Onkar Deshpande

Table with part
Joins
BankAcc
Table: PJAccounts
ACCNO number(4),
ACCTYPE varchar2(2),
CONSTRAINT pk_accno_PJAccounts PRIMARY KEY (ACCNO)
Table: PJCurrent
CACCNO number(4),
CR_LIMIT number(8),
CONSTRAINT fk_bankAcc_pjcurrent FOREIGN KEY
(CACCNO) REFERENCES PJAccounts(ACCNO)
<class name=“BankAcc" table=“PJAccounts">
……
<discriminator column="ACCTYPE" type="string"/>
…….
<subclass name="SavingsAcc" discriminator-value="SA">
</subclass>
<subclass name="CurrentAcc" discriminator-value="CA">
<join table="PJCurrent">
<key column="CACCNO"></key>
<property name="crLimit" column = "CR_LIMIT" type="long“/>
</join>
</subclass>
…..
© Onkar Deshpande

Table with
subclass joins
BankAcc
Table: SCCurrent
CACCNO number(4),
CR_LIMIT number(8),
CONSTRAINT fk_bankAcc_Sccurrent
FOREIGN KEY (CACCNO)
REFERENCES SCAccounts(ACCNO)
Table: SCAccounts
ACCNO number(4),
CONSTRAINT pk_accno PRIMARY KEY (ACCNO)
Table: SCSavings
SACCNO number(4),
CONSTRAINT fk_bankAcc_Scsaving
FOREIGN KEY (SACCNO)
REFERENCES SCAccounts(ACCNO)
<class name="SavingsAcc" table="CCSavings">
……
…….
<joined-subclass name="SavingsAcc" table="SCSavings">
<key column="SACCNO“/> // Primary / Foreign key.
</joined-subclass>
<joined-subclass name="CurrentAcc" table="SCCurrent">
<key column="CACCNO“/> // Primary / Foreign key.
<property name="crLimit" column = "CR_LIMIT" type="long“/>
</joined-subclass>
……
© Onkar Deshpande

ITEM
ITEMID
Number(3)
NAME
Varchar2(15)
1 Almirah
2 Sofa
3 Tea top
4 Cane chair
Primary Key: ITEMID
Collections
 In some online shopping web site, an item may be displayed by showing multiple
images. To represent items, there should be a table holding multiple item
entities. For each item entity, there can be one or more images.
 The Item bean should have multiple references to ItemImage. These multiple
references can be in the form of TreeSet, HashSet, ArrayList, HashMap,
LinkedHashMap, TreeMap.
© Onkar Deshpande

Collections
 Set: A collection of unique entities. There are two
implementations…
 TreeSet: An ordered collection of unique entities.
 HashSet: An un-ordered collection of unique entities.
 Bag: An un-ordered collection of may be duplicate
entities. There is no equivalent of it in Java.
 List: An ordered collection of entities. Here order
specifies the order of adding entities in collection. It
allows duplicates.
 Map: An un-ordered collection of Key-Value pairs. It has
different implementations like… HashMap.
LinkedHashMap, TreeMap etc.
© Onkar Deshpande

ITEM
ITEMID
Number(3)
NAME
Varchar2(15)
1 Almirah
2 Sofa
3 Tea top
4 Cane chair
Primary key: ITEMID
ITEM_IMAGES
ITEMID
Number(3)
FILENAME
Varchar2(15)
1 Almira image1
1 Almira image2
1 Almira image3
3 Tea top image1
3 Tea top image2
4 Chair image3
FK: ITEMID on ITEMID of ITEM
Collections: Using Set
public class Item {
private int itemId;
private String itemName;
Set<String> images;
….
}
item.hbm.xml…
<set name="images" lazy="true" table="ITEM_IMAGES" sort="natural">
<key column="ITEMID"/>
<element type="string" column="FILENAME" not-null="true"/>
</set>
© Onkar Deshpande

ITEM
ITEMID
Number(3)
NAME
Varchar2(15)
1 Almirah
2 Sofa
ITEM_IMAGES
ITEM_IMAGES_SK
(Num(3))
ITEMID
Num(3)
FILENAME
Varchar2(15)
1 1 Almira image1
2 1 Almira image1
3 1 Almira image1
4 3 Tea top image1
5 3 Tea top image1
6 4 Chair image3
Collections: Using Bag
public class Item {
private int itemId;
List<String> images;
….
}
item.hbm.xml…
<idbag name="images" lazy="true" table="ITEM_IMAGES_SK">
<collection-id type="int" column="ITEM_IMAGES_SK">
</collection-id>
</idbag>
© Onkar Deshpande

ITEM
ITEMID
Number(3)
NAME
Varchar2(15)
1 Almirah
2 Sofa
ITEM_IMAGES
ITEMID
Num(3)
POSITION FILENAME
Varchar2(15)
1 0 Almira image1
1 1 Almira image1
1 2 Almira image1
3 0 Tea top image1
3 1 Tea top image1
4 0 Chair image3
Collections: Using List
public class Item {
private int itemId;
List<String> images;
….
}
item.hbm.xml…
<list name="images" lazy="true" table="ITEM_IMAGES_POSI">
<index column="POSITION"/>
</list>
© Onkar Deshpande

ITEM
ITEMID
Number(3)
NAME
Varchar2(15)
1 Almirah
2 Sofa
ITEM_IMAGES
ITEMID
Num(3)
IMAGENAME
(varchar2(15))
FILENAME
Varchar2(15)
1 FrontView Almira image1
1 SideView Almira image1
1 InnerView Almira image1
3 FrontView Tea top image1
3 SideView Tea top image1
4 FrontView Chair image3
public class Item {
private int itemId;
Map<String, String> images;
….
}
item.hbm.xml…
<map name="images" lazy="true" table="ITEM_IMAGES_MAP“ sort=“natural”>
<index column="IMAGENAME" type="string"/>
</map>
Collections: Using Map
© Onkar Deshpande

Module 6. The Association relations
 Overview
 The paradigm mismatch Association-OOPs and RDBMS
 The Association-Multiplicity-Navigation
 Understanding uni/bi-directional relationship
 The One-One relationship
 The One-many relationship
 The Many-Many relationship
 The Cascade clauses
© Onkar Deshpande

The Association
One to One Multiplicity
Emp Profile 1 1
One to Many Multiplicity
Emp Department 0...* 1
Many to Many Multiplicity
Emp Project 0…* 0…*
© Onkar Deshpande

The Association: One to One
public class Emp {
One to One Multiplicity
Emp Profile 1 1
private Integer empNo;
private String eName;
private String job;
// One to one towards Profile
private Profile profile;
// Association scaffolding code
public Profile getProfile() {
return profile;
}
public void setProfile(Profile profile) {
this.profile = profile;
}
}
public class Profile {
private int empId;
private String skills;
private String quali;
// One to one towards emp
private Emp emp;
public Emp getEmp() {
return emp;
}
public void setEmp(Emp emp) {
this.emp = emp;
}
}
© Onkar Deshpande

The Association: One to One (Contd...)
<class name="Emp" table="EMP">
<id name="empNo">
……
<property name="eName">
……
<one-to-one name="profile" // Name of setter method which executes association in Emp
class="Profile" // Name of a class of object which is being associated with Emp.
foreign-key="empId"// Name of a property in Profile which represents foreign key for Emp
/>
</class>
<class name="Profile" table=“PROFILES">
<id name="empId">
…..
<property name="skills">
…..

<one-to-one name="emp" // Name of a setter method which establishes association in Profile
class="Emp"// Name of a class of object which is being associated with Emp.
property-ref="profile" // Name of a property in Emp which establishes Emp -> Profile relation.
/>
</class>
© Onkar Deshpande

Cascade options
Cascade Description
none To ignore association
save-update Persist transient object and all associated objects. Update
association graph.
delete Delete all associated persistent instances.
all Cascade save-update, delete and evict and lock.
all-delete-orphan Like cascade all + deletes all de-referenced objects also.
delete-orphan Deletes all de-referenced objects also.

<one-to-one name="profile“ class="Profile"
foreign-key="empId" cascade=“save-update"
/>
© Onkar Deshpande

The Association: One to Many
public class Emp {
One to Many Multiplicity
Emp Department 0…* 1
private String job;
// One to one towards Profile
private Profile profile;
public Profile getProfile() {
return profile;
}
public void setProfile(Profile profile) {
this.profile = profile;
}
}
public class Dept {
private int deptNo;
private String deptNm;
private Set<Emp> emps; // One to Many
public Set<Emp> getEmps(){
return emps;
}
public void setEmps(Set<Emp> emps){
this.emps = emps;
}
public void addEmps(Emp emp){
emp.setDepartment(this);
emps.add(emp);
}
}
© Onkar Deshpande

The Association: One to Many (Contd...)
<hibernate-mapping package="com.hibernate.pack90_association.pack20_oneMany">
<id name="empNo" column="EMPNO" length="4">
<generator class="assigned" />
</id>
<property name="eName" column="ENAME" length="15" />
<property name="job" column="JOB" length="10" />
<many-to-one name="department" column="DEPTNO" class="Dept"
not-null="true" /> 
</class>
</hibernate-mapping>
© Onkar Deshpande

The Association: Many to Many
Many to Many Multiplicity
Emp Project 0…* 0…*
public class Emp {
private String job;
// Many to many towards Project
private Set<Project> projects;
public void setProjects(Set projects){
this.projects = projects;
}
public Projects getProjects(){
return projects;
}
}
public class Project {
private Integer projectId;
private String projectTitle;
// Many to Many towards Emp
private Set<Emp> emps;
public Set<Emp> getEmployees() {
return emps;
}
public void setEmployees(Set emps) {
this.emps = emps;
}
}
© Onkar Deshpande

The Association: Many to Many (Contd...)
<class name="Project" table="PROJECT">
<id name="projectId" column="PROJECTID">
…..
<property name="projectTitle" column="TITLE" />

<set name="employees“ table=" EMP_PROJECT ">
<key column="PROJECTID" />
<many-to-many class="Emp" column="EMPNO" />
</set>
</class>
<id name="empNo" column="EMPNO" length="4">
…….
<property name="eName" column="ENAME" length="15" />
<property name="job" column="JOB" length="10" />

<set name="projects“ table=" EMP_PROJECT ">
<key column="EMPNO" />
<many-to-many class="Project" column="PROJECTID" />
</set>
</class>
© Onkar Deshpande

Module 7. Hibernate Transaction support
 Overview
 Local and global transactions
 Transactions in JDBC
 Transactions in Hibernate
 Transactions in non-managed and managed environments
 Hibernate transaction API
 JTA and Container Managed Transaction.(CMT)
 Concurrency, locks and Isolation levels
© Onkar Deshpande

Transaction
Automatic steps
Step 1----------------
Step 2----------------
Step 3----------------
Step 4----------------
Step 5----------------
Step 6----------------
Step 7----------------
If any one step
is un-successful:
Do nothing
“Rollback”
Only if all steps
are successful:
Persist state of
all commands
Commit
Database
© Onkar Deshpande

Local transaction
 One service within a
single program accessing
single database.
 Transactions confined to
objects residing in one
particular JVM.
 The JDBC transaction on
a connection is Local.
Automatic steps
Step 1----------------
Step 2----------------
Step 3----------------
Step 4----------------
Step 5----------------
Step 6----------------
Step 7----------------
Database
© Onkar Deshpande

Global transaction
 Transaction
encapsulating object
which are distributed on
various JVMs.
 Transactions on more
than one resource
managers where these
managers are running on
different servers.
 A transaction with more
than one databases.
Automatic steps
Step 1----------------
Step 2----------------
Step 3----------------
Step 4----------------
Step 5----------------
Database Database
Server/JVM Server/JVM
© Onkar Deshpande

Transaction in JDBC.
To start a transaction bound to the connection.
connection.setAutoCommit(false);
To commit a transaction:
connection.commit();
To roll back a transaction:
connection.rollback();
Alternatives for ending transaction:
1. setAutoCommit to true if set to
false previously.
2. Commit a transaction
3. Rollback a transaction
4. If timeout occurs, transaction
rollsback.
Local transactions can be turned off by adding following property to URL...
disableLocalTxn=true
© Onkar Deshpande

Transaction in Hibernate
 Hibernate supports..
 JDBC transaction in non-managed environment
 JTA transaction in managed environment.
 Non-managed environment
 An environment, data source is not provided as a ready resource.
Ex. JDBC.
 The managed environment
 The environment manages connection, its pool and the data
source. Servers (Web or appl) provide managed environments.
 The Java Transaction API (JTA):
 Manages distributed transaction
 Allows declarative transaction
 Supports Container Managed Transaction (CMT)
© Onkar Deshpande

Hibernate Transaction API
<interface>
Transaction
CORBATransaction JDBCTransaction JTATransaction
© Onkar Deshpande

Hibernate Transaction API
 session.beginTransaction():
 In non-managed environment: Starts a new JDBC transaction.
 In managed environment: Starts new JTA transaction.
 begin(): Starts a new transaction
 commit(): Synchronizes session state with database.
 rollback(): Forces underlying transaction to roll back.
 isActive(): Is this transaction still active?
 wasCommitted(): Check if this transaction was successfully
committed.
 wasRolledBack(): Was this transaction rolled back or set to
roll back?
 setTimeOut(int timeInSeconds): Sets the transaction time
out.
© Onkar Deshpande

Trasactional Attributes
 Required
 RequiresNew
 Mandatory
 Supports
 NotSupported
 Never
© Onkar Deshpande

Transactional Attributes
The Required (Default) attribute
The declared method must be invoked within the scope of the transaction.
Client (T1) T1
Client T1
Runs in propagated transaction T1
Runs in New transaction T1
The RequiredNew attribute
The declared method must be invoked always in new transaction.
Client (T1) T1
Client T1
Runs in New transaction T1
© Onkar Deshpande

The Supports attribute
The declared method is included in transaction scope if invoked within a
transaction.
Client (T1) T1
Client Method
Runs without transaction
The NotSupported attribute
The declared method when invoked within transaction scope, suspends
transaction until method completes
Client (T1) Method Runs without transaction
© Onkar Deshpande

The Mandatory attribute
The declared method is included in transaction scope if invoked within a transaction
Client (T1) T1
Client Method
Throws exception when run
without transaction.
The Never attribute
The declared method must never be invoked in any
Client (T1) T1
Client Method
Throws exception when run
within transaction
Runs without transaction
© Onkar Deshpande

Isolation Levels
Isolation levels and their values
Read Uncommitted 1
Read Committed 2
Repeatable Read 4
Serializable 8
 Every JDBC connection uses database default value of
isolation.
 Explicit setting of isolation level can be done by
introducing following entry into cfg file.
 hibernate.connection.isolation=2
© Onkar Deshpande

Locking
 A mechanism that prevents concurrent access to the
particular item of data.
 A transaction has to acquire a lock for reading or
modifying the item.
 Types of locks:
 Pessimistic
 Optimistic
© Onkar Deshpande

Pessimistic Locks
 It is acquired when item of data is read and held until
transaction is completed.
 Some databases allow locking with Select – For Update
clause.
 Hibernate’s different lock modes...
 LockMode.NONE
 LockMode.READ
 LockMode.UPGRADE
 LockMode.UPGRADE_NOWAIT
 Category cat = (Category) session.get(Category.class, catId,
LockMode.UPGRADE);
 It loads category with Select…For Update and locks the
retrieved row until transaction ends.
© Onkar Deshpande

Pessimistic Locks
 Except NONE all lock modes makes hibernate to go to
DB.
 The load() and get() by default uses LockMode.NONE.
 The LockMode.READ needs on detached object with
lock() to check version of corresponding row.
 The LockMode.UPGRADE locks a row at DB side
thereby hampering scalability.
 The strict locking at application side hampers
performance of other applications.
© Onkar Deshpande

Optimistic Locks
An additional column in table for Version or TimeStamp managed automatically by
hibernate every time object is modified
public class Item {
-------
int version;
public int getVersion(){
return version;
}
public void setVersion(int v){
this.version = v;
}
OR
Date timeStamp;
public void setLastUpdateDateTime(Date dt){
this.timeStamp = dt;
}
public Date getLast…
}
<class name=“item” table=“ITEM”>
<id>…</id>
<version name=“version” column=“VERSION” />
</class>
OR
<class name=“item” table=“ITEM”>
<id>…</id>
<timestamp name=“lastUpdateDateTime”
column=“UPDATE_DATE” />
</class>
© Onkar Deshpande

Module 8. Queries in Hibernate
 Overview
 Object retrieving
 Why HQL?
 Working with HQL
 Working with Native queries
 Working with Criteria queries
© Onkar Deshpande

Retrieving Objects
 Navigating object graph.
 aUser.getAddress().getCity()
 Retrieving by identifier.
 User user = (User) session.get(User.class, userId);
 Using Hibernate Query Language (HQL)
 String qry = “from Emp e order by e.job asc, e.sal desc”;
 List<Emp> empList = session.createQuery(qry );
 Using Criteria API
 Criterion restriction = Expression.eq("empNo", 7499);
 Emp emp = (Emp) session.createCriteria(Emp.class).add( restriction ).uniqueResult();
 Using Query By Example (QBE)
 QueryOnEmp queryByExample = new QueryOnEmp();
 queryByExample.seteName("J%");
 queryByExample.setJob("MANAGER");
 String queryString_HQL = "from Emp emp where emp.eName like :ename and emp.job like :job";
 List<Emp> emps = session.createQuery(queryString_HQL).setProperties(queryByExample).list();
 Using Native Query Language (NQL)
 String qry = “select {i.*} from EMP {i} order by JOB asc, SAL desc”;
 List<Emp> empList = session.createSQLQuery(qry );
© Onkar Deshpande

Hibernate Query Language
 Query to get all employees from table.
 Query qryForAllEmployees = session.createQuery("from Emp");
 List<Emp> empList = qryForAllEmployees.list();
 Query to get objects in pages in given order.
 String qry = “from Emp e order by e.job asc, e.sal desc”;
 Query qryForAllEmployees = session.createQuery(qry);
 qryForAllEmployees.setFirstResult(0);
 qryForAllEmployees.setMaxResults(5);
 Query for unique result. Using positional parameters, Binding
parameters
 Emp emp = (Emp) session.createQuery("from Emp e where e.empNo =
?").setInteger(0, 7499).uniqueResult();
 Query for list with named parameters
 List<Emp> empList = session.createQuery("from Emp e where e.eName like
:name").setString( “A%”, eName,).list();
© Onkar Deshpande

Hibernate Query Language (Contd...)
 Query for property value ‘null’
 List<Emp> emps = session.createQuery("from Emp as e where e.mgr is null").list();
 Query with between clause
 Query qryForAllEmployees = session.createQuery("from Emp where empNo
between :vl1 and vl2").setInteger(“vl1”, 7500).setInteger(“vl2”, 8000);
 Query with ‘in’ clause…
 from Emp where empNo in (7369, 7499)
 Query with logical operators
 from Emp where eName like :name And job like :job
 from Emp where eName like :name Or job like :job.
 Writing group queries.
 select count(*) from Emp
 select sum(sal) from Emp
© Onkar Deshpande

Criteria Queries
 Criteria for all employees
 Criteria qryForAllEmployees = session.createCriteria(Emp.class);
 Criteria to get objects in pages in given order.
 List<Emp> empList = session.createCriteria(Emp.class)
 .addOrder( Order.asc("job") )
 .addOrder( Order.desc("sal"))
 .setFirstResult(0)
 .setMaxResults(5)
 .list();.
 Criteria for unique result. Binding parameters
 Criterion restriction = Expression.eq("empNo", 7499);
 Emp emp = (Emp) session.createCriteria(Emp.class).add( restriction ).uniqueResult();
 Criteria for list with named parameters
 .add(Expression.ilike("J%“, "eName")).list();
© Onkar Deshpande

Criteria Queries (Contd...)
 Criteria with restriction on value ‘null’
 List<Emp> emps = session.createCriteria(Emp.class).add(Expression.isNull("mgr")).list();
 Criterion for between and in clauses.
 Criterion restriction = Expression.between("empNo", 7800, 7900);
 Criterion restriction = Expression.in("empNo", new Object[]{7369, 7499});
 Criteria query with logical operators- And
 Criterion restriction1 = Expression.like("eName", "J%");
 Criterion restriction2 = Expression.like("job", "MANAGER");
 .add(restriction1)
 .list();
 Criteria with restriction with complex boolean expression.
 Criterion restriction1 = Expression.like("eName", "J%");
 Criterion restriction2 = Expression.like("job", "MANAGER");
 Criterion restriction3 = Expression.or(restriction1, restriction2);
 Criterion restriction4 = Expression.gt("sal", 2500f);
 Criterion restriction5 = Expression.and(restriction3, restriction4);
 .list();
© Onkar Deshpande

Native Query Language
 Query to get all employees from table.
 SQLQuery qryForAllEmployees = session.createSQLQuery("select {i.*} from EMP
{i}");
 List<Emp> empList = qryForAllEmployees.addEntity("i", Emp.class).list()
 Query to get objects in pages in given order.
 String qry = “select {i.*} from EMP {i} order by JOB asc, SAL desc"
 List<Emp> empList= session.createSQLQuery(qry )
 .addEntity("i", Emp.class)
 .setFirstResult(0)
 .setMaxResults(5).list();
 Query for unique result. Using positional parameters, Binding parameters
 String qry = “select {i.*} from EMP {i} where EMPNO like ?"
 Emp emp = (Emp) session.createSQLQuery(qry )
 .setInteger(0, 7499).uniqueResult();
© Onkar Deshpande

Native Query Language (Contd...)
 Query for list with named parameters
 String qry = “select {i.*} from EMP {i} where EMPNO like :empNo”;
 Emp emp = (Emp) session.createSQLQuery(qry)
 .setInteger("empNo", 7499).uniqueResult();
 Query for property value ‘null’
 select {i.*} from EMP {i} where MGR is null
 Query with between and in clause
 select {i.*} from EMP {i} where EMPNO between :val1 and :val2
 select {i.*} from EMP {i} where EMPNO in (:val1, :val2)
© Onkar Deshpande

Module 9. Advanced queries
 Overview
 Query by example
 Named queries
 Report queries
 Fetching strategies and joins
© Onkar Deshpande

Query by example
public class QueryOnEmp {
private String ename;
private String job;
public String geteName() { return ename; }
public void seteName(String ename) { this.ename = ename; }
public String getJob() { return job; }
public void setJob(String job) { this.job = job; }
}
QueryOnEmp queryByExample = new QueryOnEmp();
queryByExample.seteName("J%");
queryByExample.setJob("MANAGER");
© Onkar Deshpande

Report Queries
 Projection with Object array
String qry = "select emp.empNo, emp.eName, emp.sal from Emp emp";
Iterator i = session.createQuery(qry) list().iterator();
while ( i.hasNext() ) {
Object[] row = (Object[]) i.next();
Integer empNo = (Integer) row[0];
String eName = (String) row[1];
Float sal = (Float) row[2];
System.out.println("Number:"+empNo+"tName:"+eName+"tSal:"+sal);
}
 Projection with dynamic instantiation.
String qry = "select new EmpRow(e.empNo, e.eName, e.sal) from Emp e";
Iterator i = session.createQuery(qry).list().iterator();
while ( i.hasNext() ) {
EmpRow emp = (EmpRow) i.next();
System.out.println(emp);
}
© Onkar Deshpande

Named Queries
1. A technique to externalize query.
2. All queries to be accumulated in separate XML file.
3. The code is not cluttered up with queries.
4. Code identifies queries using their unique names.

<query name="findEmpsByName-HQL">
<![CDATA[from Emp emp where emp.eName like :name]]>
</query>
<sql-query name="findEmpsByName-SQL">
<![CDATA[select {i.*} from EMP {i} where ENAME like :name]]>
<return alias="i" class="Emp"/>
</sql-query>
List<Emp> empList = session.getNamedQuery("findEmpsByName-SQL")
.setString("name", "J%").list();
List<Emp> empList = session.getNamedQuery("findEmpsByName-HQL")
.setString("name", "J%").list();
© Onkar Deshpande

Joins
 Inner Joins: All items that have bids
 Left outer Joins: All items with their bids and also items
without bids.
 Right Joins: All items with their bids and all bids which are
not on any item (Not applicable here).
 Theta style joins:
 Implicit Joins Uses multiple property paths for expressing implicit
associations or querying components.
Item
Bid bids
//Setter
//getter
Bid
Item item
//Setter
//getter
1 0..*
© Onkar Deshpande

Joins
Inner Joins
Select bid from Bid bid inner join bid.item
OR
Select bid from Bid bid join bid.item
select i.name, b.bid_id, from Bids b join Items i on i.item_id = b.item_id
Outer Joins:
Select bid from Bid bid left join fetch bid.item
Select bid from Bid bid left outer join bid.item
Select bid from Bid bid right outer join bid.item;
select i.name, b.bid_id, from Bids b left join Items i on i.item_id = b.item_id
select i.name, b.bid_id, from Bids b right join Items i on i.item_id = b.item_id
© Onkar Deshpande

Joins
Implicit Joins
Select bid from Bid bid where bid.item.itemId!=1
Select bid from Bid bid where bid.item.itemId is null
select i.name, b.bid_id from Bids b join Items i on i.item_id = b.item_id where
i.item_id is null;
Implicit Joins
Select bid from Bid bid where bid.item.itemId!=1
Select bid from Bid bid where bid.item.itemId is null
Theta style Joins:
Select i.name, b.bidId from Item i, Bid b where bid.bidId > 5
from Item, Bid // Gives Cartesian product
Criteria doesn’t provide Theta style joins and Cartesian product.
Hibernate does not support outer join on two tables which are not associated.
© Onkar Deshpande

Fetching
Types of fetching
• Immediate
• Lazy
• Eager
• Batch
• Its normal practice to define lazy fetching in mapping files.
• In the code, ‘fetch’ keyword overrides lazy fetching. Thus
code decides the fetching strategy.
select i.name, b.bid_id, from Bids b join fetch Items i on i.item_id = b.item_id
select i.name, b.bid_id, from Bids b left join fetch Items i on i.item_id = b.item_id
select i.name, b.bid_id, from Bids b right join fetch Items i on i.item_id = b.item_id
© Onkar Deshpande

Module 10. More on Hibernate
 Overview
 Automating naming conventions.
 Dynamic alterations to context
 Connection pooling
 Hibernate in web application
 Building database structure through Mapping files.
 Caching support in Hibernate.
 Using Log4J with Simple Logger Facad.
 Hibernate in Spring
© Onkar Deshpande

Naming Convensions
The emb.hbm.xml
<class name="Emp">
<id name="empNo" >
</id>
<property name="eName" />
<property name="sal" l/>
…….
</class>
Building Session
SessionFactory sessions = new Configuration()
.configure(relativePathToConfig)
.setNamingStrategy( new PRConvensions() )
.buildSessionFactory();
Code referring Emp
Query queryForEmps = session.createQuery("from Emp");
List<Emp> empList = queryForEmps.list();
for(Emp emp : empList){
System.out.println(emp);
}
© Onkar Deshpande

Naming Convensions (Contd...)
public class PRConvensions implements NamingStrategy {
private String className;
public String tableName(String tableName) {
return "PR_" + tableName;
}
public String classToTableName(String className) {
this.className = StringHelper.unqualify(className).toUpperCase();
return tableName( this.className );
}
public String propertyToColumnName(String propertyName) {
return className+"_"+propertyName.toUpperCase();
}
public String propertyToTableName(String className, String propertyName) {
return classToTableName(className) + '_'
+propertyToColumnName(propertyName);
}
public String columnName(String columnName) {
return "PR_"+columnName;
}
© Onkar Deshpande

Dynamic Context manipulation
Configuration cfg = new Configuration().configure(relativePathToConfig);
// Get the existing mapping for User from Configuration
PersistentClass userMapping = cfg.getClassMapping("pack950_moreHiber.pack20_dynaMetadata.Emp");
// Define a new column for the EMP table
Column column = new Column();
column.setSqlType("varchar2");
column.setName("EMP_MOTTO");
column.setNullable(true);
column.setUnique(false);
Table table = userMapping.getTable();
able.addColumn(column);
// Wrap the column in a Value
SimpleValue value = new SimpleValue(null, null);
value.setTable( userMapping.getTable() );
value.addColumn(column);
value.setTypeName("string");
// Define a new property of the User class
Property prop = new Property();
prop.setValue(value);
prop.setName("motto");
prop.setNodeName("motto");
userMapping.addProperty(prop);
© Onkar Deshpande

Connection Pooling
Why Connection pools?
• Acquiring new connection is expensive
• Maintaining many idle connections is expensive
• Creating prepared statements for some drivers is expensive
What is connection pool?
• Holds live connections. On demand supply them.
• Can automatically change pool size as per utilization of connections.
• Provides utmost scalability of connections.
• The DriverManager manages connections.
In managed environment
Connection pools and Driver Manager are created by environment and provided as a service to
all applications running under environment.
In non-managed environment
The third party tool can be used to avail feature. Hibernate has inbuilt support for C3P0.
Hibernate Configuration…
<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.timeout">300</property>
<property name="hibernate.c3p0.max_statements">50</property>
<property name="hibernate.c3p0.idle_test_period">3000</property>
© Onkar Deshpande

Hibernate in web application
The SessionFactory: It is thread safe and cluster safe. Heavy weight.
Should be created once in an application.
The Session: Not thread safe. Execute its instance in single thread. Light
weight, should be created and destroyed in a method or for a request.
The PersistentUtil
private static final SessionFactory sessionFactory; // To create once
// Session and transaction for each request.
private static final ThreadLocal<Session> threadSession
= new ThreadLocal<Session>();
private static final ThreadLocal<Transaction> threadTransaction
= new ThreadLocal<Transaction>();
© Onkar Deshpande

Hibernate in web application
Getting a session:
Session session = sessionFactory.openSession();
threadSession.set(session);
Getting Transaction:
Transaction transaction = session.beginTransaction();
threadTransaction.set(transaction);
Committing or Rolling back Transaction
Transaction tx = threadTransaction.get();
if ( tx != null && !tx.wasCommitted() && !tx.wasRolledBack() ) {
tx.commit(); / tx.rollBack();
threadTransaction.set(null);
}
Closing Session
Session session = (Session) threadSession.get();
threadSession.set(null);
if (session != null && session.isOpen())
session.close();
© Onkar Deshpande

Table structure from mapping files.
 Its an approach of development where entities are
identified as classes and from mapping file, Hibernate
creates a table structure with all necessary associations
and inheritance.
 Hibernate does not support creating classes from table
structure (iBatis supports).
 The cfg file.
 <property name="hibernate.hbm2ddl.auto">update</property>
 If hibernate finds that table is existing but with
mismatch in fields with table, columns are altered in
table.
© Onkar Deshpande

Caching support in Hibernate.
 There are two levels of caching…
 Transactional Cache/First level cache provided by Hibernate
Session.
 Global Cache/Second level cache provided by Cache provider.
 All transient objects are entitled for caching.
 By default hibernate queries always ignore cache.
 If second level cache is enabled, FLC contents are written to
SLC.
 The query is cached only if it is explicitly cached.
 To explicitly cache query, Query interface has method
setCacheable();
 The SessionFactory has special API to view IInd level cache
statistic.
© Onkar Deshpande

Caching support in Hibernate.
 Enabling IInd level cache.
 hibernate.cache.use_second_level_cache = true
 hibernate.cache.use_query_cache = true
 hibernate.cache.provider_class = et.sf.hibernate.cache.QueryCache
 Third party IInd level cache.
 EhCache, TerraCota, TreeCache, SwarmCache, oscache
© Onkar Deshpande

Hibernate in Nutshell

More Related Content

What's hot (19)

Similar to Hibernate in Nutshell (20)

Recently uploaded (20)

Hibernate in Nutshell

Editor's Notes