Welcome To The

H World of
I
B Hibernation - 3.0
E
R
N
A
T
E Praveen Soni
Development Center
A-Wing,Level 6,Tower X, Cybercity
Magarpatta City
Hadapsar
Pune-411028 (M.H), India
Tel : 91-20-66088000-01

[1]
 Agenda
•Problem in programming Relational DBs
•Problem with EJB
H
I •Hibernate Solution
B
E
•What is Hibernate
R •Features of Hibernate
N
A •Hibernate Architecture
T
E •Persistence Life Cycle
•Core interfaces in hibernate

[2]
 Agenda
•What is ORM
•Features of ORM
H
I
•Configuration of Hibernate.cfg.xml
B •Writing POJO Class
E
R •Basic O/R Mapping
N
A •Inheritance Mapping
T
E
•Component Mapping
•Association Mapping
•Collections Mapping
[3]
 Problem Programming to Relational DBs
What do relational DBs do well?

• Work with large amounts of data

– Searching, sorting
H
I • Work with sets of data
B – Joining, aggregating
E
R • Sharing
N – Concurrency (Transactions)
A – Many applications
T
E • Integrity
– Constraints
– Transaction isolation

[4]
 Problem Programming to Relational DBs
What do relational DBs do badly?
• Modeling
– No polymorphism / inheritance
H – No support for automatic conversion to objects
I
B • Business logic
E – There’s stored procedures, but:
R • Very database specific
N • Very coupled with the data, really belongs in the application
domain
A
T
• Transaction
E
– No concept of application level transactions

[5]
 Problem with EJB
EJB the answer?

• EJB spec tried to bridge the gap between programming

and interacting with relational dbs
H
I
• EJB provides:
B
– Basic persistence (CMP)
E
R – Method-level transaction management
N
A – Automatic management of associations
T
E – EJBQL provides a very basic object query language

[6]
 Problems with EJB
• Noisy Programming model
– Inheritance from javax.ejb
– Interface / Implementation required but do we really need interfaces of our entity beans
– Complex deployment descriptors
H – Weird combo of checked / unchecked exceptions
I
• No Polymorphism
B
E • Can’t Test Outside Container
R – For example, in JUnit
N – Why not?
A • Home is an interface
T • Relationships/instantiation done by container
E • EJBQL too limited – none of:
– Aggregation/projection for reporting
– Outer-join fetching
– Pagination
– Dynamic queries

[7]
 The Hibernate Solution

• Hibernate is a persistence framework aimed at solving the shortcomings

presented by EJB2.

H • Persistence classes (entities) are POJOs

I – Easy to write and refactor
– Can be serialized
B
– Can execute outside of the container (JUnit)
E – Eg.
R public class Book {
N private Author author;
A
T public Author getAuthor()…
E public void setAuthor(….
}

[8]
 The Hibernate Solution (cont.)
• POJO programming model
– Persistent properties are not abstract
– Can instantiate POJOS using new()
H – Detached from persistence layer
I
B • No Home Interface
E – Generic Session interface is provided for persistence operations
R – May write own DAO
N
A • No method-level transactions for entities
T – Rather emphasize transactions at the business level
E
• Truly object-oriented
– Polymorphic associations and queries
– Three inheritance mapping strategies

[9]
 What is HIBERNATE ??

 Hibernate is an object-relational mapping (ORM) library for the Java

language, providing a framework for mapping an object-oriented domain
H model to a traditional relational database.
I
B  Hibernate solves Object-Relational impedance mismatch problems by
E replacing direct persistence-related database accesses with high-level
R object handling functions.
N
A
T
E

[10]
 What is HIBERNATE ??
• Its an ORM tool.

• Supports Data retrieval and update

H
• Transaction management
I
B • Database connection pooling
E
R • Programmatic as well as declarative queries
N
• Declarative entity relationship management
A
T • Provides support for collections and object relations
E
• Supports numerous databases, including Oracle and DB2

• Improved Performance

[11]
 Features of Hibernate

• Integrates elegantly with all popular J2EE application servers, Web

containers and in standalone applications.
H
• Support fine grained Object model
I
B • Transparent Persistence(No build time bye code enhancement)
E
R • Free/open source.
N • Natural programming model.
A
T • Database independent.
E
• The query language.

[12]
 Architecture of Hibernate
A (very) high-level view of the Hibernate architecture:

H
I
B
E
R
N
A
T
E

[13]
 Components of Hibernate Architecture

• Connection management:
Connection management service provide efficient management of the database
connections. Database connection is the most expensive part of interacting with the
H database as it requires a lot of resources of open and close the database connection.
I
B •
Transaction Management:
E Transaction management service provide the ability to the user to execute more
R than one database statements at a time.
N
A
• Object Relational Mapping:
T
Object relational mapping is technique of mapping the data representation from an
E object model to a relational data model. This part of the hibernate is used to select, insert,
update and delete the records form the underlying table.

[14]
 Lite Architecture
It is called "Lite" architecture when we only uses the object relational mapping
component.

H
I
B
E
R
N
A
T
E

[15]
 Full Cream Architecture
In "Full Cream" architecture all the three component Object Relational mapping,
Connection Management and Transaction Management) are used.

