optimizing findAll in spring Data JPA

Question

I have a table which has a list of lookup values max 50 rows. Currently, I am querying this table every time to look for a particular value which is not efficient. So, I am planning to optimize this by loading all the value at once as a List from the repository using findAll.

List<CardedList> findAll();

My question here is Class A -> Class B - Class B which holds this repository. Will it query findAll everytime when Class A calls Class B?

 Class A  {
       //foreach items in the list call Class B
        b.someMethod();
    }
    
    
    Class B {
      @Autowired
      CardedListRepository cardRepo;
    
     someMethod() {
             cardRepo.findAll(); 
     }
       
  }

What is the best way to achieve this?

score 0 · Answer 1 · answered Feb 02 '22 at 17:02

If it is just 50 rows you could cache them in an instance variable of a service and check like this:

Class B {
  @Autowired
  CardedListRepository cardRepo;
  List<CardedList> cardedList = new ArrayList<>();

  someMethod() {
     if(cardedList.isEmpty())
     {
         cardedList = cardRepo.findAll();
     }
     // do others in someMethod 
 }

score 0 · Answer 2 · answered Feb 02 '22 at 21:37

The proposed "solution" by @Juliyanage Silva (to "cache" the findAll query result as a simple instance variable of service B) can be very dangerous and should not be implemented before checking very carefully that it works under all circumstances.

Just imagine the same service instance being called from a subsequent transaction - you would end up with a (probably outdated) list of detached entities.
(e.g. leading to LazyInitializationExceptions when accessing not initialized properties, etc.)

Hibernate already provides several caching mechanisms, as e.g. a standard first level cache, which avoids unnecessary DB round trips when looking for an already loaded entity by ID within the same transaction.

However, query results (as from findAll) are not cached by default, as explained in the documentation:

Caching of query results introduces some overhead in terms of your applications normal transactional processing. For example, if you cache results of a query against Person, Hibernate will need to keep track of when those results should be invalidated because changes have been committed against any Person entity.
That, coupled with the fact that most applications simply gain no benefit from caching query results, leads Hibernate to disable caching of query results by default.

To enable the Hibernate query cache, the second level cache needs to be configured. To prevent ending up with stale entries when having multiple application instances, this calls for a distributed cache (like Hazelcast or EhCache).

There are also various discussions on using springs caching mechanisms for this purpose. However, there are also various pitfalls when it comes to caching collections. And when running multiple application instances you may need a distributed cache or another global invalidation mechanism, too.

How to add cache feature in Spring Data JPA CRUDRepository

Spring Cache with collection of items/entities

Spring Caching not working for findAll method

So depending on your use-case, it may be the easiest to just avoid unnecessary calls of service B by storing the result in a local variable within the calling method of service A.

optimizing findAll in spring Data JPA

2 Answers2