标签: google-guava-cache

我用grails 3.1.16

的build.gradle:

dependencies {
    compile "com.google.guava:guava:18.0"
    compile "org.grails.plugins:spring-security-rest:2.0.0.M2"
}

在运行此代码时:

   private LoadingCache<String, Boolean> attempts

    @PostConstruct
    void init() {
        Integer time = ApplicationContextHolder.getProperty(ApplicationContextHolder.config.time)
        attempts = CacheBuilder.newBuilder()
                .expireAfterWrite(time, TimeUnit.MINUTES)
                .build({ 0 } as CacheLoader)
    }

我收到以下错误:

Caused by: java.lang.NoSuchMethodError: com.google.common.base.Platform.systemNanoTime()J
        at com.google.common.base.LocalCache(Ticker.java:60)
        at com.google.common.cache.LocalCache$Segment.put(LocalCache.java:2827)
        at com.google.common.cache.LocalCache.put(LocalCache.java:4149)
        at com.google.common.cache.LocalCache$LocalManualCache.put(LocalCache.java:4754)
        at com.google.common.cache.Cache$put.call(Unknown Source)

在运行依赖项报告之后,我发现问题是由Spring Security REST插件的依赖引起的:(com.google.guava:guava-base:r03) - 使用相同的包名"com.google.common. base"和Platform.class没有这样的方法systemNanoTime()

|    +--- org.grails.plugins:spring-security-rest:2.0.0.M2
|    |    +--- com.google.guava:guava-io:r03
|    |    |    +--- com.google.guava:guava-annotations:r03
|    |    |    \--- com.google.guava:guava-base:r03
|    |    |         \--- com.google.guava:guava-annotations:r03

任何解决这个问题的想法？

我试图对类“ A”进行单元测试，该类调用类“ B”的静态方法。类“ B”本质上具有Google番石榴缓存，该缓存从给定键的缓存中检索值（对象），或使用服务适配器将对象加载到缓存中（如果发生缓存丢失）。反过来，service-adapter类还具有其他自动关联的依赖项来检索对象。

这些是出于说明目的的类：

A级

public class A {
    public Object getCachedObject(String key) {
        return B.getObjectFromCache(key);
    }
}

B级

public class B {

    private ServiceAdapter serviceAdapter;

    public void setServiceAdapter(ServiceAdapter serAdapt) {
        serviceAdapter = serAdapt;
    } 

    private static final LoadingCache<String, Object> CACHE = CacheBuilder.newBuilder()
                .maximumSize(100) 
                .expireAfterWrite(30, TimeUnit.MINUTES)
                .build(new MyCacheLoader());

    public static Object getObjectFromCache(final String key) throws ExecutionException {
        return CACHE.get(warehouseId);
    }

    private static class MyCacheLoader extends CacheLoader<String, Object>  {

        @Override
        public Object load(final String key) throws Exception {
            return serviceAdapter.getFromService(key) …

说我的Cache定义如下:

private static Cache<String, Long> alertsUIDCache = CacheBuilder.newBuilder().
           expireAfterAccess(60).build();

从我读到的内容(如果我错了请纠正我):

如果Cache在0:00 写入值,则应在60秒后将其移至"准备被驱逐"状态.实际删除的值Cache将在下一次缓存修改时发生(什么是缓存修改？).是对的吗？

另外,我不确定invalidateAll()和cleanUp()方法之间有什么区别,有人可以提供解释吗？

我阅读了这篇文章,解释了Guava Cache:CachesExplained.我确实理解了refreshAfterWrite和expireAfterWrite正在做什么.但是,在解释refreshAfterWrite时,该文档还提到了这一点:

" 因此,例如,您可以在同一缓存上指定refreshAfterWrite和expireAfterWrite,这样只要条目有资格进行刷新,条目上的到期计时器就不会被盲目重置,因此如果条目之后没有查询条目有资格刷新,允许过期. "

这是令我困惑的部分.根据我的理解,如果您想要自动刷新密钥,您只需要指定refreshAfterWrite.为什么我们甚至想在使用refreshAfterWrite时使用expireAfterWrite？

我有一个这样的加载缓存：

MyCacheLoader loader=new MyCacheLoader();
MyRemovalListener listener=new MyRemovalListener();
LoadingCache<String, String> myCache = CacheBuilder.newBuilder()
                .concurrencyLevel(10)
                .weakKeys()
                .maximumSize(2)
                .expireAfterWrite(120, TimeUnit.SECONDS)
                .removalListener(listener)
                .build(loader);

但是当我做这样的事情来测试时：

System.out.println(myCache.get("100"));
System.out.println(myCache.get("103"));
System.out.println(myCache.get("110"));
System.out.println(myCache).get("111"));
Thread.sleep(230000);
System.out.println(myCache.size());

我仍然得到 2 而不是零。为什么 ？超过 120 秒后，如果我没有错的话，我的大小应该为零吗？

我的缓存加载器

public class MyCacheLoader extends CacheLoader<String,String>     {
    @Override
    public String load(String key) throws Exception {
        return key;
    }
}

我的移除监听器

public class MyRemovalListener implements RemovalListener<String,String> {

