JCache é uma API baseada em Java usada para cache de memória de objetos Java. Isso também inclui a criação de objetos, invalidação, spool, acesso compartilhado e consistência entre Java Virtual Machines (JVMs).
NCache é uma solução de cache distribuído muito poderosa e versátil que vem com um vasto conjunto de recursos e ferramentas. NCache fornece uma implementação da especificação JCache (JSR 107). Usando isso, você pode colher os benefícios do grande número de recursos e ferramentas fornecidos por NCache.
A criação de uma instância JCache é necessária para que você possa realizar qualquer operação no cache. Em Java, o método getCache() é considerado um dos métodos mais convenientes para obter uma instância JCache. O exemplo de código a seguir demonstra como você pode inicializar um cache usando esse método.
/*Create an instance of JCache's caching provider to get JCacheManager's instance */
CachingProvider provider = Caching.getCachingProvider();
CacheManager manager = provider.getCacheManager();
/*Get a cache from manager via its string name.*/
javax.cache.Cache jCache = manager.getCache("myreplicatedcache");Uma vez que o cache foi inicializado com sucesso e você adquiriu um identificador de cache, você pode realizar muitas operações no cache como acrescentando, buscar, atualização e eliminando dados do cache.
O exemplo de código a seguir demonstra como você pode usar a instância de cache (que você criou no exemplo de código acima) para realizar operações básicas no cache.
/*Adding data to the cache*/
Product product = fetchProductFromDB();
String key = "Product:" + product.getProductID();
jCache.put(key, product);
/*Update data in the cache*/
product.setUnitsInStock(newValue); // updated units
jCache.replace(key, product);
/*Get data from the cache*/
Object item = jCache.get(key);
/*Remove data from the cache*/
Boolean result = jCache.remove(key);Outra característica do JCache é Expiração de dados onde os dados de cache expiram com base no tempo. O JCache suporta dois tipos principais de expirações, a saber Expiração Absoluta e Expiração deslizante. Na expiração absoluta, os dados no cache expiram após um intervalo de tempo fixo. Na expiração deslizante, os dados no cache expiram após um intervalo de tempo, mas esse intervalo de tempo é redefinido toda vez que esses dados são acessados.
Os itens podem ser adicionados e atualizados no cache com expirações Absolutas e Deslizantes definidas. No exemplo de código a seguir, os dados são adicionados ao cache com a expiração Absoluta definida.
CachingProvider cachingProvider = Caching.getCachingProvider();
CacheManager manager = cachingProvider.getCacheManager();
Customer customer = new Customer();
customer.setAge(22);
String key = "Customer:" + customer.getCustomerID();
//configure the expiration duration
CompleteConfiguration<Object, Object> cacheConfig = new MutableConfiguration().setExpiryPolicyFactory(CreatedExpiryPolicy.factoryOf(Duration.ONE_MINUTE));
//create cache with customized configuration settings
javax.cache.Cache jCache = manager.createCache("mypartitionedcache", cacheConfig);
//add item to cache which will expire after 1 minute
jCache.put(key, customer);Notificações de nível de cache são eventos gerais que são acionados quando determinados eventos registrados ocorrem. Para obter notificações de eventos do JCache, você precisa implementar as interfaces relacionadas a eventos relevantes.
No exemplo abaixo, supõe-se que você implementou a fábrica de filtros de eventos.
// class that implements the event-listener factory
public class MyCacheEntryListener<K, V>
implements CacheEntryCreatedListener<K, V>, Serializable
{...
for (CacheEntryEvent<? extends K,? extends V> event: events)
{
System.out.println("Received a " + event);
}
...
}
...
//configuring
MyCacheEntryListener<String,String> m_listener = new MyCacheEntryListener<String,String>();
MutableConfiguration<String, String> config = new MutableConfiguration<String, String>();
config.setTypes(String.class, String.class).addCacheEntryListenerConfiguration(
new MutableCacheEntryListenerConfiguration<String, String>
(FactoryBuilder.factoryOf(m_listener),FactoryBuilder.factoryOf(
new MyCacheEntryEventFilter<String, String>()),true,true));
Cache<String, String> jCache = cacheManager.createCache("myreplicatedcache", config);A API fornecida por NCache oferece recursos e funções mais robustos em comparação com a API fornecida pelo JCache. Algumas das características que NCache fornece, mas o JCache não é o seguinte:
Para usar todos esses recursos fornecidos pelo NCache API você precisa ter uma instância de seu cache.
O exemplo de código a seguir demonstra como você pode usar uma API JCache para obter uma instância de cache de NCache usando o método unwrap. Esta instância é então usada para adicionar dados ao cache com Tag (característica de NCache) ativado. Essas tags podem ser usadas em vez de chaves para recuperar dados do cache posteriormente.
...
com.alachisoft.ncache.client.Cache cache = null;
cache = (com.alachisoft.ncache.client.Cache) jCache.unwrap(com.alachisoft.ncache.client.Cache.class);
Customer customer = fetchCustomer();
String customerKey = “Customer” + customer.getCustomerID();
// Specify Tags
List<Tag> tags = List.of(new Tag("East Coast Customers"));
CacheItem cacheItem = new CacheItem(customer);
cacheItem.setTags(tags);
cache.add(customerKey, cacheItem);