HIBERNATE INTERVIEW QUESTIONS

 

The configuration files hibernate.cfg.xml (or hibernate.properties) and mapping files *.hbm.xml are used by the Configuration class to create (i.e. configure and bootstrap hibernate) the SessionFactory, which in turn creates the Session instances. Session instances are

the primary interface for the persistence service.

 

hibernate.cfg.xml (alternatively can use hibernate.properties): These two files are used to configure the hibernate sevice (connection driver class, connection URL, connection username, connection password, dialect etc). If both files are present in the classpath

then hibernate.cfg.xml file overrides the settings found in the hibernate.properties file.

 

Mapping files (*.hbm.xml): These files are used to map persistent objects to a relational database. It is the best practice to store each object in an individual mapping file (i.e mapping file per class) because storing large number of persistent classes into one mapping file can be difficult to manage and maintain. The naming convention is to use the same name as the

persistent (POJO) class name. For example Account.class will have a mapping file named Account.hbm.xml. Alternatively hibernate annotations can be used as part of your persistent class code instead of the *.hbm.xml files.

 

 

Q. What is a SessionFactory? Is it a thread-safe object?

 

Answer: SessionFactory is Hibernates concept of a single datastore and is threadsafe so that many threads can access it concurrently and request for sessions and immutable cache of compiled mappings for a single database. A SessionFactory is usually only built once at startup.

SessionFactory should be wrapped in some kind of singleton so that it can be easily accessed in an application code.

 

SessionFactory sessionFactory = new Configuration().configure().buildSessionfactory();

 

 

Q. What is a Session? Can you share a session object between different theads?

 

Answer: Session is a light weight and a non-threadsafe object (No, you cannot share it between threads) that represents a single unit-of-work with the database. Sessions are opened by a SessionFactory and then are closed when all work is complete. Session is the primary interface

for the persistence service. A session obtains a database connection lazily (i.e. only when required). To avoid creating too many sessions ThreadLocal class can be used as shown below to get the current session no matter how many times you make call to the currentSession() method.

 

public class HibernateUtil {

 

public static final ThreadLocal local = new ThreadLocal();

 

public static Session currentSession() throws HibernateException {

   Session session = (Session) local.get();

   //open a new session if this thread has no session

   if(session == null) {

           session = sessionFactory.openSession();

           local.set(session);

   }

   return session;

  }

}

 

 

Q. What are the benefits of detached objects?

Answer:Detached objects can be passed across layers all the way up to the presentation layer without having to use any DTOs (Data Transfer Objects). You can later on re-attach the detached objects to another session.

 

 

Q. What are the pros and cons of detached objects?

Pros:

" When long transactions are required due to user think-time, it is the best practice to break the long transaction up into two or more transactions. You can use detached objects from the first transaction to carry data all the way up to the presentation layer. These detached objects get modified outside a transaction and later on re-attached to a new transaction via another session.


Cons

" In general, working with detached objects is quite cumbersome, and better to not clutter up the session with them if possible. It is better to discard them and re-fetch them on subsequent requests. This approach is not only more portable but also more efficient because - the objects hang around in Hibernate's cache anyway.

" Also from pure rich domain driven design perspective it is recommended to use DTOs (DataTransferObjects) and DOs (DomainObjects) to maintain the separation between Service and UI tiers.

Q. How does Hibernate distinguish between transient (i.e. newly instantiated) and detached objects?

Answer " Hibernate uses the version property, if there is one.
" If not uses the identifier value. No identifier value means a new object. This does work only for Hibernate managed surrogate keys. Does not work for natural keys and assigned (i.e. not managed by Hibernate) surrogate keys. " Write your own strategy with Interceptor.isUnsaved().

 

 

Q. What is the difference between the session.get() method and the session.load() method?

Both the session.get(..) and session.load() methods create a persistent object by loading the required object from the database. But if there was not such object in the database then the method session.load(..) throws an exception whereas session.get(&) returns null.

 

 

