2010 05-21, object-relational mapping using hibernate v2

Copyright © 2007 Accenture. All rights reserved. Accenture, its logo, and High Performance Delivered are trademarks of Accenture.

Object / Relational Mapping Using Hibernate

Session Structure

• Introduction• Why Hibernate?• Architecture • Hibernate Basics• Example Application• Transactions• Object States• O / R Mappings• Hibernate Query Language (HQL)• Improving Performance• Alternatives to Hibernate• Q & A

2

Introduction

• This presentation will consist of some background information on Hibernate and some examples that show the basic functionality of Hibernate.

• Obviously, there is more than one way to use Hibernate.

3

Introduction: O / R Mismatch

O / R Mismatch • The correlation between object types to database tables is not usually

one to one. In examining the differences and mismatches between object and relational systems, explore the simple object model below.

4


5

• How should instances of objects in this model be persisted?

• Normalized for flexibility or denormalized for performance?• How do you decide? • What if the Customer database table existed before the object model?

What would you have to do to your class/object design?


• When working with object-oriented systems, there’s a mismatch between the object model and the relational database.

• How do we map one to the other?

6


• How to map associations between objects?– References are directional, foreign keys are not.– Foreign keys can’t represent many-to-many associations.

7

Introduction: Approaches to ORM• Why relational databases?

– Flexible and robust approach

to data management.– De-facto standard in software

development.• Why object-oriented models?

– Business logic can be implemented in

Java (opposed to stored procedures).– Allows for use of design patterns and

concepts like polymorphism.– Improves code reuse and maintainability.

• Demand for mapping interaction!8

Introduction: Approaches to ORM

• Use Java serialization – Write application state to a file– Can only be accessed as a whole– Not possible to access single objects

• Object-oriented database systems– No complete query language implementation exists– Lacks necessary features

9

Introduction: Preferred Solution

• Use a Object-Relational Mapping System (e.g. Hibernate): Provides a simple API for storing and retrieving Java objects directly to and from the database.

• Non-intrusive: No need to follow specific rules or design patterns.• Transparent: Your object model is unaware.

10

Introduction: Persistent Framework

• What’s a persistent framework?

- An ORM service that stores and retrieves objects into a relational

database.• So why do we need a persistence framework?

- To avoid hard coding SQL into our Java applications.

• JDBC and SQL require Java programmers to be familiar with relational database details.

• Java programs are object-oriented (or at least should be) in nature whereas relational databases are tabular in nature.

• Persistent frameworks help alleviate the ORM “impedance mismatch.”

.

11

Session Structure


12

Why Hibernate?

Hibernate is considered a persistent framework for Java!

• Introduced to address the issues of Entity Beans.• Built on top of JNDI, JDBC, JTA.• Uses XML based configuration files for mapping.• Supports many databases like Sybase, Oracle, MySQL,other Object-

Oriented Databases etc.• Makes for easy migration from one vendor database to another.• Generates the JDBC Code based on the underlying vendor database.• Hibernate APIs are very simple to learn and use.• Provides a powerful object query language known as Hibernate Query

Language (HQL).

13

Why Hibernate?: Features

• Inheritance, polymorphism support• Custom data types• Collections• Uni and bi-directional entity associations• Transactions and concurrency• Caching• Connection pooling• HQL – Advanced Object Query Language etc.

14

Session Structure


15

Architecture

16

• Middleware that manages

persistence.

• Provides an abstraction layer

between the Persistence Layer

and the database.

Session Structure


17

Hibernate Basics

SessionFactory• A threadsafe (immutable) cache

of compiled mappings for a

single database. • A factory for Session.• Expensive to create.

18

Hibernate Basics

Session • A single-threaded, short-lived

object representing a conversation

between the application and the

persistent store.• Wraps a JDBC connection.• Factory for Transaction.• Holds a mandatory (first-level)

cache of persistent objects; used

when navigating the object graph

or looking up objects by identifier.

19

