Hibernate: OpenSessionInView reloaded

In the previous post regarding Hibernate, I've shown how the OpenSessionInView pattern can be implemented.
In short, the idea was that the transactional statements (CRUD operations with the database) happen in between the following lines:

sf.getCurrentSession().beginTransaction();
....
sf.getCurrentSession().getTransaction().commit();

These lines are executed by a servlet filter, making thus sure that the Hibernate session is kept open until the view is rendered, and thus allowing us to use managed entities, as opposed to detached.

However, there is still something about which we haven't talked yet: what happens in the real case, with several simultaneous requests to the servlet ? We know that servlets are multithreaded objects, i.e. multiple threads may call the servlet's methods at the same time. We also know that servlets are not thread safe, so we  have to pay attention to instance or class variables, which can be shared by several threads.

In the case of the OpenSessionPerView pattern, note that sf.getCurrentSession().beginTransaction() may be called by several threads. This means that the result of sf.getCurrentSession(), which is the current Session object, is shared among threads, which is dangerous since a Session is not a thread safe object. This asks for trouble, since the instance of Session is used to create queries and perform CRUD operations with the database.

So how can we ensure a thread-safe behavior of the OpenSessionPerView pattern ? ThreadLocal pattern to the rescue.
In a few words, what we need is a Session object per thread, which can be easily implemented using a ThreadLocal variable, as in the code below:

public class HibernateUtil {
    private static final SessionFactory sessionFactory;
    private static final ThreadLocal threadSession =
    new ThreadLocal();

    static {
      // initialize SessionFactory
      sessionFactory = new Configuration().configure().
      buildSessionFactory();
    }

    public static Session getSession() {
      Session s = (Session) threadSession.get();
      // open a new Session, if this thread has none yet
      try {
        if (s == null) {
          s = sessionFactory.openSession();
          threadSession.set(s);
        }
      } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
      }
      return s;
    }

    public static void closeSession() {
      try {
        Session s = (Session) threadSession.get();
        threadSession.set(null);
        if (s != null && s.isOpen()) s.close();
      } catch (HibernateException ex) {
        throw new InfrastructureException(ex);
      }
    }
}

You get the picture. We would call HibernateUtil.getSession().getTransaction() in our servlet filter, instead of sf.getCurrentSession().beginTransaction(). Now each thread running through the servlet (and the filter) gets its own session object, so it performs the CRUD operations to the database without interfering with the other threads.