Partner – Moderne – NPI EA (cat=Spring Boot)
announcement - icon

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Course – Black Friday 2026 – NPI EA – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – before_post_content
announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

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.

The code backing this article is available on GitHub. Once you're logged in as a Baeldung Pro Member, start learning and coding on the project.
Partner – Moderne – NPI EA (tag=Refactoring)
announcement - icon

Modern Java teams move fast — but codebases don’t always keep up. Frameworks change, dependencies drift, and tech debt builds until it starts to drag on delivery. OpenRewrite was built to fix that: an open-source refactoring engine that automates repetitive code changes while keeping developer intent intact.

The monthly training series, led by the creators and maintainers of OpenRewrite at Moderne, walks through real-world migrations and modernization patterns. Whether you’re new to recipes or ready to write your own, you’ll learn practical ways to refactor safely and at scale.

If you’ve ever wished refactoring felt as natural — and as fast — as writing code, this is a good place to start.

Course – Black Friday 2026 – NPI EA – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

Course – Black Friday 2026 – NPI – main – after_post_content

announcement - icon

Yes, we're now running our Black Friday Sale. All Courses are 33% off until 1st December, 2026 at 17:00 Romania time:

>> EXPLORE ACCESS NOW

4 Comments
Oldest
Newest