EDIT

import eu.etaxonomy.cdm.api.cache.CdmCacherBase;

    private static CdmCacherBase permanentCache;

    public static void setPermanentCacher(CdmCacherBase permanentCacher) {

import eu.etaxonomy.cdm.api.cache.CdmCacherBase;

        Cache defaultCache = CacheManager.create().getCache(CdmCacherBase.DEFAULT_CACHE_NAME);

package eu.etaxonomy.cdm.api.cache;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import eu.etaxonomy.cdm.model.ICdmUuidCacher;

import eu.etaxonomy.cdm.model.common.CdmBase;

import net.sf.ehcache.Cache;

import net.sf.ehcache.CacheManager;

import net.sf.ehcache.Element;

import net.sf.ehcache.config.CacheConfiguration;

import net.sf.ehcache.config.CacheConfiguration.CacheEventListenerFactoryConfiguration;

import net.sf.ehcache.store.MemoryStoreEvictionPolicy;

/**

 * CDM Entity Cacher class based on EhCache using UUID as key.

 * The cacher allows null values to be cached.

 *

 * @author cmathew

 */

public abstract class CdmCacherBase implements ICdmUuidCacher {

    public static final Logger logger = Logger.getLogger(CdmCacherBase.class);

    @Autowired

    public CacheManager cacheManager;

    public static final String DEFAULT_CACHE_NAME = "cdmDefaultCache"; //TODO compare with CacheConfiguration where the name for the default cache is 'default', Why another name here?

    /**

     * Constructor which initializes a singleton {@link net.sf.ehcache.CacheManager}

     */

    public CdmCacherBase() {

        init();

    }

    /**

     * Initializes an empty singleton {@link net.sf.ehcache.CacheManager} and

     * sets itself as the cacher object in specific CDM Entity objects.

     */

    private void init() {

        setup();

    }

    protected abstract void setup();

    /**

     * Returns the singleton default cache manager.

     */

    public void addCacheManager(CacheManager cacheManager) {

        if(this.cacheManager == null){

            this.cacheManager = cacheManager;

        } else {

            logger.error("There is already a CacheManager configured.");

        }

    }

    /**

     * Returns the default cache configuration.

     */

    protected CacheConfiguration getDefaultCacheConfiguration() {

        CacheEventListenerFactoryConfiguration factory;

        // For a better understanding on how to size caches, refer to

        // http://ehcache.org/documentation/configuration/cache-size

        CacheConfiguration cc = new CacheConfiguration(DEFAULT_CACHE_NAME, 500)

                .memoryStoreEvictionPolicy(MemoryStoreEvictionPolicy.LFU)

                .eternal(false)

                // default ttl and tti set to 2 hours

                .timeToLiveSeconds(60*60*2)

                .timeToIdleSeconds(60*60*2)

                .statistics(true);

        return cc;

    }

    /**

     * Returns the default cache

     *

     * @return

     */

    public Cache getDefaultCache() {

        Cache defaultCache = cacheManager.getCache(DEFAULT_CACHE_NAME);

        if(defaultCache == null) {

            // Create default cache

            cacheManager.addCache(DEFAULT_CACHE_NAME);

            defaultCache = cacheManager.getCache(DEFAULT_CACHE_NAME);

            //FIXME write test to check if default config as defined in EhCacheConfiguration is being used

        }

        return defaultCache;

    }

    @Override

    public void dispose(){

        cacheManager.getCache(DEFAULT_CACHE_NAME).dispose();

    }

    /**

     * Gets the cache element corresponding to the given {@link java.util.UUID}

     */

    public Element getCacheElement(UUID uuid) {

        return getDefaultCache().get(uuid);

    }

    @Override

    public  void put(UUID uuid, CdmBase cdmEntity) {

        CdmBase cachedCdmEntity = getFromCache(uuid);

        if(cachedCdmEntity == null) {

            getDefaultCache().put(new Element(uuid, cdmEntity));

        }

    }

    @Override

    public CdmBase load(UUID uuid) {

        Element e = getCacheElement(uuid);

        CdmBase cdmEntity;

        if (e == null) {

            // nothing in the cache for "key" (or expired) ... re-load the entity

            cdmEntity = findByUuid(uuid);

            // currently default cache is a non-null cache

            // We would like to have the possibility to put null values in the cache,

            // but we need to first distinguish between real null values and null values

            // returned by the service is the type of class does not match

            if(cdmEntity != null) {

                put(uuid, cdmEntity);

            }

        } else {

            // there is a valid element in the cache, however getObjectValue() may be null

            cdmEntity = (CdmBase)e.getObjectValue();

        }

        return cdmEntity;

    }

    @Override

    public  CdmBase getFromCache(UUID uuid) {

        Element e = getCacheElement(uuid);

        if (e == null) {

            return null;

        } else {

            return(CdmBase)e.getObjectValue();

        }

    }

    @Override

    public <T extends CdmBase> T getFromCache(T cdmBase) {

        return (T)getFromCache(cdmBase.getUuid());

    }

    @Override

    public void putToCache(CdmBase cdmEntity) {

        if(cdmEntity != null) {

            put(cdmEntity.getUuid(), cdmEntity);

        }

    }

    @Override

    public abstract <T extends CdmBase> T load(T cdmEntity);

    @Override

    public boolean exists(UUID uuid) {

        return getCacheElement(uuid) != null;

    }

    @Override

    public boolean exists(CdmBase cdmBase) {

        if(cdmBase != null) {

            return exists(cdmBase.getUuid());

        }

        return false;

    }

    @Override

    public boolean existsAndIsNotNull(UUID uuid) {

        Element e = getCacheElement(uuid);

        if (e != null) {

            return e.getObjectValue() != null;

        }

        return false;

    }

    /**

     * Finds CDM Entity by uuid

     */

    protected abstract CdmBase findByUuid(UUID uuid);

    @Override

    public boolean ignoreRecursiveLoad(CdmBase cdmBase){

        return false;

    }

}

public class CdmTermCacher extends CdmCacherBase {

import eu.etaxonomy.cdm.api.cache.CdmCacherBase;

     * named {@link CdmCacherBase#DEFAULT_CACHE_NAME "cdmDefaultCache"}

        CacheConfiguration cc = new CacheConfiguration(CdmCacherBase.DEFAULT_CACHE_NAME, 500)

     * query. A use case for this is the {@link eu.etaxonomy.cdm.api.cache.CdmCacherBase CdmCacher},

     * (ticket #4276) where a call to {@link eu.etaxonomy.cdm.api.cache.CdmCacherBase#load(UUID) load}

	 * {@link eu.etaxonomy.cdm.api.cache.CdmCacherBase#load(UUID uuid) load} again.

package eu.etaxonomy.cdm.api.cache;

import java.io.FileNotFoundException;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Ignore;

import org.junit.Test;

import org.unitils.spring.annotation.SpringBeanByType;

import eu.etaxonomy.cdm.api.service.IReferenceService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.model.common.Language;

import eu.etaxonomy.cdm.model.name.INonViralName;

import eu.etaxonomy.cdm.model.name.Rank;

import eu.etaxonomy.cdm.model.name.TaxonNameFactory;

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.model.reference.ReferenceFactory;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;

@Ignore

public class CdmCacherBaseTest extends CdmIntegrationTest {

	private static final Logger logger = Logger.getLogger(CdmCacherBaseTest.class);

	@SpringBeanByType

	private CdmCacherBase cdmCacherBase;

    @SpringBeanByType

    private IReferenceService referenceService;

    @SpringBeanByType

    private ITaxonService taxonService;

	@Test

	public void testLanguageCache() {

		Language defaultLanguage = Language.getDefaultLanguage();

		Language defaultLanguageInCache = (Language)cdmCacherBase.getFromCache(defaultLanguage.getUuid());

		Assert.assertEquals("Loaded Language Term should match Language Term in Cache",defaultLanguage,defaultLanguageInCache);

		Language language = Language.getLanguageFromUuid(Language.uuidFrench);

		Language languageInCache = (Language)cdmCacherBase.getFromCache(language.getUuid());

		Assert.assertEquals("Loaded Language Term should match Language Term in Cache",language,languageInCache);

		// Following test is just to make sure no exception is raised when saving a taxon corresponding

		// to a taxon name with no name cache to begin with

		Reference sec = ReferenceFactory.newDatabase();

        referenceService.save(sec);

		Taxon taxon = Taxon.NewInstance(TaxonNameFactory.NewNonViralInstance(Rank.SERIES()), sec);

        taxon.setTitleCache("Tax" + "CdmCacher", true);

        taxonService.save(taxon);

        INonViralName nvn = taxon.getName();

        String nameCache = nvn.getNameCache();

        logger.warn("name cache : " + nameCache);

	}

    @Override

    public void createTestDataSet() throws FileNotFoundException {}

}