H
I
B
E
R
N
A
T
E

[16]
 The Persistence Life-Cycle
An instance of a persistent class may be in one of three different states, which are
defined with respect to a persistence context. The Hibernate Session object is the
persistence context:

H  transient
I The instance is not, and has never been associated with any persistence context. It has no persistent
identity(primary key value).
B
E  persistent
R The instance is currently associated with a persistence context. It has a persistent identity (primary
N key value) and, perhaps, a corresponding row in the database. For a particular persistence context,
Hibernate guarantees that persistent identity is equivalent to Java identity (in-memory location of
A the object).
T
E  detached
The instance was once associated with a persistence context, but that context was closed, or the
instance was serialized to another process. It has a persistent identity and, perhaps, a corresponding
row in the database. For detached instances, Hibernate makes no guarantees about the relationship between
persistent identity and Java identity.

[17]
 The Persistence Life-Cycle

H
I
B
E
R
N
A
T
E

[18]
 Core Interfaces in Hibernate

Session interface

 Session interface is primary interface use by hibernate applications.

H  An instance of session is lightweight and inexpensive to create and destroy.
I
B  not thread safe
E
R SessionFactory interface
N  Application get instance of session from SessionFactory .
A
T  Not light weighted.
E
 Thread safe

 Single session factory for whole application

 If application access multiple database then for one database one session factory.
[19]
 Core Interfaces in Hibernate
Configuration interface
 Application get instance of SessionFactory from Configuration .
 Configuration Object is use to configure and bootstrap hibernate.
 Application use configuration instance to specify the location of mapping docs and hibernate
H
I specific properties.

B Transaction interface
E
R  Application get an instance of Transaction from Session.

N  Transaction abstract application code from underlying transaction implementation i.e.

A (JDBC,JTA,CORBA transaction)
T
E Query and Criteria interface

 The query interface allowed you to perform queries against the database and control how the
query is executed.

 Criteria interface allow user to create and execute object oriented criteria Queries.
[20]
 What is ORM?

 Object-relational mapping is a programming technique for converting

data between incompatible type systems in relational databases and object-
H oriented programming languages.
I
B  This creates, in effect, a "virtual object database" which can be used from
E within the programming language. There are both free and commercial
R packages available that perform object-relational mapping, although some
N programmers opt to create their own ORM tools.
A
T
E

[21]
 What is ORM?
(Cont..)
 Object relation mapping is the automated persistence of objects in

java application to the table in a relational database, using metadata

H
I that describe mapping between object and the database.
B
E
R
N  Using ORM we can not only store Entire object graph in database
A
but also retrieve same as and when required.
T
E

 ORM help us to Bridge gap between two different paradigms.

[22]
 Feature of ORM

H Productivity
I
B Maintainability
E
R
N
Performance
A
T Vendor independence
E
Flexible mapping

[23]
 How to configure hibernate.cfg.xml
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
H
I <property
name="connection.driver_class">com.microsoft.jdbc.sqlserver.SQLServerDriver</property>
B <property
name="connection.url">jdbc:microsoft:sqlserver://10.7.100.146:143;databasename=YashTraining</
E property>
R <property name="connection.username">trainingyash</property>
<property name="connection.password">trainingyash</property>
N <!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
A <property name="dialect">org.hibernate.dialect.SQLServerDialect</property>
T <!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
E <!—create-drop,create,update the database schema on startup -->
<property name="hbm2ddl.auto">update</property>
<mapping resource="HighScore.hbm.xml"/>
<mapping resource="GameScore.hbm.xml"/>
 
</session-factory>
</hibernate-configuration>

[24]
 Hibernate JDBC Properties