Hibernate Basics

Persistent Objects and Collections• Short-lived, single-threaded objects

containing persistent state and business function.

• These might be ordinary JavaBeans/POJOs. The only special thing about them is that they arecurrently associated with (exactlyone) Session.

• As soon as the Session is closed,they will be detached and free to usein Any application layer.

20

Hibernate Basics

Transient Objects and Collections• Instances of persistent classes that

are not currently associated with aSession.

• They may have been instantiatedby the application and not (yet) persisted or they may have been instantiated by a closed Session.

21

Hibernate Basics

Transaction • A single-threaded,

short-lived object used by the application to specify atomic units of work.

• Abstracts application from underlying JDBC, JTA or CORBA transaction.

• Multiple transactions per Session.

22

Hibernate Basics: Architecture API

23

Configuration :

•Is the first Hibernate object to be used.•Created once during application initialization•A Configuration object is used to create a SessionFactory

Session Factory :

• It is a factory for Session objects•created during application start up•Is a thread safe object•Is created per database

Session :

•Main interface to accomplish work with the database.•objects are saved and retrieved through a Session.•Is lightweight and inexpensive to create. •Is not thread safe. •Used to create a Transaction object

Transaction : •Represents a unit of work with the database (and potentially other systems). •Handled by an underlying transaction manager

Query and Criteria objects are used to retrieve (and recreate) persistent objects.

Session Structure


24

Example Application: The StudentManager

25

Java Object

26

27


Hibernate Mapping Files

• Tells Hibernate which tables and columns to use to load and store objects.

28

29


Configuration: Config File

30

31


The Configuration Object

• Represents a set of mapping files.• Mapping files can be specified

programmatically or through

the Hibernate configuration file.• Intended as a start-up time object.

32

Session Structure


33

Transactions

• A set of database operations which must be executed in entirety or not at all.

• Should end either with a commit or a rollback.• All communication with a database has to occur inside a transaction!

34

Transactions

• Most common pattern is session-per-request.

35

Session Structure


36

Object States: Transient & PersistentTransient :

•An object is transient if it has just been instantiated using the new operator.•It is not associated with a Hibernate Session. •Use the Hibernate Session to make an object persistent.

Persistent :

•A persistent instance has a representation in the database and an identifier value. •It might just have been saved or loaded.•Definied in the scope of a Session.

37

Object States: DetachedDetached :

•A detached instance is an object that has been persistent, but its Session has been closed. •The reference to the object is still valid, of course, and the detached instance might even be modified in this state. •A detached instance can be reattached to a new Session at a later point in time, making it (and all the modifications) persistent again.

Sample Code :

Session session = sessionFactory.openSession();Transaction transaction = session.beginTransaction();BallPlayer p = (BallPlayer)session.get(BallPlayer.class, 1L);

transaction.commit();session.close();

//p is now Detachedp.setNickname("Bambino"); //change is unsynchronized

session = sessionFactory.openSession(); //again open new sessiontransaction = session.beginTransaction();

//can also use session.saveOrUpdate() in method call below

session.update(p); //now new nickname is appliedtransaction.commit();session.close();

38

Object States: Complete Lifecycle

• A complete diagram of the lifecycle, given a description of the states and methods that transition

the objects between states.

39

Session Structure


40

O / R Mapping: Collection Mapping

• Collection properties must be declared as an interface type (Set, not HashSet).

• Hibernate provides built-in mapping for Set, Map, List, and more.• May contain basic types, custom types and references to other

Hibernate objects.• Collections are represented by a collection table in the database:

– Collection key: foreign key of owning object– Collection element: object in the collection

41

O / R Mapping: Collection Mapping

42

OR Mapping: Association Mapping

• Hibernate lets you easily specify all kinds of associations between objects:– Unidirectional one-to-many– Unidirectional many-to-many– Bi-directional one-to-many– Bi-directional many-to-many

• Representing associations with join tables makes the database schema cleaner.

