28

我想用 Java 中的 ehcache 做一些我认为应该非常简单的事情，但是我已经花了足够的时间让自己对文档感到沮丧......

  1. 将值写入磁盘持久缓存。关闭。

  2. 再次启动并读取该值。

这是我的Java函数：

private static void testCacheWrite() {

  // create the cache manager from our configuration
  URL url = TestBed.class.getClass().getResource("/resource/ehcache.xml");
  CacheManager manager = CacheManager.create(url);
  // check to see if our cache exits, if it doesn't create it
  Cache testCache = null;
  if (!manager.cacheExists("test")) {
    System.out.println("No cache found. Creating cache...");
    int maxElements = 50000;
    testCache = new Cache("test", maxElements,
      MemoryStoreEvictionPolicy.LFU, true, null, true, 60, 30,
      true, Cache.DEFAULT_EXPIRY_THREAD_INTERVAL_SECONDS, null);
    manager.addCache(testCache);
    // add an element to persist
    Element el = new Element("key", "value");
    testCache.put(el);
    testCache.flush();
    System.out.println("Cache to disk. Cache size on disk: " +
      testCache.getDiskStoreSize());
  } else {
    // cache exists so load it
    testCache = manager.getCache("test");
    Element el = testCache.get("key");
    if (null == el) {
      System.out.print("Value was null");
      return;
    }
    String value = (String) el.getObjectValue();
    System.out.println("Value is: " + value);
  }
  manager.shutdown();
}

这是我的缓存配置（ehcache.xml）：

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
  <diskStore path="C:/mycache"/><!-- java.io.tmpdir -->
  <defaultCache
    maxElementsInMemory="10000"
    eternal="true"
    timeToIdleSeconds="120"
    timeToLiveSeconds="120"
    overflowToDisk="true"
    maxElementsOnDisk="10000000"
    diskPersistent="true"
    diskExpiryThreadIntervalSeconds="120"
    memoryStoreEvictionPolicy="LRU" />
</ehcache>

即使我在第一次运行后看到磁盘上的 test.index 和 test.data 文件，这个函数的输出总是如下（它似乎从不从磁盘加载缓存）：

未找到缓存。创建缓存...
缓存到磁盘。磁盘上的缓存大小：2

我一定是在做一些愚蠢的事情，但我不确定是什么！

4

8 回答 8

18

好的，我解决这个问题的方法是使用配置文件配置我的缓存。这是更新的配置：

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

    <diskStore path="C:/mycache" />

    <defaultCache
        maxElementsInMemory="10000" 
        eternal="true"
        timeToIdleSeconds="120" 
        timeToLiveSeconds="120" 
        overflowToDisk="true"
        maxElementsOnDisk="10000000" 
        diskPersistent="true"
        diskExpiryThreadIntervalSeconds="120" 
        memoryStoreEvictionPolicy="LRU" />

    <cache 
        name="test" 
        maxElementsInMemory="500" 
        eternal="true"
        overflowToDisk="true" 
        timeToIdleSeconds="300" 
        timeToLiveSeconds="600"
        diskPersistent="true" 
        diskExpiryThreadIntervalSeconds="1"
        memoryStoreEvictionPolicy="LFU" />

</ehcache>

所以基本上我没有使用构造函数来定义缓存。

我想这会起作用，但我仍然想知道为什么以编程方式定义的缓存不能保存在磁盘上（特别是因为它们仍然被写入磁盘！）。

感谢您的评论。

于 2009-11-13T16:38:59.573 回答
5

在调试器上度过了一段美好的时光后，我相信我对 OP 有了答案。

问题（至少从我所见）围绕非集群磁盘缓存文件以及它们如何被读回。在文件 net.sf.ehcache.store.compound.factories.DiskPersistentStorageFactory.java 中，方法：

public DiskPersistentStorageFactory(Ehcache cache, String diskPath) {
    super(getDataFile(diskPath, cache), cache.getCacheConfiguration().getDiskExpiryThreadIntervalSeconds(),
            cache.getCacheConfiguration().getDiskSpoolBufferSizeMB(), cache.getCacheEventNotificationService(), false);

    indexFile = new File(getDataFile().getParentFile(), getIndexFileName(cache));
    flushTask = new IndexWriteTask(indexFile, cache.getCacheConfiguration().isClearOnFlush());

    if (!getDataFile().exists() || (getDataFile().length() == 0)) {
        LOG.debug("Matching data file missing (or empty) for index file. Deleting index file " + indexFile);
        indexFile.delete();
    } else if (getDataFile().exists() && indexFile.exists()) {
        if (getDataFile().lastModified() > (indexFile.lastModified() + TimeUnit.SECONDS.toMillis(1))) {
            LOG.warn("The index for data file {} is out of date, probably due to an unclean shutdown. " 
                    + "Deleting index file {}", getDataFile(), indexFile);
            indexFile.delete();
        }
    }

    diskCapacity = cache.getCacheConfiguration().getMaxElementsOnDisk();
    memoryCapacity = cache.getCacheConfiguration().getMaxElementsInMemory();
    memoryPolicy = determineEvictionPolicy(cache.getCacheConfiguration());
}

检查数据文件上的时间戳。我看到的问题是，无论我最终如何关闭缓存/管理器，文件都永远不会正确同步。我快速而肮脏的解决方法是将数据文件的时间调整为刚刚超过索引文件上的时间戳：

File index = new File( path, name + ".index" );
File data  = new File( path, name + ".data"  );

data.setLastModified( index.lastModified() + 1 );

当然，这并不优雅，但它满足了我的需求，因为我们的项目使用集群缓存，这允许我使用持久缓存进行独立调试......而无需在本地实际运行 Terracotta。

