what are the interview questions

Top 50 Hibernate questions

1. What’s Hibernate?

Hibernate is a popular framework of Java which allows an efficient Object Relational mapping using configuration files in XML format. After java objects mapping to database tables, database is used and handled using Java objects without writing complex database queries.

http://capptitudebank.blogspot.com

2. What is ORM?

ORM (Object Relational Mapping) is the fundamental concept of Hibernate framework which maps database tables with Java Objects and then provides various API’s to perform different types of operations on the data tables.

3. How properties of a class are mapped to the columns of a database table in Hibernate?

Mappings between class properties and table columns are specified in XML file as in the below example:

http://capptitudebank.blogspot.com

<?xml version="1.0"?> <!DOCTYPE hibernate-mapping PUBLIC

"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">

<hibernate-mapping>

<class name="departmentClass" table="TBL_DEPT">

<property name="dept" column="department_name">

<property name="Description" column="department_details"/>

<many-to-one name="nxtPer" cascade="all" column="NxtPerId"/>

</class>

</hibernate-mapping>

4. What’s the usage of Configuration Interface in hibernate?

Configuration interface of hibernate framework is used to configure hibernate. It’s also used to bootstrap hibernate. Mapping documents of hibernate are located using this interface.

5. How can we use new custom interfaces to enhance functionality of built-in interfaces of hibernate?

We can use extension interfaces in order to add any required functionality which isn’t supported by built-in interfaces.

6. Should all the mapping files of hibernate have .hbm.xml extension to work properly?

No, having .hbm.xml extension is a convention and not a requirement for hibernate mapping file names. We can have any extension for these mapping files.

7. How do we create session factory in hibernate?

To create a session factory in hibernate, an object of configuration is created first which refers to the path of configuration file and then for that configuration, session factory is created as given in the example below:

Configuration config = new Configuration();

config.addResource(&amp;quot;myinstance/configuration.hbm.xml&amp;quot;);

config.setProperties( System.getProperties() );

SessionFactory sessions = config.buildSessionFactory();

8. What are POJOs and what’s their significance?

POJOs( Plain Old Java Objects) are java beans with proper getter and setter methods for each and every properties.

Use of POJOs instead of simple java classes results in an efficient and well constructed code.

9. What’s HQL?

HQL is the query language used in Hibernate which is an extension of SQL. HQL is very efficient, simple and flexible query language to do various type of operations on relational database without writing complex database queries.

10. How can we invoke stored procedures in hibernate?

In hibernate we can execute stored procedures using code as below:

<sql-query name="getStudents" callable="true">

  <return alias="st" class="Student">

    <return-property name="std_id" column="STD_ID"/>

    <return-property name="s_name" column="STD_NAME"/>

    <return-property name="s_dept" column="STD_DEPARTMENT"/>

     { ? = call selectStudents() }

  </return>

 </sql-query>

11. What is criteria API?

Criteria is a simple yet powerful API of hibernate which is used to retrieve entities through criteria object composition.

12. What are the benefits of using Hibernate template?

Following are some key benefits of using Hibernate template:

a. Session closing is automated.

b. Interaction with hibernate session is simplified.

c. Exception handling is automated.

13. How can we see hibernate generated SQL on console?

We need to add following in hibernate configuration file to enable viewing SQL on the console for debugging purposes:

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

14. What are the two types of collections in hibernate?

Following are the two types of collections in hibernate:

a. Sorted Collection

b. Order Collection

15. What’s the difference between session.save() and session.saveOrUpdate() methods in hibernate?

Sessionsave() method saves a record only if it’s unique with respect to its primary key and will fail to insert if primary key already exists in the table.

saveOrUpdate() method inserts a new record if primary key is unique and will update an existing record if primary key exists in the table already.

16. What the benefits are of hibernate over JDBC?

a. Hibernate can be used seamlessly with any type of database as its database independent while in case of JDBC, developer has to write database specific queries.

b. Using hibernate, developer doesn’t need to be an expert of writing complex queries as HQL simplifies query writing process while in case of JDBC, its job of developer to write and tune queries.

c. In case of hibernate, there is no need to create connection pools as hibernate does all connection handling automatically while in case of JDBC, connection pools need to be created.

17. How can we get hibernate statistics?

We can get hibernate statistics using getStatistics() method of SessionFactory class as shown below:

SessionFactory.getStatistics()

18. What is transient instance state in Hibernate?

If an instance is not associated with any persistent context and also, it has never been associated with any persistent context, then it’s said to be in transient state.

19. How can we reduce database write action times in Hibernate?

Hibernate provides dirty checking feature which can be used to reduce database write times. Dirty checking feature of hibernate updates only those fields which require a change while keeps others unchanged.

20. What’s the usage of callback interfaces in hibernate?

Callback interfaces of hibernate are useful in receiving event notifications from objects. For example, when an object is loaded or deleted, an event is generated and notification is sent using callback interfaces.

21. When an instance goes in detached state in hibernate?

When an instance was earlier associated with some persistent context (e.g. a table) and is no longer associated, it’s called to be in detached state.

22. What the four ORM levels are in hibernate?

Following are the four ORM levels in hibernate:

a. Pure Relational

b. Light Object Mapping

c. Medium Object Mapping

d. Full Object Mapping

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

}

24. What the two methods are of hibernate configuration?

We can use any of the following two methods of hibernate configuration:

a. XML based configuration ( using hibernate.cfg.xml file)

b. Programmatic configuration ( Using code logic)

25. What is the default cache service of hibernate?

Hibernate supports multiple cache services like EHCache, OSCache, SWARMCache and TreeCache and default cache service of hibernate is EHCache.

26. What are the two mapping associations used in hibernate?

In hibernate; we have following two types of mapping associations between entities:

a. One-to-One Association

b. Many-to-Many Association

27. What’s the usage of Hibernate QBC API?

