A cache holds objects to prevent database queries. A cache is not aware of changes which bypass Hibernate for example queries issued by JDBC or from other non Java applications.

Choosing the cache mode

There are four cache modes available.

Standard cache

The standard cache is filled when you load any data with methods like

The cache is used when Hibernate has to create an instance from a given id. This is done when you use for example

You can configure the size of the cache and when items should expire. Expiring is useful when you update data with other applications from time to time but you can accept a delay during which the user sees stale data.

You do not have to set a timeout when your application is the only one accessing the database.

You can evict objects from the cache using the session factory (not the session itself). It provides methods like evict and others to deal with data in the cache.

Using the cache

Configure the cache in your hibernate.cfg.xml or in the hibernate.properties.

<property name="cache.provider_class">
   org.hibernate.cache.EhCacheProvider
</property>

Add a configuration file for your selected cache. You can find more detailed information about each cache in the following chapters. Here is a short example.

<cache name="myCache"
    maxElementsInMemory="6000"
    eternal="true"
    timeToIdleSeconds="0"
    timeToLiveSeconds="0"
    overflowToDisk="true"
/>

Add the cache tag to your class and to all relations you want to cache. You can specify a cache region to use a special configuration. For example I used the myCache configuration but you can also leave out the region definition in order to use the default configuration.

<class name="Developer" table="tdeveloper">
 <cache usage="read-only"  region="myCache" />
 <list name="computers" cascade="all">
   <cache usage="read-only"  region="myCache" />
   <key column="developer_id" not-null="true"></key>
   <list-index column="listindex"></list-index>
   <one-to-many class="Computer" />
 </list>

That’s it.

Query cache

A query cache contains the object ids found by a query. The query and the parameters are used as key. As a consequence a query cache is only useful when you have queries with the same parameters issued regularly. When a table is updated, all cached queries touching the table are evicted from the cache as they are considered to be outdated.

To sum up, a query cache is useful when you have a lot of identical selects compared to the number of updates. Typical applications are content management systems, Internet forums with a lot of read access etc.

To use the query cache you must do at least the following:

In the hibernate.properties or hibernate.cfg.xml add the property

  <property name="hibernate.cache.use_query_cache">true</property>

In your query set CacheAble to true

List result = session.createQuery(
   "from Computer c where c.name like ? order by c.name desc, c.id asc")
   .setString(0,param)
   .setCacheable(true).list();

You can also specify a special cache region used for your query using setCacheRegion

List result = session.createQuery(
   "from Computer c where c.name like ? order by c.name desc, c.id asc")
   .setString(0,param)
   .setCacheable(true).setCacheRegion(“myQueryCache”).list();

That’s it.

As opposed to the table in the Hibernate reference all of the following cache providers support query caching.

Test all caches

We provided an example application named TestCache. It will output access times to the data.

In order to use the test, generate test data first. Adapt the hibernate.cfg.xml to suit your database and uncomment the setupTest method in the class TestMain to generate random data entries.

Have a look at the class TestMain to comment or uncomment the tests you want to run and to specify which mapping to load. We have mappings for all supported cache modes. A cache provider does not support every mode.

You can configure the number of threads for running two kinds of tests. The first uses session.get to randomly select entries. The other test queries data with random parameters. Both tests log how the access times are changing by the time when your cache is filled. Run a no cache test to compare the results.

In the hibernate.cfg.xml you can configure the cache provider. Configuration files for any of the following caches can be found in the project as well. Read in the following descriptions to learn more about needed libraries.