Property name Purpose

H hibernate.connection.driver_class jdbc driver class

I
B hibernate.connection.url jdbc URL
E
R
N hibernate.connection.username database user

A
T hibernate.connection.password database user password
E
hibernate.connection.pool_size maximum number of pooled connections

[25]
 Hibernate Datasource Properties
• For use inside an application server, Hibernate may obtain connections from a javax.sql.Datasource registered
in JNDI.

• Set the following properties

H Property name Purpose

I
B hibernate.connection.datasource datasource JNDI name
E
R
hibernate.jndi.url URL of the JNDI provider (optional)
N
A
T hibernate.jndi.class class of the JNDI InitialContextFactory (optional)

E
hibernate.connection.username database user (optional)

hibernate.connection.password database user password (optional)

[26]
 Programmatic Configuration of Hibernate

Creating SessionFactory
 
Configuration cfg = new Configuration();
cfg.addResource("hello/Message.hbm.xml");
cfg.setProperties( System.getProperties() );
H SessionFactory sessions = cfg.buildSessionFactory();
I  
 Alternate approach to load mapping file is to load classes by calling addClass(class name) method.
B  
SessionFactory sessions = new Configuration()
E .addClass(org.hibernate.auction.model.Item.class)
R .addClass(org.hibernate.auction.model.Category.class)
.addClass(org.hibernate.auction.model.Bid.class)
N .setProperties( System.getProperties() )
.buildSessionFactory();
A  
T  The addClass() method assumes that the name of the mapping file ends with the .hbm.xml extension and is deployed along with the
mapped class file.
E   
 We can connect to multiple database through hibernate by creating separate instance of SessionFactory through the following
way.
SessionFactory sessions = new Configuration()
.configure("/hibernate-config/auction.cfg.xml")
.buildSessionFactory();

[27]
 Basic jar file which is required to run hibernate
+ lib

antlr.jar

cglib-full.jar
H
asm.jar
I
B asm-attrs.jar
E
commons-collections.jar
R
N commons-logging.jar
A hibernate3.jar
T
jta.jar
E
dom4j.jar

log4j.jar

and Database Driver.jar

[28]
 Writing POJO (Plain old java object) Point to remember while writing POJO.
 
POJO class must implements serializable interface. (optional)
-- when objects are stored in an HttpSession or passed by value using RMI, serialization is necessary.

H No argument constructor must be their.

-- All persistent classes must have a default constructor (which may be nonpublic) so Hibernate can instantiate
I them using Constructor.newInstance().
B
E
Declares accessor/mutator methods for all its persistent fields.
R  
N
Provide identifier property. (optional)
A -- identifier property map to primary key column of a database.it can be any primitive type or wrapper type.it Is
T optional however certain functionality of hibernate only support to class which declare identifier prop. Like
session.saveOrUpdate(), session.merge(), transitive reattachment of detached object.
E
 
Prefer non-final classes (optional)
-- if declared class is final or the methods in that class final then some functionality of hibernate like lazy loading
can not be achieved.
 
[29]
 Basic of O/R mapping
Hibernate-mapping
<hibernate-mapping
schema="schemaName" (1)
catalog="catalogName" (2)
default-cascade="cascade_style" (3)
H default-access="field|property|ClassName" (4)
default-lazy="true|false" (5)
I auto-import="true|false" (6)
B package="package.name" (7)
/>
E
(1) schema (optional): The name of a database schema.
R
(2) catalog (optional): The name of a database catalog.
N
(3) default-cascade (optional - defaults to none): A default cascade style.
A
(4) default-access (optional - defaults to property): The strategy Hibernate should use for accessing all
T
(5) default-lazy (optional - defaults to true): The default value for unspecified lazy attributes of class and collection
E
mappings.
(6) auto-import (optional - defaults to true): Specifies whether we can use unqualified class names (of classes in this
mapping) in the query language.
(7) package (optional): Specifies a package prefix to assume for unqualified class names in the mapping document.
[30]
 Basic of O/R mapping
