Ereignisbenachrichtigungen auf Elementebene
Ereignisse auf Artikelebene können registriert werden, um Benachrichtigungen für bestimmte Schlüssel zu erhalten. Neben Schlüsseln können auch Ereignisse auf Gegenstandsebene mit registriert werden CacheItem
Klasse. Die Benachrichtigungen können empfangen werden, wenn Aktualisierungs- oder Entfernungsvorgänge für bestimmte Schlüssel ausgeführt werden. Ereignisse auf Elementebene können mit registriert werden RegisterCacheNotification
durch Bereitstellen des implementierten Callbacks, EventType
und EventDataFilter
.
Wichtig
Der Schlüssel muss im Cache vorhanden sein, damit das Ereignis registriert wird. Für Ereignisse auf Elementebene können nur die Ereignistypen „Aktualisieren“ oder „Entfernen“ registriert werden.
Die relevanten Details zur Registrierung von Ereignissen auf Elementebene werden im Folgenden erläutert.
Voraussetzungen:
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Stelle sicher, dass Ereignisbenachrichtigungen aktivieren Verwendung der NCache Managementzentrum.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, CacheItem, GetEventType, Ereignisdatenfilter, Ereignistyp, CacheDataModificationListener, removeCacheTificationListener, addCacheNotificationListener, CacheDataModificationListener.
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Stelle sicher, dass Ereignisbenachrichtigungen aktivieren Verwendung der NCache Managementzentrum.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, CacheItem, Ereignistyp, Ereignisdatenfilter, entfernteatamodificificationListener, getMessagingService, addCacheDataNotificationListener, CacheDataModificationListener, GetEventType.
- Lernen Sie die Standardvoraussetzungen kennen, die für die Arbeit mit allen erforderlich sind NCache Weitere Informationen zu clientseitigen Funktionen finden Sie auf der angegebenen Seite Clientseitige API-Voraussetzungen.
- Stelle sicher, dass Ereignisbenachrichtigungen aktivieren Verwendung der NCache Managementzentrum.
- Einzelheiten zur API finden Sie unter: Cache-Speicher, CacheItem, Ereignistyp, Ereignisdatenfilter, get_messaging_service, get_event_type, add_cache_notification_listener, Remove_cache_notification_listener, CacheEventArg.
Implementieren Sie Callback für Ereignisbenachrichtigungen
Sie können einen Rückruf für Ereignisse implementieren, wo EventType
wird entsprechend der Logik des Benutzers für angegeben ItemAdded
, ItemUpdated
, oder ItemRemoved
Veranstaltungen. Das folgende Beispiel zeigt, wie Rückrufe für Ereignisbenachrichtigungen registriert werden.
public void OnCacheDataModification(string key, CacheEventArg args)
{
switch (args.EventType)
{
case EventType.ItemAdded:
Console.WriteLine($"Item with Key '{key}' has been added to cache '{args.CacheName}'");
break;
case EventType.ItemUpdated:
Console.WriteLine($"Item with Key '{key}' has been updated in the cache '{args.CacheName}'");
// Item can be used if EventDataFilter is DataWithMetadata or Metadata
if (args.Item != null)
{
Product updatedProduct = args.Item.GetValue<Product>();
Console.WriteLine($"Updated Item is a Product having name '{updatedProduct.ProductName}' with ID '{updatedProduct.ProductID}' and price '{updatedProduct.UnitPrice}'");
}
break;
case EventType.ItemRemoved:
Console.WriteLine($"Key '{key}' has been removed from the cache '{args.CacheName}'");
break;
}
}
// Precondition: Events have been enabled
// Create a target method
public class CacheDataModificationListenerImpl implements CacheDataModificationListener {
@Override
public void onCacheDataModified(String key, CacheEventArg args) {
switch (args.getEventType()) {
case ItemAdded:
System.out.println("Item with Key '" + key + "' has been added to cache '" + args.getCacheName() + "'");
break;
case ItemUpdated:
System.out.println("Item with Key '" + key + "' has been updated in the cache '" + args.getCacheName() + "'");
// Item can be used if EventDataFilter is DataWithMetadata or Metadata
if (args.getItem() != null) {
Customer updatedCustomer = args.getItem().getValue(Customer.class); //Ignore error code works
System.out.println("Updated Item: " + updatedCustomer);
}
break;
case ItemRemoved:
System.out.println("Item with Key '" + key + "' has been removed from the cache '" + args.getCacheName() + "'");
break;
}
System.out.println("Completed");
}
}
// Precondition: Events have been enabled
// Create a target method
onCacheDataModified(key, arg)
{
if (null != arg.getEventType())
{
switch (arg.getEventType())
{
// perform operations
case ncache.EventType.ItemUpdated:
// key has been updated in cache
if (args.getItem() != null)
{
Product updateProduct = args.getItem().getValue();
// perform operations
}
break;
case ncache.EventType.ItemRemoved:
// key has been removed from cache
break;
default:
break;
}
}
}
def on_cache_data_modified(key: str, arg: ncache.CacheEventArg):
if arg.get_event_type() is not None:
if arg.get_event_type() is ncache.EventType.ITEM_ADDED:
# Key has been added to cache
print("Item added")
elif arg.get_event_type() is ncache.EventType.ITEM_UPDATED:
# Key has been updated in cache
print("Item updated")
elif arg.get_event_type() is ncache.EventType.ITEM_REMOVED:
# key has been removed from cache
print("Item removed")
Note
Um sicherzustellen, dass der Vorgang ausfallsicher ist, wird empfohlen, alle potenziellen Ausnahmen in Ihrer Anwendung zu behandeln, wie in erläutert Umgang mit Fehlern.
Artikelbenachrichtigungen registrieren
Da der Rückruf implementiert wurde, wird eine Zielmethode erstellt, die mehrere Rückrufe enthält. Der angemessene EventType
wird nur zur Überwachung der spezifischen Client-Vorgänge bereitgestellt. Zu diesen Ereignistypen gehören: ItemUpdated
und ItemRemoved
die durch einen separaten Methodenaufruf angegeben werden muss. EventDataFilter
wird angegeben, um die Menge an Informationen zu quantifizieren, die bei einer Ereignisausführung zurückgegeben werden.
Note
If EventDataFilter
ist nicht angegeben, EventDataFilter.None
wird automatisch eingestellt.
Hier erklären wir, wie Sie Artikelbenachrichtigungen für einen bestimmten Artikel oder eine Artikelgruppe registrieren können.
Registrieren Sie Artikelbenachrichtigungen für einen bestimmten Artikel
Um eine Artikelbenachrichtigung für einen einzelnen Artikel zu registrieren, verwenden Sie die RegisterCacheNotifications
Methode durch Bereitstellen eines einzelnen Schlüssels, der EventType
und der EventDataFilter
. Das folgende Beispiel zeigt, wie Sie Artikelbenachrichtigungen mit registrieren ItemUpdated
Ereignistyp für ein bestimmtes Element.
// Key of the cache item to be monitored events
string key = "Product:Chai";
// create CacheDataNotificationCallback object
var dataNotificationCallback = new CacheDataNotificationCallback(OnCacheDataUpdation);
// Register notifications for a specific item being updated in cache
// EventDataFilter as DataWithMetadata which returns keys along with their entire data
cache.MessagingService.RegisterCacheNotification(key, dataNotificationCallback, EventType.ItemUpdated, EventDataFilter.DataWithMetadata);
// Callback to Update Event Notifications
public void OnCacheDataUpdation(string key, CacheEventArg args)
{
Console.WriteLine($"Item with Key '{key}' has been updated in the cache '{args.CacheName}'");
// Item can be used if EventDataFilter is DataWithMetadata or Metadata
if (args.Item != null)
{
Product updatedProduct = args.Item.GetValue<Product>();
Console.WriteLine($"Updated Item is a Product having name '{updatedProduct.ProductName}' with ID '{updatedProduct.ProductID}' and price '{updatedProduct.UnitPrice}'");
}
}
String key = "Product:Chai";
// Create CacheDataNotificationCallback object
CacheDataModificationListener dataModificationListener = new CacheDataModificationListenerImpl();
// Register notifications for a specific item being updated in cache
// EventDataFilter as DataWithMetadata which returns keys along with their entire data
cache.getMessagingService().addCacheNotificationListener(key, dataModificationListener, EnumSet.of(EventType.ItemUpdated), EventDataFilter.DataWithMetadata);
System.out.println("Item level notifications registered successfully for key: " + key);
key = "Product:1001"
# Register item notifications with 'ITEM_UPDATED' event type
# EventDataFilter as DATA_WITH_META_DATA which returns keys along with their
# entire data
messaging_service = cache.get_messaging_service()
messaging_service.add_cache_notification_listener(
event_listener,
[ncache.EventType.ITEM_UPDATED],
ncache.EventDataFilter.DATA_WITH_META_DATA,
key
)
Artikelbenachrichtigungen für einen Artikelsatz registrieren
Um Artikelbenachrichtigungen für eine Reihe von Artikeln zu registrieren, verwenden Sie die RegisterCacheNotifications
-Methode durch Bereitstellen eines Arrays von Schlüsseln, der EventType
und der EventDataFilter
. Das folgende Beispiel zeigt, wie Sie Artikelbenachrichtigungen mit registrieren ItemUpdated
Ereignistyp für eine Reihe von Elementen.
// Array of keys for items that need to be monitored on events
String[] keys = new String[]
{
"Product:Chai", "Product:Coffee", "Product:Juice", "Product:Coke"
};
// create CacheDataNotificationCallback object
var dataNotificationCallback = new CacheDataNotificationCallback(OnCacheDataUpdation);
// Register notifications for specific set of items being updated in cache
// EventDataFilter as DataWithMetadata which returns keys along with their entire data
cache.MessagingService.RegisterCacheNotification(keys, dataNotificationCallback, EventType.ItemUpdated, EventDataFilter.DataWithMetadata);
String[] keys = new String[]{
"Product:Chai", "Product:Coffee", "Product:Juice", "Product:Coke"
};
// Create CacheDataNotificationCallback object
CacheDataModificationListener dataModificationListener = new CacheDataModificationListenerImpl();
// Register notifications for a specific set of items being updated in cache
// EventDataFilter as DataWithMetadata which returns keys along with their entire data
for (String key : keys) {
cache.getMessagingService().addCacheNotificationListener(key, dataModificationListener, EnumSet.of(EventType.ItemUpdated), EventDataFilter.DataWithMetadata);
}
System.out.println("Item level notifications registered successfully for the set of keys.");
let dataModificationListener = new ncache.CacheDataModificationListener(
this.onCacheDataModified,
this.onCacheCleared
);
// Fetch all products from database
let products = this.fetchProductsFromDB();
// Create a new array keys with the specified keys for which the cache fires notifications
let keys = new String[products.length]();
var index = 0;
products.forEach((element) => {
keys[index] = "Product:1001";
index++;
});
// Register item notifications with 'ItemUpdated' and 'ItemRemoved' event type
// EventDataFilter as DataWithMetadata which returns keys along with their entire data
let messagingService = await this.cache.getMessagingService();
await messagingService.addCacheNotificationListener(
keys,
dataModificationListener,
ncache.EventType.ItemUpdated,
ncache.EventDataFilter.DataWithMetadata
);
# Register target method
data_modification_listener = event_listener
# Fetch all products from database
products = fetch_products_from_db()
# Create a array keys with the specified keys for which the cache
# fires notifications
keys = []
for product in products:
keys.append("Product:" + str(product.get_product_id()))
# Register item notifications with 'ITEM_UPDATED' and 'ITEM_REMOVED' event type
# EventDataFilter as DATA_WITH_META_DATA which returns keys along with their
# entire data
messaging_service = cache.get_messaging_service()
messaging_service.add_cache_notification_listener(
data_modification_listener,
[ncache.EventType.ITEM_UPDATED],
ncache.EventDataFilter.DATA_WITH_META_DATA,
keys
Registrieren Sie Elementbenachrichtigungen mit CacheItem
CacheItem
ist eine benutzerdefinierte Klasse, die von bereitgestellt wird NCache mit dem Daten zum Cache hinzugefügt werden können. Ereignisse auf Elementebene können auch mit einem bestimmten Schlüssel registriert werden, indem Sie die verwenden CacheItem.SetCacheDataNotification
Methode. Mit dieser Methode können Sie die entsprechenden Informationen für die Registrierung der Benachrichtigungen bereitstellen CacheItem
.
Das folgende Beispiel registriert ItemUpdated
und ItemRemoved
Veranstaltungen für ein CacheItem
.
string key = "Product:Chai";
// Fetch item from cache
CacheItem cacheItem = cache.GetCacheItem(key);
if(cacheItem == null)
{
Product product = FetchProductFromDB("Chai");
cacheItem = new CacheItem(product);
}
// create CacheDataNotificationCallback object
var dataNotificationCallback = new CacheDataNotificationCallback(OnCacheDataModification);
// Register events with CaceItem with Item Removed and ItemUpdated EventType
// Set the EventDataFilter as DataWithMetadata which returns keys along with their entire data
cacheItem.SetCacheDataNotification(dataNotificationCallback, EventType.ItemRemoved | EventType.ItemUpdated, EventDataFilter.DataWithMetadata);
//Re-inserts the cacheItem into cache with events registered
cache.Insert(key, cacheItem);
String key = "Product:Chai";
// Fetch item from cache
CacheItem cacheItem = null;
cacheItem = cache.getCacheItem(key);
if (cacheItem == null) {
Customer customer = Customer.fetchCustomerFromDB("Customer:ALFKI");
cacheItem = new CacheItem(customer);
}
// Create CacheDataNotificationCallback object
CacheDataModificationListener dataModificationListener = new CacheDataModificationListenerImpl();
// Register events with CacheItem with ItemRemoved and ItemUpdated EventType
// Set the EventDataFilter as DataWithMetadata which returns keys along with their entire data
cacheItem.addCacheDataNotificationListener(dataModificationListener, EnumSet.of(EventType.ItemRemoved, EventType.ItemUpdated), EventDataFilter.DataWithMetadata);
// Re-inserts the cacheItem into cache with events registered
cache.insert(key, cacheItem);
System.out.println("CacheItem inserted successfully");
let eventListener = new ncache.CacheDataModificationListener(
this.onCacheDataModified,
this.onCacheCleared
);
let messagingService = await this.cache.getMessagingService();
await messagingService.addCacheNotificationListener(
"key",
eventListener,
ncache.EventType.ItemAdded,
ncache.EventDataFilter.Metadata
);
// Get Product from database against given ProductID
let products = this.fetchProductsFromDB();
// Create a unique cache key for this customer.
let key = "Product:1001";
// Register events with CaceItem with Item Removed and ItemUpdated EventType
// Set the EventDataFilter as DataWithMetadata which returns keys along with their entire data
let messagingService2 = await this.cache.getMessagingService();
await messagingService2.addCacheNotificationListener(
eventListener,
ncache.EventType.ItemAdded,
ncache.EventType.ItemRemoved,
ncache.EventType.ItemUpdated,
ncache.EventDataFilter.Metadata
);
let cacheItem = ncache.CacheItem;
//Inserts the cacheItem into cache with events registered
this.cache.insert(key, cacheItem);
# Get Product from database
product = fetch_product_from_db()
# Create a unique cache key for this product.
key = "Product:1001"
# Register events with CacheItem with ITEM_REMOVED and ITEM_UPDATED EventType
# Set the EventDataFilter as DATA_WITH_META_DATA which returns keys along with their entire data
cache_item = ncache.CacheItem(product)
cache_item.add_cache_data_notification_listener(
event_listener,
[ncache.EventType.ITEM_REMOVED, ncache.EventType.ITEM_UPDATED],
ncache.EventDataFilter.DATA_WITH_META_DATA
)
# Inserts the cacheItem into cache with events registered
cache.insert(key, cache_item)
Heben Sie die Registrierung von Ereignisbenachrichtigungen auf Artikelebene auf
Sie können die Registrierung einer zuvor registrierten Ereignisbenachrichtigung auf Artikelebene auch mithilfe von aufheben UnRegisterCacheNotification
-Methode, wenn Sie keine weiteren Benachrichtigungen erhalten möchten. Verwenden Sie für Java die removeCacheDataModificationListener
Methode zum Aufheben der Registrierung der registrierten Benachrichtigungen. Verwenden Sie diese Methode, die entsprechende Taste, Callback CacheDataNotificationCallback
und EventType
muss angegeben werden.
Das folgende Beispiel zeigt, wie Sie die Registrierung von Benachrichtigungen für einen bestimmten Schlüssel aufheben.
// Key of cached item to un-register events
string key = "Product:Chai";
// callback method triggered on cache item events
var dataNotificationCallback = new CacheDataNotificationCallback(OnCacheDataUpdation);
// Unregister notifications for the ItemUpdated EventType for particular key and specify the callback
cache.MessagingService.UnRegisterCacheNotification(key, dataNotificationCallback, EventType.ItemUpdated);
// Unregister notifications for the ItemRemoved EventType for particular key and specify callback
CacheDataModificationListener dataModificationListener = new CacheDataModificationListenerImpl();
CacheEventDescriptor eventDescriptor = cache.getMessagingService().addCacheNotificationListener(dataModificationListener, EnumSet.of(EventType.ItemAdded), EventDataFilter.None);
cache.getMessagingService().removeCacheNotificationListener(eventDescriptor);
let eventListener;
// Unregister notifications for the ItemRemoved EventType for the
// particular key and specify the callback
await this.cache.removeCacheNotificationListener(
"key",
eventListener,
ncache.EventType.ItemRemoved
);
# Unregister notifications for the ITEM_REMOVED EventType for the
# particular key and specify the callback
cache.get_messaging_service().remove_cache_notification_listener
keys="key",
callablefunction=event_listener,
eventtypes=[ncache.EventType.ITEM_REMOVED]
Weitere Informationen
NCache bietet eine Beispielanwendung für Ereignisbenachrichtigungen auf Elementebene an GitHub.
Siehe auch
.NETZ: Alachisoft.NCache.Laufzeitereignisse Namespace.
Java: com.alachisoft.ncache.Veranstaltungen Namespace.
Node.js: EventCacheItem Klasse.
Python: ncache.runtime.caching.events Klasse.