Q. What is the difference between the session.update() method and the session.lock() method?

  • Both of these methods and saveOrUpdate() method are intended for reattaching a detached object.
  • The session.lock() method simply reattaches the object to the session without checking or updating the database on the assumption that the database in sync with the detached object.
  • It is the best practice to use either session.update(..) or session.saveOrUpdate().
  • Use session.lock() only if you are absolutely sure that the detached object is in sync with your
  • detached object or if it does not matter because you will be overwriting all the columns that
  • would have changed later on within the same transaction.


Note: When you reattach detached objects you need to make sure that the dependent objects are reatched as well.

 

Q. How would you reatach detached objects to a session when the same object has already been loaded into the session?

You can use the session.merge() method call.

 

Q. What are the general considerations or best practices for defining your Hibernate persistent classes?


1.You must have a default no-argument constructor for your persistent classes and there should be getXXX() (i.e accessor/getter) and setXXX( i.e. mutator/setter) methods for all your persistable instance variables.

2.You should implement the equals() and hashCode() methods based on your business key and it is important not to use the id field in your equals() and hashCode() definition if the id field is a surrogate key (i.e. Hibernate managed identifier). This is because the Hibernate only generates and sets the field when saving the object.


3. It is recommended to implement the Serializable interface. This is potentially useful if you want to migrate around a multi-processor cluster.

4.The persistent class should not be final because if it is final then lazy loading cannot be used by creating proxy objects.

5.Use XDoclet tags for generating your *.hbm.xml files or Annotations (JDK 1.5 onwards), which are less verbose than *.hbm.xml files.

 

Question: What are the Core interfaces are of Hibernate framework?

The five core interfaces are used in just about every Hibernate application. Using these interfaces, you can store and retrieve persistent objects and control transactions.

  • Session interface
  • SessionFactory interface
  • Configuration interface
  • Transaction interface
  • Query and Criteria interfaces

 

What is query cache in Hibernate?
QueryCache actually stores the result of SQL query for future calls. Query cache can be used along with second level cache for improved performance. Hibernate support various open source caching solution to implement Query cache e.g. EhCache.

 

 

 

What role does the Session interface play in Hibernate?
The Session interface is the primary interface used by Hibernate applications. It is a single-threaded, short-lived object representing a conversation between the application and the persistent store. It allows you to create query objects to retrieve persistent objects.

Session session = sessionFactory.openSession();

Session interface role:

  • 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

 

What role does the SessionFactory interface play in Hibernate?

The application obtains Session instances from a SessionFactory. There is typically a single SessionFactory for the whole application—created during application initialization. The SessionFactory caches generate SQL statements and other mapping metadata that Hibernate uses at runtime. It also holds cached data that has been read in one unit of work and may be reused in a future unit of work

SessionFactory sessionFactory = configuration.buildSessionFactory()

 

What is the general flow of Hibernate communication with RDBMS?

The general flow of Hibernate communication with RDBMS is :

  • Load the Hibernate configuration file and create configuration object. It will automatically load all hbm mapping files
  • Create session factory from configuration object
  • Get one session from this session factory
  • Create HQL Query
  • Execute query to get list containing Java objects

What is Hibernate Query Language (HQL)?

Hibernate offers a query language that embodies a very powerful and flexible mechanism to query, store, update, and retrieve objects from a database. This language, the Hibernate query Language (HQL), is an object-oriented extension to SQL

What’s the difference between load() and get()?

load() vs. get() :-

load() 

get() 

Only use the load() method if you are sure that the object exists. 

If you are not sure that the object exists, then use one of the get() methods. 

load() method will throw an exception if the unique id is not found in the database. 

get() method will return null if the unique id is not found in the database. 

load() just returns a proxy by default and database won’t be hit until the proxy is first invoked.  

get() will hit the database immediately. 

 

What is the difference between and merge and update ?

Use update() if you are sure that the session does not contain an already persistent instance with the same identifier, and merge() if you want to merge your modifications at any time without consideration of the state of the session.

 

What do you mean by Named – SQL query?

Named SQL queries are defined in the mapping xml document and called wherever required.
Example:

