Java Code Examples for net.sf.ehcache.CacheManager#getInstance()

public void testKillCacheAndSurvive() {
  EhCacheDataCache dataCache = new EhCacheDataCache();
  DataCacheKey key = new DataCacheKey();
  key.addAttribute( "Test", "test" );
  dataCache.put( key, new DefaultTableModel() );

  final CacheManager cacheManager = CacheManager.getInstance();
  // Note: EHCacheProvider will dynamically create these
  // caches if they don't exist.
  cacheManager.clearAll();
  cacheManager.removalAll();

  assertFalse( cacheManager.cacheExists( "libloader-bundles" ) );
  assertFalse( cacheManager.cacheExists( "libloader-data" ) );
  assertFalse( cacheManager.cacheExists( "libloader-factory" ) );
  assertFalse( cacheManager.cacheExists( "report-dataset-cache" ) );

  cacheManager.shutdown();

  assertNull( dataCache.get( key ) );
  dataCache.put( key, new DefaultTableModel() );
  assertNotNull( dataCache.get( key ) );

}
 

/**
 * init ehcache config
 *
 * @param props current configuration settings.
 */
public void start(Properties props) {
    if (manager != null) {
        log.warn("Attempt to restart an already started EhCacheProvider.");
        return;
    }

    // 如果指定了名称,那么尝试获取已有实例
    String ehcacheName = (String)props.get(KEY_EHCACHE_NAME);
    if (ehcacheName != null && ehcacheName.trim().length() > 0)
        manager = CacheManager.getCacheManager(ehcacheName);
    if (manager == null) {
        // 指定了配置文件路径? 加载之
        if (props.containsKey(KEY_EHCACHE_CONFIG_XML)) {
            String propertiesFile = props.getProperty(KEY_EHCACHE_CONFIG_XML);
            URL url = getClass().getResource(propertiesFile);
            url = (url == null) ? getClass().getClassLoader().getResource(propertiesFile) : url;
            manager = CacheManager.newInstance(url);
        } else {
            // 加载默认实例
            manager = CacheManager.getInstance();
        }
    }
    caches = new ConcurrentHashMap<>();
}
 

/**
 * @param cache
 */
protected CacheWrapperImpl(String cacheName, CacheConfig config) {
    this.cacheName = cacheName;
    this.config = config;
    this.cachemanager = CacheManager.getInstance();
    // now we need a cache which has appropriate (by configuration) values for cache configs such as ttl, tti, max elements and so on.
    // next line needed since cache can also be initialized through ehcache.xml
    if (cachemanager.cacheExists(cacheName)) {
        this.cache = cachemanager.getCache(cacheName);
        log.warn("using cache parameters from ehcache.xml for cache named '" + cacheName + "'");
    } else {
        this.cache = config.createCache(cacheName);
        try {
            cachemanager.addCache(this.cache);
        } catch (CacheException e) {
            throw new OLATRuntimeException("Problem when initializing the caches", e);
        }
    }
}
 

public void testKillCacheWithoutShutdownAndSurvive() {
  EhCacheDataCache dataCache = new EhCacheDataCache();
  DataCacheKey key = new DataCacheKey();
  key.addAttribute( "Test", "test" );
  dataCache.put( key, new DefaultTableModel() );

  final CacheManager cacheManager = CacheManager.getInstance();
  // Note: EHCacheProvider will dynamically create these
  // caches if they don't exist.
  cacheManager.clearAll();
  cacheManager.removalAll();

  assertFalse( cacheManager.cacheExists( "libloader-bundles" ) );
  assertFalse( cacheManager.cacheExists( "libloader-data" ) );
  assertFalse( cacheManager.cacheExists( "libloader-factory" ) );
  assertFalse( cacheManager.cacheExists( "report-dataset-cache" ) );

  assertNull( dataCache.get( key ) );
  dataCache.put( key, new DefaultTableModel() );
  assertNotNull( dataCache.get( key ) );

}
 

/**
 * Takes care of shutting down all cache managers
 */
private static void closeCaches() {
	CacheManager cm1 = CacheManager.getInstance();
	cm1.shutdown();

	for (Object cm : Context.get().getBeansOfType(CacheManager.class)) {
		((CacheManager) cm).shutdown();
	}
}
 

/**
 * 初始化缓存管理容器
 */
public static CacheManager initCacheManager() {
    try {
        if (cacheManager == null)
            cacheManager = CacheManager.getInstance();
    } catch (Exception e) {
        e.printStackTrace();
    }
    return cacheManager;
}
 