一个警告是，对于非集群缓存，我必须在每次 put() 和 remove() 之后刷新（），以保持磁盘映像新鲜，尤其是在调试时，因为当您“拉”时缺少关闭支持插头”。

于 2010-09-10T21:51:48.930 回答
4

我花了一段时间才弄清楚，但基本上这里需要做的是相应地创建 CacheManager。

如果您创建缓存管理器和缓存的方式与您在 xml 中创建它的方式相同，它将起作用。

net.sf.ehcache.CacheManager manager = net.sf.ehcache.CacheManager
        .create(new Configuration().diskStore(
            new DiskStoreConfiguration().path("C:/mycache")
        )
        .cache(new CacheConfiguration()
            .name(testName)
            .eternal(true)
            .maxBytesLocalHeap(10000, MemoryUnit.BYTES)
            .maxBytesLocalDisk(1000000, MemoryUnit.BYTES)
            .diskExpiryThreadIntervalSeconds(0)
            .diskPersistent(true)));
于 2014-11-04T15:56:09.017 回答
2

这可能有点晚了，但我遇到了同样的问题：有帮助的是关闭缓存管理器。

（来自文档：http: //ehcache.org/documentation/code-samples#ways-of-loading-cache-configuration）

关闭单例 CacheManager：

CacheManager.getInstance().shutdown();

关闭 CacheManager 实例，假设您有一个对 CacheManager 的引用，称为：

manager.shutdown();
于 2012-12-27T11:03:04.610 回答
1

我认为您应该删除manager.cacheExists(..)测试并简单地使用创建缓存testCache = manager.getCache("test");而不是使用new Cache(..). 即使你的缓存是diskPersistent，它也不会存在，直到你第一次得到它。（至少这是我认为的，因为我只是在使用getCache(..)它，它完全符合您的要求）

笔记：

您还可以添加类似这样的内容以确保缓存存在：

Cache cache = manager.getCache(name);
if (cache == null) {
    throw new NullPointerException(String.format("no cache with name %s defined, please configure it in %s", name, url));
}

笔记2：

如果您的配置文件名为 ehcache.xml，则不应使用CacheManager.create(url). 而是使用 CacheManager 单例：我想我对使用CacheManager.create(url)with 和 using感到困惑new CacheManager(url)。ehcache.xml不过，您应该将单例用于new CacheManager(url)其他任何事情。

// ehcache.xml - shared between different invocations
CacheManager defaultManager = CacheManager.getInstance();
// others - avoid calling twice with same argument
CacheManager manager = CacheManager.create(url);

使用CacheManager.create(..)是有问题的，因为如果任何方法或之前被调用过，它可能会完全忽略传递的 URL ：create(..)getInstance()

public static CacheManager create(URL configurationFileURL) throws CacheException {
    synchronized (CacheManager.class) {
        if (singleton == null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Creating new CacheManager with config URL: " + configurationFileURL);
            }
            singleton = new CacheManager(configurationFileURL);

        }
        return singleton;
    }
}

这就是为什么我不建议使用任何CacheManager.create(..)方法的原因。使用CacheManager.getInstance()或new CacheManager(url)。

于 2009-11-13T14:56:29.383 回答
1

如果磁盘上的缓存为空，小提示：确保缓存中的元素是可序列化的。如果不是这种情况，ehcache 会记录，但我的日志设置没有打印出这些日志条目。

于 2012-06-14T10:12:04.137 回答
1

我有并解决了一个类似的问题。

我想将 ehcache 配置为在磁盘上具有给定的缓存持久元素。但我只想在本地环境中执行此操作（生产环境具有distributed持久性），因此我在应用程序启动时以编程方式切换配置（在我的情况下为 Web 应用程序）

File configurationFile = new File(event.getServletContext().getRealPath(EHCACHE_CONFIG_PATH));    
Configuration configuration = ConfigurationFactory.parseConfiguration(configurationFile);

//...doing other stuff here...

CacheConfiguration cacheConfiguration = configuration.getCacheConfigurations().get("mycachename");
if(localEnvironment){    
    cacheConfiguration.addPersistence(new PersistenceConfiguration().strategy(Strategy.DISTRIBUTED));
}else{
    //siteCacheConfiguration.addPersistence(new PersistenceConfiguration().strategy(Strategy.LOCALRESTARTABLE));
    //deprecated lines..
    siteCacheConfiguration.setDiskPersistent(true);
    siteCacheConfiguration.setOverflowToDisk(true);
}

我对注释行有疑问siteCacheConfiguration.addPersistence(new PersistenceConfiguration().strategy(Strategy.LOCALRESTARTABLE))，实际上，如果您在没有企业版 jar的情况下使用 Ehcache 代码（我正在使用ehcache-2.6.11），则会引发异常：Strategy.LOCALRESTARTABLE

CacheException: You must use an enterprise version of Ehcache to successfully enable enterprise persistence.

深入研究代码，我意识到这两条（已弃用）行在逃避企业版本异常的情况下做同样的事情

siteCacheConfiguration.setDiskPersistent(true);
siteCacheConfiguration.setOverflowToDisk(true);

记得添加CacheManager.getInstance().shutdown()关闭应用程序！

希望这可以帮助。

于 2017-02-09T15:31:26.927 回答
0

我想这会起作用，但我仍然想知道为什么以编程方式定义的缓存不能保存在磁盘上（特别是因为它们仍然被写入磁盘！）

我的理解是，以编程方式创建的缓存（即未在 中声明ehcache.xml）可以使用DiskStore本身可以持久的缓存，但这并不意味着该缓存将在CacheManager重新启动时自动加载。实际上，我不认为前面提到的文件确实包含缓存参数。

但是，如果您使用相同的参数以编程方式“重新创建”缓存，您会从DiskStore.

于 2009-11-13T16:52:11.117 回答