NCache, como caché distribuido en memoria, extremadamente rápido y escalable, proporciona integración con Spring para aumentar el rendimiento de la aplicación al reducir los costosos viajes de datos.
Spring es un marco y contenedor de desarrollo orientado a aspectos y de inyección de dependencias livianos para Java. Le permite simplificar el desarrollo de su aplicación y conectar piezas reutilizables en su aplicación como NCache.
Spring en sí reduce la complejidad general del desarrollo de Java al proporcionar cohesión y acoplamiento flexible, pero crea un alto tráfico en estas aplicaciones. Estas aplicaciones Spring de alto tráfico enfrentan un importante problema de escalabilidad. Por lo tanto, es fundamental contar con una caché distribuida en memoria que cumpla con sus requisitos de escalabilidad.
Aunque estas aplicaciones pueden ampliarse añadiendo más servidores a su granja de servidores, lamentablemente las bases de datos no pueden ampliarse para soportar cargas tan elevadas. Para estos escenarios, una caché distribuida es lo mejor para manejar la base de datos. escalabilidad problema.
Por lo tanto, la mejor opción es NCache. Es un proceso rápido, en memoria, tienda de valor clave caché distribuido, que ha implementado un módulo de almacenamiento en caché Spring, lo que hace que sus aplicaciones Spring sean escalables y distribuidas. Descarga su base de datos al reducir los costosos viajes a la base de datos que causan problemas de escalabilidad y proporciona un rendimiento más rápido.
NCache proporciona soporte de almacenamiento en caché Spring de las siguientes dos maneras:
Para configurar su aplicación Spring, primero debe agregar todas las dependencias Maven requeridas que Spring y NCache proporcionar.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-spring</artifactId>
<version>x.x.x</version>
</dependency>Después de agregar estas dependencias, defina beans en su aplicación Spring, a través de la definición de bean basada en Java o XML.
Definición de Bean basado en Java:
Para definir beans utilizando una definición basada en Java, debe agregar el @Frijol anotación en la clase CachingConfiguration, donde el método setConfigFile especificará la ruta a su ncache-archivo spring.xml. Para obtener información detallada, consulte Bean basado en Java Definición.
@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;
}
}Definición de Bean basada en XML:
Para definir beans utilizando una definición basada en XML, debe agregar un archivo XML que permita el almacenamiento en caché y especifique NCache como administrador de caché. Debe definir etiquetas Bean tanto para cacheManager como para NCacheAdministrador de configuración. Además, debe especificar las siguientes propiedades para 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>Para obtener más detalles, vaya a Definición de Bean basada en XML.
Además, debe configurar sus cachés en el ncache-archivo spring.xml para el NCache Centro de Gestión. Cada caché necesita su propia definición con su propio conjunto de propiedades en este archivo. Por ejemplo:
<?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 también admite proveedores de almacenamiento en caché compatibles con JCache donde puede usar JCache en su aplicación Spring con NCache. Primero, agregue las dependencias de Maven para Spring, NCachey JCache. Después de agregar dependencias, configure los cachés:
Para más información, puede consultar nuestro Documentos de JCache Spring.
Una vez que habilite el almacenamiento en caché a través de las dos configuraciones definidas anteriormente, el siguiente paso es vincular estos comportamientos de almacenamiento en caché a sus respectivos métodos para usar. NCache como proveedor de almacenamiento en caché para Spring.
Puede vincular comportamientos de almacenamiento en caché a sus métodos de dos maneras. uno ha terminado Almacenamiento en caché de anotaciones.
// 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 no usa anotaciones, entonces Almacenamiento en caché declarativo basado en XML se puede usar donde puede especificar el método de destino y las directivas de almacenamiento en caché de forma externa.
<!-- 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>