Class
<class
name="ClassName" (1)
table="tableName" (2)
discriminator-value="discriminator_value" (3)
mutable="true|false" (4)
H schema="owner" (5)
I catalog="catalog" (6)
dynamic-update="true|false" (7)
B dynamic-insert="true|false" (8)
lazy="true|false" (9)
E />
R (1) name (optional): The fully qualified Java class name of the persistent class (or interface). If this attribute is missing, it is assumed that the
mapping is for a non-POJO entity.
N (2) table (optional - defaults to the unqualified class name): The name of its database table.
A (3) discriminator-value (optional - defaults to the class name): A value that distinguishes individual subclasses, used for polymorphic
behavior. Acceptable values include null and not null.
T (4) mutable (optional, defaults to true): Specifies that instances of the class are (not) mutable.
E (5) schema (optional): Override the schema name specified by the root <hibernate-mapping> element.
(6) catalog (optional): Override the catalog name specified by the root <hibernate-mapping> element.
(7) dynamic-update (optional, defaults to false): Specifies that UPDATE SQL should be generated at runtime and contain only those
columns whose values have changed.
(8) dynamic-insert (optional, defaults to false): Specifies that INSERT SQL should be generated at runtime and contain only the columns
whose values are not null.
(9) lazy (optional): Lazy fetching may be completely disabled by setting lazy="false".

[31]
 Basic of O/R mapping
Id
<id
name="propertyName" (1)
type="typename" (2)
column="column_name" (3)
unsaved-value="null|any|none|undefined|id_value“> (4)
H <generator class="generatorClass"/>
</id>
I
B
(1) name (optional): The name of the identifier property.
E
R (2) type (optional): A name that indicates the Hibernate type.
N
(3) column (optional - defaults to the property name): The name of the primary key column.
A
T (4) unsaved-value (optional - defaults to a "sensible" value): An identifier property value that indicates that an instance is

E newly instantiated (unsaved), distinguishing it from detached instances that were saved or loaded in a previous session.

[32]
 Basic of O/R mapping
Generator
The optional <generator> child element names a Java class used to generate unique
identifiers for instances of the persistent class.  
<generator class=”hilo”>
<param name="table">uid_table</param>
<param name="column">next_hi_value_column</param>
H </generator>
I  If any parameters are required to configure or initialize the generator instance, they are passed using the
B <param> element.
generator class value can be
E hilo,
R seqhilo,
N identity,
A sequence,
increment,
T uuid,
E guid,
native,
assigned,

foreign

[33]
 Basic of O/R mapping
property
  <property
name="propertyName" (1)
column="column_name" (2)
type="typename" (3)
update="true|false" (4)
H insert="true|false" (4)
formula="arbitrary SQL expression" (5)
I lazy="true|false" (6)
unique="true|false" (7)
B not-null="true|false" (8)
E />
(1) name: the name of the property, with an initial lowercase letter.
R (2) column (optional - defaults to the property name): the name of the mapped database table column. This may also be specified by nested
N <column> element(s).
A (3) type (optional): a name that indicates the Hibernate type.
T (4) update, insert (optional - defaults to true) : specifies that the mapped columns should be included in SQL UPDATE and/or INSERT

E statements. Setting both to false allows a pure "derived"

(5) formula (optional): an SQL expression that defines the value for a computed property. Computed properties do not have a column
mapping of their own.lazy (optional - defaults to false): Specifies that this property should be fetched lazily when the instance variable is
first accessed (requires build-time bytecode instrumentation).
(6) unique (optional): Enable the DDL generation of a unique constraint for the columns. Also, allow this to be the target of a property-ref.
(7) not-null (optional): Enable the DDL generation of a nullability constraint for the columns.
[34]
 Type of mapping supported by Hibernate

H Inheritance mapping
I
B Component mapping
E
R Association mapping
N
A Collection mapping
T
E

[35]
 Inheritance Mapping

The Three Strategies

Hibernate supports the three basic inheritance mapping strategies:
H
 table per class hierarchy
I
B  table per subclass

E  table per concrete class

R In addition, Hibernate supports a fourth, slightly different kind of
N polymorphism:
A
T 
implicit polymorphism
E

[36]
 Inheritance Mapping
Table Per class Hierarchy

Enable polymorphism by denormalizing the relational model and using a type discriminator column to hold type information
Suppose we have an interface Payment, with implementers CreditCardPayment, CashPayment, ChequePayment.
<class name="Payment" table="PAYMENT" discriminator-value="PAYMENT">
<id name="id" type="long" column="PAYMENT_ID">
H <generator class="native"/>
</id>
I <discriminator column="PAYMENT_TYPE" type="string"/>
<property name="amount" column="AMOUNT"/>
B ...
E <subclass name="CreditCardPayment" discriminator-value="CREDIT">
<property name="creditCardType" column="CCTYPE"/>
R ...
</subclass>
N <subclass name="CashPayment" discriminator-value="CASH">
A <property name="currencyType" column=" CURRENCY_TYPE "/>
...
T </subclass>
<subclass name="ChequePayment" discriminator-value="CHEQUE">
E <property name="chequeNumber" column=" CHEQUE_NO "/>
...
</subclass>
</class>
Exactly one table is required. There is one big limitation of this mapping strategy: columns declared by the subclasses, such as
CCTYPE, may not have NOT NULL constraints.
 