<sql-query name = "empdetails">

 <return alias="emp" class="com.test.Employee"/>

  SELECT emp.EMP_ID AS {emp.empid},

 emp.EMP_ADDRESS AS {emp.address},

 emp.EMP_NAME AS {emp.name} 

 FROM Employee EMP WHERE emp.NAME LIKE :name

 </sql-query>

 

Invoke Named Query :

List people = session.getNamedQuery("empdetails")

 .setString("TomBrady", name)

 .setMaxResults(50)

 .list();

 

Explain Criteria API

Criteria is a simplified API for retrieving entities by composing Criterion objects. This is a very convenient approach for functionality like "search" screens where there is a variable number of conditions to be placed upon the result set.
Example :

List employees = session.createCriteria(Employee.class)

 .add(Restrictions.like("name", "a%") )

 .add(Restrictions.like("address", "Boston"))

 .addOrder(Order.asc("name") )

 .list();

 

Define HibernateTemplate?

org.springframework.orm.hibernate.HibernateTemplate is a helper class which provides different methods for querying/retrieving data from the database. It also converts checked HibernateExceptions into unchecked DataAccessExceptions.

 

 

What are the benefits does HibernateTemplate provide?

The benefits of HibernateTemplate are :

  • HibernateTemplate, a Spring Template class simplifies interactions with Hibernate Session.
  • Common functions are simplified to single method calls.
  • Sessions are automatically closed.
  • Exceptions are automatically caught and converted to runtime exceptions.

 

How do you switch between relational databases without code changes?

Using Hibernate SQL Dialects , we can switch databases. Hibernate will generate appropriate hql queries based on the dialect defined.

If you want to see the Hibernate generated SQL statements on console, what should we do?

In Hibernate configuration file set as follows:


          <property name="show_sql">true</property>

 

What is the difference between sorted and ordered collection in hibernate?

sorted collection vs. order collection :-

sorted collection 

order collection 

A sorted collection is sorting a collection by utilizing the sorting features provided by the Java collections framework. The sorting occurs in the memory of JVM which running Hibernate, after the data being read from database using java comparator. 

Order collection is sorting a collection by specifying the order-by clause for sorting this collection when retrieval. 

If your collection is not large, it will be more efficient way to sort it. 

If your collection is very large, it will be more efficient way to sort it . 

 

What are the Collection types in Hibernate ?

  • Bag
  • Set
  • List
  • Array
  • Map

What are the ways to express joins in HQL?

HQL provides four ways of expressing (inner and outer) joins:-

  • An implicit association join
  • An ordinary join in the FROM clause
  • A fetch join in the FROM clause.
  • A theta-style join in the WHERE clause.

What are Callback interfaces?

Callback interfaces allow the application to receive a notification when something interesting happens to an object—for example, when an object is loaded, saved, or deleted. Hibernate applications don't need to implement these callbacks, but they're useful for implementing certain kinds of generic functionality.

 

 

What is the advantage of Hibernate over jdbc?     Hibernate Vs. JDBC :-

JDBC 

Hibernate 

With JDBC, developer has to write code to map an object model's data representation to a relational data model and its corresponding database schema.  

Hibernate is flexible and powerful ORM solution to map Java classes to database tables. Hibernate itself takes care of this mapping using XML files so developer does not need to write code for this. 

With JDBC, the automatic mapping of Java objects with database tables and vice versa conversion is to be taken care of by the developer manually with lines of code.  

Hibernate provides transparent persistence and developer does not need to write code explicitly to map database tables tuples to application objects during interaction with RDBMS.  

JDBC supports only native Structured Query Language (SQL). Developer has to find out the efficient way to access database, i.e. to select effective query from a number of queries to perform same task.  

Hibernate provides a powerful query language Hibernate Query Language (independent from type of database) that is expressed in a familiar SQL like syntax and includes full support for polymorphic queries. Hibernate also supports native SQL statements. It also selects an effective way to perform a database manipulation task for an application.  

