Object Relational Mapping (ORM)

Transcription

1 Object Relational Mapping (ORM) Hibernate and Java Persistence API (JPA) Gregg Lippa Senior Technical Analyst Themis Education Themis, Inc. Visit us at: Also:

2 This Webinar Addresses These Questions What is an ORM; what are it s benefits What is the architecture of an ORM? How is an ORM configured? How do Hibernate and JPA implement ORM? How does JPA differ from Hibernate? How is data mapped to classes via metadata? How are inheritance relationships, collections and associations managed? How do you retrieve and store objects? How do you use detached objects? What does a persistence manager do? What efficiency and optimization techniques (like caching) exist? How do transactions and concurrency work in an ORM environment? What query options are there? (HQL, JPQL, QBC, QBE, native SQL) Please submit questions via to glippa@themisinc.com 2

3 Persistence of Objects: A Paradigm Mismatch Business data is usually stored in a relational databases Where it "persists" for use by enterprise applications Applications use SQL to store and retrieve the data Typically embedded within a programming language Object-oriented languages like Java are increasingly popular Support for relational data access is provided, however, rows of data from tables are different than the web of objects comprising an application An object's fields must be mapped to a table's columns Objects participate in various relationships with other objects Association, inheritance, polymorphism, composition, collections Object identity and table identity may also differ, raising issues Overcoming the object/relational paradigm mismatch has a cost Much Java code is often requried to manually bridge the gap

4 What is Object/Relational Mapping (ORM)? ORM automates the persistence of Java objects to relational tables Uses metadata to describe the mapping of objects to the database Transparently transforms data from one representation to the other Problems to be addressed by ORM Persistent class design, definition and lifecycle Definition of mapping metadata Mapping class inheritance hierarchies Determining object identity and object equality Runtime interaction between persistence logic and business objects Facilities for searching, sorting, and aggregating Efficiency, especially when using joins to navigate an object graph An ORM solution: Specifies mapping metadata Performs CRUD on objects of persistent classes Supports queries that refer to classes and their properties Provides transaction support and optimization capabilities

5 Why Use ORM? Eliminates the tedious work of perisistence-related code Allows developers to concentrate on the business problems Reduces the amount of code required Makes the system more understandable and easier to refactor Focuses developers on business logic rather than plumbing Often improves performance Many performance optimizations are provided by ORM software with simple property settings Equal performance is possible without an ORM but requires greater developer expertise and additional development time Insulates application from underlying database ORM implementations typically support many DBMSs Simplifies the task of changing database vendors

