Configurare la dichiarazione di memorizzazione nella cache per Spring Cache
Dopo aver configurato l'applicazione Spring e aver abilitato la memorizzazione nella cache, il passaggio successivo consiste nell'identificare i metodi che devono essere memorizzati nella cache e le rispettive politiche.
Puoi associare i comportamenti di memorizzazione nella cache ai metodi in Spring Cache utilizzando:
- Annotazioni nella cache
- Caching dichiarativo basato su XML
Configura utilizzando le annotazioni Spring Caches
Per le dichiarazioni di memorizzazione nella cache, l'astrazione fornisce annotazioni Java che consentono ai metodi di attivare il popolamento o l'eliminazione della cache Spring.
Esempio
Consideriamo un servizio Web con due classi che spiegano come avviene la memorizzazione nella cache nella cache Spring utilizzando il file @ Memorizzabile nella cache annotazione.
// 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);
}
}
Per ottenere una comprensione dettagliata e saperne di più su altre annotazioni di memorizzazione nella cache o sulla creazione del generatore di chiavi personalizzate, fare riferimento al Documentazione primaverile.
Configura utilizzando la memorizzazione nella cache dichiarativa basata su XML
Se le annotazioni non sono un'opzione, cioè se hai accesso limitato ai sorgenti o non hai codice esterno, puoi utilizzare XML per la memorizzazione nella cache dichiarativa. Qui è possibile specificare esternamente il metodo di destinazione e le direttive di memorizzazione nella cache.
Nella configurazione seguente, il servizio di prenotazione viene reso memorizzabile nella cache. La semantica della memorizzazione nella cache è incapsulata nel file cache:advice
definizione, che istruisce il metodo findBookByIsbn per inserire i dati nella cache mentre si lavora contro il file demoCache.
Note:
Quando si utilizza la class
tag assicurati di utilizzare il nome completo della tua classe.
<!-- 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>
Inoltre, per utilizzare il generatore di chiavi personalizzato per la generazione di chiavi di cache tramite la memorizzazione nella cache basata su XML, i bean creati per il generatore di chiavi devono essere definiti come mostrato di seguito in CustomerKeyGenerator
come classe.
<bean id="customerKeyGenerator" class="cachekeygenerator.CustomerKeyGenerator">
Qui, il customerKeyGenerator
genera una chiave di cache ogni volta che un cliente viene aggiunto a clientiCache. Per utilizzare questo generatore, è necessario specificare il file keygenerator
fagiolo nel tuo cache:advice
etichetta.
<cache:advice id="customerCacheAdvice" key-generator="customerKeyGenerator">
<cache:caching cache="customersCache">
<cache:cacheable method="findCustomerByID"/>
</cache:caching>
</cache:advice>
Dopo aver modificato tutte queste configurazioni, l'applicazione è ora pronta per l'uso NCache come provider di caching primaverile.
Vedere anche
Configura l'applicazione per il provider di memorizzazione nella cache di primavera generico
NCache come cache di dati di primavera