Application using JDBC to handle persistent data (database tables) having database specific code in large amount. The code written to map table data to application objects and vice versa is actually to map table fields to object properties. As table changed or database changed then it’s essential to change object structure as well as to change code written to map table-to-object/object-to-table. 

Hibernate provides this mapping itself. The actual mapping between tables and application objects is done in XML files. If there is change in Database or in any table then the only need to change XML file properties.  

With JDBC, it is developer’s responsibility to handle JDBC result set and convert it to Java objects through code to use this persistent data in application. So with JDBC, mapping between Java objects and database tables is done manually.  

Hibernate reduces lines of code by maintaining object-table mapping itself and returns result to application in form of Java objects. It relieves programmer from manual handling of persistent data, hence reducing the development time and maintenance cost.  

With JDBC, caching is maintained by hand-coding. 

Hibernate, with Transparent Persistence, cache is set to application work space. Relational tuples are moved to this cache as a result of query. It improves performance if client application reads same data many times for same write. Automatic Transparent Persistence allows the developer to concentrate more on business logic rather than this application code.  

In JDBC there is no check that always every user has updated data. This check has to be added by the developer.  

Hibernate enables developer to define version type field to application, due to this defined field Hibernate updates version field of database table every time relational tuple is updated in form of Java class object to that table. So if two users retrieve same tuple and then modify it and one user save this modified tuple to database, version is automatically updated for this tuple by Hibernate. When other user tries to save updated tuple to database then it does not allow saving it because this user does not have updated data.  

 

 

 

What are the types of Hibernate instance states ? Three types of instance states:

  • Transient -The instance is not associated with any persistence context
  • Persistent -The instance is associated with a persistence context
  • Detached -The instance was associated with a persistence context which has been closed – currently not associated

What are the types of inheritance models in Hibernate?

There are three types of inheritance models in Hibernate:

  • Table per class hierarchy
  • Table per subclass
  • Table per concrete class

What the Core interfaces are of hibernate framework?

There are many benefits from these. Out of which the following are the most important

one.

 

  1. Session Interface – This is the primary interface used by hibernate applications.The instances of this interface are lightweight and are inexpensive to create and destroy.Hibernate sessions are not thread safe.
  2. SessionFactory Interface – This is a factory that delivers the session objects tohibernate application. Generally there will be a single SessionFactory for the whole application and it will be shared among all the application threads.
  3. Configuration Interface – This interface is used to configure and bootstrap hibernate. The instance of this interface is used by the application in order to specify the location of hibernate specific mapping documents.
  4. Transaction Interface – This is an optional interface but the above three interfaces are mandatory in each and every application. This interface abstracts the code from any kind of transaction implementations such as JDBC transaction, JTA transaction.
  5. Query and Criteria Interface – This interface allows the user to perform queries and also control the flow of the query execution.

 

What are Callback interfaces?

These interfaces are used in the application to receive a notification when some object

events occur. Like when an object is loaded, saved or deleted. There is no need to

implement callbacks in hibernate applications, but they’re useful for implementing

certain kinds of generic functionality.

 

What are Extension interfaces?

When the built-in functionalities provided by hibernate is not sufficient enough, it

provides a way so that user can include other interfaces and implement those interfaces

for user desire functionality. These interfaces are called as Extension interfaces.

 

 

What are the Extension interfaces that are there in hibernate?

There are many extension interfaces provided by hibernate.

  1. ProxyFactory interface - used to create proxies
  2. ConnectionProvider interface – used for JDBC connection management
  3. TransactionFactory interface – Used for transaction management
  4. Transaction interface – Used for transaction management
  5. TransactionManagementLookup interface – Used in transaction management.
  6. Cahce interface – provides caching techniques and strategies
  7. CacheProvider interface – same as Cache interface
  8. ClassPersister interface – provides ORM strategies
  9. IdentifierGenerator interface – used for primary key generation
  10. Dialect abstract class – provides SQL support

What are different environments to configure hibernate?

There are mainly two types of environments in which the configuration of hibernate

