ehcache

net.sf.ehcache.event
Class TerracottaCacheEventReplication

java.lang.Object
  extended by net.sf.ehcache.event.TerracottaCacheEventReplication
All Implemented Interfaces:
Cloneable, CacheEventListener

public class TerracottaCacheEventReplication
extends Object
implements CacheEventListener

Creates a wrapper for sending out cache events through the Terracotta cluster

Version:
$Id: TerracottaCacheEventReplication.java 5594 2012-05-07 16:04:31Z cdennis $
Author:
Geert Bevin

Constructor Summary
TerracottaCacheEventReplication()
           
 
Method Summary
 TerracottaCacheEventReplication clone()
          Creates a clone of this listener.
 void dispose()
          Give the listener a chance to cleanup and free resources when no longer needed
 void notifyElementEvicted(Ehcache cache, Element element)
          Called immediately after an element is evicted from the cache.
 void notifyElementExpired(Ehcache cache, Element element)
          Called immediately after an element is found to be expired.
 void notifyElementPut(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache.
 void notifyElementRemoved(Ehcache cache, Element element)
          Called immediately after an attempt to remove an element.
 void notifyElementUpdated(Ehcache cache, Element element)
          Called immediately after an element has been put into the cache and the element already existed in the cache.
 void notifyRemoveAll(Ehcache cache)
          Called during Ehcache.removeAll() to indicate that the all elements have been removed from the cache in a bulk operation.
 
Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

TerracottaCacheEventReplication

public TerracottaCacheEventReplication()
Method Detail

notifyElementRemoved

public void notifyElementRemoved(Ehcache cache,
                                 Element element)
                          throws CacheException
Called immediately after an attempt to remove an element. The remove method will block until this method returns.

This notification is received regardless of whether the cache had an element matching the removal key or not. If an element was removed, the element is passed to this method, otherwise a synthetic element, with only the key set is passed in.

This notification is not called for the following special cases:

  1. removeAll was called. See CacheEventListener.notifyRemoveAll(net.sf.ehcache.Ehcache)
  2. An element was evicted from the cache. See CacheEventListener.notifyElementEvicted(net.sf.ehcache.Ehcache, net.sf.ehcache.Element)

Specified by:
notifyElementRemoved in interface CacheEventListener
Parameters:
cache - the cache emitting the notification
element - the element just deleted, or a synthetic element with just the key set if no element was removed.
Throws:
CacheException

notifyElementPut

public void notifyElementPut(Ehcache cache,
                             Element element)
                      throws CacheException
Called immediately after an element has been put into the cache. The Cache.put(net.sf.ehcache.Element) method will block until this method returns.

Implementers may wish to have access to the Element's fields, including value, so the element is provided. Implementers should be careful not to modify the element. The effect of any modifications is undefined.

Specified by:
notifyElementPut in interface CacheEventListener
Parameters:
cache - the cache emitting the notification
element - the element which was just put into the cache.
Throws:
CacheException

notifyElementUpdated

public void notifyElementUpdated(Ehcache cache,
                                 Element element)
                          throws CacheException
Called immediately after an element has been put into the cache and the element already existed in the cache. This is thus an update.

The Cache.put(net.sf.ehcache.Element) method will block until this method returns.

Implementers may wish to have access to the Element's fields, including value, so the element is provided. Implementers should be careful not to modify the element. The effect of any modifications is undefined.

Specified by:
notifyElementUpdated in interface CacheEventListener
Parameters:
cache - the cache emitting the notification
element - the element which was just put into the cache.
Throws:
CacheException

notifyElementExpired

public void notifyElementExpired(Ehcache cache,
                                 Element element)
Called immediately after an element is found to be expired. The Cache.remove(Object) method will block until this method returns.

Elements are checked for expiry in ehcache at the following times:

If an element is found to be expired, it is deleted and this method is notified.

Specified by:
notifyElementExpired in interface CacheEventListener
Parameters:
cache - the cache emitting the notification
element - the element that has just expired

Deadlock Warning: expiry will often come from the DiskStore expiry thread. It holds a lock to the DiskStorea the time the notification is sent. If the implementation of this method calls into a synchronized Cache method and that subsequently calls into DiskStore a deadlock will result. Accordingly implementers of this method should not call back into Cache.


notifyElementEvicted

public void notifyElementEvicted(Ehcache cache,
                                 Element element)
Called immediately after an element is evicted from the cache. Evicted in this sense means evicted from one store and not moved to another, so that it exists nowhere in the local cache.

In a sense the Element has been removed from the cache, but it is different, thus the separate notification.

Specified by:
notifyElementEvicted in interface CacheEventListener
Parameters:
cache - the cache emitting the notification
element - the element that has just been evicted

notifyRemoveAll

public void notifyRemoveAll(Ehcache cache)
Called during Ehcache.removeAll() to indicate that the all elements have been removed from the cache in a bulk operation. The usual CacheEventListener.notifyElementRemoved(net.sf.ehcache.Ehcache, net.sf.ehcache.Element) is not called.

This notification exists because clearing a cache is a special case. It is often not practical to serially process notifications where potentially millions of elements have been bulk deleted.

Specified by:
notifyRemoveAll in interface CacheEventListener
Parameters:
cache - the cache emitting the notification

clone

public TerracottaCacheEventReplication clone()
                                      throws CloneNotSupportedException
Creates a clone of this listener. This method will only be called by ehcache before a cache is initialized.

This may not be possible for listeners after they have been initialized. Implementations should throw CloneNotSupportedException if they do not support clone.

Specified by:
clone in interface CacheEventListener
Overrides:
clone in class Object
Returns:
a clone
Throws:
CloneNotSupportedException - if the listener could not be cloned.

dispose

public void dispose()
Give the listener a chance to cleanup and free resources when no longer needed

Specified by:
dispose in interface CacheEventListener

ehcache

Copyright 2001-2015, Terracotta, Inc.