NCache è un archivio chiave-valore distribuito e in memoria che si integra con Spring Framework per eliminare i colli di bottiglia del database. Funge da Spring Cache Provider ad alte prestazioni, consentendo una scalabilità lineare per applicazioni Java ad alto numero di transazioni.
Spring è un contenitore e framework di sviluppo leggero e orientato agli aspetti per Java. Ti consente di semplificare lo sviluppo della tua applicazione e collegare pezzi riutilizzabili nella tua applicazione come NCache.
Spring stesso riduce la complessità complessiva dello sviluppo Java fornendo coesione e accoppiamento libero, ma crea un traffico elevato in queste applicazioni. Queste applicazioni Spring ad alto traffico devono affrontare un significativo problema di scalabilità. Pertanto, è fondamentale una cache distribuita in memoria che soddisfi i requisiti di scalabilità.
Sebbene queste applicazioni possano espandersi aggiungendo più server alla server farm, sfortunatamente i database non possono scalare per gestire carichi così elevati. Per questi scenari, una cache distribuita è la soluzione migliore per gestire il database modulabilità problema.
Pertanto, l'opzione migliore è NCache. È un veloce, in memoria, negozio di valori-chiave cache distribuita, che ha implementato un modulo di memorizzazione nella cache Spring, rendendo le tue applicazioni Spring scalabili e distribuite. Scarica il tuo database riducendo i costosi spostamenti del database che causano problemi di scalabilità e fornisce prestazioni più veloci.
Per configurare un'applicazione Spring con NCache, gli sviluppatori possono scegliere tra il provider nativo Spring Caching o il provider compatibile con JCache.
Per configurare la tua applicazione Spring con, devi innanzitutto aggiungere tutte le dipendenze Maven richieste che Spring e NCache fornire.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-spring</artifactId>
<version>x.x.x</version>
</dependency>Dopo aver aggiunto queste dipendenze, definisci i bean nella tua applicazione Spring, tramite la definizione di bean basata su Java o XML.
Definizione di bean basato su Java:
Per definire i bean utilizzando la definizione basata su Java, è necessario aggiungere il file @Fagiolo annotazione nella classe CachingConfiguration, dove il metodo setConfigFile specificherà il percorso al tuo file ncache-spring.xml. Per informazioni dettagliate, fai riferimento a Bean basato su Java Definizione.
@Configuration
class CachingConfiguration {
@Bean
public CacheManager cacheManager() {
String resource = Path.of(System.getenv("NCHOME"), "config/ncache-spring.xml").toString();
SpringConfigurationManager springConfigurationManager = new SpringConfigurationManager();
springConfigurationManager.setConfigFile(resource);
NCacheCacheManager cacheManager = new NCacheCacheManager();
cacheManager.setSpringConfigurationManager(springConfigurationManager);
return cacheManager;
}
}Definizione di bean basata su XML:
Per definire i bean utilizzando una definizione basata su XML, è necessario aggiungere un file XML che consenta la memorizzazione nella cache e specifichi NCache come gestore della cache. È necessario definire i tag Bean sia per cacheManager che per NCacheGestore della configurazione. Inoltre, è necessario specificare le seguenti proprietà per cacheManager.
<bean id="cacheManager" class="com.alachisoft.integrations.spring.NCacheCacheManager">
<property name="springConfigurationManager" ref="NCacheConfigurationManager"/>
<property name="logFilePath" value=" C:\Program Files\NCache\log-files\CustomerDBSpringLogs"/>
</bean><bean id="NCacheConfigurationManager" class="com.alachisoft.integrations.spring.configuration.SpringConfigurationManager">
<property name="configFile" value="ncache-spring.xml">
</bean>Per i dettagli, vai a Definizione di bean basata su XML.
Inoltre, è necessario configurare le cache nel file ncache-spring.xml per NCache Centro Direzionale. Ogni cache necessita della propria definizione con il proprio set di proprietà in questo file. Per esempio:
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<application-config default-cache-name="books">
<caches>
<cache name="books" ncacheid-instance="democache" priority="normal" expiration-type="absolute" expiration-period="300"/>
</caches>
</application-config>Spring supporta anche i provider di caching conformi a JCache con cui puoi utilizzare JCache nella tua applicazione Spring NCache. Innanzitutto, aggiungi le dipendenze Maven per Spring, NCachee JCache. Dopo aver aggiunto le dipendenze, configura le cache:
Per maggiori informazioni potete consultare il nostro Documenti di primavera JCache.
@Cacheable nei dati di primaveraUna volta abilitata la memorizzazione nella cache tramite entrambe le configurazioni definite sopra, il passaggio successivo è associare questi comportamenti di memorizzazione nella cache ai rispettivi metodi da utilizzare NCache come fornitore di cache per la primavera.
Puoi associare i comportamenti di memorizzazione nella cache ai relativi metodi in due modi. Uno è finito Annotazioni nella cache.
// BookController.java
@RestController
@RequestMapping("/books")
public class BookController {
@Autowired
// Get a Spring Service to save objects in the DB. This also caches them with 5min absolute (TTL) expiration.
BookService service = context.getBean(BookService.class);
service.save(new Book(18001, "The Second Machine Age", "Erik Brynjolfsson, Andrew McAfee", new Date(2014, 0, 20)));
// Print all saved books details
printBooks(service.listAll());
// Use Spring Service to get a book from the DB. It actually comes from the cache
Book foundBook = service.findBookByIsbn(18001);
printBookDetails(foundBook);
foundBook.setAuthor("New Author");
Book UpdatedBook = service.update(foundBook);
printBookDetails(UpdatedBook);
context.close();
System.exit(0);
}
// BookService.java
@Service
class BookService {
@Autowired
private BookRepository repo;
public List<Book> listAll() {
return repo.findAll();
}
@CachePut(value = "demoCache", key = "#book.getISBN()")
public Book save(Book book) { return repo.save(book); }
@CachePut(value = "demoCache", key = "#book.getISBN()")
public Book update(Book book) { return repo.save(book); }
@Cacheable(value = "demoCache", key = "#id")
public Book get(int id) {
return repo.findById(id);
}
@Cacheable(value = "demoCache", key = "#isbn")
public Book findBookByIsbn(long isbn) {
return repo.findBookByIsbn(isbn);
}
@CacheEvict(value = "demoCache", allEntries = true)
public void delete(int id) {
repo.deleteById(id);
}
}Se non usi le annotazioni, allora Caching dichiarativo basato su XML può essere utilizzato dove è possibile specificare il metodo di destinazione e le direttive di memorizzazione nella cache esternamente.
<!-- the service we want to make cacheable -->
<bean id="bookService" class="x.y.service.BookService"/>
<!-- cache definitions -->
<cache:advice id="booksCacheAdvice" cache-manager="cacheManager">
<cache:caching cache="demoCache">
<cache:cacheable method="getBookNameByIsbn" key="#isbn"/>
<cache:cache-evict method="loadBooks" all-entries="true"/>
</cache:caching>
</cache:advice>© Copyright Alachisoft 2002 - . Tutti i diritti riservati. NCache è un marchio registrato di Diyatech Corp.