How to configure Sesion Factory in Hibernate to implement getCurrentSession

Question

Hi,
I am new in Hibernate and I am using an application where I need to improve the performance while uploading the users through a utility. While analyzing the system, I found that, to insert a single user there were around 8 hits are made to DB to get the information and based on that finally it inserts the user. The strange thing I have noticed is that for every hit, a new DB connection is opened in code using the snippet getHibernateTemplate().getSessionFactory().openSession();
However, the connection is getting closed in finally block. But I think instead of using Open Connection; getCurrentSession can save time.
Can any one suggest whether I am on right track?
Also, when I have tried to use getCurrentSession I have simply replaced "getHibernateTemplate().getSessionFactory().openSession();" with "getHibernateTemplate().getSessionFactory().getCurrentSession();" from everywhere in code.
But when I tried to run the Utility I got some Hibernate Exception stating "No Hibernate Session bound to thread, and configuration does not allow creation".
Could anyone suggest do I need to configure anything else in my applicationcontext.xml to use the getCurrentSession() method.
Thanks in advance.

Answer 1

the method getCurrentSession() should be done using Singleton factory method so that you have only one connection per application. You can implement something like this as coded below:
import java.io.File;
import javax.naming.InitialContext;
import org.apache.log4j.Logger;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
* @author hennebrueder This class garanties that only one single SessionFactory
*         is instanciated and that the configuration is done thread safe as
*         singleton. Actually it only wraps the Hibernate SessionFactory.
*         When a JNDI name is configured the session is bound to to JNDI,
*         else it is only saved locally.
*         You are free to use any kind of JTA or Thread transactionFactories.
public class InitSessionFactory {
      * Default constructor.
     private InitSessionFactory() {
      * Location of hibernate.cfg.xml file. NOTICE: Location should be on the
      * classpath as Hibernate uses #resourceAsStream style lookup for its
      * configuration file. That is place the config file in a Java package - the
      * default location is the default Java package.<br>
      * <br>
      * Examples: <br>
      * <code>CONFIG_FILE_LOCATION = "/hibernate.conf.xml".
      * CONFIG_FILE_LOCATION = "/com/foo/bar/myhiberstuff.conf.xml".</code>
     private static String CONFIG_FILE_LOCATION = "<Path to hibernate.cfg.xml>";
     /** The single instance of hibernate configuration */
     private static final Configuration cfg = new Configuration();
     /** The single instance of hibernate SessionFactory */
     private static org.hibernate.SessionFactory sessionFactory;
      * initialises the configuration if not yet done and returns the current
      * instance
      * @return
     public static SessionFactory getInstance() {
          if (sessionFactory == null)
               initSessionFactory();
          return sessionFactory;
      * Returns the ThreadLocal Session instance. Lazy initialize the
      * <code>SessionFactory</code> if needed.
      * @return Session
      * @throws HibernateException
     public Session openSession() {
          return sessionFactory.getCurrentSession();
      * The behaviour of this method depends on the session context you have
      * configured. This factory is intended to be used with a hibernate.cfg.xml
      * including the following property <property
      * name="current_session_context_class">thread</property> This would return
      * the current open session or if this does not exist, will create a new
      * session
      * @return
     public Session getCurrentSession() {
          return sessionFactory.getCurrentSession();
      * initializes the sessionfactory in a safe way even if more than one thread
      * tries to build a sessionFactory
     private static synchronized void initSessionFactory() {
           * [laliluna] check again for null because sessionFactory may have been
           * initialized between the last check and now
          Logger log = Logger.getLogger(InitSessionFactory.class);
          if (sessionFactory == null) {
               try {
                    File f = new File(CONFIG_FILE_LOCATION);
                    cfg.configure(f);
                    String sessionFactoryJndiName = cfg
                    .getProperty(Environment.SESSION_FACTORY_NAME);
                    if (sessionFactoryJndiName != null) {
                         cfg.buildSessionFactory();
                         log.debug("get a jndi session factory");
                         sessionFactory = (SessionFactory) (new InitialContext())
                                   .lookup(sessionFactoryJndiName);
                         //sessionFactory = new AnnotationConfiguration().configure(System.getProperty("user.dir") + "\\" + CONFIG_FILE_LOCATION).buildSessionFactory();
                    } else{
                         log.debug("classic factory");
                         sessionFactory = cfg.buildSessionFactory();
               } catch (Exception e) {
                    System.err
                              .println("%%%% Error Creating HibernateSessionFactory %%%%");
                    e.printStackTrace();
                    throw new HibernateException(
                              "Could not initialize the Hibernate configuration");
     public static void close(){
          if (sessionFactory != null)
               sessionFactory.close();
          sessionFactory = null;
}Test it and let me know.