public EhCacheBackedMapImpl() {
    final CacheManager cacheManager = CacheManager.getInstance();
    final Cache tempCache = cacheManager.getCache(DEFAULT_CACHE_NAME);

    if (tempCache == null) {
        this.cache = new Cache(DEFAULT_CACHE_NAME, 20000, false, false, 60000, 60000);
        cacheManager.addCache(this.cache);
    } else {
        this.cache = tempCache;
    }
}
 

private void initializeCacheManager() {
  if ( ClassicEngineBoot.getInstance().getExtendedConfig().getBoolProperty(
      "org.pentaho.reporting.engine.classic.core.cache.EhCacheDataCache.UseGlobalCacheManager" ) ) {
    manager = CacheManager.getInstance();
  } else if ( manager == null ) {
    manager = createCacheManager();
  }
}
 

/** Test.
 * @throws IOException e */
@Test
public void testCache() throws IOException {
	final String cacheName = "test 1";
	final CacheManager cacheManager = CacheManager.getInstance();
	cacheManager.addCache(cacheName);
	// test empty cache name in the cache keys link:
	// cacheManager.addCache("") does nothing, but cacheManager.addCache(new Cache("", ...)) works
	cacheManager.addCache(new Cache("", 1000, true, false, 10000, 10000, false, 10000));
	final String cacheName2 = "test 2";
	try {
		final Cache cache = cacheManager.getCache(cacheName);
		cache.put(new Element(1, Math.random()));
		cache.get(1);
		cache.get(0);
		cacheManager.addCache(cacheName2);
		final Cache cache2 = cacheManager.getCache(cacheName2);
		cache2.getCacheConfiguration().setOverflowToDisk(false);
		cache2.getCacheConfiguration().setEternal(true);
		cache2.getCacheConfiguration().setMaxElementsInMemory(0);

		// JavaInformations doit être réinstancié pour récupérer les caches
		final List<JavaInformations> javaInformationsList2 = Collections
				.singletonList(new JavaInformations(null, true));
		final HtmlReport htmlReport = new HtmlReport(collector, null, javaInformationsList2,
				Period.TOUT, writer);
		htmlReport.toHtml(null, null);
		assertNotEmptyAndClear(writer);
		setProperty(Parameter.SYSTEM_ACTIONS_ENABLED, "false");
		htmlReport.toHtml(null, null);
		assertNotEmptyAndClear(writer);
	} finally {
		setProperty(Parameter.SYSTEM_ACTIONS_ENABLED, null);
		cacheManager.removeCache(cacheName);
		cacheManager.removeCache(cacheName2);
	}
}
 

private static CacheManager constructDefault() {
    CacheManager manager = CacheManager.getInstance();
    manager.addCacheIfAbsent("org.red5.io.amf.Output.stringCache");
    manager.addCacheIfAbsent("org.red5.io.amf.Output.getterCache");
    manager.addCacheIfAbsent("org.red5.io.amf.Output.fieldCache");
    manager.addCacheIfAbsent("org.red5.io.amf.Output.serializeCache");
    return manager;
}
 

/**
 * @param ureq
 * @param wControl
 */
public AllCachesController(final UserRequest ureq, final WindowControl wControl) {
    super(ureq, wControl);
    // create page
    myContent = createVelocityContainer("index");

    final TableGuiConfiguration tableConfig = new TableGuiConfiguration();

    tableCtr = new TableController(tableConfig, ureq, getWindowControl(), getTranslator());
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.name", 0, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.disk", 1, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.hitcnt", 2, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.mcexp", 3, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.mcnotfound", 4, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.quickcount", 5, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.tti", 6, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.ttl", 7, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new DefaultColumnDescriptor("cache.maxElements", 8, null, ureq.getLocale()));
    tableCtr.addColumnDescriptor(new StaticColumnDescriptor("empty", "cache.empty", translate("action.choose")));
    listenTo(tableCtr);
    myContent.contextPut("title", translate("caches.title"));

    // eh cache
    try {
        cm = CacheManager.getInstance();
    } catch (final CacheException e) {
        throw new AssertException("could not get cache", e);
    }
    cnames = cm.getCacheNames();
    tdm = new AllCachesTableDataModel(cnames);
    tableCtr.setTableDataModel(tdm);
    myContent.put("cachetable", tableCtr.getInitialComponent());

    // returned panel is not needed here, because this controller only shows content with the index.html velocity page
    putInitialPanel(myContent);

}
 

