Ehcache(2.9.x) - API Developer Guide, Cache Event Listeners
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Ehcache(2.9.x) - API Developer Guide, Cache Event Listeners，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10571字，纯文字阅读大概需要16分钟。
内容图文
About Cache Event Listeners
Cache listeners allow implementers to register callback methods that will be executed when a cache event occurs. Cache listeners implement the CacheEventListener interface. The events include:
- An Element has been put
- An Element has been updated. Updated means that an Element exists in the Cache with the same key as the Element being put.
- An Element has been removed
- An Element expires, either because timeToLive or timeToIdle have been reached.
Configuring a Cache Event Listener
Cache event listeners are configured per cache. Each cache can have multiple listeners. Each listener is configured by adding a cacheEventListenerFactory element as follows:
<
cache
...
>
<
cacheEventListenerFactory
class
=""
properties
=""
listenFor
=""
/>
...
</
cache
>
The entry specifies a CacheEventListenerFactory that creates a CacheEventListener, which then receives notifications. The attributes of a CacheEventListenerFactory are:
- class — a fully qualified factory class name.
- properties — optional comma-separated properties having meaning only to the factory.
-
listenFor — describes which events will be delivered in a clustered environment (defaults to “all”).
These are the possible values:
- "all" — the default is to deliver all local and remote events.
- "local" — deliver only events originating in the current node.
- "remote" — deliver only events originating in other nodes (for BigMemory Max only).
Callbacks to listener methods are synchronous and unsynchronized. It is the responsibility of the implementer to safely handle the potential performance and thread safety issues depending on what their listener is doing.
Implementing a Cache Event Listener Factory and Cache Event Listener
A CacheEventListenerFactory is an abstract factory for creating cache event listeners. Implementers should provide their own concrete factory, extending this abstract factory. It can then be configured in ehcache.xml. The following example demonstrates how to create an abstract CacheEventListenerFactory:
/**
* An abstract factory for creating listeners. Implementers should provide their own
* concrete factory extending this factory. It can then be configured in ehcache.xml.
*
*
@author
Greg Luck
*
@version
$Id: CacheEventListenerFactory.java 5594 2012-05-07 16:04:31Z cdennis $
*/
public
abstract
class
CacheEventListenerFactory {
/**
* Create a <code>CacheEventListener</code>
*
*
@param
properties implementation specific properties. These are configured as comma
* separated name value pairs in ehcache.xml
*
@return
a constructed CacheEventListener
*/
public
abstract
CacheEventListener createCacheEventListener(Properties properties);
}
The following example demonstrates how to create a concrete implementation of the CacheEventListener interface:
/**
* Allows implementers to register callback methods that will be executed when a cache event
* occurs.
* The events include:
* <ol>
* <li>put Element
* <li>update Element
* <li>remove Element
* <li>evict Element
* <li>an Element expires, either because timeToLive or timeToIdle has been reached.
* <li>removeAll, which causes all elements to be cleared from the cache
* </ol>
* <p/>
* Callbacks to these methods are synchronous and unsynchronized. It is the responsibility of
* the implementer to safely handle the potential performance and thread safety issues
* depending on what their listener is doing.
* <p/>
* Cache also has putQuiet and removeQuiet methods which do not notify listeners.
*
*
@author
Greg Luck
*
@version
$Id: CacheEventListener.java 7439 2013-04-26 19:16:59Z ljacomet $
*
@see
CacheManagerEventListener
*
@since
1.2
*/
public
interface CacheEventListener extends Cloneable {
/**
* Called immediately after an attempt to remove an element. The remove method will block until
* this method returns.
* <p/>
* 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.
* <p/>
* This notification is not called for the following special cases:
* <ol>
* <li>removeAll was called. See {@link #notifyRemoveAll(net.sf.ehcache.Ehcache)}
* <li>An element was evicted from the cache.
* See {@link #notifyElementEvicted(net.sf.ehcache.Ehcache, net.sf.ehcache.Element)}
* </ol>
*
* @param cache the cache emitting the notification
* @param element the element just deleted, or a synthetic element with just the key set if
* no element was removed.
*/void notifyElementRemoved(Ehcache cache, Element element) throws CacheException;
/**
* Called immediately after an element has been put into the cache. The
* {@link net.sf.ehcache.Cache#put(net.sf.ehcache.Element)} method
* will block until this method returns.
* <p/>
* 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.
*
* @param cache the cache emitting the notification
* @param element the element which was just put into the cache.
*/void notifyElementPut(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.
* <p/>
* The {@link net.sf.ehcache.Cache#put(net.sf.ehcache.Element)} method
* will block until this method returns.
* <p/>
* 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.
*
* @param cache the cache emitting the notification
* @param element the element which was just put into the cache.
*/void notifyElementUpdated(final Ehcache cache, final Element element) throws CacheException;
/**
* Called immediately after an element is <i>found</i> to be expired. The
* {@link net.sf.ehcache.Cache#remove(Object)} method will block until this method returns.
* <p/>
* Elements are checked for expiry in ehcache at the following times:
* <ul>
* <li>When a get request is made
* <li>When an element is spooled to the diskStore in accordance with a MemoryStore
* eviction policy
* <li>In the DiskStore when the expiry thread runs, which by default is
* {@link net.sf.ehcache.Cache#DEFAULT_EXPIRY_THREAD_INTERVAL_SECONDS}
* </ul>
* If an element is found to be expired, it is deleted and this method is notified.
*
* @param cache the cache emitting the notification
* @param element the element that has just expired
* <p/>
* Deadlock Warning: expiry will often come from the <code>DiskStore</code>
* 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 <code>Cache</code> method and that subsequently calls into
* DiskStore a deadlock will result. Accordingly implementers of this method
* should not call back into Cache.
*/void notifyElementExpired(final Ehcache cache, final 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.
* <p/>
* In a sense the Element has been <i>removed</i> from the cache, but it is different,
* thus the separate notification.
*
* @param cache the cache emitting the notification
* @param element the element that has just been evicted
*/void notifyElementEvicted(final Ehcache cache, final Element element);
/**
* Called during {@link net.sf.ehcache.Ehcache#removeAll()} to indicate that the all
* elements have been removed from the cache in a bulk operation. The usual
* {@link #notifyElementRemoved(net.sf.ehcache.Ehcache, net.sf.ehcache.Element)}
* is not called.
* <p/>
* 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.
* @param cache the cache emitting the notification
*/void notifyRemoveAll(final Ehcache cache);
/**
* Creates a clone of this listener. This method will only be called by ehcache before a
* cache is initialized.
* <p/>
* This may not be possible for listeners after they have been initialized. Implementations
* should throw CloneNotSupportedException if they do not support clone.
*
* @return a clone
* @throws CloneNotSupportedException if the listener could not be cloned.
*/public Object clone() throws CloneNotSupportedException;
/**
* Give the listener a chance to cleanup and free resources when no longer needed
*/void dispose();
}
Two other methods are also available:
-
void notifyElementEvicted(Ehcache cache, Element element)
Called immediately after an element is evicted from the cache. Eviction, which happens when a cache entry is deleted from a store, should not be confused with removal, which is a result of calling Cache.removeElement(Element).
-
void notifyRemoveAll(Ehcache cache)
Called during Ehcache.removeAll() to indicate that all elements have been removed from the cache in a bulk operation. The usualnotifyElementRemoved(net.sf.ehcache.Ehcache, net.sf.ehcache.Element) is not called. Only one notification is emitted because performance considerations do not allow for serially processing notifications where potentially millions of elements have been bulk deleted.
The implementations need to be placed in the classpath accessible to Ehcache. For details on how the loading of these classes will be done, see Class Loading.
Adding a Listener Programmatically
To add a listener programmatically, follow this example:
cache.getCacheEventNotificationService().registerListener(myListener);
原文：http://www.cnblogs.com/huey/p/5846982.html
内容总结
以上是互联网集市为您收集整理的Ehcache(2.9.x) - API Developer Guide, Cache Event Listeners全部内容，希望文章能够帮你解决Ehcache(2.9.x) - API Developer Guide, Cache Event Listeners所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。