[37]
 Inheritance Mapping
Table Structure (Payment)

Payment_ID Payment_Amount Credit_Card_Type Currency_Type Cheque_No Paym

ent_ty
pe
H
I 1 10000 Null Null Null PAYM
B ENT

E
R 1 10000 10001 Null Null CRED
IT
N
A 1 10000 Null RS Null CASH
T
E 1 10000 Null Null 1234 CHEQ
UE

[38]
 Inheritance Mapping
Table Per Subclass
Represent “is a” (inheritance) relationships as “has a” (foreign key) relationships
A table per subclass mapping would look like:
  <class name="Payment" table="PAYMENT">
<id name="id" type="long" column="PAYMENT_ID">
<generator class="native"/>
H </id>
I <property name="amount" column="AMOUNT"/>
...
B <joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">
<key column="PAYMENT_ID"/>
E <property name="creditCardType" column="CCTYPE"/>
R ...
</joined-subclass>
N <joined-subclass name="CashPayment" table="CASH_PAYMENT">
<key column="PAYMENT_ID"/>
A <property name="currencyType" column="CURRENCY_TYPE"/>
T ...
</joined-subclass>
E <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
<key column="PAYMENT_ID"/>
<property name="chequeNo column="CHEQUE_NO"/>
</joined-subclass>
</class>
Four tables are required. The three-subclass tables have primary key associations to the super class table (so the\relational model is
actually a one-to-one association).

[39]
 Inheritance Mapping
Payment
Paymemt_id Payment_Amount
1 10000
2 30000
3 2000
H
I
B
Credit_Payment Credit_Card_no Paymemt_id
E
1001 2
R
N
A Cash_Payment Currency_id Paymemt_id

T Rs 1

E
Cheque_Payment Cheque_no Paymemt_id
2345 3

[40]
 Inheritance Mapping
Table per concrete class
Discard polymorphism and inheritance relationships completely from the relational model
The following are the mapping for Table per Concrete Class
  <class name="Payment" table="PAYMENT">
<id name="id" type="long" column="PAYMENT_ID">
H </id>
<generator class="native"/>

I <property name="amount" column="AMOUNT"/>

...
B <union-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">
E <property name="creditCardType" column="CCTYPE"/>
...
R </union-subclass>
<union-subclass name="CashPayment" table="CASH_PAYMENT">
N <property name="currencyType" column="CURRENCY_TYPE"/>
A ...
</union -subclass>
T <union -subclass name="ChequePayment" table="CHEQUE_PAYMENT">
<property name="chequeNo column="CHEQUE_NO"/>
E ………
</union -subclass>
</class>

Three tables are involved. Each table defines columns for all properties of the class, including inherited properties.

[41]
 Inheritance Mapping
Credit_Card_no Paymemt_id Payment_Amount
Credit_Payment
1001 2 10000

H Cash_Payment Currency_id Paymemt_id Payment_Amount

I Rs 1 2000
B
E Cheque_Payment Cheque_no Paymemt_id Payment_Amount
R 2345 3 5000
N
A limitation of this approach
T If a property is mapped on the superclass, the column name must be the same on all subclass tables.
E
The identity generator strategy is not allowed in union subclass inheritance, indeed the primary key seed has
to be shared accross all unioned subclasses of a hierarchy.

It doesn’t support polymorphism.

[42]
 Component Mapping
Dependent objects
A component is a contained object that is persisted as a value type, not an entity reference. The term "component" refers to the object-
oriented notion of composition
 
class Person.java
public class Person {
H private java.util.Date birthday;
I private Name name;
private Set personQualification =new HashSet();
B private Set personEmailAddresses=new HashSet();
private int id;
E }
R class Name.java
N public class Name {
char initial;
A String first;
T   }
String last;

E
class PersonQualification .java
public class PersonQualification {
private String collegeStudied = null;
private String qualification = null;
}

[43]
 Component Mapping
