When and how to use hibernate second level cache?

Question

I have trouble understanding when hibernate hits the second level cache and when does it invalidate the cache.

This is what I currently understand:

• Second level cache stores entities between sessions, scope is the SessionFactory
• You have to tell which entities to cache, no entity will get cached by default
• Query cache stores results of queries in the cache.

What I don't understand is

• When does hibernate hit this cache?
• Let's say I've set up the second level cache but not the query caching. I want to cache my customers, there's 50000 of them. In what ways can I retrieve the customers from the cache?
• I assume I can get them by id from cache. That would be easy but also not worthy of caching. But what if I want to do some calculation with all my customers. Let's say I want to show a list of the customers then how would I access them?
• How would I get all my customers if query caching is disabled?
• What would happen if someone updated one of the customers?
  • Would that customer get invalidated in the cache or would all customers get invalidated?

Or am I thinking caching totally wrong? What would be more appropriate uses of second level cache in that case? The hibernate documentation is not at all clear how the cache works in reality. There are only instructions on how to get it set up.

Update: So I've come to understand that second level cache(without query cache) would be good for loading data by id's. For example I have user object that I want to check for permissions in every request in a web application. Would this be a good case to reduce database access by caching the user in the second level cache? Like I would store the user id in the session or wherever and when I need to check for permissions I would load the user by it's id and check permissions.

Droplight

possible duplicate of What is second level cache in hibernate? – Suspend

Answer 1

First of all, let's talk about process level cache (or 2nd level cache as they call it in Hibernate). To make it work, you should

1. configure cache provider
2. tell hibernate what entities to cache (right in hbm.xml file if you use this kind of mapping).

You tell to the cache provider how many objects it should store and when/why they should be invalidated. So let's say you have a Book and an Author entities, each time you're getting them from the DB, only those that are not in cache will be selected from actually DB. This increases performance significantly. It's useful when:

• You write to the database only via Hibernate (because it needs a way to know when to change or invalidate entities in the cache)
• You read objects often
• You have a single node, and you don't have replication. Otherwise you'll need to replicate the cache itself (use distributed caches like JGroups) which adds more complexity, and it doesn't scale as good as share-nothing apps.

So when does cache work?

• When you session.get() or session.load() the object that was previously selected and resides in cache. Cache is a storage where ID is the key and the properties are the values. So only when there is a possibility to search by ID you could eliminate hitting the DB.
• When your associations are lazy-loaded (or eager-loaded with selects instead of joins)

But it doesn't work when:

• If you don't select by ID. Again - 2nd level cache stores a map of entities' IDs to other properties (it doesn't actually store objects, but the data itself), so if your lookup looks like this: from Authors where name = :name, then you don't hit cache.
• When you use HQL (even if you use where id = ?).
• If in your mapping you set fetch="join", this means that to load associations joins will be used everywhere instead of separate select statements. Process level cache works on children objects only if fetch="select" is used.
• Even if you have fetch="select" but then in HQL you use joins to select associations - those joins will be issued right away and they will overwrite whatever you specified in hbm.xml or annotations.

Now, about Query Cache. You should note that it's not a separate cache, it's an addition to the process level cache. Let's say you have a Country entity. It's static, so you know that each time there will be the same result set when you say from Country. This is a perfect candidate for query cache, it will store a list of IDs in itself and when you next time select all countries, it will return this list to the process level cache and the latter, in turn, will return objects for each ID as these objects are stored already in the 2nd level cache. Query cache is invalidated each time anything related to the entity changes. So let's say you configured from Authors to be placed into a Query Cache. It won't be effective as Author changes often. So you should use Query Cache only for more or less static data.

Florinda

Does the query "from Author a fetch join a.books" require Query cache to fetch authors from cache? – Droplight

No, query cache is only for static data and it stores only IDs. Authors will be taken from 2nd level cache. – Florinda

@ctapobep : not true what you say ! "from Author a fetch join a.books" works fine if the field books of the entity Author is annotated (fetch EAGER) ... it is too late I think – Trolley

after enabling the 'query cache', does it fetch the data from cache if you select by other property than id? – Sawyer

Answer 2

• the 2nd level cache is a key-value store. It only works if you get your entities by id
• the 2nd level cache is invalidated / updated per entity when an entity is updated/deleted via hibernate. It is not invalidated if the database is updated in a different way.
• for queries (e.g. list of customers) use the query cache.

In reality it is useful to have a key-value distributed cache - that's what memcached is, and it powers facebook, twitter and many more. But if you don't have lookups by id, then it won't be very useful.

Bille

Query cache (works with Projections, ResultTransformers for DTO patterns) and is invalidated if you update a Entity that was used on the cached query. As you said, the 2nd level cache works only for those querys where you get the entity by id (doesn't work for criteria restrictions) or Criteria with projections (Select only some properties). BTW the best (resumed) answer for "how hibernate cache works." – Midbrain

Answer 3

Late to the party but wanted to systematically answer these question which many developers ask.

Taking your question one by one here is my answer.

Q. When does hibernate hit this cache?

A. First Level cache is associated with the Session object. The Second Level Cache is associated with the Session Factory object. If object is not found in the first, then the second level is checked.

Q. Let's say I've set up the second level cache but not the query caching. I want to cache my customers, there's 50000 of them. In what ways can I retrieve the customers from the cache?

A. You got that answered in your update. Also the query cache stores just the list of IDs of the object and those Objects w.r.t their IDs are stored in the same second level cache. So if you enable query cache, you'll utilize the same resource. Neat right ?

Q. I assume I can get them by id from cache. That would be easy but also not worthy of caching. But what if I want to do some calculation with all my customers. Let's say I want to show a list of the customers then how would I access them?

A. Answered above.

Q. How would I get all my customers if query caching is disabled?

A. Answered above.

Q. What would happen if someone updated one of the customers? Would that customer get invalidated in the cache or would all customers get invalidated?

A. Hibernate has no idea but you could use other third party IMDG / distributed caches to be implemented as hibernate second level cache and get them invalidated. e.g. TayzGrid is one such product and there are more i guess.

Erumpent

Answer 4

The Hibernate second-level cache is a little tricky to understand and implement. Here’s what we can say based on your questions:

When does Hibernate hit this cache?

As you suggest, the Hibernate L2 cache (if enabled; it’s not turned on by default) is queried only after the L1 cache. This is a key-value cache whose data is preserved across multiple sessions.

Let's say I've set up the second level cache but not the query caching. I want to cache my customers, there's 50000 of them. In what ways can I retrieve the customers from the cache?

Query caching would be best for this use case, since the customer data is static and retrieved from a relational database.

What would happen if someone updated one of the customers? Would that customer get invalidated in the cache or would all customers get invalidated?

It depends on the specific Hibernate cache strategy you’re using. Hibernate actually has four different cache strategies:

READ_ONLY: Objects don’t change once inside the cache.

NONSTRICT_READ_WRITE: Objects change (eventually) after the corresponding database entry is updated; this guarantees eventual consistency.

READ_WRITE: Objects change (immediately) after the corresponding database entry is updated; this guarantees strong consistency by using "soft" locks.

TRANSACTIONAL: Objects change using distributed XA transactions, ensuring data integrity; this guarantees either total success or rolling back all changes. In all four of these cases, though, updating a single database entry would not invalidate the entire list of customers in the cache. Hibernate is a little smarter than that :)

To learn more about how L2 caching works in Hibernate, you can check out the article “What is the Hibernate L2 cache,” or the in-depth article Caching in Hibernate with Redis

For

Answer 5

My working second-level cache code.

hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/practice</property>
        <property name="connection.user">root</property>
        <property name="connection.password">Welcome123#</property>
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>
        <property name="hbm2ddl.auto">update</property>

        <property name="cache.use_second_level_cache">true</property>
        <property name="cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
        <property name="cache.ehcache.missing_cache_strategy">create</property>

        <mapping class="com.oracle.dto.BankAccount"/>
        <mapping class="com.oracle.dto.Citizen"/>



    </session-factory>
</hibernate-configuration>

Bean

package com.oracle.dto;

import lombok.AccessLevel;
import lombok.Data;
import lombok.Setter;
import org.hibernate.annotations.CacheConcurrencyStrategy;

import javax.persistence.*;
import java.util.Date;

@Entity
@Data
@Cacheable
@org.hibernate.annotations.Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class BankAccount {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO,generator = "bid")
    @SequenceGenerator(name = "bid",sequenceName = "b_id",initialValue = 2000,allocationSize = 1)
    @Setter(AccessLevel.NONE)
    @Column(name="bank_id",updatable = false,nullable = false)
    private Long bId;
    private Integer branchCode;
    private Double accountBalance;
    @Temporal(TemporalType.DATE)
    @Column(name="account_opening_date",updatable = false,nullable = false)
    private Date accountOpeningDate;
}

Main Class

package com.oracle.main;

import com.oracle.dto.BankAccount;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class CacheDriver {
    public static void main(String[] args) {
        SessionFactory sf=new Configuration().configure().buildSessionFactory();
        Session session1 = sf.openSession();
        BankAccount account1 = session1.get(BankAccount.class,2000l);
        System.out.println(account1);
        session1.close();
        Session session2 = sf.openSession();
        BankAccount account2 = session2.get(BankAccount.class,2000l);
        System.out.println(account2);
        session1.close();
        sf.close();
    }
}

Pokelogan