Java tutorial
/* * Created on Nov 10, 2004 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. * * Copyright @2007 the original author or authors. */ package org.springmodules.cache.provider.ehcache; import net.sf.ehcache.Cache; import net.sf.ehcache.CacheManager; import net.sf.ehcache.Ehcache; import net.sf.ehcache.Element; import net.sf.ehcache.constructs.blocking.BlockingCache; import net.sf.ehcache.constructs.blocking.SelfPopulatingCache; import net.sf.ehcache.constructs.blocking.UpdatingCacheEntryFactory; import net.sf.ehcache.constructs.blocking.UpdatingSelfPopulatingCache; import org.springframework.beans.propertyeditors.StringArrayPropertyEditor; import org.springframework.util.ObjectUtils; import org.springmodules.cache.CacheException; import org.springmodules.cache.CachingModel; import org.springmodules.cache.FatalCacheException; import org.springmodules.cache.FlushingModel; import org.springmodules.cache.provider.AbstractCacheProviderFacade; import org.springmodules.cache.provider.CacheAccessException; import org.springmodules.cache.provider.CacheModelValidator; import org.springmodules.cache.provider.CacheNotFoundException; import org.springmodules.cache.provider.ObjectCannotBeCachedException; import org.springmodules.cache.provider.ReflectionCacheModelEditor; import java.beans.PropertyEditor; import java.io.Serializable; import java.util.Collections; import java.util.HashMap; import java.util.Map; /** * Implementation of * <code>{@link org.springmodules.cache.provider.CacheProviderFacade}</code> * that uses EHCache as the underlying cache implementation. * * @author Omar Irbouh * @author Alex Ruiz */ public final class EhCacheFacade extends AbstractCacheProviderFacade { /** * Map referencing caches looked up from EHCache CacheManager. */ private Map caches = Collections.synchronizedMap(new HashMap()); /** * EHCache cache manager. */ private CacheManager cacheManager; private CacheModelValidator cacheModelValidator; /** * Constructor. */ public EhCacheFacade() { cacheModelValidator = new EhCacheModelValidator(); } /** * Returns the validator of cache models. It is always an instance of * <code>{@link EhCacheModelValidator}</code>. * * @return the validator of cache models */ public CacheModelValidator modelValidator() { return cacheModelValidator; } /** * @see org.springmodules.cache.provider.CacheProviderFacade#getCachingModelEditor() */ public PropertyEditor getCachingModelEditor() { ReflectionCacheModelEditor editor = new ReflectionCacheModelEditor(); editor.setCacheModelClass(EhCacheCachingModel.class); return editor; } /** * @see org.springmodules.cache.provider.CacheProviderFacade#getFlushingModelEditor() */ public PropertyEditor getFlushingModelEditor() { Map propertyEditors = new HashMap(); propertyEditors.put("cacheNames", new StringArrayPropertyEditor()); ReflectionCacheModelEditor editor = new ReflectionCacheModelEditor(); editor.setCacheModelClass(EhCacheFlushingModel.class); editor.setCacheModelPropertyEditors(propertyEditors); return editor; } /** * Sets the EHCache cache manager to use. * * @param newCacheManager the new cache manager */ public void setCacheManager(CacheManager newCacheManager) { cacheManager = newCacheManager; } /** * Returns a EHCache cache from the cache manager. * * @param model the model containing the name of the cache to retrieve * @return the cache retrieved from the cache manager * @throws CacheNotFoundException if the cache does not exist * @throws CacheAccessException wrapping any unexpected exception thrown by the cache */ protected Ehcache getCache(CachingModel model) throws CacheNotFoundException, CacheAccessException { EhCacheCachingModel ehCacheCachingModel = (EhCacheCachingModel) model; String cacheName = ehCacheCachingModel.getCacheName(); Ehcache cache = (Cache) caches.get(cacheName); if (cache == null) { cache = decorateCache(getCache(cacheName), ehCacheCachingModel); } return cache; } /** * Returns a EHCache cache from the cache manager. * * @param name the name of the cache * @return the cache retrieved from the cache manager * @throws CacheNotFoundException if the cache does not exist * @throws CacheAccessException wrapping any unexpected exception thrown by the cache */ protected Cache getCache(String name) throws CacheNotFoundException, CacheAccessException { Cache cache = null; try { if (cacheManager.cacheExists(name)) { cache = cacheManager.getCache(name); } } catch (Exception exception) { throw new CacheAccessException(exception); } if (cache == null) { throw new CacheNotFoundException(name); } return cache; } /** * Decorate the given Cache, if necessary. * <p>The default implementation simply returns the given cache object as-is. * * @param cache the raw Cache object, based on the configuration of this FactoryBean * @param model the model containing the name of the cache to retrieve * @return the (potentially decorated) cache object to be registered with the CacheManager */ protected Ehcache decorateCache(Cache cache, EhCacheCachingModel model) { if (model.getCacheEntryFactory() != null) { if (model.getCacheEntryFactory() instanceof UpdatingCacheEntryFactory) { return new UpdatingSelfPopulatingCache(cache, (UpdatingCacheEntryFactory) model.getCacheEntryFactory()); } else { return new SelfPopulatingCache(cache, model.getCacheEntryFactory()); } } if (model.isBlocking()) { return new BlockingCache(cache); } return cache; } /** * @return <code>true</code>. EHCache can only store Serializable objects * @see AbstractCacheProviderFacade#isSerializableCacheElementRequired() */ protected boolean isSerializableCacheElementRequired() { return true; } /** * Removes all the entries in the caches specified in the given flushing * model. The flushing model should be an instance of * <code>{@link EhCacheFlushingModel}</code>. * * @param model the flushing model. * @throws CacheNotFoundException if the cache specified in the given model cannot be found. * @throws CacheAccessException wrapping any unexpected exception thrown by the cache. * @see AbstractCacheProviderFacade#onFlushCache(FlushingModel) */ protected void onFlushCache(FlushingModel model) throws CacheException { EhCacheFlushingModel flushingModel = (EhCacheFlushingModel) model; String[] cacheNames = flushingModel.getCacheNames(); if (!ObjectUtils.isEmpty(cacheNames)) { CacheException cacheException = null; int nameCount = cacheNames.length; try { for (int i = 0; i < nameCount; i++) { Cache cache = getCache(cacheNames[i]); cache.removeAll(); } } catch (CacheException exception) { cacheException = exception; } catch (Exception exception) { cacheException = new CacheAccessException(exception); } if (cacheException != null) { throw cacheException; } } } /** * Retrieves an object stored under the given key from the cache specified in * the given caching model. The caching model should be an instance of * <code>{@link EhCacheCachingModel}</code>. * * @param key the key of the cache entry * @param model the caching model * @return the object retrieved from the cache. Can be <code>null</code>. * @throws CacheNotFoundException if the cache specified in the given model cannot be found. * @throws CacheAccessException wrapping any unexpected exception thrown by the cache. * @see AbstractCacheProviderFacade#onGetFromCache(Serializable,CachingModel) */ protected Object onGetFromCache(Serializable key, CachingModel model) throws CacheException { Ehcache cache = getCache(model); Object cachedObject = null; try { Element cacheElement = cache.get(key); if (cacheElement != null) { cachedObject = cacheElement.getValue(); } } catch (Exception exception) { throw new CacheAccessException(exception); } return cachedObject; } /** * Stores the given object under the given key in the cache specified in the * given caching model. The caching model should be an instance of * <code>{@link EhCacheCachingModel}</code>. * * @param key the key of the cache entry * @param model the caching model * @param obj the object to store in the cache * @throws ObjectCannotBeCachedException if the object to store is not an implementation of * <code>java.io.Serializable</code>. * @throws CacheNotFoundException if the cache specified in the given model cannot be found. * @throws CacheAccessException wrapping any unexpected exception thrown by the cache. * @see AbstractCacheProviderFacade#onPutInCache(Serializable,CachingModel, *Object) */ protected void onPutInCache(Serializable key, CachingModel model, Object obj) throws CacheException { Ehcache cache = getCache(model); Element newCacheElement = new Element(key, (Serializable) obj); try { cache.put(newCacheElement); } catch (Exception exception) { throw new CacheAccessException(exception); } } /** * Removes the object stored under the given key from the cache specified in * the given caching model. The caching model should be an instance of * <code>{@link EhCacheCachingModel}</code>. * * @param key the key of the cache entry * @param model the caching model * @throws CacheNotFoundException if the cache specified in the given model cannot be found. * @throws CacheAccessException wrapping any unexpected exception thrown by the cache. * @see AbstractCacheProviderFacade#onRemoveFromCache(Serializable, *CachingModel) */ protected void onRemoveFromCache(Serializable key, CachingModel model) throws CacheException { Ehcache cache = getCache(model); try { cache.remove(key); } catch (Exception exception) { throw new CacheAccessException(exception); } } /** * @throws FatalCacheException if the cache manager is <code>null</code>. * @see AbstractCacheProviderFacade#validateCacheManager() */ protected void validateCacheManager() throws FatalCacheException { assertCacheManagerIsNotNull(cacheManager); } }