public static synchronized CacheManager getCacheManager() throws CacheException {
  if ( cacheManager == null ) {
    cacheManager = CacheManager.getInstance();
  }
  return cacheManager;
}
 

@Override
public void afterPropertiesSet() throws CacheException {
	// If no cache name given, use bean name as cache name.
	String cacheName = getName();
	if (cacheName == null) {
		cacheName = this.beanName;
		if (cacheName != null) {
			setName(cacheName);
		}
	}

	// If no CacheManager given, fetch the default.
	if (this.cacheManager == null) {
		if (logger.isDebugEnabled()) {
			logger.debug("Using default EhCache CacheManager for cache region '" + cacheName + "'");
		}
		this.cacheManager = CacheManager.getInstance();
	}

	synchronized (this.cacheManager) {
		// Fetch cache region: If none with the given name exists, create one on the fly.
		Ehcache rawCache;
		boolean cacheExists = this.cacheManager.cacheExists(cacheName);

		if (cacheExists) {
			if (logger.isDebugEnabled()) {
				logger.debug("Using existing EhCache cache region '" + cacheName + "'");
			}
			rawCache = this.cacheManager.getEhcache(cacheName);
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Creating new EhCache cache region '" + cacheName + "'");
			}
			rawCache = createCache();
			rawCache.setBootstrapCacheLoader(this.bootstrapCacheLoader);
		}

		if (this.cacheEventListeners != null) {
			for (CacheEventListener listener : this.cacheEventListeners) {
				rawCache.getCacheEventNotificationService().registerListener(listener);
			}
		}

		// Needs to happen after listener registration but before setStatisticsEnabled
		if (!cacheExists) {
			this.cacheManager.addCache(rawCache);
		}

		if (this.disabled) {
			rawCache.setDisabled(true);
		}

		Ehcache decoratedCache = decorateCache(rawCache);
		if (decoratedCache != rawCache) {
			this.cacheManager.replaceCacheWithDecoratedCache(rawCache, decoratedCache);
		}
		this.cache = decoratedCache;
	}
}
 

public void afterPropertiesSet() throws CacheException, IOException {
	// If no CacheManager given, fetch the default.
	if (this.cacheManager == null) {
		if (log.isDebugEnabled()) {
			log.debug("Using default EHCache CacheManager for cache region '" + this.cacheName + "'");
		}
		this.cacheManager = CacheManager.getInstance();
	}

	// If no cache name given, use bean name as cache name.
	if (this.cacheName == null) {
		this.cacheName = this.beanName;
	}

	// Fetch cache region: If none with the given name exists,
	// create one on the fly.
	Ehcache rawCache;
	if (this.cacheManager.cacheExists(this.cacheName)) {
		if (log.isDebugEnabled()) {
			log.debug("Using existing EHCache cache region '" + this.cacheName + "'");
		}
		rawCache = this.cacheManager.getEhcache(this.cacheName);
	}
	else {
		if (log.isDebugEnabled()) {
			log.debug("Creating new EHCache cache region '" + this.cacheName + "'");
		}
		rawCache = createCache();
           // Not look for any custom configuration.
           // Check for old configuration properties.
           if(serverConfigurationService.getString(this.cacheName) == null) {
               log.warn("Old cache configuration "+ this.cacheName+ " must be changed to memory."+ this.cacheName);
           }
           String config = serverConfigurationService.getString("memory."+ this.cacheName);
           if (config != null && config.length() > 0) {
               log.debug("Found configuration for cache: "+ this.cacheName+ " of: "+ config);
               new CacheInitializer().configure(config).initialize(
                       rawCache.getCacheConfiguration());
           }

		this.cacheManager.addCache(rawCache);
	}
	boolean override = false;
	if (serverConfigurationService != null) {
		override = serverConfigurationService.getBoolean(
				"memory.cache.statistics.force.disabled", false);
	}
	if (this.statisticsEnabled && !override) {
		rawCache.setStatisticsEnabled(true);
	}
	if (this.sampledStatisticsEnabled) {
		rawCache.setSampledStatisticsEnabled(true);
	}

	// Decorate cache if necessary.
	Ehcache decoratedCache = decorateCache(rawCache);
	if (decoratedCache != rawCache) {
		this.cacheManager.replaceCacheWithDecoratedCache(rawCache, decoratedCache);
	}
	this.cache = decoratedCache;
}
 