6 What is Hibernate? Hibernate is an open source ORM Maps Java classes to database tables Maps Java data types to SQL data types Provides data query and retrieval facilities Generates the SQL calls Relieves developer from manually converting result sets to objects Delivers database portability with very little performance overhead Hibernate development led by Gavin King, now of JBoss (RedHat) Became available through JBoss in 2003 Hibernate Version 3.2 is a certified implementation of JPA Supports JDK 5.0 annotations (Java's metadata feature) Other ORM implementations Oracle TopLink OpenJPA EclipseLink More on JPA

7 Java Persistence API (JPA) JPA became part of the Java EE 5 (EJB 3.0) specification in 2006 Replaces heavyweight, complicated entity beans The specification requires JPA engines to be pluggable and to be able to run outside of an EJB environment (container) Hibernate implements the JPA specification And provides numerous extensions as well JPA 2.0 was approved as final on December 10, 2009 Adds features that were present in some of the popular ORM vendor offerings but unable to gain approval for JPA 1.0: Support for collections of embedded objects and ordered lists Standardization of additional metadata to support DDL generation Standardization of query 'hints' A criteria query API Support for validation

8 Hibernate Architecture The heart of an ORM is the mapping of objects to the database Hibernate uses an XML Mapping Document to support this As Hibernate has evolved, support via annotations has been added Classes are mapped to tables and properties are mapped to columns It also specifies unique identifiers and relationships Hibernate depends on database tables to store persistent data Hibernate apps define persistent classes that are mapped to them The Hibernate Session is the persistence manager Manages a collection of loaded objects relating to a single unit of work A Hibernate SessionFactory is used to obtain Session instances A Hibernate Configuration is used to obtain a SessionFactory Specifies mapping documents and Hibernate configuration Hibernate also offers several other useful optional APIs Transaction abstracts the underlying transaction implementation Query and Criteria support execution of database queries

9 Hibernate Example A Table and a Class Simple database table named CUSTOMER and a persistent class to support it package sample1; public class Customer { private int id; private String name; private String ; public Customer(int i) { setid(i); } public int getid() { return id; } private void setid(int i) { id = i; } public String getname() { return name; } public void setname(string n) { name = n; } public String get () { return ; } public void set (string e) { = e; (name= @Column(name= CUSTID NAME ) Annotations Configuration XML CUSTID NAME 123 Joe Smith jsmith@aol.com 456 Eva Jones ejones@xyz.net Simple class with no special features; just a public constructor, properties that match the table definition and accessor methods. No special imports, no need to extend or implement anything

10 Hibernate Example XML Mapping File This file specifies how the table maps to the persistence class Specifies unique identifier and column mappings Capable of defining relationships (not shown here) Recommended name for this file: Customer.hbm.xml By convention, one mapping file is defined for each class <?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" " <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"> <generator class="increment"/> </id> <property name="name" column="name" /> <property name=" " column=" " /> </class> </hibernate-mapping>

11 Hibernate Properties File Configuring Hibernate is largely about the database connection Sample entries found in hibernate.properties based on Hibernate's built in connection pool C3P0 (suitable for testing purposes only) hibernate.connection.driver_class = org.postgresql.driver hibernate.connection.url = jdbc:postgresql://localhost/custdb hibernate.connection.username = someuser hibernate.connection.password = secret hibernate.dialect = net.sf.hibernate.dialect.postgresqldialect hibernate.c3p0.min_size = 5 hibernate.c3p0.max_size = 20 hibernate.c3p0.timeout = 300 hibernate.c3p0.max_statements = 50 hibernate.c3p0.idle_test_period = 3000 A JEE application server often provides a connection pool An instance of javax.jdbc.datasource returned via JNDI lookup Sample hibernate.properties for this case hibernate.connection.datasource = java:comp/env/jdbc/custdb hibernate.transaction.factory_class = net.sf.hibernate.transaction.jtatransactionfactory hibernate.transaction.manager_lookup_class = net.sf.hibernate.transaction.jbosstransactionmanagerlookup hibernate.dialect = net.sf.hibernate.dialect.postgresqldialect

12 Hibernate Configuration The SessionFactory can be configured by an XML Configuration file hibernate.cfg.xml contains entries like those found in hibernate.properties Java code can also be used to configure the Hibernate environment <?xml version="1.0"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN" " <hibernate-configuration> <session-factory name="java:/hibernate/hibernatefactory"> <property name="show_sql">true</property> <property name="connection.datasource"> java:comp/env/jdbc/custdb </property> <property name="dialect"> net.sf.hibernate.dialect.postgressqldialect </property> <property name="transaction.manager_lookup_class"> net.sf.hibernate.transaction.jbosstransactionmanagerlookup </property> <mapping resource="sample1/customer.hbm.xml" /> <mapping resource="sample1/someother.hbm.xml" /> <mapping resource="somepkg/yetanother.hbm.xml" /> </session-factory> </hibernate-configuration> Automatically binds session factory to JNDI Locations of mapping files

13 Using Hibernate to Work With the Data Get a Session, begin a transaction, do a get, and update Then commit the transaction and close the Session Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); Customer cust = (Customer) session.get(customer.class, 123); cust.setname("tom Swift"); cust.set ("tswift@gmail.com"); trx.commit(); session.close(); SQL is generated and executed as a result of the above code select c.custid, c.name, c. from APP1.CUSTOMER c where c.custid = 123 update APP1.CUSTOMER set NAME = "Tom Swift", = "tswift@gmail.com" where CUSTID = 123

14 Hibernate Deployment Options Hibernate can be deployed into a managed environment A JEE application server like WAS may be used for this Hibernate can use container-managed transactions and datasources Hibernate can also be deployed into non-managed environments A servlet container like Tomcat may be used for this Without container-managed transactions and datasources available, the application manages database connections and transaction boundaries

15 Transparent Automated Persistence Separation of concerns: persistence classes vs. persistence logic Persistence classes are unaware of the persistence mechanism No code-level dependency no superclasses or interfaces required Persistence classes may be used outside of the persistence context Persistence classes are implemented as Plain Old Java Objects POJOs are simple lightweight classes Very similar to JavaBeans These features make Hibernate applications More readable More portable More testable

16 Mapping Metadata Associations The mapping of classes to tables, columns to properties, as well as mapping of associations is supported by the XML mapping metadata Suppose the Customer class is designed to track all Orders placed by the Customer XML metadata below reflects this change package sample1; public class Customer { private int id; private String name; private String ; private List orders; // constructor and // accessor methods // not shown } <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"> <generator class="increment"/> </id> <property name="name" column="name" /> <property name=" " column=" " /> <set name="orders"> <key column="custid"/> <one-to-many class="orders" /> </set> </class> </hibernate-mapping> Specifies the relationship between Customer and the Orders they placed

17 Object Identity Database identity relates to primary key values Each row has a unique primary key value Hibernate allows the definition of an identifier property Supports numerous built-in identifier generator strategies Database identity columns are supported as well as sequences Also supports creating a custom identifier generator <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"> <generator class="identity"/> </id> <property name="name" column="name" /> <property name=" " column=" " /> <set name="orders"> <key column="custid"/> <one-to-many class="orders" /> </set> </class> </hibernate-mapping>

18 Composition Objects are often made up of other objects Hibernate provides components to support composition User-defined class persisted to the same table as the owning entity Consider an Address class that is used by the Customer class Both a shipto and a billto address is attached to a customer package sample1; public class Customer { private int id; private String name; private String ; private Address shipto; private Address billto; private List orders; // constructor and // accessor methods // not shown } package sample1; public class Address { private String street; private String city; private String state; private String zip; // constructor and // accessor methods // not shown }

19 Mapping Composition The XML mapping document defines the components Address class is used to support both component entries <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"><generator class="identity"/></id> <property name="name" column="name" /> <property name=" " column=" " /> <component name="shipto" class="address"> <property name="street" column="ship_street" /> <property name="city" column="ship_city" /> <property name="state" column="ship_state" /> <property name="zip" column="ship_zip" /> </component> <component name="billto" class="address"> <property name="street" column="bill_street" /> <property name="city" column="bill_city" /> <property name="state" column="bill_state" /> <property name="zip" column="bill_zip" /> </component> <set name="orders"> <key column="custid"/><one-to-many class="orders" /> </set> </class> </hibernate-mapping>

20 Mapping Inheritance Relational databases do not support inheritance directly Inheritance hierarchies can be represented in three ways 1. One table per concrete class ignores inheritance and polymorphism 2. One table per hierarchy enables polymorphism through denormalization 3. One table per subclass uses foreign keys to represent inheritance Consider the following class hierarchy Account id : int cust : Customer balance : double <<abstract class>> CheckingAccount monthlyfee : double checkfee : double SavingsAccount interestrate : double

21 Mapping Inheritance: Table Per Concrete Class Define two tables; include details from abstract superclass in each table Union required to get information about all accounts in a single report CHECKINGACCT ACCTID <<PK>> <<customerinfo>> ACCTBAL MON_FEE CHK_FEE SAVINGSACCT ACCTID <<PK>> <<customerinfo>> ACCTBAL INT_RATE Customer Info columns are omitted in these examples Later versions of Hibernate mapping support <union-subclass> <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.account" abstract="true"> <id name="id" column="acctid"><generator class="identity"/></id> <component name="cust" class="customer"> <property name=... />... </component> <property name="balance" column="acctbal" /> <union-subclass name="checkingaccount" table="app1.checkingacct"> <property name="monthlyfee" column="mon_fee"/> <property name="checkfee" column="chk_fee"/> </union-subclass> <union-subclass name="savingsaccount" table="app1.savingsacct"> <property name="interestrate" column="int_rate"/> </union-subclass> </class> </hibernate-mapping>

22 Mapping Inheritance: Table Per Class Hierarchy Define one table; include columns for all properties of all classes Makes use of a type discriminator column Downside: not normalized and columns for subclass properties must be nullable Hibernate mapping support via <subclass> and <discriminator> elements ACCOUNT ACCTID <<PK>> <<customerinfo>> ACCTBAL ACCT_TYPE MON_FEE CHK_FEE INT_RATE <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.account" table="app1.account"> <id name="id" column="acctid"><generator class="identity"/></id> <discriminator column="acct_type" type="string" /> <component name="cust" class="customer"> <property name=... />... </component> <property name="balance" column="acctbal" /> <subclass name="checkingaccount" discriminator-value="c"> <property name="monthlyfee" column="mon_fee"/> <property name="checkfee" column="chk_fee"/> </subclass> <subclass name="savingsaccount" discriminator-value="s"> <property name="interestrate" column="int_rate"/> </subclass> </class> </hibernate-mapping>

23 Mapping Inheritance: Table Per Subclass Define a separate table for every subclass and abstract superclass Foreign keys used to handle associations Normalized (though least common) solution Hibernate mapping support via <joined-subclass> element CHECKINGACCT ACCTID <<FK>> MON_FEE CHK_FEE ACCOUNT ACCTID <<PK>> <<customerinfo>> ACCTBAL <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.account" table="app1.acount"> <id name="id" column="acctid"><generator class="identity"/></id> <component name="cust" class="customer">... </component> <property name="balance" column="acctbal" /> <joined-subclass name="checkingaccount" table="app1.checkingacct"> <key column="acctid"> <property name="monthlyfee" column="mon_fee"/> <property name="checkfee" column="chk_fee"/> </joined-subclass> <joined-subclass name="savingsaccount" table="app1.savingsacct"> <key column="acctid"> <property name="interestrate" column="int_rate"/> </joined-subclass> </class> </hibernate-mapping> SAVINGSACCT ACCTID <<FK>> INT_RATE

24 Mapping File Elements for Collections The Java Collections framework supports managing groups of objects Hibernate mapping documents support Collections <list> supports ordered (indexed) groups of objects (most commonly used) <set> supports unordered groups of objects with no duplicates allowed optional sort attribute <bag> and <idbag> unordered groups of objects with duplicates allowed <map> supports key-value pairs and has an optional sort attribute <primitive-array> and <array> support Java arrays (rarely used) package sample1; public class Customer { private int id; private String name; private String ; private List orders; // constructor and // accessor methods // not shown } <!-- XML prolog, including doctype, not shown --> <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"> <generator class="increment"/> </id> <property name="name" column="name" /> <property name=" " column=" " /> <set name="orders"> <key column="custid"/> <one-to-many class="orders" /> </set> </class> </hibernate-mapping>

25 Mapping File Elements for Associations Associations are relationships between entities Associations are unidirectional Unidirectional many-to-one associations are very common CUSTOMER CUST_ID <<PK>> NAME ADDRESS ORDERS ORDER_NUM <<PK>> CUST_ID <<FK>> ORDER_DATE TOTAL_COST <hibernate-mapping> <class name="sample1.customer" table="app1.customer">... <set name="orders" inverse="true"> <key column="custid"/> <one-to-many class="sample1.orders" /> </set> </class> </hibernate-mapping> <hibernate-mapping> <class name="sample1.orders" table="app1.orders">... <many-to-one name="customers" column="custid" class="customer" non-null="true" /> </class> </hibernate-mapping>

26 Persistence Lifecycle Hibernate applications use a Session as the persistence manager Retrieves a graph of objects while minimizing database hits Controls saving of persistent objects when changes occur to them The persistence mechanism is transparent to persistent classes Hibernate applications can avoid requesting database updates directly Calls to Hibernate session are used by the developer to propagate objects' state in memory to the database

27 Retrieving, Storing and Deleting Objects Simple object retrieval is typically done using Session's get() method Requires a class and identifier and returns a database row Returns null if no row exists with the given identifier Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); Customer cust = (Customer) session.get(customer.class, 123); cust.setname("tom Swift"); cust.set ("tswift@gmail.com"); session.save(cust); trx.commit(); session.close(); The setname and set calls above change the object's state When commit is called, modifications are propagated to the database Using automatic dirty checking, this happens only if object is changed Also propagates deletes to the database for deleted objects Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); Customer cust = (Customer) session.get(customer.class, 123); session.delete(cust); trx.commit(); session.close();

28 States of a Persistent Object (1 of 2) States defined by Hibernate include transient, persistent, detached Objects are transient after they are instantiated using Java s new operator Transient objects become persistent objects When the Hibernate save() operation is called Or by creating a reference to the object from an object that is already persistent Gives them a database identity (primary key value) Associates them with a Session makes them transactional Customer cust = new Customer(789); cust.setname("tom Swift"); cust.set ("tswift@gmail.com"); Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); session.save(cust); trx.commit(); session.close(); Customer object enters detached state at this point New row added to Customer table at this point New Customer object is transient at this point Customer object becomes persistent at this point

29 States of a Persistent Object (2 of 2) Object s state changes back to transient via Session.delete() The persistent object then enters the removed state Causes rows to be deleted from the database at commit Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); Customer cust = (Customer) session.get(customer.class, 123); session.delete(cust); trx.commit(); session.close(); Persistent objects become detached via Session.close() Lose their association to the persistence manager No longer synchronized with the database state Can be reassociated with a new persistence manager Customer cust = new Customer(789); cust.setname("tom Swift"); cust.set ("tswift@gmail.com"); Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); session.save(cust) trx.commit(); session.close(); Row associated with Customer object is deleted at this point Customer object enters detached state at this point Customer object enters removed state at this point

30 Transitive Persistence Objects typically have relationships to other objects A set of related objects is known as an object graph or web of objects Transitive persistence propagates updates to subgraph automatically CUSTOMER ORDERS ITEM Cascading persistence is supported Allows specification of a cascade style for each association mapping Offers flexibility and fine-grained control Enable transitive persistence by specifying the cascade attribute Applies to many-to-one elements as well as collection elements such as set

31 Cascade Options The cascade attribute supports a dozen valid values including: none ignore the association save-update save associated objects when parent object is saved delete delete associated objects when parent object is deleted all cascade to associated objects for both save and delete of parent delete-orphan delete objects that have been removed from association all-delete-orphan combines the features of all and delete-orphan CUSTOMER ORDERS ITEM <hibernate-mapping> <class name="orders" table="app1.orders"> <id name="ordernum" column="ordernum">... </id> <property... />... <many-to-one name="customers" class="customer" column="custid" cascade="none" <set name="items" table="app1.item" cascade="save-update"> <key column="ordernum"/> <one-to-many class="item" /> </set> </class> </hibernate-mapping>

32 Hibernate Query Language (HQL) Hibernate Query Language (HQL) only supports data retrieval Unlike SQL which supports update, insert, delete and much more Syntax implies a select *, although column specification is supported All of the other standard features of SQL are supported Filtering with a where clause, including all SQL operators Ordering, grouping, having, aggregation and many other functions Various types of joins, including outer joins Subqueries, including correlated subqueries and quantifiers (ANY, ALL) Positional and named parameters Queries can also be named and defined in mapping files Then reusable via Session's getnamedquery() method Session session = getsessionfactory().opensession(); String sql = "from Customer c where c.lastname = :lookupvalue" Query qry = session.createquery(sql); qry.setstring("lookupvalue", "Smith"); List results = qry.list(); session.close(); Executes the query and returns the results as a List Named parameter

33 JPA Query Language (JPQL) JPA Query Language (JPQL) is a standardized subset of HQL JPA QL is part of the Java EE5 and EJB3 standard HQL is not Some of the differences include: JPA QL requires the query to include the Select portion JPA QL and HQL support both support standard functions HQL supports many additional functions HQL supports a syntax shortcut for subqueries Hibernate is a more mature product; JPA is a relatively newer Hibernate supports Criteria objects; JPA added it in version 2.0 Alternative to the Query object used to request database rows

34 Query By Criteria (QBC) QBC allows constraints to be specified without string manipulation Makes use of the Criteria object A tree of Criterion instances produced by a factory class for Criterion Query syntax is parsed and validated at compile (vs runtime for HQL) Criteria supports all capabilities of the SQL WHERE clause The ordering of results by one or more columns is supported Hibernate now also supports grouped results Criteria crit = session.createquery(customer.class); crit.add(expression.like(" ", "%gmail.com")); //V2 crit.add(restrictions.like(" ", "%gmail.com")); //V3 List results = crit.list(); session.close();

35 Query By Example (QBE) QBE builds upon the QBC concept of using a Criteria object Supplies an instance of the queried class with some property values set Utilizes the Example object to provide the sample instance Example is a subtype of Criterion So QBC and QBE can be combined in a single query Customer cust = new Customer(555); cust.set ("gmail.com"); Example samplecust = Example.create(cust); samplecust.ignorecase(); samplecust.enablelike(matchmode.anywhere); Criteria crit = session.createquery(customer.class); crit.add(samplecust); List results = crit.list();

36 Additional Query Options Native SQL Native SQL syntax can also be used in Hibernate and JPA JPA EntityManager is the equivalent of Hibernate Session Provides a mechanism to feed optimizer hints to the optimizer HQL, JPQL and Criteria have no support for optimizer hints No difference in handling resultset returned from a native query String sqlstring = "select {c.*} from Customer c " + " join Orders O on i.custid = o.custid " + " where o.orderdate = :adate"; SQLQuery qry = session.createsqlquery(sqlstring); qry.addentity(customer.class); qry.setparameter("adate", " "); List results = qry.list(); //list of Customer objects Named parameter Specifies which class to populate with result data

37 Transactions Transactions support multiple related updates in a single unit of work all succeeding together; all failing if any one fails In JDBC, setautocommit(false) call on the Connection is usually used Turns off auto commit thereby enabling proper transactional processing This is done automatically by Hibernate as soon as it gets a connection Multiple DBMSs may participate in a single unit of work Java Transaction API (JTA) supports distributed transactions Hibernate uses a JDBC Connection to communicate with the database If Hibernate is being managed in an application server, JTA may be used Hibernate application code is the same in both environments The Hibernate Transaction hides the underlying transaction API

38 Transactions Session session = getsessionfactory().opensession(); Transaction trx = session.begintransaction(); try { processcustomerwithinatransaction(123); trx.commit(); } catch (Exception e) { if (trx!= null) { try { trx.rollback(); } catch (HibernateException he) { /* handle it */ } } throw e; } finally { try { session.close(); } catch (HibernateException he) { throw he; } } Commit synchronizes the Session state with the database in a process called flushing Use Hibernate Transaction API to begin a transaction Transparent write behind is used to combine all of the changes made during the unit of work into a minimal set of database requests to maximize performance It is extremely important to close the Session in a finally block to ensure the proper release of the connection back to the pool

39 Concurrency and Isolation Levels Locking is required to ensure that concurrent applications do not damage data integrity or produce erroneous results Isolation level indicates how long a lock will be held Used to address issues including lost updates phantom read dirty read unrepeatable read ANSI SQL standard isolation levels: Read uncommitted Read committed Repeatable read Serializable Too much isolation which can harm performance Too little can lead to integrity issues Hibernate allows you to configure Isolation Level on the connection object

40 Caching A cache is a local copy of the data stored in memory Used to avoid a trip to the database under certain circumstances Hibernate and JPA employ first-level cache and second-level cache First-level cache is scoped to the transaction Managed by the Session; cannot be turned off Used for save(), update(), load(), list(), and other methods of Session Second-level cache is scoped to the server (or cluster) Optional; pluggable; configurable; scoped to the SessionFactory Risky if legacy applications concurrently updating the same data Beneficial for relatively static or non-critical data For mass updates and deletes, Query supports executeupdate( ) Bypasses all caching

41 Object Retrieval Efficiency: Fetching Strategies Hibernate executes SQL select statements to load objects into memory Populating object graphs often requires access to multiple tables A fetching strategy is employed to minimize the number of SQL statements and to simplify the SQL to optimize performance Hibernate offers several fetching strategies Immediate fetching sequential database read (or cache lookup) Least efficient unless requested object is likely to be in cache Lazy fetching retrieved upon first access via database request (or cache) Default, recommended approach for optimal performance in most cases Can be overridden by specifying lazy="false" in the mapping document Eager fetching associated objects retrieved with owning object Single request using outer join may be beneficial in some scenarios Batch fetching batch of objects retrieved when lazy association accessed Specified via batch-size attribute in the class element in mapping document FetchMode can also be set in code on a Criteria

42 Calling Stored Procedures Mapping documents in Hibernate can define named queries that call stored procedures, including handling resultsets Assume a stored procedure named CUST_BY_NAME that returns a set of Customers based on a name passed into it when it is called Definition of the named query in the mapping file <hibernate-mapping> <sql-query name="custbyname" callable="true"> <return class="customer" /> {call APP1.CUST_BY_NAME (:aname)} </sql-query> </hibernate-mapping> Code to call the named query Indicates that a stored procedure is defined by this named query. Query qry = session.getnamedquery("custbyname"); qry.setparameter("aname", requestedname); List results = qry.list();

43 Object Modification The mapping documents in Hibernate are able to specify SQL statements to support insert, update and delete operations Override the default statements that are generated by Hibernate <hibernate-mapping> <class name="sample1.customer" table="app1.customer"> <id name="id" column="custid"> <generator class="identity"/> </id> <property name="name" column="name" /> <property name=" " column=" " /> <set name="orders" inverse="true"> <key column="custid"/> <one-to-many class="orders" /> </set> <sql-insert> insert into Customer (CUSTID, NAME) values(?,?) </sql-insert> <sql-udpate>... </sql-update> <sql-delete>... </sql-delete> </class> </hibernate-mapping>

44 Modification Optimization Considerations Transitive persistence involves the propagation of changes to the entire network of objects related to the one being saved Hibernate and JPA support numerous cascade options Determine whether associated objects are saved and when Apply to inserts, updates, and deletes; may be used in combination Provide alternatives to support application tuning Bulk and batch operations are suitable for large-scale updates HQL and JPA QL support bulk update and delete operations Bypasses caching, which adds overhead but no benefit in this scenario HQL additionally supports bulk insert using a subselect Batching updates based on cursor processing or inserts in a loop Cursor processing is supported by Hibernate but not JPA Stored procedures provide yet another update alternative

45 Generating Database Schema from Hibernate Mapping metadata can be used to generate SQL DDL Hibernate s hbm2ddl, aka SchemaExport, can be run several ways Typically as an Ant target; or automatically when SessionFactory is built <taskdef name="hibernatetool" class="org.hibernate.tool.ant.hibernatetooltask" classpathref="sample1.app1" /> <target name="schemaexport" depends="compile, copymetafiles" description="export generated schema to dbms"> <hibernatetool destdir="${basedir}"> <classpath path="${build.dir}"/> <configuration configurationfile="${build.dir}/hibernate.cfg.xml"/> <hbm2ddl drop="true" create="true" export="true" outputfilename="myapp-ddl.sql" delimiter=";" format="true" /> </hibernatetool> </target> Drop and recreate schema each time Connect to database and execute the DDL Write DDL out to this file Format the DDL using indentation SQL dialect must be specified here

46 Review ORM automates the persistence of Java objects to relational tables Simplifies development; optimizes performance; isolates database interactions Hibernate is very mature and implements ORM quite fully JPA provides a subset of Hibernate's capabilities A Hibernate Session manages persistence automatically In JPA, EntityManager supports this function Uses automatic dirty checking to generate SQL at commit time Hibernate is configured using hibernate.properties and/or hibernate.cfg.xml Persistent classes are configured via XML mapping files and/or annotations Class fields are mapped to table columns; class relationships are mapped as well Persistence classes are implemented as Plain Old Java Objects (similar to JavaBeans) Hibernate supports transactions using JDBC or JTA; allows setting isolation too The Query object is available in Hibernate and JPA Supports HQL and JPQL and sell as native SQL Hibernate additionally supports the Criteria object Query By Criteria (QBC) and Query By Example (QBE) Hibernate supports the export of schema to the database Generates SQL DLL from Hibernate mapping files

47 Where Do I Go From Here?

48 Course Information for Java Development Using Hibernate as your ORM Course Information for Java Development Using JPA as your ORM

49 Learning More About Java, OO and Database Interaction Java 1 (Intro Java) and Java 2 (Intermediate Java) These courses spend two weeks in Java Standard Edition Both courses are necessary to get a complete background Java Enterprise Servlets and JSPs One week course on these critical components of Java EE Object Oriented Analysis and Design This course gives the budding OO developer a solid background in OO requirements specification and UML Many other courses depending on your environment Enterprise Java Beans (EJBs); Java Persistence API (JPA); Java Messaging Service (JMS); Java Server Faces (JSF); Web Services with Java; Design Patterns; Spring; XML; HTML; Hibernate; Struts; many more 49

50 Thank you for coming US Intl On-site and Public Instructor-led Hands-on Training Hundreds of IT Courses Customization Available