Getting "org.hibernate.LazyInitializationException" exceptions after retrieving items from my second-level ehcache

Take a look at a similar question. Basically, your cache is not a Hibernate second-level cache. You are accessing a lazy uninitialized association on a detached entity instance, so a LazyInitializationException is expected to be thrown.

You can try to play around with hibernate.enable_lazy_load_no_trans, but the recommended approach is to configure Hibernate second level cache so that:

• Cached entities are automatically attached to the subsequent sessions in which they are loaded.
• Cached data is automatically refreshed/invalidated in the cache when they are changed.
• Changes to the cached instances are synchronized taking the transaction semantics into consideration. Changes are visible to other sessions/transactions with the desired level of cache/db consistency guarantees.
• Cached instances are automatically fetched from the cache when they are navigated to from the other entities which have associations with them.

EDIT

If you nevertheless want to use Spring cache for this purpose, or your requirements are such that this is an adequate solution, then keep in mind that Hibernate managed entities are not thread-safe, so you will have to store and return detached entities to/from the custom cache. Also, prior to detachment you would need to initialize all lazy associations that you expect to be accessed on the entity while it is detached.

To achieve this you could:

1. Explicitly detach the managed entity with EntityManager.detach. You would need to detach or cascade detach operation to the associated entities also, and make sure that the references to the detached entities from other managed entities are handled appropriately.

2. Or, you could execute this in a separate transaction to make sure that everything is detached and that you don't reference detached entities from the managed ones in the current persistence context:

   @Override
   @Cacheable(value = "main")
   @Transactional(propagation = Propagation.REQUIRES_NEW)
   public Item findItemById(String id) {
       Item result = entityManager.find(Item.class, id);
       Hibernate.initialize(result.getAssociation1());
       Hibernate.initialize(result.getAssociation2());
       return result;
   }
   

   Because it may happen that the Spring transaction proxy (interceptor) is executed before the cache proxy (both have the same default order value: transaction; cache), then you would always start a nested transaction, be it to really fetch the entity, or to just return the cached instance.

   While we may conclude that performance penalty for starting unneeded nested transactions is small, the issue here is that you leave a small time window when a managed instance is present in the cache.

   To avoid that, you could change the default order values:

   <tx:annotation-driven order="200"/>
   <cache:annotation-driven order="100"/>
   

   so that cache interceptor is always placed before the transaction one.

   Or, to avoid ordering configuration changes, you could simply delegate the call from the @Cacheable method to the @Transactional(propagation = Propagation.REQUIRES_NEW) method on another bean.

What you implemented in your code snippets is a custom cache based on spring-cache. With your implementation you would need to take care of cache evictions, making sure that at the point when your object graphs will get cached they are properly loaded, etc. Once they get cached and the original hibernate session that loaded them is closed they'll become detached, you can no longer navigate unfetched lazy associations. Also, your custom cache solution in its current state would cache entity graphs, which is probably not what you want, since any part of that graph might change at a given time, and your cache solution would need to watch for changes in all parts of that graph to properly handle evictions.

The configuration you posted in your question is not Hibernate second-level cache.

Managing a cache is a complex endeavor and I don't recommend it doing it by yourself, unless you're absolutely sure what you're doing (but then you won't be asking this question on Stackoverflow).

Let me explain what is happening with when you get the LazyInitializationException: you marked one of your dao methods with @org.springframework.cache.annotation.Cacheable. What happens in this case is the following:

1. Spring attaches an interceptor to your managed bean. The interceptor will intercept the dao method call, it will create a cache key based on the interceptor method and the actual method arguments (this can be customized), and look up the cache to see if there's any entry in the cache for that key. In case there's an entry it will return that entry without actually invoking your method. In case there's no cache entry for that key, it will invoke your method, serializes the return value and store it in the cache.
2. For the case when there was no cache entry for the key, your method will get invoked. Your method uses a spring provided singleton proxy to the thread bound EntityManager which was assigned earlier when Spring encountered the first @Transactional method invocation. In your case this was the getContent(...) method of another spring service bean. So your method loads an entity with EntityManager.find(). This will give you a partially loaded entity graph containing uninitialized proxies and collections to other associated entities not yet loaded by the persistence context.
3. Your method returns with the partially loaded entity graph and spring will immediately serialize it for you and store it in the cache. Note that serializing a partially loaded entity graph will deserialize to a partially loaded entity graph.
4. On the second invocation of the dao method marked with @Cacheable with the same arguments, Spring will find that there is indeed an entry in the cache corresponding to that key and will load and deserialize the entry. Your dao method will not be called since it uses the cached entry. Now you encounter the problem: your deserialized cached entity graph was only partially loaded when you stored in the cache, and as soon as you touch any uninitialized part of the graph you'll get the LazyInitializationException. A deserialized entity will always be detached, so even if the original EntityManager would be still open (which is not), you would still get the same exception.