• Nullable foreign keys is bad practice.

43

O / R Mapping: Unidirectional (One-to-Many)

44

O / R Mapping: Unidirectional (Many-to-Many)

45

O / R Mapping: Bi-directional (One-to-Many)

46

O / R Mapping: Bi-directional (Many-to-Many)

47

O / R Mapping: The Inverse Property Explained

• Bi-directional associations must be updated on both sides in the Java code!

• Hibernate maps many-relationships with a join table.• Hibernate must ignore one side to avoid constraint violations!• Must be the many side for one-to-many, but doesn’t matter for many-to-

many.

48

O / R Mapping: Component Mapping

• A component is an object saved as a value, not as a reference.• Saved directly – no need to declare interfaces or identifiers.• Required to define an empty constructor.• Shared references not supported.

49

O / R Mapping: Component Mapping

50

Session Structure


51

Hibernate Query Language (HQL): The Query Interface

• You need a query when you don’t know the identifiers of the objects you are looking for.

• Used mainly to execute Hibernate Query Language queries.• Obtained from a Hibernate Session instance.• Provides functionality for:

– Parameter binding to named query parameters– Retrieving lists of objects or unique objects– Limiting the number of retrieved objects

52

Hibernate Query Language (HQL)

• HQL is an object-oriented query language– Syntax has similarities to SQL– Not working against tables and columns, but objects!

• Understands object-oriented concepts like inheritance• Has advanced features like:

– Associations and joins– Polymorphic queries– Sub-queries– Expressions

• Reduces the size of queries

53


54


55

56

Hibernate Query Language (HQL): Where Clause

Hibernate Query Language (HQL): Query Example

57

58

Hibernate Query Language (HQL): Query Example

Session Structure


59

Improving Performance

Fetching strategies: Hibernate uses a fetching strategy to retrieve associated objects if the application needs to navigate the association. Fetch strategies can be declared in the O / R mapping metadata, or overridden by a particular HQL or criteria query.

– Join fetching– Select fetching– Sub-select fetching– Batch fetching

60


61


62


About Caching:• All objects that are passed to methods save(), update() or

saveOrUpdate() or those you get from load(), get(), list(), iterate() or scroll() will be saved into cache.

• Flush() is used to synchronize the object with database and evict() is used to delete it from cache.

• Contains() used to find whether the object belongs to the cache or not. • Session.clear() used to delete all objects from the cache. • Suppose the query wants to force a refresh of its query cache region,

we should call Query.setCacheMode(CacheMode.REFRESH).

63

Session Structure


64

Alternatives to Hibernate

• Other popular ORMs are:

– iBatis

– JPA

– TopLink

• iBatis

– You want to create your own SQL's and are willing to maintain them

– Your environment is driven by relational data model

– Needs SQL Statements to be coded in its Mapping files

– Good when developer needs control over the SQL

• TopLink

– Very similar and quite powerful but costs

– Vendor lock-in

65

Alternatives to Hibernate

• JPA – Java Persistence API– Java EE 5 ORM Solution– Part of EJB 3 Specification– Supported by all Java EE vendors– Designed based on popular ORM solutions like iBatis,JDO, TopLink

including Hibernate– Replaces Entity Beans– It’s more of a specification; you can use any provider like TopLink,

etc.– Depends on provider which may implement more than standard

specification– JPA lags in defining Caching and other advanced features– Useful in case of standard Java based solution using Java EE

platform66

Session Structure


67

68

Q & A

Questions?

References

• Christian Bauer and Gavin King: Hibernate in Action• James Elliot: Hibernate – A Developer’s notebook• Justin Gehtland, Bruce A. Tate: Better, Faster, Lighter Java• http://www.hibernate.org• http://www.hibernate-training-guide.com

69

Thanks eveybody for attending this session.

Thanks

70

2010 05-21, object-relational mapping using hibernate v2

Technology

Transcript of 2010 05-21, object-relational mapping using hibernate v2