Hibernate Query By Criteria (QBC) API is used to create queries by manipulation of criteria objects at runtime.

28. In how many ways, objects can be fetched from database in hibernate?

Hibernate provides following four ways to fetch objects from database:

a. Using HQL

b. Using identifier

c. Using Criteria API

d. Using Standard SQL

29. 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:

<id name="deptId" type="string" >

<column name="columnId" length="30"/>

<generator/>

 </id>

30. How can we reattach any detached objects in Hibernate?

Objects which have been detached and are no longer associated with any persistent entities can be reattached by calling session.merge() method of session class.

31. What are different ways to disable hibernate second level cache?

Hibernate second level cache can be disabled using any of the following ways:

a. By setting use_second_level_cache as false.

b. By using CACHEMODE.IGNORE

c. Using cache provider as org.hibernate.cache.NoCacheProvider

32. What is ORM metadata?

All the mapping between classes and tables, properties and columns, Java types and SQL types etc is defined in ORM metadata.

33. Which one is the default transaction factory in hibernate?

With hibernate 3.2, default transaction factory is JDBCTransactionFactory.

34. What’s the role of JMX in hibernate?

Java Applications and components are managed in hibernate by a standard API called JMX API. JMX provides tools for development of efficient and robust distributed, web based solutions.

35. How can we bind hibernate session factory to JNDI ?

Hibernate session factory can be bound to JNDI by making configuration changes in hibernate.cfg file.

36. In how many ways objects can be identified in Hibernate?

Object identification can be done in hibernate in following three ways:

a. Using Object Identity: Using == operator.

b. Using Object Equality: Using equals() method.

c. Using database identity: Relational database objects can be identified if they represent same row.

37. What different fetching strategies are of hibernate?

Following fetching strategies are available in hibernate:

1. Join Fetching

2. Batch Fetching

3. Select Fetching

4. Sub-select Fetching

38. How mapping of java objects is done with database tables?

To map java objects with database tables, we need to have Java beans properties names same as column names of a database table. Then mapping is provided in hbm.xml file as given below:

<hibernate-mapping>

<class name="Student"  table="tbl_student">

<property  column="studentname" length="255"

name="studentName" not-null="true"  type="java.lang.String"/>

<property  column="studentDisciplne" length="255"

name="studentDiscipline" not-null="true"  type="java.lang.String"/>

 </class>

</hibernate-mapping>

39. What are derived properties in hibernate?

Derived properties are those properties which are not mapped to any columns of a database table. Such properties are calculated at runtime by evaluation of any expressions.

40. What is meant by a Named SQL Query in hibernate and how it’s used?

Named SQL queries are those queries which are defined in mapping file and are called as required anywhere.

For example, we can write a SQL query in our XML mapping file as follows:

<sql-query name = "studentdetails">

<return alias="std"/>

SELECT std.STUDENT_ID AS {std.STUDENT_ID},

std.STUDENT_DISCIPLINE AS {std.discipline},

FROM Student std WHERE std.NAME LIKE :name

</sql-query>

Then this query can be called as follows:

List students = session.getNamedQuery(&amp;quot;studentdetails&amp;quot;)

 .setString(&amp;quot;TomBrady&amp;quot;, name)

 .setMaxResults(50)

 .list();

41. What’s the difference between load() and get() method in hibernate?

Load() methods results in an exception if the required records isn’t found in the database while get() method returns null when records against the id isn’t found in the database.

So, ideally we should use Load() method only when we are sure about existence of records against an id.

42. What’s the use of version property in hibernate?

Version property is used in hibernate to know whether an object is in transient state or in detached state.

43. What is attribute oriented programming?

In Attribute oriented programming, a developer can add Meta data (attributes) in the java source code to add more significance in the code. For Java (hibernate), attribute oriented programming is enabled by an engine called XDoclet.

44. What’s the use of session.lock() in hibernate?

session.lock() method of session class is used to reattach an object which has been detached earlier. This method of reattaching doesn’t check for any data synchronization in database while reattaching the object and hence may lead to lack of synchronization in data.

45. Does hibernate support polymorphism?

Yes, hibernate fully supports polymorphism. Polymorphism queries and polymorphism associations are supported in all mapping strategies of hibernate.

46. What the three inheritance models are of hibernate?

Hibernate has following three inheritance models:

a. Tables Per Concrete Class

b. Table per class hierarchy

c. Table per sub-class

47. How can we map the classes as immutable?

If we don’t want an application to update or delete objects of a class in hibernate, we can make the class as immutable by setting mutable=false

48. What’s general hibernate flow using RDBMS?

General hibernate flow involving RDBMS is as follows:

a. Load configuration file and create object of configuration class.

b. Using configuration object, create sessionFactory object.

c. From sessionFactory, get one session.

d. Create HQL query.

e. Execute HQL query and get the results. Results will be in the form of a list.

49. What is Light Object Mapping?

Light Object Mapping is one of the levels of ORM quality in which all entities are represented as classes and they are mapped manually.

50. What’s difference between managed associations and hibernate associations?

Managed associations relate to container management persistence and are bi-directional while hibernate associations are unidirectional.

Integrating Spring and Hibernate: Transactions

In the previous post, I described different ways in which spring and hibernate can
be integrated. In this post I will describe how to use Spring's transaction features
in hibernate. The following methods of transaction management with spring and hibernate are discussed.

1. Declarative Transaction Mangement with AOP Interceptors
2. Schema-based Declarative Transaction Management
3. Schema-based Declarative Transaction Management with Annotations
4. Programmatic Transaction Management

The easiest way to check if transactions are working for this example is to remove the transaction declarations for the getStockQuote() method. Removing transactions will cause the following exception

org.hibernate.LazyInitializationException: could not initialize proxy - no Session

There's More ...
For this example, start off with the following as described in the "Integrating Spring and Hibernate" post.