    Logger logger = LoggerFactory.getLogger(MyRemovalListener.class);
    @Override
    public void onRemoval(RemovalNotification<String, String> removalNotification) {
        logger.info("Message with message Id ("+
                removalNotification.getKey()+ ") is removed.");
        System.out.println("Message with …

我正在使用谷歌缓存在单例 ejb 中缓存数据。并且缓存的资源被多个 ejb 使用。但是现在不确定如果部署在可以存在多个 JVM 的多节点集群环境中，同一个应用程序是否可以工作。

请指教！

我正在尝试使用Google Guava缓存按服务相关对象进行缓存。在发生缓存未命中时，我使用我的REST客户端来获取对象。我知道我可以通过以下方式做到这一点：

CacheLoader<Key, Graph> loader = new CacheLoader<Key, Graph>() {
     public Graph load(Key key) throws InternalServerException, ResourceNotFoundException {
       return client.get(key);
     }
   };
   LoadingCache<Key, Graph> cache = CacheBuilder.newBuilder().build(loader)

现在，client.getKey(Key k)实际上抛出InternalServerException和ResourceNotFoundException。当我尝试使用此缓存实例获取对象时，可以将异常捕获为ExecutionException。

try {
  cache.get(key);
} catch (ExecutionException e){

}

但是，我想专门捕获并处理我定义的CacheLoader抛出的异常（即InternalServerException和ResourceNotFoundException）。

我不确定是否检查的实例是否ExecutionException是我自己的异常之一，是否会导致load（）方法的签名实际上抛出Exception而不是ExecutionException。即使我可以使用instanceof，它也不是很干净。有解决这个问题的好方法吗？

我有一组包含元素的数组.我需要通过使用java中断言的guava比较特定字段来找到该数组中的重复元素.

例如:
我有一个带有员工详细信息的arraylist.我需要找到同名员工的详细信息.

我有一个番石榴缓存，我想弄清楚某个特定的密钥是否已经存在，这样我就不会覆盖它们？这可能与番石榴缓存有关吗？

private final Cache<Long, PendingMessage> cache = CacheBuilder.newBuilder()
    .maximumSize(1_000_000)
    .concurrencyLevel(100)
    .build()

// there is no put method like this
if (cache.put(key, value) != null) {
  throw new IllegalArgumentException("Message for " + key + " already in queue");
}

看起来没有返回布尔值的 put 方法，我可以在其中确定键是否已经存在。有没有其他方法可以确定密钥是否已经存在，这样我就不会覆盖它？

当我从番石榴缓存中删除对象时，我想执行一些清理操作。但是我需要一段时间后再做。我可以在那里睡觉吗？会阻塞所有线程吗？还是removeListener在单独的线程中运行？

CacheBuilder.newBuilder().
.removalListener(notification -> {
    try {
        Thread.sleep(10 * 60 * 1000);
    } catch (InterruptedException e) {
    }
    try {
        //close
    } catch (final IOException e) {
    }
})
.build();