NCache, como um cache distribuído na memória, extremamente rápido e escalável, fornece integração com Spring para aumentar o desempenho do aplicativo, reduzindo viagens de dados caras.
Spring é uma injeção de dependência leve e um contêiner e estrutura de desenvolvimento orientado a aspectos para Java. Ele permite simplificar o desenvolvimento de seu aplicativo e conectar peças reutilizáveis em seu aplicativo, como NCache.
O próprio Spring reduz a complexidade geral do desenvolvimento Java, fornecendo coesão e baixo acoplamento, mas cria alto tráfego nessas aplicações. Esses aplicativos Spring de alto tráfego enfrentam um problema significativo de escalabilidade. Portanto, um cache distribuído na memória que atenda aos requisitos de escalabilidade é fundamental.
Embora esses aplicativos possam ser ampliados adicionando mais servidores ao seu farm de servidores, infelizmente, os bancos de dados não podem ser dimensionados para lidar com cargas tão altas. Para esses cenários, um cache distribuído é o melhor para lidar com o banco de dados escalabilidade problema.
Portanto, a melhor opção é NCache. É um processo rápido, na memória, armazenamento de valor-chave cache distribuído, que implementou um módulo de cache Spring, tornando seus aplicativos Spring escalonáveis e distribuídos. Ele descarrega seu banco de dados, reduzindo as dispendiosas viagens ao banco de dados que causam problemas de escalabilidade e fornece desempenho mais rápido.
NCache fornece suporte ao cache do Spring das duas maneiras a seguir:
Para configurar seu aplicativo Spring, primeiro você deve adicionar todas as dependências Maven necessárias que Spring e NCache proporcionar.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-spring</artifactId>
<version>x.x.x</version>
</dependency>Depois de adicionar essas dependências, defina beans em seu aplicativo Spring - por meio da definição de Bean baseada em Java ou XML.
Definição de Bean baseada em Java:
Para definir beans usando definição baseada em Java, você precisa adicionar o @Feijão anotação na classe CachingConfiguration, onde o método setConfigFile especificará o caminho para seu ncache-spring.xml arquivo. Para obter informações detalhadas, consulte Bean baseado em Java Definição.
@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;
}
}Definição de Bean baseada em XML:
Para definir beans usando definição baseada em XML, é necessário adicionar um arquivo XML que habilite o armazenamento em cache e especifique NCache como gerenciador de cache. Você deve definir tags Bean para cacheManager e NCacheGerenciador de configuração. Além disso, você deve especificar as propriedades a seguir 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 obter detalhes, vá para Definição de Bean baseada em XML.
Além disso, você deve configurar seus caches no ncache-spring.xml arquivo para o NCache Centro de Gestão. Cada cache precisa de sua própria definição com seu próprio conjunto de propriedades neste arquivo. Por exemplo:
<?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 também oferece suporte a provedores de cache compatíveis com JCache, onde você pode usar JCache em seu aplicativo Spring com NCache. Primeiro, adicione dependências do Maven para Spring, NCachee JCache. Após adicionar dependências, configure os caches:
Para mais informações, pode consultar o nosso Documentos do JCache Spring.
Depois de ativar o cache por meio de ambas as configurações definidas acima, a próxima etapa é vincular esses comportamentos de cache aos seus respectivos métodos a serem usados NCache como um provedor de cache para Spring.
Você pode vincular comportamentos de cache aos seus métodos de duas maneiras. Um já passou Cache de anotações.
// 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 você não usar anotações, então Cache declarativo baseado em XML pode ser usado onde você pode especificar o método de destino e as diretivas de cache externamente.
<!-- 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>