Advanced Hibernate

Advanced Hibernate Presented by Haitham Raik

The persistence lifecycle. The persistence context. Object equality. Flush modes. The persistence manager. Transactions. Contextual session. Concurrency. Caching. Agenda

Bulk and batch operations. Filters. Interceptors. The core event system. Fetching plans. Fetching strategies. Advance query options. ToolSet. Agenda (cont.)

The persistence lifecycle get() load() find() list() scroll() Iterate() uniqueResult() Transient Persistent Detached Removed save() saveOrUpdate() merge() persist() evict() close() clear() update() saveOrUpdate() lock() merge() delete()

One session has one internal persistence context. It is useful for: Automatic dirty checking. First-level cache. Guarantee a scope of java object identity. The persistence context

Automatic Dirty Check: Dirty object: is a persistence object with modifications that have not yet been propagated to the Database. By default, all columns included in the SQL UPDATE statement. To enable dynamic update/insert use : <class name = "BlogItem" table = "BLOG_ITEMS" dynamic-update = "true" dynamic-insert = "true" > </class> The persistence context (cont.)

Object identity: Persistence object has two identifiers: java identifier (x==y) and Database identifier x.getId().equals(y.getId()). bean.getId() or session.getIdentifier(bean) Scope of object identity refers to the conditions under which java identity is equivalent to database identity. The persistence context (cont.)

Session session1 = sessionFactory.openSession(); Transaction tx1 = session1.beginTransaction(); Item a = (Item) session1.get(Item. class , new Long(1234) ); Item b = (Item) session1.get(Item. class , new Long(1234) ); ( a==b ) // True, persistent a and b are identical (a.getId().equals(b.getId())) // True, match the same record tx1.commit(); session1.close(); // References a and b are now to an object in detached state Session session2 = sessionFactory.openSession(); Transaction tx2 = session2.beginTransaction(); Item c = (Item) session2.get(Item. class , new Long(1234) ); ( a==c ) // False, detached a and persistent c are not identical (a.getId().equals(c.getId())) // True, match the same record tx2.commit(); session2.close(); The persistence context (cont.)

What is the size of the following Set object? ... session2.close(); Set allObjects = new HashSet(); allObjects.add(a); allObjects.add(b); allObjects.add(c); Do not treat detached objects as identical in-memory. You need to override the equals() and hashCode() methods The persistence context (cont.)

database identifier equality : if (this==other) return true; if ( !(other instanceof User) ) return false; final User that = (User) other; return this.id.equals( that.getId() ) ; All properties equality (except the id and collections): if (this==other) return true; if ( !(other instanceof User) ) return false; final User that = (User) other; if ( !this.getUsername().equals( that.getUsername() ) ) return false; if ( !this.getPassword().equals( that.getPassword() ) ) return false; return true; Object equality

Business key equality: if (this==other) return true; if ( !(other instanceof User) ) return false; final User that = (User) other; return this.username.equals( that.getUsername() ); Key that would identify our instance in the real world. Immutable attribute. Attribute with UNIQUE constraint. Database identifier for associated object. Any date or time-based attribute. Object equality (cont.)

Flushing the persistence context Changes made to object aren’t immediately propagated to database ( write-behind ). Flushing occur at the following times: When commit a transaction. Sometimes before executing a query. Call session.flush() session.setFlushMode() FlushMode.AUTO: the default FlushMode.COMMIT. FlushMode.MANUAL. Flush mode

Making a transient object persistent: Item item = new Item(); item.setName("Playstation3 incl. all accessories"); item.setEndDate( ... ); Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); Serializable itemId = session.save(item); tx.commit(); session.close(); The persistence manager

Retrieving a persistent object: Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); Item item = (Item) session.load(Item.class, new Long(1234)); // Item item = (Item) session.get(Item.class, new Long(1234)); tx.commit(); session.close(); The persistence manager (cont.)

Modifying a persistence object Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); Item item = (Item) session.get(Item.class, new Long(1234)); item.setDescription("This Playstation is as good as new!"); tx.commit(); session.close(); The persistence manager (cont.)

Making a persistent object transient hibernate.use_identifier_rollback Example: Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); Item item = (Item) session.load(Item.class, new Long(1234)); session.delete(item); tx.commit(); session.close(); The persistence manager (cont.)

