Notificaciones de eventos en JCache
Las notificaciones de eventos se refieren a un mecanismo que permite a los oyentes recibir notificaciones sobre eventos de caché. Estos eventos representan múltiples operaciones o actualizaciones que ocurren dentro de la memoria caché, lo que permite tomar acciones cuando ocurren dichos eventos. Para recibir dichas notificaciones de eventos, las aplicaciones cliente deben incluir los métodos de controlador de eventos específicos para responder a los eventos generados. Siempre que se generan estos eventos, el método controlador de eventos de destino ejecuta el código completo escrito en el cuerpo del método. De forma predeterminada, estas notificaciones están deshabilitadas para todas las configuraciones de caché (excepto para clearCache
) y debe estar habilitado para que se publiquen eventos.
Requisitos previos para notificaciones de eventos en JCache
- Para usar JCache con NCache Professional, Reemplace la
ncache-client
ncache-professional-client
en su pom.xml.
<dependency>
<groupId>com.alachisoft.ncache</groupId>
<artifactId>ncache-client</artifactId>
<version>x.x.x</version>
</dependency>
- Importe los siguientes paquetes en su aplicación:
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.spi.CachingProvider;
- Asegúrese de que los datos estén serializados o registrados con NCache formato de serialización.
- Asegúrese de que el caché se esté ejecutando e inicializado.
Registrar eventos a nivel de caché
El modelo de eventos JCache permite que las aplicaciones reciban y procesen eventos que representan cambios en las entradas de una caché. El modelo de eventos utiliza eventos estándar de Java y convenciones de escucha de eventos. El siguiente fragmento de código demuestra cómo registrar eventos en JCache. El código primero obtiene la instancia de JCache Manager, crea una configuración de escucha, registra un evento específico a través de registerCacheEntryListener
y agrega un valor para obtener ese evento usando el put
método.
// 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");
Anular el registro de eventos a nivel de caché
También puede cancelar el registro de un evento de nivel de caché previamente registrado utilizando JCache. deregisterCacheEnteryListener
método con una instancia de escucha de entrada de caché registrada para cancelar el registro.
// 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);
Implementar CacheEntryListenerFactory
Puede implementar el CacheEntryListenerFactory
a través de CacheEntryListenerFactoryImpl
clase que sirve como escucha para eventos de entrada de caché. La clase reacciona a ciertos cambios en un caché, como la creación, actualización o eliminación de elementos.
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();
}
}
Implementar CacheEntryEventFilter
Puede implementar el CacheEntryEventFilter
a través de CacheEntryEventFilterImpl
clase, implementando el CacheEntryEventFilter
interfaz para determinar si un evento de caché específico debe ser considerado o ignorado por un oyente de entrada de caché. La clase también implementa el Factory<CacheEntryEventFilter>
que crea objetos de la CacheEntryEventFilter
tipo.
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();
}
}
Registrar eventos a nivel de artículo
Junto con los eventos nativos de JCache, NCache ofrece eventos avanzados a nivel de elemento a través de los cuales sus aplicaciones cliente pueden recibir notificaciones sobre varias operaciones que tienen lugar en el caché con claves específicas. Eventos a nivel de artículo proporcione actualizaciones sobre claves específicas, en lugar de bombardear la aplicación con notificaciones para cada clave.
Los eventos a nivel de elemento deben registrarse con algunas claves específicas y estos son los eventos publicados para estas claves específicas en el NCache API. para aprovechar NCachepara los eventos de nivel de elemento, puede utilizar el método "desenvolver" proporcionado NCache. Este método le permite acceder y utilizar eficazmente los eventos avanzados a través de su NCache instancia de caché. En el siguiente ejemplo, el caché generará una notificación cuando se realice una operación específica en la clave de una pregunta.
// 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);
Anular el registro de eventos a nivel de artículo
También puedes cancelar el registro de eventos a nivel de artículo previamente registrados usando el removeCacheNotificationListener
método.
// 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));
Implementar CacheDataModificationListener
Puede implementar el CacheDataModificationListener
a través de CacheDataModificationListenerImpl
clase que implementa un único método del CacheDataModificationListener
interfaz, llamada onCacheDataModified
. La clase monitorea y reacciona a diferentes cambios en un caché, como actualizar o eliminar elementos.
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;
}
}
}
Vea también
Operaciones CRUD con JCache
NCache Integración con primavera
Envolturas de terceros