NCache, en tant que cache distribué en mémoire, extrêmement rapide et évolutif, fournit une intégration avec Spring pour améliorer les performances de l'application en réduisant les déplacements de données coûteux.
Spring est un conteneur et un framework léger d'injection de dépendances et de développement orienté aspect pour Java. Il vous permet de simplifier le développement de votre application et d'intégrer des éléments réutilisables dans votre application, comme NCache.
Spring lui-même réduit la complexité globale du développement Java en assurant la cohésion et le couplage lâche, mais il crée un trafic élevé dans ces applications. Ces applications Spring à fort trafic sont confrontées à un problème d’évolutivité important. Par conséquent, un cache distribué en mémoire répondant à leurs exigences d’évolutivité est essentiel.
Bien que ces applications puissent évoluer en ajoutant davantage de serveurs à leur batterie de serveurs, malheureusement, les bases de données ne peuvent pas évoluer pour gérer des charges aussi élevées. Pour ces scénarios, un cache distribué est le meilleur pour gérer la base de données évolutivité problème.
Par conséquent, la meilleure option est NCache. C'est un système rapide, en mémoire, magasin clé-valeur cache distribué, qui a implémenté un module de mise en cache Spring, rendant vos applications Spring évolutives et distribuées. Il décharge votre base de données en réduisant les déplacements coûteux de la base de données qui entraînent des problèmes d'évolutivité et offre des performances plus rapides.
NCache fournit la prise en charge de la mise en cache Spring des deux manières suivantes :
Pour configurer votre application Spring avec, vous devez d'abord ajouter toutes les dépendances Maven requises avec Spring et NCache bereitzustellen.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-spring</artifactId>
<version>x.x.x</version>
</dependency>Après avoir ajouté ces dépendances, définissez les beans dans votre application Spring - via la définition de bean basée sur Java ou XML.
Définition du bean basé sur Java :
Pour définir des beans à l'aide d'une définition basée sur Java, vous devez ajouter le @Haricot annotation dans la classe CachingConfiguration, où la méthode setConfigFile spécifiera le chemin d'accès à votre ncache-fichier spring.xml. Pour des informations détaillées, reportez-vous à Bean basé sur Java Définition.
@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;
}
}Définition du bean basé sur XML :
Pour définir des beans à l'aide d'une définition basée sur XML, vous devez ajouter un fichier XML qui active la mise en cache et spécifie NCache en tant que gestionnaire de cache. Vous devez définir des balises Bean pour le cacheManager et NCachePanneau de configuration. De plus, vous devez spécifier les propriétés suivantes pour 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>Pour plus de détails, rendez-vous sur Définition de bean basée sur XML.
De plus, vous devez configurer vos caches dans le ncache-fichier spring.xml pour le NCache Centre de gestion. Chaque cache nécessite sa propre définition avec son propre ensemble de propriétés dans ce fichier. Par exemple:
<?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 prend également en charge les fournisseurs de mise en cache compatibles JCache où vous pouvez utiliser JCache dans votre application Spring avec NCache. Tout d'abord, ajoutez les dépendances Maven pour Spring, NCacheet JCache. Après avoir ajouté les dépendances, configurez les caches :
Pour plus d'informations, vous pouvez consulter notre Documents de printemps JCache.
Une fois que vous avez activé la mise en cache via les deux configurations définies ci-dessus, l'étape suivante consiste à lier ces comportements de mise en cache à leurs méthodes respectives à utiliser. NCache en tant que fournisseur de mise en cache pour Spring.
Vous pouvez lier les comportements de mise en cache à leurs méthodes de deux manières. L'un est à travers Mise en cache des annotations.
// 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);
}
}Si vous n'utilisez pas d'annotations, alors Mise en cache déclarative basée sur XML peut être utilisé lorsque vous pouvez spécifier la méthode cible et les directives de mise en cache en externe.
<!-- 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>