Disable @Cacheable in Spring Boot

1. Introduction

Caching is an effective strategy to improve performance by avoiding repeated execution of logic when the execution result hasn’t changed (effectively the same) for a known period.

Spring Boot provides the @Cacheable annotation, which we define over a method, and it caches the result of the method. In some scenarios, such as during testing in a lower environment, we may need to disable caching to observe certain modified behaviors.

In this article, we’ll configure the cache in Spring Boot and learn how to disable the cache when needed.

2. Caching Setup

Let’s set up a simple use case of querying book reviews by ISBN and cache the method in some logic using @Cacheable.

Our entity class will be the BookReview class, which contains rating, isbn, and so on:

@Entity
@Table(name="BOOK_REVIEWS")
public class BookReview {
    @Id
    @GeneratedValue(strategy= GenerationType.SEQUENCE, generator = "book_reviews_reviews_id_seq")
    @SequenceGenerator(name = "book_reviews_reviews_id_seq", sequenceName = "book_reviews_reviews_id_seq", allocationSize = 1)
    private Long reviewsId;
    private String userId;
    private String isbn;
    private String bookRating;
   
    // getters & setters
}

We add a simple findByIsbn() method in BookRepository to query book reviews by isbn:

public interface BookRepository extends JpaRepository<BookReview, Long> {
    List<BookReview> findByIsbn(String isbn);
}

BookReviewsLogic class contains a method that calls findByIsbn() in BookRepository. We add @Cacheable annotation, which caches the result for given isbn in the book_reviews cache:

@Service
public class BookReviewsLogic {
    @Autowired
    private BookRepository bookRepository;

    @Cacheable(value = "book_reviews", key = "#isbn")
    public List<BookReview> getBooksByIsbn(String isbn){
        return bookRepository.findByIsbn(isbn);
    }
}

Since we’re using @Cacheable in the logic class, we need to configure our cache. We can set up cache config by annotation config class with @Configuration and @EnableCaching. Here, we’re returning HashMap as our cache storage:

@Configuration
@EnableCaching
public class CacheConfig {
    @Bean
    public CacheManager cacheManager() {
        return new ConcurrentMapCacheManager();
    }
}

We’re ready with the cache setup. If we execute getBooksByIsbn() in BookReviewsLogic, our result gets cached in the first execution and it’s returned immediately from then on without re-computing (i.e., querying to the database) thus improving the performance.

Let’s write a simple test to verify it:

@Test
public void givenCacheEnabled_whenLogicExecuted2ndTime_thenItDoesntQueriesDB(CapturedOutput output){
    BookReview bookReview = insertBookReview();

    String target = "Hibernate: select bookreview0_.reviews_id as reviews_1_0_, "
      + "bookreview0_.book_rating as book_rat2_0_, "
      + "bookreview0_.isbn as isbn3_0_, "
      + "bookreview0_.user_id as user_id4_0_ "
      + "from book_reviews bookreview0_ "
      + "where bookreview0_.isbn=?";

    // 1st execution
    bookReviewsLogic.getBooksByIsbn(bookReview.getIsbn());
    String[] logs = output.toString()
      .split("\\r?\\n");
    assertThat(logs).anyMatch(e -> e.contains(target));

    // 2nd execution
    bookReviewsLogic.getBooksByIsbn(bookReview.getIsbn());
    logs = output.toString()
      .split("\\r?\\n");

    long count = Arrays.stream(logs)
      .filter(e -> e.equals(target))
      .count();

    // count 1 means the select query log from 1st execution.
    assertEquals(1,count);
}

In the above test, we’re executing the getBooksByIsbn() twice, capturing the logs, and confirming the select query is executed just once since the getBooksByIsbn() method returns a cached result on the second execution.

To generate an SQL log for the query executed against the database, we can set the below property in the application.properties file:

spring.jpa.show-sql=true

3. Disabling Cache

For disabling the cache, we’ll use an additional custom property (i.e., appconfig.cache.enabled) in the application.properties file:

appconfig.cache.enabled=true

Afterward, we can read this config in the cache config file and have a conditional check:

@Bean
public CacheManager cacheManager(@Value("${appconfig.cache.enabled}") String isCacheEnabled) {
    if (isCacheEnabled.equalsIgnoreCase("false")) {
        return new NoOpCacheManager();
    }

    return new ConcurrentMapCacheManager();
}

As we can see above, our logic checks whether the property is set to disable the cache. If so, we can return an instance of NoOpCacheManager, which is a caching manager that doesn’t perform caching. Otherwise, we can return our Hash-based cache manager.

With the above simple setup, we can disable the cache in the Spring Boot app. Let’s verify the above setup with a simple test.

First, we need to modify the cache property that we defined in application.properties. For our test setup, we can override the property using @TestPropertySource:

@SpringBootTest(classes = BookReviewApplication.class)
@ExtendWith(OutputCaptureExtension.class)
@TestPropertySource(properties = {
    "appconfig.cache.enabled=false"
})
public class BookReviewsLogicCacheDisabledUnitTest {
    // ...
}

Now, our test would be similar to earlier, where we executed the logic twice. We check the SQL query log if it logged twice in the current test since execution won’t be cached:

long count = Arrays.stream(logs)
   .filter(e -> e.contains(target))
   .count();

// count 2 means the select query log from 1st and 2nd execution.
assertEquals(2, count);

4. Conclusion

In this tutorial, we briefly touched on caching in Spring Boot and then set up the cache in the app. We also learned how to disable the cache when we need to test certain parts of the code. Additionally, we wrote the necessary tests to verify the working of enabling and disabling the cache.

As always, the example code is available over on GitHub.