public void init() {
    log.info("Loading ehcache");
    // log.debug("Appcontext: " + applicationContext.toString());
    try {
        // instance the manager
        cm = CacheManager.getInstance();
        // Use the Configuration to create our caches
        Configuration configuration = new Configuration();
        //set initial default cache name
        @SuppressWarnings("unused")
        String defaultCacheName = Cache.DEFAULT_CACHE_NAME;
        //add the configs to a configuration
        for (CacheConfiguration conf : configs) {
            //set disk expiry
            conf.setDiskExpiryThreadIntervalSeconds(diskExpiryThreadIntervalSeconds);
            //set eviction policy
            conf.setMemoryStoreEvictionPolicy(memoryStoreEvictionPolicy);
            if (null == cache) {
                //get first cache name and use as default
                defaultCacheName = conf.getName();
                configuration.addDefaultCache(conf);
            } else {
                configuration.addCache(conf);
            }
        }
        //instance the helper
        ConfigurationHelper helper = new ConfigurationHelper(cm, configuration);
        //create the default cache
        cache = helper.createDefaultCache();
        //init the default
        cache.initialise();
        cache.bootstrap();
        //create the un-init'd caches
        @SuppressWarnings("unchecked")
        Set<Cache> caches = helper.createCaches();
        if (log.isDebugEnabled()) {
            log.debug("Number of caches: " + caches.size() + " Default cache: " + (cache != null ? 1 : 0));
        }
        for (Cache nonDefaultCache : caches) {
            nonDefaultCache.initialise();
            nonDefaultCache.bootstrap();
        }
    } catch (Exception e) {
        log.warn("Error on cache init", e);
    }
    if (log.isDebugEnabled()) {
        log.debug("Cache is null? {}", (null == cache));
    }
}
 

protected AllCachesTableDataModel(final String[] cnames) {
    this.cnames = cnames;
    this.cacheManager = CacheManager.getInstance();
}
 

public void afterPropertiesSet() throws CacheException, IOException {
	// If no CacheManager given, fetch the default.
	if (this.cacheManager == null) {
		if (log.isDebugEnabled()) {
			log.debug("Using default EHCache CacheManager for cache region '" + this.cacheName + "'");
		}
		this.cacheManager = CacheManager.getInstance();
	}

	// If no cache name given, use bean name as cache name.
	if (this.cacheName == null) {
		this.cacheName = this.beanName;
	}

	// Fetch cache region: If none with the given name exists,
	// create one on the fly.
	Ehcache rawCache;
	if (this.cacheManager.cacheExists(this.cacheName)) {
		if (log.isDebugEnabled()) {
			log.debug("Using existing EHCache cache region '" + this.cacheName + "'");
		}
		rawCache = this.cacheManager.getEhcache(this.cacheName);
	}
	else {
		if (log.isDebugEnabled()) {
			log.debug("Creating new EHCache cache region '" + this.cacheName + "'");
		}
		rawCache = createCache();
           // Not look for any custom configuration.
           // Check for old configuration properties.
           if(serverConfigurationService.getString(this.cacheName) == null) {
               log.warn("Old cache configuration "+ this.cacheName+ " must be changed to memory."+ this.cacheName);
           }
           String config = serverConfigurationService.getString("memory."+ this.cacheName);
           if (config != null && config.length() > 0) {
               log.debug("Found configuration for cache: "+ this.cacheName+ " of: "+ config);
               new CacheInitializer().configure(config).initialize(
                       rawCache.getCacheConfiguration());
           }

		this.cacheManager.addCache(rawCache);
	}
	boolean override = false;
	if (serverConfigurationService != null) {
		override = serverConfigurationService.getBoolean(
				"memory.cache.statistics.force.disabled", false);
	}
	if (this.statisticsEnabled && !override) {
		rawCache.setStatisticsEnabled(true);
	}
	if (this.sampledStatisticsEnabled) {
		rawCache.setSampledStatisticsEnabled(true);
	}

	// Decorate cache if necessary.
	Ehcache decoratedCache = decorateCache(rawCache);
	if (decoratedCache != rawCache) {
		this.cacheManager.replaceCacheWithDecoratedCache(rawCache, decoratedCache);
	}
	this.cache = decoratedCache;
}
 

/**
 * Obtain CacheManager used by Hibernate
 */
public CacheManager getManager() {
	return CacheManager.getInstance();
}
 