1. The bean StockQuoteBean
2. The Portfolio classes : PortfolioDAO, PortfolioDAOSupport and PortfolioDAOTemplate
3. The hibernate mapping file stockquote.hbm.xml

The following main class can be used:

package springhibernate;


import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class SpringHibernateTest {


public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

  IPortfolioService portfolioService = (IPortfolioService) ctx.getBean("portfolioService");
System.out.println("Portfolio Service type : " + portfolioService.getClass());
portfolioService.getStockQuote("123");
}


}

SpringHibernateTest.java
Note that here we use an Interface IPortfolioService, and also note the change to ApplicationContext instead of a BeanFactory.
The reason for using ApplicationContext is enable the use of AOP for declarative transaction management. Also we are not expecting any return to the main class as all the execution is expected to happen in the transaction context.

The Portfolio Service Interface:

package springhibernate;

import beans.StockQuoteBean;

public interface IPortfolioService {

public void getStockQuote(String id);

public void updateStockQuote(StockQuoteBean stockQuoteBean);

}

IPortfolioService.java

Declarative Transaction Management

Declarative transaction management in Spring has the advantage of being less invasive. There is no need for changing application code when using declarative transactions. All you have to do is to modify the application context.

The Service class will be same for all the modes of Declarative transaction management described below.

package springhibernate;

import beans.StockQuoteBean;
import dao.PortfolioDAO;


public class PortfolioService implements IPortfolioService {
private PortfolioDAO portfolioDAO;



public void getStockQuote(String id) {
StockQuoteBean result = portfolioDAO.getStockQuote(id);
System.out.println("Result in Service : " + result.getStockSymbol());

}

public void updateStockQuote(StockQuoteBean stockQuoteBean) {
portfolioDAO.updateStockQuote(stockQuoteBean);
}

public PortfolioDAO getPortfolioDAO() {
return portfolioDAO;
}

public void setPortfolioDAO(PortfolioDAO portfolioDAO) {
this.portfolioDAO = portfolioDAO;
System.out.println("Setting portfolio DAO to : " + portfolioDAO.getClass());
}

}

PortfolioService.java

Declarative Transaction Management with AOP Interceptor

In this method, you have to define a proxy for the bean that will be made transactional.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="portfolioDAOTemplate" class="dao.PortfolioDAOTemplate">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

<bean id="portfolioDAOSupport" class="dao.PortfolioDAOSupport">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

 <bean id="myPortfolioService" class="springhibernate.PortfolioService">
  <property name="portfolioDAO" ref="portfolioDAOTemplate"></property>
 </bean>

 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <bean id="transactionInterceptor" class="org.springframework.transaction.interceptor.TransactionInterceptor">
  <property name="transactionManager">
   <ref bean="transactionManager" />
  </property>
  <property name="transactionAttributeSource">
   <value>springhibernate.PortfolioService.*=PROPAGATION_REQUIRED</value>
  </property>
 </bean>

 <bean id="hibernateInterceptor" class="org.springframework.orm.hibernate3.HibernateInterceptor">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <bean id="portfolioService" class="org.springframework.aop.framework.ProxyFactoryBean">
  <property name="target" ref="myPortfolioService"></property>
  <property name="interceptorNames">
   <list>
    <value>transactionInterceptor</value>
    <value>hibernateInterceptor</value>
   </list>
  </property>
 </bean>

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:@localhost:1521/xe" />
<property name="username" value="appUser" />
<property name="password" value="password" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
 <value>stockquote.hbm.xml</value>
</list>
</property>

<property name="hibernateProperties">
<props>
 <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
 <prop key="hibernate.show_sql">true</prop>
 <prop key="hibernate.generate_statistics">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

</beans>

applicationContext.xml
Note that the transactionInterceptor and hibernateTransactionInterceptor are declared. While transactionInterceptor is used to set the transaction properties, the hibernateTransactionInterceptor will manage the hibernate transactions.

Schema-based Declarative Transaction Management

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="portfolioDAOTemplate" class="dao.PortfolioDAOTemplate">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

<bean id="portfolioDAOSupport" class="dao.PortfolioDAOSupport">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

 <bean id="portfolioService" class="springhibernate.PortfolioService">
  <property name="portfolioDAO" ref="portfolioDAOTemplate"></property>
 </bean>

 <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  <property name="sessionFactory" ref="sessionFactory" />
 </bean>

 <aop:config>
  <aop:pointcut id="serviceMethods" expression="execution(* springhibernate.IPortfolioService.*(..))" />
  <aop:advisor  advice-ref="txAdvice" pointcut-ref="serviceMethods" />
 </aop:config>
 
 <tx:advice id="txAdvice"  transaction-manager="transactionManager" >
  <tx:attributes>
   <tx:method name="*" propagation="REQUIRES_NEW" />
  </tx:attributes>
 </tx:advice>


<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:@localhost:1521/xe" />
<property name="username" value="appUser" />
<property name="password" value="password" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
 <value>stockquote.hbm.xml</value>
</list>
</property>

<property name="hibernateProperties">
<props>
 <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
 <prop key="hibernate.show_sql">true</prop>
 <prop key="hibernate.generate_statistics">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

</beans>

applicationContext.xmlUsing Schema-based declarative transaction management is a lot simpler and a lot cleaner. However it is adviced that this method not be used in conjunction with explicit auto-proxying using BeanNameAutoProxyCreator, as it might raise issues like advice not being woven etc. Note that the AOP pointcut is defined to be all methods on the IPortfolioService inteface.

Schema-based Declarative Transaction Management with Annotations

<?xml version="1.0" encoding="UTF-8"?>
<beans  xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<bean id="portfolioDAOTemplate" class="dao.PortfolioDAOTemplate">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

<bean id="portfolioDAOSupport" class="dao.PortfolioDAOSupport">
<property name="hibernateTemplate" ref="hibernateTemplate" />
</bean>