• Now Name may be persisted as a component of Person.Notice that doesn't need to declare any or identifier properties.
 
<class name="com.yash.hibernate.Person" table="person">
<id name="id" column="pid" type="int">
<generator class="increment"/>
</id>
H <property name="birthday" type="date"/>
I attribute optional -->
<component name="Name" class="com.yash.hibernate.Name"> <!-- class

B <parent name="namedPerson“ not-null=“true”/>

<property name="initial“ not-null=“true”/>
E <property name="first“ not-null=“true”/>
<property name="last“ not-null=“true”/>
R </component>
N </class>
 
A • The person table would have the columns pid, birthday, initial, first and last.
 
T • properties of a component may be of any Hibernate type (collections, many-to-one associations, other components etc)
E  
• The <component> element allows a <parent> subelement that maps a property of the component class as a reference back to the
containing entity.

[44]
 Component Mapping
Collections of dependent objects
Collections of components are supported. Declare your component collection by replacing the <element> tag with a <composite-element>
tag.
<set name="personQualifications" table="PersonQualifications" lazy="true">
<key column="id"/>
<composite-element class="com.yash.hibernate.PersonQualification"> <!-- class attribute required -->
H <property name="collegeStudied“ not-null=“true”/>
I <property name="qualification“ not-null=“true”/>
</composite-element>
B </set>
<set name="emailAddresses" table="PersonEmailAddresses">
E <key column="id" not-null="true"/>
R </set>
<element type="string" column="EMAIL_ADDRESS“ not-null=“true”/>

N  
 
A Composite elements may contain components but not collections. If your composite element itself contains components, use the
T <nested-composite-element> tag.
 
E Limitation of component mapping

-- Shared references aren’t possible.

-- There is no elegant way to represent a null reference to an Address.

[45]
 Association Mapping

Association

H
I
B Unidirectional Bi-Directional
E
R
N Many to
Many Many One One One
A To
One Many
To To To -------- To
T Many To
Many One One One to Many One
E Many

[46]
 Unidirectional Association Mapping (Many to One)

<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
H </id>
<many-to-one name=“address” column=“addressId” not-null=“true” />
I </class>
 
B <class name="Address">
E <id name=“id” column=“addressId”>
<generator class=“native” />
R </id>
</class>
N
A
Created Table Structure
T
E create table Person ( personId bigint not null primary key, addressId bigint not null )
 
create table Address ( addressId bigint not null primary key )

[47]
 Unidirectional Association Mapping (One to One)
A unidirectional one-to-one association on a foreign key is almost identical. The only difference is the column (unique constraint.)
 
<class name="Person">
<id name=“id” column=“personId”>
<generator class=“native” />
H </id>
<many-to-one name=“address” column=“addressId” unique=“true” not-null=“true” />
I </class>
B <class name="Address">
E <id name=“id” column=“addressId”>
<generator class=“native” />
R </id>
N </class>

A
Created Table Structure
T
E create table Person ( personId bigint not null primary key, addressId bigint not null unique )

create table Address ( addressId bigint not null primary key )

[48]
 Unidirectional Association Mapping (One to Many)
 
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
H <set name="addresses">
<key column="personId“ not-null="true"/>
I <one-to-many class="Address"/>
B </class>
</set>

E <class name="Address">
<id name="id" column="addressId">
R <generator class="native"/>
N </class>
</id>

A
T
E Created Table Structure

create table Person ( personId bigint not null primary key )

create table Address ( addressId bigint not null primary key, personId bigint not null references
person(personId))

[49]
 Unidirectional Association Mapping (Many to Many)
 <class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses" table="PersonAddress">
H <key column="personId"/>
<many-to-many column="addressId“ class="Address"/>
I </set>
B </class>
<class name="Address">
E <id name="id" column="addressId">
<generator class="native"/>
R </id>
N </class>

A Created Table Structure

T create table Person ( personId bigint not null primary key )
E create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key (personId))
create table Address ( addressId bigint not null primary key )

[50]
 Bi-directional Association Mapping

A bidirectional association allows navigation from both "ends" of the

association. Two kinds of bidirectional association are supported:
H
I
B
 one-to-many/many-to-one
E  set or bag valued at one end, single-valued at the other
R  many-to-many
N  set or bag valued at both ends
A
T
E

[51]
 Bi-directional Association Mapping (One to Many / Many to One)
A bidirectional many-to-one association is the most common kind of association. (This is the standard parent/child relationship.)