@Override
public void afterPropertiesSet() throws CacheException {
	// If no cache name given, use bean name as cache name.
	String cacheName = getName();
	if (cacheName == null) {
		cacheName = this.beanName;
		setName(cacheName);
	}

	// If no CacheManager given, fetch the default.
	if (this.cacheManager == null) {
		if (logger.isDebugEnabled()) {
			logger.debug("Using default EhCache CacheManager for cache region '" + cacheName + "'");
		}
		this.cacheManager = CacheManager.getInstance();
	}

	synchronized (this.cacheManager) {
		// Fetch cache region: If none with the given name exists, create one on the fly.
		Ehcache rawCache;
		boolean cacheExists = this.cacheManager.cacheExists(cacheName);

		if (cacheExists) {
			if (logger.isDebugEnabled()) {
				logger.debug("Using existing EhCache cache region '" + cacheName + "'");
			}
			rawCache = this.cacheManager.getEhcache(cacheName);
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Creating new EhCache cache region '" + cacheName + "'");
			}
			rawCache = createCache();
			rawCache.setBootstrapCacheLoader(this.bootstrapCacheLoader);
		}

		if (this.cacheEventListeners != null) {
			for (CacheEventListener listener : this.cacheEventListeners) {
				rawCache.getCacheEventNotificationService().registerListener(listener);
			}
		}

		// Needs to happen after listener registration but before setStatisticsEnabled
		if (!cacheExists) {
			this.cacheManager.addCache(rawCache);
		}

		// Only necessary on EhCache <2.7: As of 2.7, statistics are on by default.
		if (this.statisticsEnabled && setStatisticsEnabledMethod != null) {
			ReflectionUtils.invokeMethod(setStatisticsEnabledMethod, rawCache, true);
		}
		if (this.sampledStatisticsEnabled && setSampledStatisticsEnabledMethod != null) {
			ReflectionUtils.invokeMethod(setSampledStatisticsEnabledMethod, rawCache, true);
		}

		if (this.disabled) {
			rawCache.setDisabled(true);
		}

		Ehcache decoratedCache = decorateCache(rawCache);
		if (decoratedCache != rawCache) {
			this.cacheManager.replaceCacheWithDecoratedCache(rawCache, decoratedCache);
		}
		this.cache = decoratedCache;
	}
}
 

@Override
public void afterPropertiesSet() throws CacheException {
	// If no cache name given, use bean name as cache name.
	String cacheName = getName();
	if (cacheName == null) {
		cacheName = this.beanName;
		setName(cacheName);
	}

	// If no CacheManager given, fetch the default.
	if (this.cacheManager == null) {
		if (logger.isDebugEnabled()) {
			logger.debug("Using default EhCache CacheManager for cache region '" + cacheName + "'");
		}
		this.cacheManager = CacheManager.getInstance();
	}

	synchronized (this.cacheManager) {
		// Fetch cache region: If none with the given name exists, create one on the fly.
		Ehcache rawCache;
		boolean cacheExists = this.cacheManager.cacheExists(cacheName);

		if (cacheExists) {
			if (logger.isDebugEnabled()) {
				logger.debug("Using existing EhCache cache region '" + cacheName + "'");
			}
			rawCache = this.cacheManager.getEhcache(cacheName);
		}
		else {
			if (logger.isDebugEnabled()) {
				logger.debug("Creating new EhCache cache region '" + cacheName + "'");
			}
			rawCache = createCache();
			rawCache.setBootstrapCacheLoader(this.bootstrapCacheLoader);
		}

		if (this.cacheEventListeners != null) {
			for (CacheEventListener listener : this.cacheEventListeners) {
				rawCache.getCacheEventNotificationService().registerListener(listener);
			}
		}

		// Needs to happen after listener registration but before setStatisticsEnabled
		if (!cacheExists) {
			this.cacheManager.addCache(rawCache);
		}

		// Only necessary on EhCache <2.7: As of 2.7, statistics are on by default.
		if (this.statisticsEnabled && setStatisticsEnabledMethod != null) {
			ReflectionUtils.invokeMethod(setStatisticsEnabledMethod, rawCache, true);
		}
		if (this.sampledStatisticsEnabled && setSampledStatisticsEnabledMethod != null) {
			ReflectionUtils.invokeMethod(setSampledStatisticsEnabledMethod, rawCache, true);
		}

		if (this.disabled) {
			rawCache.setDisabled(true);
		}

		Ehcache decoratedCache = decorateCache(rawCache);
		if (decoratedCache != rawCache) {
			this.cacheManager.replaceCacheWithDecoratedCache(rawCache, decoratedCache);
		}
		this.cache = decoratedCache;
	}
}