<bean id="portfolioService" class="springhibernate.PortfolioService">
<property name="portfolioDAO" ref="portfolioDAOTemplate"></property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

 <tx:annotation-driven/>

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
<property name="url" value="jdbc:oracle:thin:@localhost:1521/xe" />
<property name="username" value="appUser" />
<property name="password" value="password" />
</bean>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
 <value>stockquote.hbm.xml</value>
</list>
</property>

<property name="hibernateProperties">
<props>
 <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
 <prop key="hibernate.show_sql">true</prop>
 <prop key="hibernate.generate_statistics">true</prop>
</props>
</property>
</bean>
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

</beans>

applicationContext.xmlWhen using annotations, you only have to declare the transaction manager and add <tx:annotation-driven/> to the application context. If the transaction manager is named "transactionManager" then you don't have to declare a transaction-manager attribute for <tx:annotation-driven/> as it happens to be the default value for that attribute.
Also we have to declare the pointcuts in the Service class itself. Note that as annotations are not inherited, declaring the annotations has to be done at the class level.

@Transactional
public class PortfolioService implements IPortfolioService {
private PortfolioDAO portfolioDAO;...

Programmatic Transaction Management

For programmatic transaction management in spring, you will need a PlatformTransctionManger in your bean which will be used to create a TransactionTemplate. The TransactionTemplate is used in the same way the HibernateTemplate was used in previous example. Additionally you will have to create a HibernateTransactionManager as shown in the above example.

package springhibernate;

import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

import beans.StockQuoteBean;
import dao.PortfolioDAO;

public class PortfolioServiceTransaction implements IPortfolioService{
private PortfolioDAO portfolioDAO;

private PlatformTransactionManager transactionManager;

public void getStockQuote(final String id) {
  TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
  transactionTemplate.execute(new TransactionCallbackWithoutResult() {

   public void doInTransactionWithoutResult(TransactionStatus status) {
    StockQuoteBean result = portfolioDAO.getStockQuote(id);
    System.out.println("Symbol in transaction " + result.getStockSymbol());
   }
  });

}

 public void updateStockQuote(final StockQuoteBean stockQuoteBean) {
  TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
  transactionTemplate.execute(new TransactionCallbackWithoutResult() {

   public void doInTransactionWithoutResult(TransactionStatus status) {
    portfolioDAO.updateStockQuote(stockQuoteBean);
   }
  });
  
 }

public PortfolioDAO getPortfolioDAO() {
return portfolioDAO;
}

public void setTransactionManager(PlatformTransactionManager transactionManager) {
this.transactionManager = transactionManager;
}

public void setPortfolioDAO(PortfolioDAO portfolioDAO) {
this.portfolioDAO = portfolioDAO;
System.out.println("Setting portfolio DAO to : " + portfolioDAO.getClass());
}

}

PortfolioService.java

Hibernate N+1 select problem & solution

Also have a look @

http://expertdevelopers.blogspot.com/2010/12/hibernate-fetching-strategy-infamous-n.html

Hibernate 3.2

The Hibernate developer team released Hibernate 3.2.0 GA, this release is certified compliant with the Java Persistence API. In addition to JPA compliance, hibernate adds new query capabilities, declarative data filters, Hibernate Annotations, Hibernate EntityManager and optimistic locking in a cluster with JBoss Cache. The Hibernate Java Persistence provider has been certified with the Sun TCKThe Hibernate 3.2 release includes:

• Natural programming model - Hibernate supports natural OO idiom; inheritance, polymorphism, composition and the Java collections framework
• Support for fine-grained object models - a rich variety of mappings for collections and dependent objects
• No build-time bytecode enhancement - there's no extra code generation or bytecode processing steps in your build procedure
• Extreme scalability - Hibernate is extremely performant, has a dual-layer cache architecture, and may be used in a cluster
• The query options - Hibernate addresses both sides of the problem; not only how to get objects into the database, but also how to get them out again
• Support for "conversations" - Hibernate supports both long-lived persistence contexts, detach/reattach of objects, and takes care of optimistic locking automatically
• Free/open source - Hibernate is licensed under the LGPL (Lesser GNU Public License)
• EJB 3.0 - Hibernate implements the Java Persistence management API and object/relational mapping options, two members of the Hibernate team are active in the expert group
• Hibernate Annotations offers several packages of JDK 5.0 code annotations that developers can use to map classes, as a replacement or in addition to XML metadata.

Integrating Spring and Hibernate

This post applies to integrating Spring framework 2.5.3 and Hibernate 3.0.

The Spring framework provides extensive support for data access through the use of support classes (JdbcDaoSupport, JdbcTemplate etc.), and extensive exception hierarchy to wrap any platform specific SQLException into an exception in the spring exception hierarchy. Additionally Spring framework also provides good support for integrating with ORM technologies like Hibernate and iBatis etc. This post will show how to integrate Spring framework with Hibernate ORM. There's more ...

1. Create the bean: The bean here represents a simple stock quote

   package beans;
   
   public class StockQuoteBean {
   private String quoteId;
   
   private String stockSymbol;
   
   private String name;
   
   public String getQuoteId() {
   return quoteId;
   }
   
   public void setQuoteId(String quoteId) {
   this.quoteId = quoteId;
   }
   
   public String getStockSymbol() {
   return stockSymbol;
   }
   
   public void setStockSymbol(String stockSymbol) {
   this.stockSymbol = stockSymbol;
   }
   
   public String getName() {
   return name;
   }
   
   public void setName(String name) {
   this.name = name;
   }
   }

   StockQuoteBean.java
2. Create a Hibernate Mapping file for the bean:

   <?xml version="1.0"?>
   <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
   "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
   <hibernate-mapping>
   <class name="beans.StockQuoteBean" table="STOCK_QUOTES" lazy="false">
   <id name="quoteId" column="quote_id">
    <generator class="assigned" />
   </id>
   
