Java – Caching inside transactions with Spring

1 Oct 2021 | 11 min read
caching in Java with Spring
Dawid Necka Java Developer
Share

Caching in Java is a popular way to speed up your application. It enables you to receive data multiple times when the actual database request is executed only once.

The transaction is something that does not let an application do something only partially. Either the whole thing is done, or everything is rolled back.

Since the Spring framework provides us with annotations that implement both of the previously mentioned mechanisms, in this article I will be covering that framework.

Cache

Let’s see how the use of Cache looks in code. I assume that at this point you know what Spring Bean is and how Dependency Injection works in Spring.

First, you need to define CacheManager with caches named within:

@Configuration
@EnableCaching
public class CacheConfiguration {

   @Bean
   public CacheManager cacheManager() {
       return new ConcurrentMapCacheManager(GROCERIES_CACHE);
   }

}

Having CacheManager set up, you can now write your methods using `@Cacheable` and `@CacheEvict` annotations:

@Cacheable(value = ITEM_CACHE)
public List<Item> getItems() {
   return itemRepository.findAll();
}

@CacheEvict(value = ITEM_CACHE, allEntries = true)
public Item saveItem(Item item) {
   return itemRepository.save(item);
}

The first one writes data to caches while the second one erases that data. If you don’t do that, two things could happen:

  • Firstly, you would have your cache only growing. This means that at some point you’d run out of disk space.
  • Secondly, you would have the wrong data. If someone gets objects for the first time it writes to the cache. When they ask for it for the second time, they would get the same data without asking the database. But what if someone puts new data into the database in the meantime? Without `@CacheEvict` anyone who asked for cached objects would not get the new data.
Cache after Cacheable method
Cache after CacheEvict method

Transaction

What does `@Transactional` annotation even do? Well, you can think about it like a `try and catch` block – try to do some things and if any of those fails, revert all the changes.

But simple `try and catch` has some cons. For example, if `Method1` is transactional and inside it calls `Method2` which also is transactional, there would be two transactions. `@Transactional` annotation handles that and other things.

Cache in transaction

Let’s now use both of the previously mentioned mechanisms. We will create a new item using the transactional method:

@Override
@Transactional
public ItemResponse createItem(ItemRequest itemRequest) {

   //Check if object with that name already exists
   List<Item> items = itemRepositoryFacade.getItems();
   items.stream()
           .filter(filterItem -> filterItem.getName().equals(itemRequest.getName()))
           .findAny()
           .ifPresent(item -> {
               throw new EntityExistsException("Item with that name already exists");
           });

   //Add new object to database
   Item item = itemMapper.toEntity(itemRequest);
   Item savedItem = itemRepositoryFacade.saveItem(item);

   //Check if there are too many items with the same price
   List<Item> updatedItems = itemRepositoryFacade.getItems();
   long samePrice = updatedItems.stream()
           .filter(filterItem -> filterItem.getPrice().equals(itemRequest.getPrice()))
           .count();

   if (samePrice > 5) {
       throw new StockException();
   }

   return itemMapper.toResponse(savedItem);
}

As you can see, we used `@Transactional` annotation here and we also used two cache methods. `getItems()` writes or gets from the cache and `saveItem()` removes data from that cache.

  • Step 1.  Get items to check if one already exists with the same name as we provided in the request (Cacheable method).
  • Step 2. Save the new item to the database.
  • Step 3. Get all items to check if there are too many items with the same price. If the number is higher than 5, throw an exception. 

But…

Keep in mind that it could and probably should be done in a different way, even at the database level, this is just an example.

If every step goes well it means there are no problems with cache. 

But let’s imagine you’ve had more than 5 items with the same price:

  • Step 1:  Get data from the database and put values into the cache.
  • Step 2: Write data to the database and evict data from the cache. 
  • Step 3: Repeat step 1. 

BOOM – exception is thrown. 

