Hibernate

As far as it is compared to J2EE environment, if the SessionFactory is placed in JNDI then it can be easily accessed and shared between different threads and various components that are hibernate aware. You can set the SessionFactory to a JNDI by configuring a property hibernate.session_factory_name in the hibernate.properties file.

Hibernate simplifies:

* Saving and retrieving your domain objects

* Making database column and table name changes

* Centralizing pre save and post retrieve logic

* Complex joins for retrieving related items

* Schema creation from object model

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.

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.

Using <generator> tag.

Example:-

<id column=”USER_ID” name=”id” type=”java.lang.Long”>

<generator class=”sequence”>

<param name=”table”>SEQUENCE_NAME</param>

<generator>

</id>

load() vs. get()

load() :-

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

load() method will throw an exception 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():-

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

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

get() will hit the database immediately.

<sql-query name=”selectAllEmployees_SP” callable=”true”>

<return alias=”emp” class=”employee”>

<return-property name=”empid” column=”EMP_ID”/>

<return-property name=”name” column=”EMP_NAME”/>

<return-property name=”address” column=”EMP_ADDRESS”/>

{ ? = call selectAllEmployees() }

</return>

</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();

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?

POJO stands for plain old java objects. These are just basic JavaBeans that have defined setter and getter methods for all the properties that are there in that bean. Besides they can also have some business logic related to that property. Hibernate applications works efficiently with POJOs rather then simple java classes.

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();

It informs hibernate to ignore that end of the relationship. If the one–to–many was marked as inverse, hibernate would create a child–>parent relationship (child.getParent). If the one–to–many was marked as non–inverse then a child–>parent relationship would be created.

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.

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

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.

The properties that are not mapped to a column, but calculated at runtime by evaluation of an expression are called derived properties. The expression can be defined using the formula attribute of the element.

People who read this also read:

Core Java Questions

Spring Questions

SCJP 6.0 Certification

EJB Interview Questions

Servlets Questions

* A component is an object saved as a value, not as a reference

* A component can be saved directly without needing to declare interfaces or identifier properties

* Required to define an empty constructor

* Shared references not supported

sorted collection vs. order collection

sorted 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.

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

order collection :-

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

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

In Hibernate configuration file set as follows:

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