   <property name="stockSymbol">
    <column name="stock_symbol" />
   </property>
   <property name="name">
    <column name="name" />
   </property>
   </class>
   </hibernate-mapping>

   stockquote.hbm.xml
   The one important thing to note here is that in the declaration, a [lazy="false"] has been added to the mapping for the stockquote bean. The reason for this is that in hibernate 3, lazy initialization is turned on by default. This raises a problem when used with spring's HibernateCallback. The spring HibernateTemplate.execute() by default closes any open sessions upon completion. When used with lazy initialization you may get a LazyInitializationException like the following

   org.hibernate.LazyInitializationException: could not initialize proxy - no Session

   If you want to use lazy initialization with HibernateCallback, you will have to use this within a transaction context. The javadoc for HibernateTemplate specifies this explicitly

   Note that operations that return an Iterator (i.e. iterate) are supposed
   to be used within Spring-driven or JTA-driven transactions (with
   HibernateTransactionManager, JtaTransactionManager, or EJB CMT). Else, the
   Iterator won't be able to read results from its ResultSet anymore, as the
   underlying Hibernate Session will already have been closed.
   
   Lazy loading will also just work with an open Hibernate Session, either within a
   transaction or within OpenSessionInViewFilter/Interceptor. Furthermore, some
   operations just make sense within transactions, for example: contains, evict,
   lock, flush, clear.

3. The service class: The service class simply acts as an intermediary between the client and the DAO classes.

   package springhibernate;
   
   import beans.StockQuoteBean;
   import dao.PortfolioDAO;
   
   public class PortfolioService {
   private PortfolioDAO portfolioDAO;
   
   public StockQuoteBean getStockQuote(String id) {
   StockQuoteBean result = portfolioDAO.getStockQuote(id);
   return result;
   }
   
   public void updateStockQuote(StockQuoteBean stockQuoteBean) {
   portfolioDAO.updateStockQuote(stockQuoteBean);
   }
   
   public PortfolioDAO getPortfolioDAO() {
   return portfolioDAO;
   }
   
   public void setPortfolioDAO(PortfolioDAO portfolioDAO) {
   this.portfolioDAO = portfolioDAO;
   System.out.println("Setting portfolio DAO to : " + portfolioDAO.getClass());
   }
   
   }

   PortfolioService.java
4. The DAO interface:

   package dao;
   
   import beans.StockQuoteBean;
   
   public interface PortfolioDAO {
   public StockQuoteBean getStockQuote(String id);
   public void updateStockQuote(StockQuoteBean bean);
   public StockQuoteBean getStockQuote_hibernateTemplate(String id);
   public void updateStockQuote_hibernateTemplate(StockQuoteBean bean);
   }
   

   PortfolioDAO.java
5. The DAO Classes: The DAO classes shows the different ways in which the Hibernate calls can be made using the Spring support classes. There are three primary ways in which these calls can be made
   1. Using the HibernateCallback
   2. Using the HibernateTemplate directly
   3. Using the hibernate native calls using Session
   Spring also provides two different ways to create the Data access objects that interact with Hibernate.
   1. Using Composition, with HibernateTemplate
   2. Using Inheritance by extending HibernateDaoSupport
   All these methods will be explained when used in the following sections.
   1. Using HibernateTemplate

      package dao;
      
      import java.sql.SQLException;
      import java.util.List;
      
      import org.hibernate.HibernateException;
      import org.hibernate.Session;
      import org.springframework.orm.hibernate3.HibernateCallback;
      import org.springframework.orm.hibernate3.HibernateTemplate;
      
      import beans.StockQuoteBean;
      
      public class PortfolioDAOTemplate implements PortfolioDAO{
      private HibernateTemplate hibernateTemplate;
      
      public PortfolioDAOTemplate() {
      System.out.println("Init transaction dao");
      }
      
      
      public StockQuoteBean getStockQuote(final String id) {
      
      HibernateCallback callback = new HibernateCallback() {
         public Object doInHibernate(Session session) throws HibernateException, SQLException {
          return session.load(StockQuoteBean.class, id);
         }
        };
      return (StockQuoteBean) hibernateTemplate.execute(callback);
      }
      
       public void updateStockQuote(final StockQuoteBean StockQuoteBean) {
        HibernateCallback callback = new HibernateCallback() {
         public Object doInHibernate(Session session) throws HibernateException, SQLException {
          session.saveOrUpdate(StockQuoteBean);
          return null;
         }
        };
        hibernateTemplate.execute(callback);
        
       }
      
       public void updateStockQuote_hibernateTemplate(StockQuoteBean StockQuoteBean) {
        hibernateTemplate.update(StockQuoteBean);
      
       }
       public StockQuoteBean getStockQuote_hibernateTemplate(String id) {
        List<StockQuoteBean> transactions = hibernateTemplate.find("from beans.StockQuoteBean stockQuoteBean where stockQuoteBean.quoteId=?", id);
        return transactions.get(0);
       }
      
      
      public HibernateTemplate getHibernateTemplate() {
      return hibernateTemplate;
      }
      
      
      public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
      this.hibernateTemplate = hibernateTemplate;
      }
      
      
      
      }

      PortfolioDAOTemplate
      This class shows how to use the HibernateTemplate to make calls to Hibernate. The getStockQuote() and updateStockQuote() methods use HibernateCallback class, note that when using HibernateCallback, it is necessary to either do it in a transactional context or turn off lazy initialization. While the getStockQuote_hibernateTemplate() and updateStockQuote_hibernateTemplate() make calls using hibernateTemplate directly. Also note that the parameters to the getStockQuote(), and updateStockQuote() methods are marked final.
      
   2. Using HibernateDaoSupport

      package dao;
      
      import java.util.List;
      
      import org.hibernate.Query;
      import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
      
      import beans.StockQuoteBean;
      
      public class PortfolioDAOSupport extends HibernateDaoSupport implements PortfolioDAO {
      
      public void updateStockQuote(StockQuoteBean stockQuoteBean) {
        Query query = getSession().createQuery("update beans.StockQuoteBean set stockSymbol=? where quoteId=?");
        query.setString(0, stockQuoteBean.getStockSymbol());
        query.setString(1, stockQuoteBean.getQuoteId());
        query.executeUpdate();
       }
       public StockQuoteBean getStockQuote(String id) {
        Query query = getSession().createQuery("from beans.StockQuoteBean stockQuoteBean where stockQuoteBean.quoteId=?");
        query.setString(0, id);
        List results = query.list();
        if(results == null || results.size() == 0) {
         throw new RuntimeException("No result");
        }
        return (StockQuoteBean)results.get(0);
       }
      
      public void updateStockQuote_hibernateTemplate(StockQuoteBean StockQuoteBean) {
      getHibernateTemplate().update(StockQuoteBean);
      
      }
      public StockQuoteBean getStockQuote_hibernateTemplate(String id) {
      List<StockQuoteBean> transactions = getHibernateTemplate().find("from beans.StockQuoteBean stockQuoteBean where stockQuoteBean.quoteId=?", id);
      return transactions.get(0);
      }
      
      }

      PortfolioDAOSupport
      This class uses HibernateDaoSupport to get instances of HibernateTemplate, and the Hibernate Session. The getStockQuote() and updateStockQuote() in this class make calls to hibernate session directly.