<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
H <set name="address" inverse="true">
<key column="personId"/>
I <one-to-many class="address"/>
B </class>
</set>

E <class name="Address">
<id name="id" column="addressId">
R <generator class="native"/>
N </id>
<many-to-one name="person“ column="personId“ not-null="true"/>
A </class>

T
E
create table Person ( personId bigint not null primary key )

create table Address ( addressId bigint not null primary key, personId references(person) );

[52]
 Bi-directional Association Mapping (Many to Many)
<class name="Person">
<id name="id" column="personId">
<generator class="native"/>
</id>
<set name="addresses">
<key column="personId"/>
H </set>
<many-to-many column="addressId“ class="Address"/>

I </class>
<class name="Address">
B <id name="id" column="addressId">
E </id>
<generator class="native"/>

R <set name="people" inverse="true">

<key column="addressId"/>
N <many-to-many column="personId“ class="Person"/>
A </class>
</set>

T
 
E create table Person ( personId bigint not null primary key )

create table PersonAddress ( personId bigint not null, addressId bigint not null, primary key
(personId,addressed))

create table Address ( addressId bigint not null primary key )

[53]
 Bi-directional Association Mapping (One to One)
one-to-one only applies to the shared primary key approach and that when you want to
use the foreign key approach you have to use many-to-one. with a unique constraint.

<class name="Person">
<id name="id" column="personId">
H <generator class="native"/>
</id>
I <many-to-one name="address“ column="addressId“ unique="true“ not-null="true"/>
B </class>
<class name="Address">
E <id name="id" column="addressId">
<generator class="native"/>
R </id>
N <one-to-one name="person“ property-ref="address"/>
</class>
A
T
E
create table Person ( personId bigint not null primary key, addressId bigint not null unique )

create table Address ( addressId bigint not null primary key )

[54]
 Bi-directional Association Mapping (One to One)

on primary key using special id generator

foreign: uses the identifier of another associated object. Usually used in conjunction
with a <one-to-one> primary key association.
H
I <class name="Person">
<id name="id" column="personId">
B <generator class="native"/>
</id>
E <one-to-one name="address"/>
R </class>
<class name="Address">
N <id name="id" column="personId">
<generator class="foreign">
A <param name="property">person</param>
T </id>
</generator>

E <one-to-one name="person“ constrained="true"/>

</class>
 
create table Person ( personId bigint not null primary key )
create table Address ( personId bigint not null primary key )

[55]
 Collection Mapping
 Hibernate Map Collections as value type and required persistent collection valued fields be
declared as an interface type.

H  Hibernate support following mapping

I Mapping of Set
B
E Mapping of idBag
R
N Mapping of List
A
T Mapping of Map
E
 Following are the attribute which are common for all mapping element like
<set>, <map>, <list>, <idbag>.

[56]
 Collection Mapping
<map
name=”propertyName” (1)
table=”table_name” (2)
schema=”schema_name” (3)
lazy=”true|false” (4)
inverse=”true|false” (5)
H cascade=”all|none|save-update|delete|all-delete-orphan” (6)
sort=”unsorted|natural|comparatorClass” (7)
I order-by=”column_name asc|desc” (8)
optimistic-lock=”true|false” (9)
B >
E <key …. />
<map-key …. />
R <element …. />
</map>
N (1) name the collection property name
A (2) table (optional – defaults to property name) the name of the collection table (not used for one-to-many associations)
(3) schema (optional) the name of a table schema to override the schema declared on the root element
T (4) lazy (optional – defaults to true) may be used to disable lazy fetching and specify that the association is always eagerly fetched (not
available for arrays)
E (5) inverse (optional – defaults to false) mark this collection as the “inverse” end of a i-directional association
(6) cascade (optional – defaults to none) enable operations to cascade to child entities
(7) sort (optional) specify a sorted collection with natural sort order, or a given comparator class
(8) order-by (optional, JDK1.4 only) specify a table column (or columns) that define the iteration order of the Map, Set or bag but not list,
together with an optional asc or desc
(9) access (optional – defaults to property): The strategy Hibernate should use for accessing the property value.

[57]
 Collection Mapping (Example)
Considering following example for all collection mapping demo

H
I
B
E
R
N
A
T
(Collection of Image components in Item)
E

[58]
 Mapping of Set

Point to be remember for set

 Set can’t contain duplicate element.

H
I
 Equals () and hashcode () must be override for comparison.