Replicating objects: Session session = sessionFactory1.openSession(); Transaction tx = session.beginTransaction(); Item item = (Item) session.get(Item.class, new Long(1234)); tx.commit(); session.close(); Session session2 = sessionFactory2.openSession(); Transaction tx2 = session2.beginTransaction(); session2.replicate(item, ReplicationMode.LATEST_VERSION); tx2.commit(); session2.close(); ReplicationMode.IGNORE ReplicationMode.OVERWRITE ReplicationMode.EXCEPTION ReplicationMode.LATEST_VERSION The persistence manager (cont.)

Reattaching a modified detached instance: select-before-update=“true” item.setDescription(...); // Loaded in previous Session Session sessionTwo = sessionFactory.openSession(); Transaction tx = sessionTwo.beginTransaction(); sessionTwo.update(item); item.setEndDate(...); tx.commit(); sessionTwo.close(); The persistence manager (cont.)

Reattaching an unmodified detached object: Session sessionTwo = sessionFactory.openSession(); Transaction tx = sessionTwo.beginTransaction(); sessionTwo.lock(item, LockMode.NONE); item.setDescription(...); item.setEndDate(...); tx.commit(); sessionTwo.close(); The persistence manager (cont.)

Making a detached object transient Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); session.delete(item); tx.commit(); session.close(); The persistence manager (cont.)

A tomicity: if one step fails, the whole unit of work must fail. C onsistency: left data in a clean and consistent state after the transactions complete. I solation: a particular transaction should not be visible to other concurrently running transaction. D urability: once the transaction completes, all changes become persistent. Transactions

Transaction demarcation: Is determining the transaction boundaries (the start and the end point) Transaction boundaries can be set either programmatically or declaratively. Transactions (cont.)

Hibernate Transaction: It is unified. It works in a non-managed plain JDBC environment and in an application server with JTA. Another benefit is tight integration with persistence context. Transactions (cont.)

