Using JPAContainer with Hibernate

Hibernate needs special handling in some cases.

Lazy loading

In order for lazy loading to work automatically, an entity must be attached to an entity manager. Unfortunately, Hibernate can not keep entity managers for long without problems. To work around the problem, you need to use a special lazy loading delegate for Hibernate.

JPAContainer entity providers handle lazy loading in delegates defined by the LazyLoadingDelegate interface. The default implementation for Hibernate is defined in HibernateLazyLoadingDelegate. You can instantiate one and use it in an entity provider with setLazyLoadingDelegate().

The default implementation works so that whenever a lazy property is accessed through the Vaadin Property interface, the value is retrieved with a separate (JPA Criteria API) query using the currently active entity manager. The value is then manually attached to the entity instance, which is detached from the entity manager. If this default implementation is not good enough, you may need to make your own implementation.

The EntityManager-Per-Request pattern

One issue with Hibernate is that it is designed for short-lived sessions, but the lifetime of an entity manager is normally roughly that of a user session. The problem is that if an error occurs in a session or an entity manager, the manager becomes unuseable. This causes big problems with long-lived sessions that would work fine with EclipseLink.

The recommended solution is to use the EntityManager-per-Request pattern. It is highly recommended always when using Hibernate.

An entity manager can only be open during the request-response cycle of the Vaadin servlet, so that one is created at the beginning of the request and closed at the end.

Storing an Entity Manager

You first need to implement an EntityManagerProvider that returns a stored EntityManager with getEntityManager(). The entity manager must be stored in a ThreadLocal variable.

  1. public class LazyHibernateEntityManagerProvider
  2.        implements EntityManagerProvider {
  3.     private static ThreadLocal<EntityManager>
  4.         entityManagerThreadLocal =
  5.             new ThreadLocal<EntityManager>();
  7.     @Override
  8.     public EntityManager getEntityManager() {
  9.         return entityManagerThreadLocal.get();
  10.     }
  12.     public static void setCurrentEntityManager(
  13.                                EntityManager em) {
  14.         entityManagerThreadLocal.set(em);
  15.     }
  16. }

You need to create and store the per-request instance at the beginning of each request with setCurrentEntityManager() and clear it at the end by setting it as null.

Creating Entity Managers in a Servlet Filter

You can create the entity managers for each request either by extending VaadinServlet and overriding the service() method or by implementing a servlet filter. In the following, we describe how to implement a servlet filter to do the task, but overriding the servlet could be even easier.

  1. public class LazyHibernateServletFilter
  2.        implements Filter {
  4.     private EntityManagerFactory entityManagerFactory;
  6.     @Override
  7.     public void init(FilterConfig filterConfig)
  8.             throws ServletException {
  9.         entityManagerFactory = Persistence
  10.             .createEntityManagerFactory("lazyhibernate");
  11.     }
  13.     @Override
  14.     public void doFilter(ServletRequest servletRequest,
  15.                          ServletResponse servletResponse,
  16.                          FilterChain filterChain)
  17.             throws IOException, ServletException {
  18.         try {
  19.             // Create and set the entity manager
  20.             LazyHibernateEntityManagerProvider
  21.                 .setCurrentEntityManager(
  22.                     entityManagerFactory
  23.                         .createEntityManager());
  25.             // Handle the request
  26.             filterChain.doFilter(servletRequest,
  27.                                  servletResponse);
  28.         } finally {
  29.             // Reset the entity manager
  30.             LazyHibernateEntityManagerProvider
  31.                     .setCurrentEntityManager(null);
  32.         }
  33.     }
  35.     @Override
  36.     public void destroy() {
  37.         entityManagerFactory = null;
  38.     }
  39. }

You need to define the servlet filter in the web.xml deployment descriptor as follows:

  1. <filter>
  2.     <filter-name>LazyHibernateServletFilter</filter-name>
  3.     <filter-class>com.example.LazyHibernateServletFilter</filter-class>
  4. </filter>
  5. <filter-mapping>
  6.     <filter-name>LazyHibernateServletFilter</filter-name>
  7.     <url-pattern>/*</url-pattern>
  8. </filter-mapping>

The url-pattern must match the pattern for your Vaadin servlet.

Joins in Hibernate vs EclipseLink

EclipseLink supports implicit joins, while Hibernate requires explicit joins. In SQL terms, an explicit join is a “ FROM a INNER JOIN b ON a.bid = b.id” expression, while an implicit join is done in a WHERE clause, such as: “ FROM a,b WHERE a.bid = b.id”.

In a JPAContainer filter with EclipseLink, an implicit join would have form:

  1. new Equal("skills.skill", s)

In Hibernate you would need to use JoinFilter for the explicit join:

  1. new JoinFilter("skills", new Equal("skill", s))