Configure Caching Declaration for Spring Cache

After configuring your Spring application and enabling caching, the next step is to identify the methods that need to be cached and their respective policies. You can bind the caching behaviors to the methods in Spring Cache using:

• Caching Annotations
• Declarative XML-based Caching

Configure Using Spring Caches Annotations

For caching declarations, the abstraction provides Java annotations that allow methods to trigger Spring cache population or eviction.

Example

Let’s consider a web service with two classes that explain how caching takes place in Spring cache using the @Cacheable annotation.

// BookController.java
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
    BookService booksService;

    @InitBinder
    public void initBinder(WebDataBinder binder) {
        SimpleDateFormat sdf = new SimpleDateFormat("MM-dd-yyyy");
        sdf.setLenient(true);
        binder.registerCustomEditor(Date.class, new CustomDateEditor(sdf, true));
    }

    @RequestMapping(value="/bookstore", method = RequestMethod.GET)
    public ModelAndView homePage(Model model) {
        model.addAttribute("availableBooks", booksService.listAll());
        return new ModelAndView("bookstore");
    }

    @RequestMapping(value = "/bookstore/new", method = RequestMethod.GET)
    public String add(ModelMap model) {
        model.addAttribute("book", new Book());
        return "newBook";
    }

    @RequestMapping(value = "/bookstore/save", method = RequestMethod.POST)
    public String saveBook(@ModelAttribute("book") Book book, BindingResult result) {
        if (result.hasErrors()) {
            return "newBook";
        }
        booksService.save(book);
        return "redirect:/bookstore";
    }

    @RequestMapping(value = "/bookstore/edit", method = RequestMethod.GET)
    public String showEditBookPage(@RequestParam int id, ModelMap model) {
        Book book = booksService.get(id);
        model.put("book", book);
        return "newBook";
    }

    @RequestMapping(value = "/bookstore/edit", method = RequestMethod.POST)
    public String updateBook(@ModelAttribute("book") Book book, BindingResult result) {
        if (result.hasErrors()) {
            return "newBook";
        }
        booksService.update(book);
        return "redirect:/bookstore";
    }

    @RequestMapping(value = "/bookstore/delete")
    public String deleteBook(@RequestParam int id) {
        booksService.delete(id);
        return "redirect:/bookstore";
    }

    @RequestMapping(value="/bookstore", method = RequestMethod.POST)
    public ModelAndView findBook(ModelMap model, @RequestParam long isbn) {
        Book book = booksService.findBookByIsbn(isbn);
        if (book == null) {
            return returnError(model, isbn);
        }
        model.put("book", book);
        return new ModelAndView("bookdetails");
    }

    private ModelAndView returnError(ModelMap model, long isbn) {
        String errorMessage = "The book with ISBN: " + isbn + " is not available.";
        model.put("errorMessage", errorMessage);
        return new ModelAndView(new RedirectView("bookstore"));
    }
}

// BookService.java
@Service
class BookService {
    @Autowired
    private BookRepository repo;

    public List<Book> listAll() {
        return repo.findAll();
    }

    @CachePut(value = "books", key = "#book.getISBN()")
    public void save(Book book) {
        repo.save(book);
    }

    @CachePut(value = "books", key = "#book.getISBN()")
    public void update(Book book) { repo.save(book); }

    @Cacheable(value = "books", key = "#id")
    public Book get(int id) {
        return repo.findById(id);
    }

    @Cacheable(value = "books", key = "#isbn")
    public Book findBookByIsbn(long isbn) {
        return repo.findBookByIsbn(isbn);
    }

    @CacheEvict(value = "books", allEntries = true)
    public void delete(int id) {
        repo.deleteById(id);
    }
}

To get a detailed understanding and to learn more about other Caching Annotations or the creation of the Custom Key Generator, refer to the Spring Documentation.

Configure using Declarative XML-based Caching

If you have limited access to the sources or no external code, you can use XML for declarative caching. Here, you can specify the target method and the caching directives externally.

In the configuration below, the bookService is made cacheable. The caching semantics are encapsulated in the cache:advice definition, which instructs the method findBookByIsbn to put data into the cache while working against the demoCache.

Note

When using the class tag please make sure you use the fully qualified name of your class.

<!-- the service we want to make cacheable -->
<bean id="bookService" class="com.spring.service.BookService"/>

<!-- cache definitions -->
<cache:advice id="booksCacheAdvice" cache-manager="cacheManager">
    <cache:caching cache="demoCache">
        <cache:cacheable method="findBookByIsbn" key="#isbn"/>
    </cache:caching>
</cache:advice>

<app:config>
    <app:advisor advice-ref="booksCacheAdvice" pointcut="execution(* com.spring.service.BookService.*(..))"/>
</app:config>

Also, for using the Custom Key Generator for cache key generation through XML-based caching, beans created for the key generator need to be defined as shown below in CustomerKeyGenerator as a class.

<bean id="customerKeyGenerator" class="cachekeygenerator.CustomerKeyGenerator">

Here, the customerKeyGenerator generates a cache key whenever a customer is added to the customersCache. To use this generator, you must specify the keygenerator bean in your cache:advice tag.

<cache:advice id="customerCacheAdvice" key-generator="customerKeyGenerator">
    <cache:caching cache="customersCache">
        <cache:cacheable method="findCustomerByID"/>
    </cache:caching>
</cache:advice>

After modifying all these configurations, your application is now ready to use NCache as a Spring Caching Provider.

See Also

Configure Application for Generic Spring Caching Provider
NCache as Spring Data Cache