Java CacheEntryRemovedListener类代码示例

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
private void determineEventListener(ArrayList arrayList, javax.cache.event.EventType eventType) {
    
    if(eventType == javax.cache.event.EventType.CREATED) {
        if(_isOnCreatedListener)
            ((CacheEntryCreatedListener<K, V>)_cacheEntryListener).onCreated(arrayList);
    }
    else if(eventType == javax.cache.event.EventType.EXPIRED) {
        if(_isOnExpiredListener)
                ((CacheEntryExpiredListener<K,V>) _cacheEntryListener).onExpired(arrayList);
    }
    else if(eventType == javax.cache.event.EventType.REMOVED) {
        if(_isOnRemovedListener)
            ((CacheEntryRemovedListener<? super K, ? super V>) _cacheEntryListener).onRemoved(arrayList);
    }
     else if(eventType == javax.cache.event.EventType.UPDATED) {
         if(_isOnUpdatedListener) 
                ((CacheEntryUpdatedListener<K, V>)_cacheEntryListener).onUpdated(arrayList);
     }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
/**
 * Returns whether this {@link ListenerEntry} is listening to the given eventType
 * @param eventType The event Type
 * @return true, if the listener is listening to the given eventType
 */
boolean isListeningFor(EventType eventType)
{
	switch (eventType)
	{
		case CREATED:
			return listener instanceof CacheEntryCreatedListener;
		case EXPIRED:
			return listener instanceof CacheEntryExpiredListener;
		case REMOVED:
			return listener instanceof CacheEntryRemovedListener;
		case UPDATED:
			return listener instanceof CacheEntryUpdatedListener;
	}

	return false;
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
@SuppressWarnings("unchecked")
static <K, V> List<EventListenerAdaptor<K, V>> ehListenersFor(CacheEntryListener<? super K, ? super V> listener,
    CacheEntryEventFilter<? super K, ? super V> filter, Cache<K, V> source, boolean requestsOld) {
  List<EventListenerAdaptor<K, V>> rv = new ArrayList<>();

  if (listener instanceof CacheEntryUpdatedListener) {
    rv.add(new UpdatedAdaptor<>(source, (CacheEntryUpdatedListener<K, V>) listener,
      (CacheEntryEventFilter<K, V>) filter, requestsOld));
  }
  if (listener instanceof CacheEntryCreatedListener) {
    rv.add(new CreatedAdaptor<>(source, (CacheEntryCreatedListener<K, V>) listener,
      (CacheEntryEventFilter<K, V>) filter, requestsOld));
  }
  if (listener instanceof CacheEntryRemovedListener) {
    rv.add(new RemovedAdaptor<>(source, (CacheEntryRemovedListener<K, V>) listener,
      (CacheEntryEventFilter<K, V>) filter, requestsOld));
  }
  if (listener instanceof CacheEntryExpiredListener) {
    rv.add(new ExpiredAdaptor<>(source, (CacheEntryExpiredListener<K, V>) listener,
      (CacheEntryEventFilter<K, V>) filter, requestsOld));
  }

  return rv;
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
public CacheEventListener(CacheEntryListener<K,V> cacheEntryListener, final TayzGridCache<K,V> jCache, final CacheEntryListenerConfiguration<K,V> cacheEntryListenerConfiguration) {
    _cacheEntryListener = cacheEntryListener;
    _jCache = jCache;
    
    if(cacheEntryListenerConfiguration.getCacheEntryEventFilterFactory() != null) 
        _cacheEntryEventFilter = cacheEntryListenerConfiguration.getCacheEntryEventFilterFactory().create();
    else
        _cacheEntryEventFilter = null;
    
    _isOnCreatedListener = implementsMethod(CacheEntryCreatedListener.class);
    _isOnExpiredListener = implementsMethod(CacheEntryExpiredListener.class);
    _isOnRemovedListener = implementsMethod(CacheEntryRemovedListener.class);
    _isOnUpdatedListener = implementsMethod(CacheEntryUpdatedListener.class);
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
private void sendEvents(TCacheEntryEventCollection<K, V> eventColl, CacheEntryListener<K, V> listener)
	{
		EventType eventType = eventColl.eventType();
//		System.out.println("sendEvents to listener " + listener + ", eventType=" + eventColl.eventType());
		switch (eventType)
        {
            case CREATED:
                if (listener instanceof CacheEntryCreatedListener)
                    eventManager.created((CacheEntryCreatedListener<K, V>)listener, eventColl);
                break;

            case EXPIRED:
                if (listener instanceof CacheEntryExpiredListener)
                    eventManager.expired((CacheEntryExpiredListener<K, V>)listener,  eventColl);
                break;

            case UPDATED:
                if (listener instanceof CacheEntryUpdatedListener)
                    eventManager.updated((CacheEntryUpdatedListener<K,V>)listener,  eventColl);
                break;

            case REMOVED:
                if (listener instanceof CacheEntryRemovedListener)
                    eventManager.removed((CacheEntryRemovedListener<K,V>)listener,  eventColl);
                break;

            default:
                // By default do nothing. If new event types are added to the Spec, they will be ignored.
        }
	}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
BlazingCacheCacheEntryListenerWrapper(boolean synchronous, boolean oldValueRequired, CacheEntryListener<K, V> listener, CacheEntryEventFilter<K, V> filter, CacheEntryListenerConfiguration<K, V> configuration, BlazingCacheCache<K, V> parent) {
    this.synchronous = synchronous;
    this.parent = parent;
    this.oldValueRequired = oldValueRequired;
    this.listener = listener;
    this.filter = filter;
    this.configuration = configuration;
    this.onCreate = listener instanceof CacheEntryCreatedListener;
    this.onUpdate = listener instanceof CacheEntryUpdatedListener;
    this.onRemove = listener instanceof CacheEntryRemovedListener;
    this.needPreviousValue = oldValueRequired || onRemove || onUpdate;
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
void onEntryRemoved(K key, V oldValue) {
    if (onRemove) {
        BlazingCacheCacheEntryEvent event = new BlazingCacheCacheEntryEvent(key, oldValue, oldValue, parent, EventType.REMOVED, true);
        if (filter != null && !filter.evaluate(event)) {
            return;
        }
        ((CacheEntryRemovedListener) listener).onRemoved(Arrays.asList(event));
    }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
/**
 * Requests that the specified event be prepared for dispatching to their specific type of listeners.
 *
 * @param event         the event to be dispatched
 */
public void queueEvent(CacheEntryEvent<K, V> event) {
    if (event == null) {
        throw new NullPointerException("event can't be null");
    }

    Class<? extends CacheEntryListener> listenerClass;
    switch (event.getEventType()) {
        case CREATED:
            listenerClass = CacheEntryCreatedListener.class;
            break;
        case UPDATED:
            listenerClass = CacheEntryUpdatedListener.class;
            break;
        case REMOVED:
            listenerClass = CacheEntryRemovedListener.class;
            break;
        case EXPIRED:
            listenerClass = CacheEntryExpiredListener.class;
            break;
        default:
            throw new IllegalArgumentException("Unknown event type " + event.getEventType());
    }

    List<CacheEntryEvent<K, V>> queue;
    synchronized (this) {
        queue = eventQueues.get(listenerClass);
        if (queue == null) {
            queue = new ArrayList<CacheEntryEvent<K, V>>();
            eventQueues.put(listenerClass, queue);
        }
    }

    queue.add(event);
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
protected void dispatchForRemove() {
    List<CacheEntryEvent<K, V>> events = eventQueues.get(CacheEntryRemovedListener.class);
    if (events == null) {
        return;
    }

    for (ListenerEntry entry: entries) {
        if (entry.getListener() instanceof CacheEntryRemovedListener) {
            ((CacheEntryRemovedListener) entry.getListener()).onRemoved(filterEvents(entry, events));
        }
    }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
@Override
public void onRemoved(Iterable<CacheEntryEvent<? extends K, ? extends V>> cacheEntryEvents) throws CacheEntryListenerException {
  if (isDirectCallable()) {
    for (CacheEntryListener<K,V> l : listenerServer.getListeners()) {
      if (l instanceof CacheEntryRemovedListener) {
        ((CacheEntryRemovedListener<K,V>) l).onRemoved(cacheEntryEvents);
      }
    }
    return;
  }
  for (CacheEntryEvent<? extends K, ? extends V> event : cacheEntryEvents) {
    getClient().invoke(new OnCacheEntryEventHandler<K, V>(event));
  }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
private void runHandlers(EventType eventType, TestCacheEntryEvent event) {
  ArrayList events = new ArrayList(1);
  events.add(event);

  for (CacheEntryListener listener : listeners) {
    switch (eventType) {
      case CREATED :
        if (listener instanceof CacheEntryCreatedListener) {
          ((CacheEntryCreatedListener) listener).onCreated(events);
        }
        break;

      case UPDATED:
        if (listener instanceof CacheEntryUpdatedListener) {
          ((CacheEntryUpdatedListener) listener).onUpdated(events);
        }
        break;

      case REMOVED:
        if (listener instanceof CacheEntryRemovedListener) {
          ((CacheEntryRemovedListener) listener).onRemoved(events);
        }
        break;

      case EXPIRED:
        if (listener instanceof CacheEntryExpiredListener) {
          ((CacheEntryExpiredListener) listener).onExpired(events);
        }
        break;

      default:
        break;
    }
  }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
private void notifyListeners(CacheEntryEvent<K, V> event)
{
    for (CacheEntryListenerConfiguration<K, V> listenerConfiguration : cacheEntryListenerConfigurations)
    {
        boolean invokeListener = true;

        if (listenerConfiguration.getCacheEntryEventFilterFactory() != null)
        {
            invokeListener = listenerConfiguration.getCacheEntryEventFilterFactory().create().evaluate(event);
        }

        if (invokeListener)
        {
            CacheEntryListener<?, ?> cel = listenerConfiguration.getCacheEntryListenerFactory().create();

            switch (event.getEventType())
            {
                case CREATED:
                    if (cel instanceof CacheEntryCreatedListener)
                    {
                        throw new CacheEntryListenerException("Not supported!");
                    }
                    break;

                case EXPIRED:
                    if (cel instanceof CacheEntryExpiredListener)
                    {
                        ((CacheEntryExpiredListener) cel).onExpired(Sets.newHashSet(event));
                    }
                    break;

                case REMOVED:
                    if (cel instanceof CacheEntryRemovedListener)
                    {
                        ((CacheEntryRemovedListener) cel).onRemoved(Sets.newHashSet(event));
                    }
                    break;

                case UPDATED:
                    if (cel instanceof CacheEntryUpdatedListener)
                    {
                        ((CacheEntryUpdatedListener) cel).onUpdated(Sets.newHashSet(event));
                    }
                    break;
            }
        }
    }
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
@Override
public void removed(CacheEntryRemovedListener<K, V> listener, TCacheEntryEventCollection<K, V> eventColl)
{
	listener.onRemoved(eventColl.events());
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
protected AbstractJCacheTest(String cacheName, EventType... eventTypesToListenFor) {
	cacheEvents = new EnumMap<>(EventType.class);
	cache = cacheManager.getCache(cacheName);
	activeCacheEntryListenerConfigurations = new ArrayList<>();

	final Consumer<Iterable<CacheEntryEvent<? extends K, ? extends V>>> listener = iterable -> iterable.forEach(
			event -> {
				if (LOG.isTraceEnabled()) {
					LOG.trace("{}: an entry has been {}.", event.getSource().getName(), event.getEventType());
				}
				cacheEvents.get(event.getEventType()).add(event);
			});

	Factory<? extends CacheEntryListener<? super K, ? super V>> listenerFactory;
	for (final EventType eventTypeToListenFor : eventTypesToListenFor) {

		// create the specific listenerFactory for the eventType
		switch (eventTypeToListenFor) {
		case CREATED:
			listenerFactory = (Factory<CacheEntryCreatedListener<K, V>>) (() -> listener::accept);
			break;

		case EXPIRED:
			listenerFactory = (Factory<CacheEntryExpiredListener<K, V>>) (() -> listener::accept);
			break;

		case REMOVED:
			listenerFactory = (Factory<CacheEntryRemovedListener<K, V>>) (() -> listener::accept);
			break;

		case UPDATED:
			listenerFactory = (Factory<CacheEntryUpdatedListener<K, V>>) (() -> listener::accept);
			break;

		default:
			throw new IllegalArgumentException(String.format("Unknown EventType: %s!", eventTypeToListenFor));
		}
		// initialize the backing collection for the specific eventType
		cacheEvents.put(eventTypeToListenFor, new ArrayList<>());

		// add the listenerConfiguration to the list which will be used to register/deregister them
		activeCacheEntryListenerConfigurations.add(
				new MutableCacheEntryListenerConfiguration<>(listenerFactory, null, true, false));
	}
}
 

import javax.cache.event.CacheEntryRemovedListener; //导入依赖的package包/类
RemovedAdaptor(Cache<K, V> source, CacheEntryRemovedListener<K, V> listener, CacheEntryEventFilter<K, V> filter,
    boolean requestsOld) {
  super(source, filter, requestsOld);
  this.listener = listener;
}