Coffee Moth - Hibernate L2 cache and Subclasses

Yesterday I was investigateing a very strange behavior in Hibernate. Yesterday morning I added EhCache as a second level cache to the hibernate and I made some tests to be sure everything is alright. I was very surprised when I saw that my entities are not cached so I started investigating the bug.

Firstly I tried different setups but nothing changed. Because I used this configuration many times without Spring, I suspected it can cause the bug. In the next step I tried get rid of all the Spring related stuff, e.g. removed the spring transaction management. I used the Hibernate as pure as it was possible and the cache was still not working.

Today morning (after I fixed an other bug) I leaned again to the problem, having downloaded the hibernate and ehcache source code I was debugging the code. It did't take a long time to find the reason. The second level cache is NOT enabled for my entities because those are extended classes, inherited some properties from our GenericEntity class.

Environment

• EhCache 2.5.1 - http://ehcache.org/
• Hibernate 3.3.2 GA - http://hibernate.org (Docs)
• Spring
• Tomcat 7
• MySql

Domain model

Invesigation

Shortly After I fired up the my debugger and I was running a query on the database, I found the code which should have stored the entities in the second level cache. It lays in the TwoPhaseLoad class initializeEntity method.

org.hibernate.engine.TwoPhaseLoad#initializeEntity(Object, boolean, SessionImplementor, PreLoadEvent,PostLoadEvent)

if ( persister.hasCache() && session.getCacheMode().isPutEnabled() ) {
    
    if ( log.isDebugEnabled() )
        log.debug(
                "adding entity to second-level cache: " +
                MessageHelper.infoString( persister, id, session.getFactory() )
            );

    Object version = Versioning.getVersion(hydratedState, persister);
    CacheEntry entry = new CacheEntry(
            hydratedState, 
            persister, 
            entityEntry.isLoadedWithLazyPropertiesUnfetched(), 
            version, 
            session, 
            entity
    );
    CacheKey cacheKey = new CacheKey( 
            id, 
            persister.getIdentifierType(), 
            persister.getRootEntityName(), 
            session.getEntityMode(), 
            session.getFactory() 
    );
    boolean put = persister.getCacheAccessStrategy().putFromLoad(
            cacheKey,
            persister.getCacheEntryStructure().structure( entry ),
            session.getTimestamp(),
            version,
            useMinimalPuts( session, entityEntry )
    );

    if ( put && factory.getStatistics().isStatisticsEnabled() ) {
        factory.getStatisticsImplementor().secondLevelCachePut( persister.getCacheAccessStrategy().getRegion().getName() );
    }
}

But if the code is here, why it is not invoked?
When the entity is being loaded by the TwoPhaseLoad, the persister hasCache() method returns false. This method checks the AbstractEntityPersister's cacheAccessStrategy property which is null.

org.hibernate.persister.entity.AbstractEntityPersister

public boolean hasCache() {
    return cacheAccessStrategy != null;
}

The AbstractEntityPersister gets the cacheAccessStrategy instance through its constructor. Therefore I investigated where the constructor is invoked.
The creation of AbstractEntityPersister happends in the SessionFactoryImpl and the second parameter will be the cacheAccessStrategy, here called simply accessStrategy.

org.hibernate.impl.SessionFactoryImpl

EntityRegionAccessStrategy accessStrategy = ( EntityRegionAccessStrategy ) entityAccessStrategies.get( cacheRegionName );
if ( accessStrategy == null && settings.isSecondLevelCacheEnabled() ) {
    final AccessType accessType = AccessType.parse( model.getCacheConcurrencyStrategy() );
    if ( accessType != null ) {
        log.trace( "Building cache for entity data [" + model.getEntityName() + "]" );
        EntityRegion entityRegion = settings.getRegionFactory().buildEntityRegion( cacheRegionName, properties, CacheDataDescriptionImpl.decode( model ) );
        accessStrategy = entityRegion.buildAccessStrategy( accessType );
        entityAccessStrategies.put( cacheRegionName, accessStrategy );
        allCacheRegions.put( cacheRegionName, entityRegion );
    }
}
EntityPersister cp = PersisterFactory.createClassPersister( model, accessStrategy, this, mapping );

The accessStrategy (although there is a pretty complex code) is always null, because the settings.isSecondLevelCacheEnabled() is always false and the body of the if statement never runs. But why? The secret is in the model classes. As I mentioned before the cache behaviour is defined on our subclasses, therefore hibernate will invoke SubClass's getCacheConcurrencyStrategy() method, which forwards the request to the root class.

org.hibernate.mapping.RootClass

public String getCacheConcurrencyStrategy() {
    return cacheConcurrencyStrategy;
}

org.hibernate.mapping.SubClass

public String getCacheConcurrencyStrategy() {
    return getSuperclass().getCacheConcurrencyStrategy();
}

At the moment I have no solution, but I'll update this post when I'll have found it although I wrote a test application to test Hibernate 4.

The test project