6. The application context

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
   
    <bean id="portfolioDAOTemplate" class="dao.PortfolioDAOTemplate">
     <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>
    
    <bean id="portfolioDAOSupport" class="dao.PortfolioDAOSupport">
     <property name="hibernateTemplate" ref="hibernateTemplate" />
    </bean>
   
   <bean id="portfolioService" class="springhibernate.PortfolioService">
   <property name="portfolioDAO" ref="portfolioDAOSupport"></property>
   </bean>
   
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
   <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
   <property name="url" value="jdbc:oracle:thin:@localhost:1521/xe" />
   <property name="username" value="appUser" />
   <property name="password" value="password" />
   </bean>
   <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
     <property name="dataSource" ref="dataSource" />
     <property name="mappingResources">
      <list>
       <value>stockquote.hbm.xml</value>
      </list>
     </property>
   
     <property name="hibernateProperties">
      <props>
       <prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
       <prop key="hibernate.show_sql">true</prop>
       <prop key="hibernate.generate_statistics">true</prop>
      </props>
     </property>
    </bean>
    <bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
     <property name="sessionFactory" ref="sessionFactory" />
    </bean>
   </beans>

   applicationContext.xml
   • The SessionFactory is defined with the datasource and mapping-resources. The hibernate specific properties are defined under the hibernateProperties property.
   • The HibernateTemplate uses are reference to the SessionFactory.
   • The HibernateTemplate is used as a reference to the DAO classes.
   • The porfolioService bean in uses a reference to the PortfolioDAO, which can be switched between the dao.PortfolioDAOSupport and dao.PortfolioDAOTemplate beans
7. The main class

   package springhibernate;
   
   
   import org.springframework.beans.factory.BeanFactory;
   import org.springframework.beans.factory.xml.XmlBeanFactory;
   import org.springframework.core.io.FileSystemResource;
   import org.springframework.core.io.Resource;
   
   import beans.StockQuoteBean;
   
   
   public class SpringHibernateTest {
   
   
   public static void main(String[] args) {
   Resource resource = new FileSystemResource("applicationContext.xml");
   BeanFactory factory = new XmlBeanFactory(resource);
   
   PortfolioService portfolioService = (PortfolioService) factory.getBean("portfolioService");
   
   StockQuoteBean result = portfolioService.getStockQuote("123");
   System.out.println(result.getStockSymbol());
   
   empResult.setStockSymbol("GOOG");
   portfolioService.updateStockQuote(result);
   }
   
   
   }

   SpringHibernateTest.java
8. Necessary JAR files:
   • commons-logging-1.1.1.jar
   • hibernate3.jar
   • dom4j-1.6.1.jar
   • ojdbc14.jar
   • commons-collections-3.2.jar
   • log4j-1.2.15.jar
   • commons-dbcp.jar
   • commons-pool.jar
   • spring.jar
   • cglib-nodep-2.1_3.jar
   • antlr-2.7.6.jar
   • jta.jar

Paging in JSP with Hibernate

In the past, I had a few posts on how to implement pagination using displaytag(1, 2). That solution is feasible only with small result sets, the reason being that we will have the entire result set in memory (also called cache based paging). If the result set is large, then having the entire result set in memory will not be feasible. With large result sets, you cannot afford to have them in memory. In such case, you have to fetch a chunk of data at a time (query based paging). The down side of using query based paging, is that there will be multiple calls to the database for multiple page requests. In this post, I will describe how to implement simple query based caching solution, using Hibernate and a simple JSP. Time permitting, I will soon post a hybrid of cache based and query based paging example. Here is the code for implementing simple paging using a JSP and Hibernate:

1. Download the latest version of hibernate from hibernate.org, and include all the required jars in your classpath.
2. Hibernate configuration

   <?xml version='1.0' encoding='utf-8'?>
   <!DOCTYPE hibernate-configuration PUBLIC
          "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
          "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
   <hibernate-configuration>
    <session-factory>
      <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
      <property name="connection.url">jdbc:oracle:thin:@localhost:1521/orcl</property>
      <property name="connection.username">scott</property>
      <property name="connection.password">tiger</property>
      <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
      <property name="hibernate.current_session_context_class">thread</property>
      <mapping resource="beans/Employee.hbm.xml" />
    </session-factory>
   </hibernate-configuration>

   hibernate.cfg.xml
