Spring Data: How to maintain cache consistency in transactional methods?

Question

Let's assume we have a standard Spring Boot application with JPA. We have repositories, services and REST controllers. On the service layer, we have this:

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepo;

    @Transactional(readOnly = true)
    public User getUserById(userId: String) {
        return this.userRepo.findById(userId).orElse(null);
    }    

    @Transactional(readOnly = false)
    public User saveUser(User user){
        this.userRepo.save(user);
    }
}

We want to cache the result of getUserById, either via @Cacheable or via an explicit cache. We have the following two options:

• If a call to saveUser(...) occurs, we call repo.save(user) and then we immediately put the saved user into our cache (write-through).
• If a call to saveUser(...) occurs, we invalidate the corresponding entry in the cache. Once the user is requested by ID again, we read it from the database and put it into the cache.

Both methods have issues:

• If we write-through, we risk that the database transaction fails at some point after the repo.save(user) call and is rolled back. We may have written a version of the user into our cache that never hit the database. Our cache is out-of-sync with the database.

• If we only invalidate the cache, there is a time period between the invalidation and the transaction commit where a concurrent transaction may call getUserById(...). This transaction will still read the old version of the user and write it into the cache. The result is that we have outdated data in our cache.

Is the built-in spring cache susceptible to these issues as well? How do you avoid such problems in your application?

Answer 1

Ok so I got confused here. There is the Spring Boot side of caching, which is supposed to cache method results, and then there is the 2nd level cache of the JPA provider. These are different things with different purposes. My bad for mixing them up.