JCache è un'API basata su Java utilizzata per la memorizzazione nella cache di oggetti Java. Ciò include anche la creazione di oggetti, l'invalidazione, lo spooling, l'accesso condiviso e la coerenza tra Java Virtual Machines (JVM).
NCache è una soluzione di memorizzazione nella cache distribuita molto potente e versatile che viene fornita con un vasto set di funzionalità e strumenti. NCache fornisce un'implementazione della specifica JCache (JSR 107). Usando questo, puoi sfruttare i vantaggi del vasto numero di funzionalità e strumenti forniti da NCache.
La creazione di un'istanza JCache è necessaria per poter eseguire qualsiasi operazione sulla cache. In Java, il metodo getCache() è considerato uno dei metodi più convenienti per ottenere l'istanza JCache. L'esempio di codice seguente mostra come inizializzare una cache usando questo metodo.
/*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");Una volta che la cache è stata inizializzata correttamente e hai acquisito un handle di cache, puoi eseguire molte operazioni sulla cache come l'aggiunta di, recupero, aggiornamentoe eliminazione dati dalla cache.
Nell'esempio di codice seguente viene illustrato come utilizzare l'istanza della cache (creata nell'esempio di codice precedente) per eseguire operazioni di base sulla 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);Un'altra caratteristica di JCache è Scadenza dei dati dove i dati della cache sono scaduti in base al tempo. JCache supporta due tipi principali di scadenze, vale a dire Scadenza assoluta ed Scadenza scorrevole. In Scadenza assoluta, i dati all'interno della cache sono scaduti dopo un intervallo di tempo fisso. In Scadenza scorrevole, i dati all'interno della cache scadono dopo un intervallo di tempo, ma questo intervallo di tempo viene reimpostato ogni volta che si accede a questi dati.
Gli elementi possono essere aggiunti e aggiornati nella cache con le scadenze Assolute e Scorrevoli definite. Nell'esempio di codice seguente i dati vengono aggiunti alla cache con la scadenza assoluta definita.
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);Notifiche a livello di cache sono eventi generali che vengono attivati quando si verificano determinati eventi registrati. Per ricevere le notifiche degli eventi da JCache, è necessario implementare le interfacce relative agli eventi pertinenti.
Nell'esempio seguente, si presuppone che tu abbia implementato la fabbrica del filtro degli eventi.
// 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);L'API fornita da NCache offre caratteristiche e funzioni più robuste rispetto all'API fornita da JCache. Alcune delle caratteristiche che NCache fornisce ma JCache non è il seguente:
Per utilizzare tutte queste funzionalità fornite dal NCache API devi avere un'istanza della sua cache.
L'esempio di codice seguente mostra come utilizzare un'API JCache per ottenere un'istanza cache di NCache utilizzando il metodo unwrap. Questa istanza viene quindi utilizzata per aggiungere dati nella cache con tag (caratteristica di NCache) abilitato. Questi tag possono essere utilizzati al posto delle chiavi per recuperare i dati dalla cache in un secondo momento.
...
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);