application differs.

  1. Managed environment – In this kind of environment everything from database connections, transaction boundaries, security levels and all are defined. An example of this kind of environment is environment provided by application servers such as JBoss,Weblogic and WebSphere.
  2. Non-managed environment – This kind of environment provides a basic configuration template. Tomcat is one of the best examples that provide this kind of environment.

18. What is the file extension you use for hibernate mapping file?

The name of the file should be like this : filename.hbm.xml

The filename varies here. The extension of these files should be “.hbm.xml”.

This is just a convention and it’s not mandatory. But this is the best practice to follow this

extension.

 

What do you create a SessionFactory?

      Configuration cfg = new Configuration();

      cfg.addResource("myinstance/MyConfig.hbm.xml");

      cfg.setProperties( System.getProperties() );

      SessionFactory sessions = cfg.buildSessionFactory();

 

First, we need to create an instance of Configuration and use that instance to refer to the

location of the configuration file. After configuring this instance is used to create the

SessionFactory by calling the method buildSessionFactory().

 

 

Difference between session.save() , session.saveOrUpdate() and session.persist()?

session.save() : Save does an insert and will fail if the primary key is already persistent.

session.saveOrUpdate() : saveOrUpdate does a select first to determine if it needs to do an insert or an update.Insert data if primary key not exist otherwise update data.

session.persist() : Does the same like session.save().
session.save() return Serializable object but session.persist() return void.
 session.save() returns the generated identifier (Serializable object) and session.persist() doesn't.


For Example :
         if you do :-
         System.out.println(session.save(question));
         This will print the generated primary key.
         if you do :-
         System.out.println(session.persist(question));
         Compile time error because session.persist() return void.

 

Why do you need ORM tools like hibernate?

The main advantage of ORM like hibernate is that it shields developers from messy SQL. Apart from this, ORM provides following benefits:
 

  1. Improved productivity
  2. High-level object-oriented API
  3. Less Java code to write
  4. No SQL to write
  5. Improved performance
  6. Sophisticated caching
  7. Lazy loading
  8. Eager loading
  9. Improved maintainability
  10. A lot less code to write
  11. Improved portability
  12. ORM framework generates database-specific SQL for you

 

Q. What is the difference between sorted and ordered collection in hibernate?
A. A sorted collection is sorted in-memory using java comparator, while order collection is ordered at the database level using order by clause.

 

Q. What are the types of inheritence models and describe how they work like vertical inheritence and horizontal?

A. There are three types of inheritance mapping in hibernate:

Example: Let us take the simple example of 3 java classes.
Class Manager and Worker are inherited from Employee Abstract class.

 

1. Table per concrete class with unions : In this case there will be 2 tables.

Tables: Manager, Worker [all common attributes will be duplicated]


2. Table per class hierarchy: Single Table can be mapped to a class hierarchy.There will be only one table in database called 'Employee' that will represent allthe attributes required for all 3 classes. But it needs some discriminating columnto differentiate between Manager and worker;

 

3. Table per subclass: In this case there will be 3 tables represent Employee,

Manager and Worker

 

Q. What are different types of cache hibernate supports ?

A. Caching is widely used for optimizing database applications. Hibernate uses two different caches for objects: first-level cache and second-level cache.

First-level cache is associated with the Session object, while

second-level cache is associated with the Session Factory object.

By default, Hibernate uses first-level cache on a per-transaction basis.

Hibernate uses this cache mainly to reduce the number of SQL queries it needs to generate within a given transaction.

For example, if an object is modified several times within the same transaction,

Hibernate will generate only one SQL UPDATE statement at the end of the transaction, containing all the modifications.

 

To reduce database traffic, second-level cache keeps loaded objects at the Session Factory level between multiple transactions.

These objects are available to the whole application, not just to the user running the query.

This way, each time a query returns an object that is already loaded in the cache, one or more database transactions potentially are avoided.

In addition, you can use a query-level cache if you need to cache actual query results, rather than just persistent objects.

The query cache should always be used in conjunction with the second-level cache.