3. The Employee bean class to hold the data

   public class Employee {
    public long empId;
    public String empName;
    public String empJob;
    public long empSal;
    public long getEmpId() {
      return empId;
    }
    public void setEmpId(long empId) {
      this.empId = empId;
    }
    public String getEmpJob() {
      return empJob;
    }
    public void setEmpJob(String empJob) {
      this.empJob = empJob;
    }
    public String getEmpName() {
      return empName;
    }
    public void setEmpName(String empName) {
      this.empName = empName;
    }
    public long getEmpSal() {
      return empSal;
    }
    public void setEmpSal(long empSal) {
      this.empSal = empSal;
    } 
   }

   Employee.java
4. The Employee Mapping file: This listing of the Data Access Object uses the setMaxResults, and setFirstResult method of the Query object to extract the appropriate set of results for each page.

   <?xml version="1.0"?>
   <!DOCTYPE hibernate-mapping PUBLIC
      "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
      "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
   <hibernate-mapping>
    <class name="beans.Employee" table="Emp">
      <id name="empId" column="EMPNO" type="long">
        <generator class="native"/>
      </id>
      <property name="empName" column="ENAME" />
      <property name="empJob" column="JOB" />
      <property name="empSal" column="SAL" type="long"/>
    </class>
   </hibernate-mapping>

   Employee.hbm.xml
5. The Data Access Object

   public class DAO {
    private static int pageSize = 3;
    public static List getData(int pageNumber) {
      SessionFactory sessionFactory = new Configuration().configure().buildSessionFactory();
      Session session = sessionFactory.getCurrentSession();
      List result = null;
      try {
        session.beginTransaction();
        Query query = session.createQuery("from Employee");
         query = query.setFirstResult(pageSize * (pageNumber - 1));
         query.setMaxResults(pageSize);
        result = query.list();
        session.getTransaction().commit();
      } catch (Exception e) {
        e.printStackTrace();
      }
      return result;
    }
   }

   DAO.java
6. The JSP

   <jsp:root version="1.2" xmlns:jsp="http://java.sun.com/JSP/Page"
    xmlns:c="urn:jsptld:http://java.sun.com/jsp/jstl/core">
    <jsp:directive.page contentType="text/html; charset=UTF-8" />
   
    <link rel="stylesheet" type="text/css" href="css/screen.css" />
    <jsp:scriptlet>
        int pageNumber=1;
        if(request.getParameter("page") != null) {
          session.setAttribute("page", request.getParameter("page"));
          pageNumber = Integer.parseInt(request.getParameter("page"));
        } else {
          session.setAttribute("page", "1");
        }
        String nextPage = (pageNumber +1) + "";
        session.setAttribute( "EmpList", data.DAO.getData(pageNumber));
        System.out.println(((java.util.List)session.getAttribute("EmpList")).size());
        String myUrl = "pagingEmp.jsp?page=" + nextPage;
        System.out.println(myUrl);
   
        pageContext.setAttribute("myUrl", myUrl);
    </jsp:scriptlet>
    <h2 align="center">Emp Table with Display tag</h2>
    <jsp:useBean id="EmpList" scope="session" type="java.util.List"></jsp:useBean>
    <table>
      <tr>
        <th>Employee Id</th>
        <th>Name</th>
        <th>Job</th>
        <th>Salary</th>
      </tr>
      <c:forEach items="${EmpList}" var="emp" begin="0" end="10">
        <tr>
          <td><c:out value="${emp.empId}"></c:out></td>
          <td><c:out value="${emp.empName}"></c:out></td>
          <td><c:out value="${emp.empJob}"></c:out></td>
          <td><c:out value="${emp.empSal}"></c:out></td>
        </tr>
      </c:forEach>
   
      <tr>
        <td colspan="2"></td>
        <td colspan="2"><a href="${pageScope.myUrl}">nextPage</a></td>
      </tr>
    </table>
   </jsp:root>
   

   pagingEmp.jsp
   This JSP uses the DAO class to retrieve the Employee information from the database. The page number is passed as a parameter to the DAO. Notice that I did not implement the "previous" page, but it is similar to next. I assumed that we do not know the number of results for this example.

Hibernate in Action ebook Download

Hibernate practically exploded on the Java scene. Why is this open-source tool so popular? Because it automates a tedious task: persisting your Java objects to a relational database. The inevitable mismatch between your object-oriented code and the relational database requires you to write code that maps one to the other. This code is often complex, tedious and costly to develop. Hibernate does the mapping for you.

Not only that, Hibernate makes it easy. Positioned as a layer between your application and your database, Hibernate takes care of loading and saving of objects. Hibernate applications are cheaper, more portable, and more resilient to change. And they perform better than anything you are likely to develop yourself.


Hibernate in Action carefully explains the concepts you need, then gets you going. It builds on a single example to show you how to use Hibernate in practice, how to deal with concurrency and transactions, how to efficiently retrieve objects and use caching.
The authors created Hibernate and they field questions from the Hibernate community every day - they know how to make Hibernate sing. Knowledge and insight seep out of every pore of this book

                                                   

HibernateSearch in Action ebook Download

Enterprise and web applications require full-featured, "Google-quality" search capabilities, but such features are notoriously difficult to implement and maintain. Hibernate Search builds on the Lucene feature set and offers an easyto- implement interface that integrates seamlessly with Hibernate-the leading data persistence solution for Java applications.

Hibernate Search in Action introduces both the principles of enterprise search and the implementation details a Java developer will need to use Hibernate Search effectively. This book blends the insights of the Hibernate Search lead developer with the practical techniques required to index and manipulate data, assemble and execute search queries, and create smart filters for better search results. Along the way, the reader masters performance-boosting concepts like using Hibernate Search in a clustered environment and integrating with the features already in your applications.

                                                     

Native Queries with Hibernate Annotations

Hibernate EntityManager implements the programming interfaces and lifecycle rules as defined by the EJB3 persistence specification. Together with Hibernate Annotations, this wrapper implements a complete (and standalone) EJB3 persistence solution on top of the mature Hibernate core. In this post I will describe how map native queries (plain SQL) using Hibernate Annotations. Hibernate Annotations supports the use of Native queries through the @NamedNativeQuery and the @SqlResultSetMapping annotations.

