Ereignisbenachrichtigungen in JCache
Ereignisbenachrichtigungen beziehen sich auf einen Mechanismus, der es Listenern ermöglicht, über Cache-Ereignisse benachrichtigt zu werden. Diese Ereignisse stellen mehrere Vorgänge oder Aktualisierungen dar, die im Cache stattfinden, und ermöglichen die Durchführung von Maßnahmen, wenn solche Ereignisse auftreten. Um solche Ereignisbenachrichtigungen zu erhalten, müssen Clientanwendungen die spezifischen Ereignishandlermethoden enthalten, um auf die ausgelösten Ereignisse zu reagieren. Immer wenn diese Ereignisse ausgelöst werden, führt die Ziel-Ereignishandlermethode den gesamten im Methodenkörper geschriebenen Code aus. Standardmäßig sind diese Benachrichtigungen für alle Cache-Konfigurationen deaktiviert (außer clearCache
) und muss aktiviert sein, damit Ereignisse veröffentlicht werden können.
Voraussetzungen für Ereignisbenachrichtigungen in JCache
- Zur Verwendung von JCache mit NCache Professional, ersetze das
ncache-client
mitncache-professional-client
in Ihrer pom.xml.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-client</artifactId>
<version>x.x.x</version>
</dependency>
- Importieren Sie die folgenden Pakete in Ihre Anwendung:
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.spi.CachingProvider;
- Stellen Sie sicher, dass die Daten serialisiert oder registriert sind NCache Serialisierungsformat.
- Stellen Sie sicher, dass der Cache ausgeführt und initialisiert wird.
Registrieren Sie Ereignisse auf Cache-Ebene
Das JCache-Ereignismodell ermöglicht es Anwendungen, Ereignisse zu empfangen und zu verarbeiten, die Änderungen an den Einträgen in einem Cache darstellen. Das Ereignismodell verwendet Standard-Java-Ereignisse und Ereignis-Listener-Konventionen. Der folgende Codeausschnitt zeigt, wie Ereignisse in JCache registriert werden. Der Code ruft zunächst die Instanz von JCache Manager ab, erstellt eine Listener-Konfiguration und registriert ein bestimmtes Ereignis registerCacheEntryListener
und fügt einen Wert hinzu, um dieses Ereignis mithilfe von abzurufen put
Methode.
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
boolean isOldValueRequired = false;
boolean isSynchronous = false;
CacheEntryEventFilterImpl eventListener = new CacheEntryEventFilterImpl();
// Making listener config
MutableCacheEntryListenerConfiguration listenerConfig = new MutableCacheEntryListenerConfiguration(eventListener, new CacheEntryEventFilterImpl<String, Object>(), isOldValueRequired, isSynchronous);
// Registering events
jCache.registerCacheEntryListener(listenerConfig);
// Adding a value to get an event
jCache.put("key", "value");
Registrierung von Ereignissen auf Cache-Ebene aufheben
Sie können die Registrierung eines zuvor registrierten Ereignisses auf Cache-Ebene auch mithilfe des JCache aufheben deregisterCacheEnteryListener
Methode mit einer registrierten Cache-Eintrag-Listener-Instanz zum Aufheben der Registrierung.
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
boolean isOldValueRequired = false;
boolean isSynchronous = false;
// Making listener config
MutableCacheEntryListenerConfiguration listenerConfig = new MutableCacheEntryListenerConfiguration(eventListener, new CacheEntryEventFilterImpl<String, Object>(), isOldValueRequired, isSynchronous);
// Unregistering events
jCache.deregisterCacheEntryListener(listenerConfig);
Implementieren Sie CacheEntryListenerFactory
Sie können das implementieren CacheEntryListenerFactory
durch das CacheEntryListenerFactoryImpl
Klasse, die als Listener für Cache-Eintragsereignisse dient. Die Klasse reagiert auf bestimmte Änderungen in einem Cache, z. B. das Erstellen, Aktualisieren oder Entfernen von Elementen.
public class CacheEntryListenerFactoryImpl<K, V> implements CacheEntryCreatedListener, CacheEntryUpdatedListener, CacheEntryRemovedListener, Factory<CacheEntryListener> {
@Override
public void onCreated(Iterable iterable) throws CacheEntryListenerException {
// Business Logic
System.out.println("Item Created");
}
@Override
public void onRemoved(Iterable iterable) throws CacheEntryListenerException {
// Business Logic
System.out.println("Item Removed");
}
@Override
public void onUpdated(Iterable iterable) throws CacheEntryListenerException {
// Business Logic
System.out.println("Item Updated");
}
@Override
public CacheEntryListener create() {
// Business Logic
return new CacheEntryListenerFactoryImpl();
}
}
Implementieren Sie CacheEntryEventFilter
Sie können das implementieren CacheEntryEventFilter
durch das CacheEntryEventFilterImpl
Klasse, durch Implementierung der CacheEntryEventFilter
Schnittstelle, um zu bestimmen, ob ein bestimmtes Cache-Ereignis von einem Cache-Eintrags-Listener berücksichtigt oder ignoriert werden soll. Die Klasse implementiert auch die Factory<CacheEntryEventFilter>
wodurch Objekte der erstellt werden CacheEntryEventFilter
Art.
public class CacheEntryEventFilterImpl<K, V> implements CacheEntryEventFilter, Factory<CacheEntryEventFilter> {
@Override
public boolean evaluate(CacheEntryEvent event) throws CacheEntryListenerException {
// Business Logic
return true;
}
@Override
public CacheEntryEventFilter create() {
// Business Logic
return new CacheEntryEventFilterImpl();
}
}
Registrieren Sie Ereignisse auf Artikelebene
Zusammen mit nativen JCache-Ereignissen NCache bietet erweiterte Ereignisse auf Elementebene, durch die Ihre Client-Anwendungen über verschiedene Vorgänge im Cache für bestimmte Schlüssel benachrichtigt werden können. Ereignisse auf Artikelebene Stellen Sie Aktualisierungen zu bestimmten Schlüsseln bereit, anstatt die Anwendung mit Benachrichtigungen für jeden Schlüssel zu bombardieren.
Ereignisse auf Elementebene müssen für bestimmte Schlüssel registriert werden. Dabei handelt es sich um die Ereignisse, die für diese bestimmten Schlüssel im veröffentlicht werden NCache API. Hebeln NCacheBei Ereignissen auf Elementebene können Sie die bereitgestellte „Unwrap“-Methode verwenden NCache. Mit dieser Methode können Sie auf die erweiterten Ereignisse zugreifen und diese effektiv nutzen NCache Cache-Instanz. Im folgenden Beispiel generiert der Cache eine Benachrichtigung, wenn eine bestimmte Operation für den Schlüssel in einer Frage ausgeführt wird.
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Unwrapping NCache's cache instance from JCache's cache instance
Cache ncache = (Cache) jCache.unwrap(Cache.class);
// Product to be registered for events
String key = "Product:1001";
CacheDataModificationListenerImpl eventListener = new CacheDataModificationListenerImpl();
// Registering events
ncache.getMessagingService().addCacheNotificationListener(key, eventListener, EnumSet.of(EventType.ItemUpdated, EventType.ItemRemoved), EventDataFilter.DataWithMetadata);
Heben Sie die Registrierung von Ereignissen auf Artikelebene auf
Sie können die Registrierung zuvor registrierter Ereignisse auf Artikelebene auch mithilfe von aufheben removeCacheNotificationListener
Methode.
// Get instance of JCacheManager
CacheManager manager = Caching.getCachingProvider().getCacheManager();
// Get a cache from manager via its string name.
javax.cache.Cache jCache = manager.getCache("demoCache");
// Unwrapping NCache's cache instance from JCache's cache instance
Cache ncache = (Cache) jCache.unwrap(Cache.class);
// Product to be unregistered for events
String key = "Product:1001";
// Unregistering events
ncache.getMessagingService().removeCacheNotificationListener(key, eventListener, EnumSet.of(EventType.ItemUpdated, EventType.ItemRemoved));
Implementieren Sie CacheDataModificationListener
Sie können das implementieren CacheDataModificationListener
durch das CacheDataModificationListenerImpl
Klasse, die eine einzelne Methode aus implementiert CacheDataModificationListener
Schnittstelle, genannt onCacheDataModified
. Die Klasse überwacht und reagiert auf verschiedene Änderungen in einem Cache, z. B. das Aktualisieren oder Entfernen von Elementen.
public class CacheDataModificationListenerImpl implements CacheDataModificationListener {
@Override
public void onCacheDataModified(String key, CacheEventArg eventArgs) {
switch (eventArgs.getEventType())
{
case ItemUpdated:
// 'key' has been updated in the cache
break;
case ItemRemoved:
// 'key' has been removed from the cache
break;
}
}
}
Siehe auch
CRUD-Operationen mit JCache
NCache Integration mit Spring
Wrapper von Drittanbietern