Hibernate supports the following open-source cache implementations out-of-the-box:

 

  • EHCache is a fast, lightweight, and easy-to-use in-process cache. It supports read-only and read/write caching, and memory- and disk-based caching. However, it does not support clustering.
  • OSCache is another open-source caching solution. It is part of a larger package, which also provides caching functionalities for JSP pages or arbitrary objects. It is a powerful and flexible package, which, like EHCache, supports read-only and read/write caching, and memory- and disk-based caching. It also provides basic support for clustering via either JavaGroups or JMS.
  • SwarmCache is a simple cluster-based caching solution based on JavaGroups. It supports read-only or nonstrict read/write caching (the next section explains this term). This type of cache is appropriate for applications that typically have many more read operations than write operations
  •  JBoss TreeCache is a powerful replicated (synchronous or asynchronous) and transactional cache. Use this solution if you really need a true transaction-capable caching architecture.
  • Commercial Tangosol Coherence cache.

 

Q. What are the different caching strategies?

A. The following four caching strategies are available:

 

  • Read-only: This strategy is useful for data that is read frequently but never updated. This is by far the simplest and best-performing cache strategy.
  • Read/write: Read/write caches may be appropriate if your data needs to be updated. They carry more overhead than read-only caches. In non-JTA environments, each transaction should be completed when Session.close() or Session.disconnect() is called.
  • Nonstrict read/write: This strategy does not guarantee that two transactions won't simultaneously modify the same data. Therefore, it may be most appropriate for data that is read often but only occasionally modified.
  •  Transactional: This is a fully transactional cache that may be used only in a JTA environment.

 

Q. How do you configure 2nd level cach in hibernate?

A. To activate second-level caching, you need to define the hibernate.cache.provider_class property in the hibernate.cfg.xml file as follows:

 

<hibernate-configuration>

   <session-factory>

       <property name="hibernate.cache.provider_class">org.hibernate.cache.EHCacheProvider</property>

   </session-factory>

</hibernate-configuration>

 

By default, the second-level cache is activated and uses the EHCache provider.

To use the query cache you must first enable it by setting the property hibernate.cache.use_query_cache to true in hibernate.properties.

 

If load() can’t find the object in the cache or database, an exception is thrown. The load() method never returns null. The get() method returns

null if the object can’t be found

 

 

Q. How do you configure 2nd level cach in hibernate?

A.To activate second-level caching,you define

 

hibernate.cache.provider_class property in the hibernate.cfg.xml file as follows:

 

<hibernate-configuration>

<session-factory>

   <property

         name="hibernate.cache.provider_class">org.hibernate.cache.EHCacheProvider</property>

</session-factory>

</hibernate-configuration>

 

What’s transaction management in hibernate? How it works?
Transaction management is the process of managing a set of statements or commands. In hibernate; transaction management is done by transaction interface as shown in below code:

 

Session s = null;

Transaction tr = null;

try{

       s = sessionFactory.openSession();

       tr = s.beginTransaction();

       doTheAction(s);

       tr.commit();

} catch(RuntimeException exc) {

       tr.rollback();

} finally{

       s.close();

}



 
 

What are the different fetching strategies in Hibernate?

A. Hibernate3 defines the following fetching strategies:

 

Join fetching - Hibernate retrieves the associated instance or collection in the

same SELECT, using an OUTER JOIN.

 

Select fetching - a second SELECT is used to retrieve the associated entity or collection.

Unless you explicitly disable lazy fetching by specifying lazy="false", this second select will

only be executed when you actually access the association. Subselect fetching - a second SELECT is used to retrieve the associated collections for all entities retrieved in a previous query or fetch.

Unless you explicitly disable lazy fetching by specifying lazy="false", this second select will only

be executed when you actually access the association.Batch fetching - an optimization strategy for

select fetching - Hibernate retrieves a batch of entity instances or collections in a single SELECT, 

by specifying a list of primary keys or foreign keys.

 

 

How primary key is created by using hibernate?
Database primary key is specified in the configuration file hbm.xml. Generator can also be used to specify how primary key is being created in the database.
In the below example, deptId acts as primary key:

<idname="deptId"type="string">

    <columnname="columnId"length="30"/>

<generator/>

 </id>

 

 

What are the ways to express joins in HQL?

HQL provides four ways of expressing (inner and outer) joins:-

  • An implicit association join
  • An ordinary join in the FROM clause
  • A fetch join in the FROM clause.
  • A theta-style join in the WHERE clause.

Define cascade and inverse option in one-many mapping?

cascade - enable operations to cascade to child entities.
cascade="all|none|save-update|delete|all-delete-orphan"

inverse - mark this collection as the "inverse" end of a bidirectional association.
inverse="true | false"
Essentially "inverse" indicates which end of a relationship should be ignored, so when persisting a parent who has a collection of children, should you ask the parent for its list of children, or ask the children who the parents are?


What is Hibernate proxy?

The proxy attribute enables lazy initialization of persistent instances of the class. Hibernate will initially return CGLIB proxies which implement the named interface. The actual persistent object will be loaded when a method of the proxy is invoked.

What are the types of inheritance models in Hibernate?

There are three types of inheritance models in Hibernate:

  • Table per class hierarchy
  • Table per subclass
  • Table per concrete class

Q:5 What do you mean by first and second level cache in hibernate?
Two different cache types are used by hibernate.
First level cache is associated with Session Object. This is used to cache all updates in a given transaction and apply them as a single update statement at the end of transaction. This reduces number of update queries fired.

Second level cache is associated with SessionFactory object. This reduces database traffic by caching loaded objects between different transactions. Such objects are available to whole application.You need one session factory per database, if u need multiple databases then u need multiple session factories per database. Session should be accessed within a single thread of execution.


Session provides

  • caching functionality,
  • manages lazy loading of objects,
  • watches changes to associated objects.

 

One session factory for each database your app will access, session factory is thread safe, creating many session objects one per thread, sessions in hibernate are not thread safe , session must not be shared between thread will otherwise will cause deadlocks and dataloss.

 

Transaction and locking are related, ACID – atomic, consistent, isolation, durability

 

Isolation levels are following

 

READ UNCOMMITED –   dirty, non-repeatable, phantom read are permitted

READ COMMITTED – , non-repeatable, phantom read are permitted

REPEATABLE READ – , phantom read are permitted

SERIALIZABLE –

 

Dirty read sees in-progress changes of un committed transaction

Non-repeatable read sees different data for the same query

Phantom read see different number of rows for the same query

 

Isolation is implemented using locking , to prevent simultaneous access to data , database will acquire lock on that data .

Optimistic Locking - Momentary operation on that data only USING VERSIONING

                                   Optimistic-lock = “version”

Pessimistic Locking – uses a locking mechanism ,lock can be retained until the end of the transaction

 

Read-Uncommitted isolation always get Optimistic Locks

Serializable isolation will get pessimistic locks

 

DeadLocks – Two thread can get into a situation in which each is waiting for the other thread to release a resource that it needs. Deadlocks also occur when a single thread of execution is carrying out an equivalent sequence of operations using 2 session objects connected to the same database.

DO NOT SHARE session object between multiple threads.

 

Do not use the same session object outside the current thread by using an instance local to the current thread, if u need to maintain instance for longer duration , maintain the instance inside a ThreadLocal object

 

Configuring the second level cache is a 2 step process,

  • first decide the concurrent strategy,
  • second choose the cache provider that implement the caching strategy

 

There are Four built in concurrency strategies

  1. Transactional
  2. Read-write
  3. Non-Strict read-write
  4. Read Only

 

First level cache is at the transaction level, it is default, is associated with a session. If the same query is executed multiple times in the same session.

 

Isolation defines how and when changes made by one transaction are made visible to other transactions.

 

Serializable – Transactions are executed serially, one after the other. This isolation level allows a transaction to get read locks or write locks for the entire range of data that it effects.

 

Repeatable read – read locks and write locks are qcquired.

Read Committed -

Read Un committed -