• @NamedNativeQuery: Specifies a native SQL named query.
• @SqlResultSetMapping: Used to specify the mapping of the result of a native SQL query.

You will not need any EJB container support. At a minimum, you will need Hibernate core and Hibernate Annotations. The entire list of required Jar files is provided at the end.

1. The Hibernate Configuration File: Nothing new here. Except that there are no mappings defined. I used programmatic declaration of mapping for this example as shown in the following steps.

   <!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
   
   <hibernate-configuration>
    <session-factory>
     <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
     <property name="connection.url">jdbc:oracle:thin:@localhost:1521/orcl</property>
     <property name="connection.username">scott</property>
     <property name="connection.password">tiger</property>
     <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
     <property name="hibernate.current_session_context_class">thread</property>
    </session-factory>
   </hibernate-configuration>

   hibernate.cfg.xml
2. The Entity class:

   package data;
   
   import javax.persistence.Column;
   import javax.persistence.Entity;
   import javax.persistence.EntityResult;
   import javax.persistence.FieldResult;
   import javax.persistence.Id;
   import javax.persistence.NamedNativeQuery;
   import javax.persistence.SqlResultSetMapping;
   
   @Entity
   @SqlResultSetMapping(name = "implicit", entities = @EntityResult(entityClass = data.Employee.class))
   @NamedNativeQuery(name = "implicitSample", query = "select e.empno empNumber, e.ename empName, e.job empJob, e.sal empSalary, salg.grade empGrade from emp e, salgrade salg where e.sal between salg.losal and salg.HISAL", resultSetMapping = "implicit")
   //@SqlResultSetMapping(name = "explicit", entities = { @EntityResult(entityClass = data.Employee.class, fields = { 
   //    @FieldResult(name = "empNumber", column = "empno"), 
   //    @FieldResult(name = "empName", column = "ename"),
   //    @FieldResult(name = "empJob", column = "job"), 
   //    @FieldResult(name = "empSalary", column = "sal"), 
   //    @FieldResult(name = "empGrade", column = "grade") }) })
   //@NamedNativeQuery(name = "implicitSample", 
   //    query = "select e.empno empno, e.ename ename, e.job job, e.sal sal, salg.grade grade from emp e, salgrade salg where e.sal between salg.losal and salg.HISAL", resultSetMapping = "explicit")
   public class Employee {
   
    private String empNumber;
   
    private String empName;
   
    private String empJob;
   
    private Double empSalary;
   
    private int empGrade;
   
    @Column
    @Id
    public int getEmpGrade() {
      return empGrade;
    }
   
    public void setEmpGrade(int empGrade) {
      this.empGrade = empGrade;
    }
   
    @Column
    public String getEmpJob() {
      return empJob;
    }
   
    public void setEmpJob(String empJob) {
      this.empJob = empJob;
    }
   
    @Column
    public String getEmpName() {
      return empName;
    }
   
    public void setEmpName(String empName) {
      this.empName = empName;
    }
   
    @Column
    public String getEmpNumber() {
      return empNumber;
    }
   
    public void setEmpNumber(String empNumber) {
      this.empNumber = empNumber;
    }
   
    @Column
    public Double getEmpSalary() {
      return empSalary;
    }
   
    public void setEmpSalary(Double empSalary) {
      this.empSalary = empSalary;
    }
   
   }

   Employee.java
   • The implitic mapping (the uncommented @NamedNativeQuery and @SqlResultSetMapping declarations are used for implicitly mapping the ResultSet to the entity class. Note that the SQL column names match the field names in the class. If the names do not match then you can set the name attribute of the @Column annotation to the column name in the query.
   • The commented @NamedNativeQuery and the @SqlResultSetMapping declarations explicitly map the fields to the columns. This will come in handy when using joins and composite keys etc.
   • Note the package definitions refer to javax.persistence and not the hibernate packages. If the packages are not declared properly, you will most likely end up with some exceptions like the following

     org.hibernate.hql.ast.QuerySyntaxException: Employee is not mapped.

     While there are other causes for this exception, the package declarations did cause a little trouble for me.
3. The Client:

   import java.util.List;
   
   import org.hibernate.Session;
   import org.hibernate.SessionFactory;
   import org.hibernate.cfg.AnnotationConfiguration;
   import org.hibernate.cfg.Configuration;
   
   import data.Employee;
   
   public class Client {
   
    public static void main(String[] args) {
      Configuration config = new AnnotationConfiguration().addAnnotatedClass(Employee.class).configure();
   
      SessionFactory sessionFactory = config.buildSessionFactory();
      Session session = sessionFactory.getCurrentSession();
   
      List result = null;
      try {
        session.beginTransaction();
   
        result = session.getNamedQuery("implicitSample").list();
        System.out.println("Result size : " + result.size());
        session.getTransaction().commit();
      } catch (Exception e) {
        e.printStackTrace();
      }
      System.out.println(result.size());
    }
   
   }

   Client.java
4. Jar Files: The following jar files need to be included in the classpath

   hibernate3.jar
   commons-collections-2.1.1.jar
   antlr-2.7.6.jar
   commons-logging-1.0.4.jar
   hibernate-annotations.jar
   ejb3-persistence.jar
   hibernate-commons-annotations.jar
   dom4j-1.6.1.jar
   ojdbc14.jar
   jta.jar
   log4j-1.2.11.jar
   xerces-2.6.2.jar
   xml-apis.jar
   cglib-2.1.3.jar
   asm.jar

   All the Jar files will be available in the hibernate download. The hibernate-annotations.jar file is available in the hibernate annotations download.

This example was tested on Java 5 Update 9 with Hibernate version 3.2.3 and Hibernate Annotations Version: 3.3.0.GA.