BigMemory 4.3.7 | Product Documentation | BigMemory Max Developer Guide | Cache Exception Handlers | Implementing a Cache Exception Handler Factory and Cache Exception Handler
 
Implementing a Cache Exception Handler Factory and Cache Exception Handler
A CacheExceptionHandlerFactory is an abstract factory for creating cache exception handlers. Implementers should provide their own concrete factory, extending this abstract factory. It can then be configured in ehcache.xml.
Note:
Your implementations need to be placed in the classpath accessible to Ehcache. For information about how class loading is handled, see Class Loading.
The factory class needs to be a concrete subclass of the abstract factory class CacheExceptionHandlerFactory, which is reproduced below.
/**
* An abstract factory for creating <code>CacheExceptionHandler</code>s at
* configuration time, in ehcache.xml.
* <p/>
* Extend to create a concrete factory
*
*/
public abstract class CacheExceptionHandlerFactory {
/**
* Create an <code>CacheExceptionHandler</code>
*
* @param properties implementation specific properties. These are configured
* as comma separated name value pairs in ehcache.xml
* @return a constructed CacheExceptionHandler
*/
public abstract CacheExceptionHandler createExceptionHandler(Properties properties);
}
The factory creates a concrete implementation of the CacheExceptionHandler interface, which is reproduced below:
/**
* A handler which may be registered with an Ehcache, to handle exception on
* Cache operations.
*
* Handlers may be registered at configuration time in ehcache.xml, using a
* CacheExceptionHandlerFactory, or set at runtime (a strategy).
*
* If an exception handler is registered, the default behaviour of throwing the
* exception will not occur. The handler method on Exception will be called.
* Of course, if the handler decides to throw the exception, it will propagate
* up through the call stack. If the handler does not, it won't.
*
* Some common Exceptions thrown, and which therefore should be considered when
* implementing this class, are listed below:
* <ul>
* <li>{@link IllegalStateException} if the cache is not
* {@link net.sf.ehcache.Status#STATUS_ALIVE}
* <li>{@link IllegalArgumentException} if an attempt is made to put a null
* element into a cache
* <li>{@link net.sf.ehcache.distribution.RemoteCacheException} if an issue
* occurs in remote synchronous replication
* <li>
* <li>
* </ul>
*
*/
public interface CacheExceptionHandler {
/**
* Called if an Exception occurs in a Cache method. This method is not
* called if an Error occurs.
*
* @param Ehcache the cache in which the Exception occurred
* @param key the key used in the operation, or null if the operation
* does not use a key or the key was null
* @param exception the exception caught
*/
void onException(Ehcache ehcache, Object key, Exception exception);
}