Guava缓存数据到本地 - 极悦
首页 课程 师资 教程 报名

Guava缓存数据到本地

  • 2022-05-31 08:55:26
  • 591次 极悦

缓存使您可以轻松地显着加速应用程序。 Java平台的两种出色的缓存实现是Guava缓存工具和Ehcache 。 尽管Ehcache功能丰富得多(例如其Searchable API ,将缓存持久化到磁盘或溢出到大内存的可能性),但与Guava相比,它也带来了相当大的开销。

下面小编将以实际Guava Cache实例的包装器形式实现此文件持久性缓存FilePersistingCache 。

首先,将定义一个受保护的方法,该方法创建前面提到的后备缓存:

private LoadingCache<K, V> makeCache() {
  return customCacheBuild()
    .removalListener(new PersistingRemovalListener())
    .build(new PersistedStateCacheLoader());
} 
protected CacheBuilder<K, V> customCacheBuild(CacheBuilder<K, V> cacheBuilder) {
  return CacheBuilder.newBuilder();
}

第一种方法将在内部使用以构建必要的缓存。 为了实现对缓存的任何自定义要求(例如,过期策略),应该重写第二种方法。 例如,这可以是条目或软引用的最大值。 此缓存将与其他任何Guava缓存一样使用。 缓存功能的关键是用于此缓存的RemovalListener和CacheLoader 。 我们将这两个实现定义为FilePersistingCache内部类:

private class PersistingRemovalListener implements RemovalListener<K, V> {
  @Override
  public void onRemoval(RemovalNotification<K, V> notification) {
    if (notification.getCause() != RemovalCause.COLLECTED) {
      try {
        persistValue(notification.getKey(), notification.getValue());
      } catch (IOException e) {
        LOGGER.error(String.format("Could not persist key-value: %s, %s",
          notification.getKey(), notification.getValue()), e);
      }
    }
  }
} 
public class PersistedStateCacheLoader extends CacheLoader<K, V> {
  @Override
  public V load(K key) {
    V value = null;
    try {
      value = findValueOnDisk(key);
    } catch (Exception e) {
      LOGGER.error(String.format("Error on finding disk value to key: %s",
        key), e);
    }
    if (value != null) {
      return value;
    } else {
      return makeValue(key);
    }
  }
}

从代码中可以明显FilePersistingCache ,这些内部类调用了我们尚未定义的FilePersistingCache方法。 这使我们可以通过重写此类来定义自定义序列化行为。 删除侦听器将检查清除缓存条目的原因。 如果RemovalCause被COLLECTED ,缓存条目没有由用户手动删除,但它已被删除作为高速缓存的驱逐策略的结果。 因此,如果用户不希望删除条目,我们将仅尝试保留一个缓存条目。 CacheLoader将首先尝试从磁盘还原现有值并仅在无法还原该值时创建一个新值。

缺少的方法定义如下:

private V findValueOnDisk(K key) throws IOException {
  if (!isPersist(key)) return null;
  File persistenceFile = makePathToFile(persistenceDirectory, directoryFor(key));
  (!persistenceFile.exists()) return null;
  FileInputStream fileInputStream = new FileInputStream(persistenceFile);
  try {
    FileLock fileLock = fileInputStream.getChannel().lock();
    try {
      return readPersisted(key, fileInputStream);
    } finally {
      fileLock.release();
    }
  } finally {
    fileInputStream.close();
  }
} 
private void persistValue(K key, V value) throws IOException {
  if (!isPersist(key)) return;
  File persistenceFile = makePathToFile(persistenceDirectory, directoryFor(key));
  persistenceFile.createNewFile();
  FileOutputStream fileOutputStream = new FileOutputStream(persistenceFile);
  try {
    FileLock fileLock = fileOutputStream.getChannel().lock();
    try {
      persist(key, value, fileOutputStream);
    } finally {
      fileLock.release();
    }
  } finally {
    fileOutputStream.close();
  }
} 
private File makePathToFile(@Nonnull File rootDir, List<String> pathSegments) {
  File persistenceFile = rootDir;
  for (String pathSegment : pathSegments) {
    persistenceFile = new File(persistenceFile, pathSegment);
  }
  if (rootDir.equals(persistenceFile) || persistenceFile.isDirectory()) {
    throw new IllegalArgumentException();
  }
  return persistenceFile;
} 
protected abstract List<String> directoryFor(K key); 
protected abstract void persist(K key, V value, OutputStream outputStream)
  throws IOException;
protected abstract V readPersisted(K key, InputStream inputStream)
  throws IOException;
protected abstract boolean isPersist(K key);

所实现的方法在同步文件访问并保证流被适当关闭的同时,还要注意对值进行序列化和反序列化。 最后四种方法仍然是抽象的,并由缓存的用户来实现。 directoryFor(K)方法应为每个密钥标识一个唯一的文件名。 在最简单的情况下,密钥的K类的toString方法是以这种方式实现的。 此外,小编还对persist , readPersisted和isPersist方法进行了抽象化处理,以实现自定义序列化策略,例如使用Kryo 。 在最简单的情况下,您将使用内置的Java功能,该功能使用ObjectInputStream和ObjectOutputStream 。 对于isPersist ,假设仅在需要序列化时才使用此实现,则将返回true 。 添加了此功能以支持混合缓存,在混合缓存中,您只能将值序列化为某些键。 确保不要在persist和readPersisted方法中关闭流,因为文件系统锁依赖于要打开的流。 上面的实现将为您关闭流。

最后,添加了一些服务方法来访问缓存。 当然,实现Guava的Cache接口将是一个更优雅的解决方案:

public V get(K key) {
  return underlyingCache.getUnchecked(key);
} 
public void put(K key, V value) {
  underlyingCache.put(key, value);
} 
public void remove(K key) {
  underlyingCache.invalidate(key);
} 
protected Cache<K, V> getUnderlyingCache() {
  return underlyingCache;
}

当然,可以进一步改善该解决方案。 如果在并发场景中使用缓存,请注意, RemovalListener是除大多数Guava缓存方法以外的异步执行的。 从代码中可以明显看出,添加了文件锁,以避免在文件系统上发生读/写冲突。如果大家想了解更多相关知识,不妨来关注一下极悦的Guava教程,里面有更丰富的知识等着大家去学习,希望对大家能够有所帮助。

选你想看

你适合学Java吗?4大专业测评方法

代码逻辑 吸收能力 技术学习能力 综合素质

先测评确定适合在学习

在线申请免费测试名额
价值1998元实验班免费学
姓名
手机
提交