Transactions in JavaSE Hibernate obtains a JDBC connection for each Session Session session = null; Transaction tx = null; try { session = sessionFactory.openSession(); //session is lazy // a conn will obtained only when the trxn begins tx = session.beginTransaction(); // conn.setAutoCommit(false) concludeAuction(session); tx.commit(); // flush and commit (here conn is released) // here you can begin another trxn with the same session } catch (RuntimeException ex) {tx.rollback(); } finally {session.close();} // release all other resources Transactions (cont.)

Transactions with JTA hibernate.transaction.factory_class = org. hibernate.transaction.JTATransactionFactory hibernate.transaction.manager_lookup_class The previous example will work without code changes. In case you want to send a message to queue and then save a record to database within a transaction. Then you need to use JTA interface directly. Transactions (cont.)

UserTransaction utx = (UserTransaction) new InitialContext() .lookup("java:comp/UserTransaction"); Session session1 = null; Session session2 = null; try { utx.begin(); session1 = auctionDatabase.openSession(); session2 = billingDatabase.openSession(); concludeAuction(session1); billAuction(session2); session1.flush(); // it’s your responsibility to sync with db session2.flush(); utx.commit(); } catch (RuntimeException ex) {utx.rollback(); // rollback } finally {session1.close();session2.close(); // close } Transactions (cont.)

Hibernate can sync with database automatically before JTA transaction end using: hibernate.transaction.flush_before_completion Hibernate can close session automatically after JTA transaction end using: hibernate.transaction.auto_close_session To enable CMT with hibernate set the following configuration: hibernate.transaction.factory_class = org. hibernate.transaction.CMTTransactionFactory Transactions (cont.)

session-per-request : the beginning and end of a session is defined by the duration of a database transaction. SessionFactory.getCurrentSession() get the current session in specific context. hibernate.current_session_context_class org.hibernate.context.JTASessionContext (jta) org.hibernate.context.ThreadLocalSessionContext (thread) commit the transaction will close the session Contextual session

Transaction isolation issues: Lost update: two transactions update the same data without locking. Concurrency

Dirty read: transaction A reads uncommitted data. Concurrency (cont.)

Unrepeatable read: transaction A executes two non-repeatable reads. Concurrency (cont.)

Second lost updates problem: Transaction A overwrites changes made by Transaction B. Concurrency (cont.) Tx B Tx A 4. Commit 6. Commit

Phantom read: transaction A reads new data in the second select. Concurrency (cont.)

Isolation levels: Read uncommitted: permits dirty read but not lost updates. Read committed: permits unrepeatable reads but not dirty reads. Repeatable read: permits neither unrepeatable reads nor dirty reads. Phantom reads may occur. Serializable: provides the strictest transaction isolation. Concurrency (cont.)

Setting an isolation level: Using hibernate configuration option ( hibernate.connection.isolation ) This option values: 1 – Read uncommitted 2 – Read committed 4 – Repeatable Read 8 – Serializable Concurrency (cont.)

Pessimistic locking: Item i = (Item) session.get(Item.class, 123); // May be another concurrent trxn changes the price i.setPrice(i.getPrice() - 10); tx.commit(); // will sync with db Concurrency (cont.) Tx B Tx A 4. Commit 6. Commit

Pessimistic locking: Increase the isolation level. Or use pessimistic lock only for this unit of work Item i = (Item) session.get(Item.class, 123, LockMode.UPGRADE); i.setPrice(i.getPrice() - 10); tx.commit(); // will sync with db Concurrency (cont.)

Lock Modes LockMode.NONE LockMode.READ LockMode.UPGRADE LockMode.UPGRADE _NOWAIT LockMode.WRITE LockMode.FORCE Concurrency (cont.)

The cache sits between your application and the database The cache keeps a representation of current database state close to the application. To avoid a database hit. Types of cache: Transaction scope cache. Process scope cache. Cluster scope cache. Caching

Caching and object identity: Transaction scoped cache: guarantee transaction scoped identity. Process scoped cache: Process-scoped identity (must provide object-level locking). Return by value. Cluster scoped cache: Needs a remote communication therefore it can’t guarantee identity across a cluster. Caching (cont.)

Do not use process scoped cache in the following: Clustered applications (rather use cluster scoped cache) Shared databases between many java applications. Caching (cont.)

Good candidate classes for caching are classes that represent: data changes rarely Non-critical data (non-financial data) Data that is local to the application and not shared Caching (cont.)

Cache concurrency strategies: Transactional Read-write Non-strict read-write Read-only (data will never change) Caching (cont.)

Second-level cache config: hibernate.cache.provider_class = org.hibernate.cache.EhCacheProvider hibernate.cache.use_second_level_cache = true Controlling hibernate caches programmatically: Session.evict() and Session.clear() SessionFactory.evict() Session.setCacheMode(): CacheMode.NORMAL and CacheMode.IGNORE Caching (cont.)

Updating and deleting objects directly in the database without retrieving objects into memory. Query q = session.createQuery("update Item i set i.isActive = :isActive"); q.setBoolean("isActive", true); int updatedItems = q.executeUpdate(); Bulk and batch operations

insert a new entity from another selected entity. Session session = sessionFactory.openSession(); Transaction tx = session.beginTransaction(); String hqlInsert = "insert into VIPCustomer (id, name) select c.id, c.name from Customer c where c.balance > 10000"; int createdEntities = s.createQuery( hqlInsert ).executeUpdate(); tx.commit(); session.close(); Bulk and batch operations (cont.)

Batches ScrollableResults itemCursor = session.createQuery("from Item") .scroll(); // cursor is a pointer to a rs that stays in DB int count=0; while ( itemCursor.next() ) { Item item = (Item) itemCursor.get(0); modifyItem(item); if ( ++count % 100 == 0 ) { session.flush(); session.clear(); } } tx.commit(); session.close(); Bulk and batch operations (cont.)

Batches For best performance set the value of hibernate.jdbc.batch_size as the size of your procedure batch. Disable the second-level cache for that persistent class. Bulk and batch operations

Define filter: <filter-def name="myFilter"> <filter-param name="myFilterParam" type="string“ [condtion=“default condtion that applies to many entities”]/> </filter-def> Attach to a class: <class name="myClass" ...> ... <filter name="myFilter" condition=":myFilterParam = MY_FILTERED_COLUMN"/> </class> Filters

Example: <filter name=“userTypeFilter" condition=":userType = userTypeColumn"/> Enable filter: session.enableFilter("myFilter").setParameter("myFilterParam", "some-value"); Filters use cases: Security limits. Regional data. Temporal data. Filters (cont.)

Write an interceptor: public class AuditLogInterceptor extends EmptyInterceptor { public boolean onSave(…) { } public boolean onUpdate(…) {} public boolean postFlush(Iterator iter) {} … } Interceptors

Enabling the interceptor: AuditLogInterceptor interceptor = new AuditLogInterceptor(); Session session = getSessionFactory().openSession(interceptor); Or set it globally (thread-safe interceptor) Configuration.setInterceptor( new AuditLogInterceptor() ); Interceptors (cont.)

The new core engine for hibernate is based on events/listeners model. You can override the default listener and provider your own listener: public class SecurityLoadListener extends DefaultLoadEventListener { public void onLoad(LoadEvent event, LoadEventListener.LoadType loadType) throws HibernateException { super.onLoad(event, loadType); } } The core event system

Enable your listener: <session-factory> ... <event type="load"> <listener class=“com.b1me. SecurityLoadListener "/> </event> </session-factory> The core event system (cont.)

What part of the persistence object network should be loaded into memory. Hibernate by default loads only the objects you’re querying for. Item item = (Item) session.load(Item.class, new Long(123)); Fetching plans

After initializing the proxy (either by using the get() or by calling one of its properties): Item item = (Item) session.load(Item.class, new Long(123)); // Item item = (Item) session.get(Item.class, new Long(123)); item.getId(); // Initialize the proxy item.getDescription(); Fetching plans (cont.) In the figure associated proxies are just forign keys in the item’s row

Disabling proxy generation for a particular entity: <class name="CompanyBean" table="company" lazy="false" > session.load(CompanyBean.class, new Integer(2)) // no proxy Eager loading of assotiations: <class name="UserBean" table="user"> <many-to-one name=“address" column=“addId“ class=“Address" not-null="true" lazy="false"/> </class> <class name=“CompanyBean" table=“company"> <many-to-one name=“address" column=“addId" class=“Address" not-null="true" /> </class> Fetching plans (cont.) User Company Address

How an associated objects should be loaded, when the owning entity object is loaded. By default, hibernate fetches associated objects and collections lazily. Item item = (Item) session.get(Item.class, new Long(123)); select item.* from ITEM item where item.ITEM_ID=? If you access any associated proxy, a second SELECT is executed. Fetching strategies

List allItems = session.createCriteria(Item.class).list(); // suppose allItems size is 3 ((Item) allItems.get(0)).getSeller().getName(); ((Item) allItems.get(1)).getSeller().getName(); ((Item) allItems.get(2)).getSeller().getName(); Using lazy loading line 1 will execute: select * from ITEM While lines from 3 to 5 will execute: Line 2: Select * from User where id = ? Line 3: Select * from User where id = ? Line 4: Select * from User where id = ? This will cause n+1 selects problem. Fetching strategies (cont.)

Batch fetching: if one proxy must be fetched, go ahead and initialize several in the same SELECT. Batch fetching is a blind-guess optimization. You make a guess and apply a batch size to your user class mapping file: <class name="User” table="USERS” batch-size="10" > The resulted (n/10+1) SQL statements select * from ITEM select * from USER where id in (?, ?, ?) Fetching strategies (cont.)

Eager Fetching with join (Try to not use): “ Every time I need an Item, I also need the seller of that item” <class name="Item" table="ITEM"> <many-to-one name="seller” class="User” column="SELLER_ID” fetch="join" /> </class> The following SQL statement will be executed: select i.*, u.* from ITEM i left outer join USERS u on i.SELLER_ID = u.USER_ID where i.ITEM_ID = ? To control the number of joined tables: hibernate.max_fetch_depth Fetching strategies (cont.)

Setting query hints: setFlushMode(FlushMode.COMMIT) setCacheMode(CacheMode.IGNORE) setReadOnly(true) setTimeout(60) // 1 minute setFetchSize(50) setLockMode(LockMode.UPGRADE) setComment(“My comment …”)/ hibernate.use_sql_comments=true Advanced query

Executing a query List all results (you may use setFetchSize()) List l = query.list() List l = criteria.list() Iterating through the results Iterator iter = query.iterate() Scrolling with database cursors ScrollableResults c = query.scroll(); ScrollableResults c = criteria.scroll(); Advanced query (cont.)

Calling SQL functions: Any function that is not defined in the Dialect super class may not portable to other database system. To add SQL function to HQL: Configuration cfg = new Configuration(); cfg.addSqlFunction( "lpad", new StandardSQLFunction("lpad", Hibernate.STRING) ); Advanced query (cont.)

Projection - HQL: Select u.id, upper(u.name), u.age from User u Select count(distinct u.name) from User u Select u.birthofdate, current_date() from User u where u.birthofdate > current_date() Select new StudentSummary(count(s.id), avg(s.mark)) from Student s Advanced query (cont.)

Projection - Criteria: Session.createCriteria(User.class).setProjection(Projections.id()) criteria.setProjection(Projections.projectionList() .add(Projections.id()) // Property.forName(“id”) .add(Projections.property(“name”)) ); criteria.setProjection(Projections.projectionList() .add(Projections.count(“id”)) .add(Property.forName(“mark”).avg().as(“averag”)) ); criteria.setProjection(Projections.projectionList() .add(Projections.count(“id”).as(“size”)) .add(Property.forName(“mark”).avg().as(“averag”)) .setResultTransformer(new AliasToBeanResultTransformer(UserSummary.class)) ) Advanced query (cont.)

Joining relations and associations: Implicit association joins: Querying components: from User u where u.homeAddress.city = 'Bangkok‘ select distinct u.homeAddress.city from User u Expressing implicit association joins From user where user.company.name = ‘STS’ From user where user.company.country.isoCode = ‘JO’ Select user.company.name from User user Advanced query (cont.)

Joining relations and associations: Ordinary (explicit) join in the FROM clause -For Restrictions (inner join) Using HQL: from UserBean u join u.company c where u.name like '%a%' and c.name = 'STS‘ Select u from UserBean u join u.company c where u.name like '%a%' and c.name = 'STS‘ from UserBean u join u.addresses a where u.name like '%a%' and a.city = ‘amman’ Select distinct u from UserBean u join u.addresses a where u.name like '%a%' and a.city = ‘amman’ Advanced query (cont.)

Joining relations and associations: Ordinary (explicit) join in the FROM clause - For Restrictions (inner join) Using Criteria: session.createCriteria(User.class) .add(Restrictions.like(“name”, “%a%”)) . createCriteria (“company”) .add(Restrictions.eq(“name”, “sts”)) Session.createCriteria(User.class) . createAlias (“addresses”, “a”) .add(Restrictions.ilike(“[this.]name”, “%a%”)) .add(Restrictions.eq(“a.city”, “amman”)) . setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY) ; Advanced query (cont.)

Joining relations and associations: Dynamic (Eager) fetching strategies - HQL: from UserBean u join fetch u.company c where u.name like '%a%' and c.name = 'STS’ Select [DISTINCT] u from UserBean u join fetch u.addresses a where u.name like '%a%' and a.city = ‘amman’ Select [DISTINCT] u from UserBean u left join fetch u.addresses a where u.name like '%a%' and a.city = ‘amman’ Advanced query (cont.)

Joining relations and associations: Dynamic (Eager) fetching strategies - Criteria: Criteria criteira = session.createCriteria(User.class) criteria.createCriteria(“company”) criteria.setFetchMode(“company”,FetchMode.JOIN).add.. criteria .setFetchMode(“addresses”, FetchMode.JOIN) /outer join .add... // restrictions to the root entity criteira.createAlias(“addresses”, “a”, CriteriaSpecification.INNER_JOIN ).setFetchMode(“a”, FetchMode.JOIN) criteria.setFetchMode(“addresses”, “a”, FetchMode.JOIN).setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY) Advanced query (cont.)

Joining relations and associations: Theta style joins: Is useful when your join condition isn’t a foreign key relationship mapped to a class association from User user, LogRecord log where user.username = log.username Select u from User u, LogRecord l where u.username = l.username Advanced query (cont.)

Using named query Defining a named query <query name="findItemsByDescription” cache-mode="ignore" comment="My Comment...” fetch-size="50" read-only="true" timeout="60"> <![CDATA[ from Item item where item.description like :desc ]]></query> Calling a named query session.getNamedQuery("findItemsByDescription"). setString("desc", description); Advanced query – HQL (cont.)

Conjunction & disjunction session.createCriteria(User.class) .add( Restrictions.or( Restrictions.and( Restrictions.like("firstname", "G%"), Restrictions.like("lastname", "K%") ), Restrictions.in("email", emails) ) ); Advanced query – Criteria (cont.)

Conjunction & disjunction session.createCriteria(User.class) .add( Restrictions.disjunction() .add( Restrictions.conjunction() .add( Restrictions.like("firstname", "G%") ) .add( Restrictions.like("lastname", "K%") ) ) .add( Restrictions.in("email", emails) ) ); Advanced query – Criteria (cont.)

Advanced Hibernate

Recommended

More Related Content

What's hot (20)

Viewers also liked (14)

Similar to Advanced Hibernate (20)

More from Haitham Raik (11)

Recently uploaded (20)

Advanced Hibernate

Editor's Notes