JCache ist eine Java-basierte API, die für das Zwischenspeichern von Java-Objekten im Arbeitsspeicher verwendet wird. Dazu gehören auch die Erstellung von Objekten, Invalidierung, Spooling, gemeinsamer Zugriff und Konsistenz über Java Virtual Machines (JVMs).
NCache ist eine sehr leistungsstarke und vielseitige verteilte Caching-Lösung, die mit einer Vielzahl von Funktionen und Tools ausgestattet ist. NCache stellt eine Implementierung der JCache (JSR 107)-Spezifikation bereit. Auf diese Weise können Sie die Vorteile der zahlreichen Funktionen und Tools nutzen, die von bereitgestellt werden NCache.
Die Erstellung einer JCache-Instanz ist erforderlich, damit Sie Vorgänge im Cache ausführen können. In Java gilt die Methode getCache () als eine der bequemsten Methoden, um eine JCache-Instanz zu erhalten. Das folgende Codebeispiel zeigt, wie Sie mit dieser Methode einen Cache initialisieren können.
/*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");Sobald der Cache erfolgreich initialisiert wurde und Sie ein Cache-Handle erworben haben, können Sie viele Operationen auf dem Cache ausführen, z Hinzufügen, holen, Aktualisierung und löschen Daten aus dem Cache.
Das folgende Codebeispiel zeigt, wie Sie die Cacheinstanz (die Sie im obigen Codebeispiel erstellt haben) verwenden können, um grundlegende Vorgänge im Cache auszuführen.
/*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);Eine weitere Funktion von JCache ist Datenablauf wo Cache-Daten auf der Grundlage der Zeit abgelaufen sind. JCache unterstützt nämlich zwei Haupttypen von Ablaufzeiten Absoluter Ablauf und Gleitender Ablauf. Beim absoluten Ablauf verfallen Daten im Cache nach einem festen Zeitintervall. Beim gleitenden Ablauf laufen Daten im Cache nach einem Zeitintervall ab, aber dieses Zeitintervall wird jedes Mal zurückgesetzt, wenn auf diese Daten zugegriffen wird.
Elemente können im Cache hinzugefügt und aktualisiert werden, wobei absolute und gleitende Ablaufzeiten definiert sind. Im folgenden Codebeispiel werden Daten mit definiertem absolutem Ablaufdatum in den Cache eingefügt.
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);Benachrichtigungen auf Cache-Ebene sind allgemeine Ereignisse, die ausgelöst werden, wenn bestimmte registrierte Ereignisse eintreten. Um Ereignisbenachrichtigungen von JCache zu erhalten, müssen Sie die entsprechenden ereignisbezogenen Schnittstellen implementieren.
Im folgenden Beispiel wird davon ausgegangen, dass Sie die Event-Filter-Factory implementiert haben.
// 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);Die API von NCache bietet Ihnen im Vergleich zur von JCache bereitgestellten API robustere Features und Funktionen. Einige der Funktionen, die NCache bietet, JCache jedoch nicht, lauten wie folgt:
Um alle diese Funktionen nutzen zu können, die von der bereitgestellt werden NCache API benötigen Sie eine Instanz ihres Caches.
Das folgende Codebeispiel zeigt, wie Sie eine JCache-API verwenden können, um eine Cache-Instanz von abzurufen NCache mit der Unwrap-Methode. Diese Instanz wird dann verwendet, um Daten in den Cache einzufügen Tags (Merkmal von NCache) aktiviert. Diese Tags können anstelle von Schlüsseln verwendet werden, um später Daten aus dem Cache abzurufen.
...
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);