B
E
 For component mapping it is required to override equals() and hashcode() its help
R
N
hibernate for dirty checking although it is not mandatory.
A
T
 Not-null constraint must be true for all the composite elements.
E

[59]
 Mapping of Set

Mata data for set

 
<set name="images“ lazy="true“ table="ITEM_IMAGE" order-by="IMAGE_NAME asc">
<key column="ITEM_ID"/>
H <composite-element class="src.Image">
I <property name="name" column="IMAGE_NAME" not-null="true"/>
<property name="fileName" column="FILENAME" not-null="true"/>
B <property name="sizeX" column="SIZEX" not-null="true"/>
<property name="sizeY" column="SIZEY" not-null="true"/>
E </composite-element>
R </set>

N
A Table structure
T  
Item_table(Item_id,Item_name,Item_desc,price)
E Item_Image(Item_id,Image_name,File_Name,SizeX,SizeY)

 Item_id of Item_Image is foreign key of item_table

[60]
 Mapping of idBag

If your table doesn't have an index column, and you still wish to use List as the property type,

you should map the property as a Hibernate <bag>. A bag does not retain its order when it is

H retrieved from the database, but it may be optionally sorted or ordered.

I
B • Unordered collection that support duplicate element.
E
R • Its just like List but it is unordered.
N
• Composite element can contain null values.
A
T • Its an hibernate mapping collection mapping type
E
• We can use List in POJO for mapping bag.

• <idbag> mapping lets us attach a surrogate key column to the collection table

[61]
 Mapping of idBag

<idbag name="images“ lazy="true“ table="ITEM_IMAGE“ order-by="IMAGE_NAME asc">

<collection-id type="int" column="ITEM_IMAGE_ID">
<generator class="native"/>
</collection-id>
<key column="ITEM_ID"/>
H <composite-element class="src.Image">
I <property name="name" column="IMAGE_NAME"/>
<property name="fileName" column="FILENAME" not-null="true"/>
B <property name="sizeX" column="SIZEX"/>
<property name="sizeY" column="SIZEY"/>
E </composite-element>
R </idbag>
 
N  

A Table structure
T  
Item_table(Item_id,Item_name,Item_desc,price)
E Item_Image(Item_image_id,Item_id,Image_name,File_Name,SizeX,SizeY)
 
Item_id of Item_Image is foreign key of item_table

[62]
 Mapping of List

Ordered collection that support duplicate element.

H
I Required the addition of an index column to database table .Index column define position of
B
E
element in collection.
R
N
A List doesn’t support order-by attribute.
T
E

[63]
 Mapping of List
Metadata of List
  
<list name="images" lazy="true" table="ITEM_IMAGE">
<key column="ITEM_ID"/>
<index column="POSITION"/>
H <composite-element class="src.Image">
<property name="name" column="IMAGE_NAME"/>
I <property name="fileName" column="FILENAME" not-null="true"/>
B <property name="sizeX" column="SIZEX"/>
<property name="sizeY" column="SIZEY"/>
E </composite-element>
</list>
R  
N
A Table Structure
T  
E Item_table(Item_id,Item_name,Item_desc,price)
Item_Image(position,Item_id,Image_name,File_Name,SizeX,SizeY)
 
Item_id of Item_Image is foreign key of item_table

[64]
 Mapping of Map

H Store the value in form of key and Value

I
B Key and value both with be going to store in database
E
R Map is an unordered .
N
A Map can be sort base on natural order or based on implementation of comparator
T
E Key must be unique but value can be duplicated.

[65]
 Mapping of Map
Meta data for Map
 
<map name="images" lazy="true" table="ITEM_IMAGE" sort="src.ImageComparator">
<key column="ITEM_ID"/>
<map-key column="IMAGE_NAME" type="string"/>
H <composite-element class="src.Image">
<property name="fileName" column="FILENAME" not-null="true"/>
I <property name="sizeX" column="SIZEX"/>
<property name="sizeY" column="SIZEY"/>
B </composite-element>
E </map>
 
R
N Table Structure
 
A Item_table(Item_id,Item_name,Item_desc,price)
T Item_Image(Item_id,Image_name,File_Name,SizeX,SizeY)
E  
 Item_id of Item_Image is foreign key of item_table
 Primary key of Item_image is(item_id,Image_name)
 Image_name is key of Map

[66]
H
I
B
E
R
Thanking You!!
N
A
T
E

[67]