Now the question is: what can you do to avoid the LazyInitializationException. Well, my recommendation is that you forget about implementing a custom cache and just configure Hibernate to do the caching for you. I will talk about how to do that later. If you want to stick with the custom cache you tried to implement, here's what you need to do:

Go through your whole code base and find all invocations of your @Cacheable dao method. Follow all possible code paths where the loaded entity graph is passed around and mark all parts of the entity graph which ever gets touched by client code. Now go back to your @Cacheable method and modify it so that it loads and initializes all parts of the entity graph that would ever get possibly touched. Because once you return it and it gets serialized, and deserialized later, it will always be in a detached state so better make sure all possible graph paths are properly loaded. You should already feel how impractical this will end up. If that still didn't convince you not to follow this direction, here's another argument.

Since you load up a potentially big chunk of the database, you will have a snapshot of that part of the database at the given time when it got actually loaded and cached. Now, whenever you use a cached version of this big chunk of the database, there's is a risk that you are using a stale version of that data. To defend from this, you would need to watch for any changes in the current version of that big chunk of the database you just cached and evict the whole entity graph from the cache. So you pretty much need to take into account which entities are parts of your entity graph and set up some event listeners whenever those entities are changed and evict the whole graph. None of these issues are present with Hibernate second-level cache.

Now back to my recommendation: set up Hibernate second-level cache

Hibernate second-level cache is managed by Hibernate and you get eviction management from hibernate automatically. If you have Hibernate second-level cache enabled, Hibernate will cache the data needed to reconstruct your entities and, if - when seeking to load an entity from the database - it finds that it has a valid cache entry for your entity, it will skip hitting the database and reconstruct your entity from its cache. (Mark the difference to caching an entity graph with its possibly unfetched associations and uninitialized proxies in your custom cache solution). It will also replace stale cache entries when you update an entity. It does all sorts of things related to managing the cache so that you don't have to worry about it.

Here's how can you enable Hibernate second-level cache: in addition to your configuration do the following:

1. In addition to the hibernate properties you already have for second-level management, namely

   <entry key="hibernate.cache.region.factory_class" value="org.hibernate.cache.ehcache.EhCacheRegionFactory"/>
   <entry key="hibernate.cache.provider_class" value="org.hibernate.cache.EhCacheProvider"/>
   <entry key="hibernate.cache.use_second_level_cache" value="true" />
   

   add the following entry:

   <entry key="javax.persistence.sharedCache.mode" value="ENABLE_SELECTIVE" />
   

   alternatively, you could add a shared-cache-mode configuration option to your persistence.xml (since you didn't post it, I assumed you don't use it hence the previous alternative; the following one is preferred though):

   <persistence-unit name="default">
       <!-- other configuration lines stripped -->
   
       <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
   
       <!-- other configuration lines stripped -->
   </persistence-unit>
   

2. Add javax.persistence.@Cacheable annotation to your @Entity classes you want to be cacheable.

3. If you want to add caching for collection valued associations which Hibernate doesn't cache by default, you can add a @org.hibernate.annotations.Cache annotation (with a proper cache concurrency strategy choice) for each such collection:

   @ManyToMany(fetch = FetchType.LAZY)
   @JoinTable(name = "product_category", joinColumns = { @JoinColumn(name = "PRODUCT_ID")
              }, inverseJoinColumns = { @JoinColumn(name = "CATEGORY_ID") })
   @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
   private List<Category> categories;
   

See Improving performance/The Second Level Cache in the Hibernate Reference Documentation for further details.

This is a nice informative article about the subject: Pitfalls of the Hibernate Second-Level / Query Caches

I have put together a small project based on your posted code snippets which you can check out to see Hibernate second-level cache in action.

The problem is that you are caching references to objects which are loaded lazily. Cache the object once it is all loaded or do not use the cache at all.

Here is how you could load the categories manually before caching it:

Item item = entityManager.find(Item.class, id);
item.getParent().getProduct().getCategories();
return item;

Also a better caching strategy would be to have the cache at the service level of your application instead of the DAO level or no cache at all.

Your issue is caused by the following events:

An Item is being retrieved without its categories then put in the cache in transaction 1. In transaction 2, you call the same method and retrieve the Item and try to read its categories. At that moment hibernate tries to read the categories from transaction 1 which is associated to the Item object but transaction 1 is already completed so it fails.