<cache ...>   <cacheEventListenerFactory class="" properties="" listenFor=""/>   ... </cache>

/** * 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);}

/** * 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();}

cache.getCacheEventNotificationService().registerListener(myListener);