What does that mean? This whole method has been marked as transactional, so changes that were made to the database during the second step had been rolled back. There will be no new items in it. Yet, the rollback has been done after an exception had been thrown, so changes in cache stayed as they were before an exception. 

So now if you ask for items using a method annotated with `@Cacheable`, like `getItems()`,  you’ll have a list of items including that new one whose insertion was rolled back.

Thankfully, Spring does come with a partial solution to this. It is called `TransactionAwareCacheManagerProxy`. It wraps a given CacheManager and that helps to work with transactions.

@Bean
public CacheManager cacheManager() {

   SimpleCacheManager cacheManager = new SimpleCacheManager();
   cacheManager.setCaches(List.of(new ConcurrentMapCache(ITEM_CACHE)));
   cacheManager.initializeCaches();

   return new TransactionAwareCacheManagerProxy(cacheManager);
}

Notice that when using `getItems()` you do not put any data into the cache. A similar thing happens when using `saveItem()` – you do not evict cache data. But if data would already be in the cache, `getItems()` would retrieve it from there. Basically, with this new wrapper, you don’t do any changes to cache until the transaction is completed, yet you can still retrieve data from it.

This solution may save you from polluting our cache with wrong data, yet it has a big flaw. What is it, you ask? You can find out in the next article about transactions and caching, so stay tuned!

But it is not the end yet.

But it’s not over yet.

Cache and reference

We covered examples where data is being put into the cache or evicted. What will happen if you retrieve an object from cache and change its field values?

Let’s see our `updateItem` method:

@Override
@Transactional
public ItemResponse updateItem(ItemRequest itemRequest) {

   List<Item> items = itemRepositoryFacade.getItems();
   Optional<Item> itemOptional = items.stream()
           .filter(filterItem -> filterItem.getName().equals(itemRequest.getName()))
           .findFirst();

   if (itemOptional.isEmpty()) {
       throw new ItemNotFoundException();
   }

   Item item = itemOptional.get();
   Double price = itemRequest.getPrice();
   item.setPrice(price);
   item.setDiscount(calculateDiscount(price, items.size()));

   Item savedItem = itemRepositoryFacade.saveItem(item);

   return itemMapper.toResponse(savedItem);
}

As you can see, it does retrieve all items from the database, because you need information about how many items are there for calculating a discount. That calculation can throw an exception, e.g. when the price is equal to 0.

So where is the catch? In `item.setPrice(price)`. Objects in the cache are stored using reference. So when you change some value in that object, it changes in the cache as well. 

What if something goes wrong in saving or mapping to response? You’ll be left with changed data in the cache, but not in the database.

Object in cache is accessed by reference

To prevent this from happening, you can make a copy of our object and work on that copy instead:

Item cacheItem = itemOptional.get();
Item item = cacheItem.clone();

Note! clone() only makes a shallow copy. If you have custom objects that you would like to change here, you should consider implementing a deep copy mechanism.

By using a copy of an object, you must perform a cache evict, since no changes to objects in the cache have been made. Thankfully, saving our item to the database does exactly that.

Conclusion

In this article, I’ve covered problems that come with using cache in transactions and modifying cache reference data. I’ve tried to come up with solutions to the real-life examples I have personally experienced. However, they are not that universal and could generate other problems.

In the second article on this topic, I’ll try to discover other kinds of problems those could be, Stay tuned and expect another article on this topic!

Dawid Necka Java Developer
Share

Want to talk about your project?

Hi, I’m Sebastian, Account Executive at Miquido. Fill in the form to the right and I’ll get in touch with you soon!


    0/2000

    The controller of your personal data is Miquido sp. z o.o. sp.k. We process your personal data in order to respond to your questions and for sending marketing communication, if you agreed.
    You have the right to access data, the right to request rectification, deletion or limitation of their processing, data transfer, the right to object, as well as the right to lodge a complaint to the supervisory body. Full information about processing of personal data can be found in the Privacy Policy.
    Show more

    We have received your message. One of our colleagues will get back to you shortly. Have a great day!