Question

我只是想知道Scala中是否有任何缓存解决方案。我正在寻找类似Guava在Java中提供的东西。

我是否应该在Scala中使用Guava？ Scalaz中是否有包装/皮条客或类似的东西？任何更适合Scala开发者的替代方案？

番石榴提供的内容：

LoadingCache<Key, Graph> CACHE= CacheBuilder.newBuilder()
       .maximumSize(1000)
       .expireAfterWrite(10, TimeUnit.MINUTES)
       .removalListener(MY_LISTENER)
       .build(
           new CacheLoader<Key, Graph>() {
             public Graph load(Key key) throws AnyException {
               return createExpensiveGraph(key);
             }
           });

Supplier<Animal> singleAnimalCache = Suppliers.memoizeWithExpiration(animalFromDbSupplier(), 365, TimeUnit.DAYS);

我需要像Guava一样的基本缓存管理。

Answer 1

我们有相同的要求，最终围绕番石榴建造包装纸。我们最近开源的部分名为Mango。如果你不介意额外的依赖，你可以像

一样使用它

import org.feijoas.mango.common.cache._
import org.feijoas.mango.common.base.Suppliers._

val MY_LISTENER = (remNot: RemovalNotification[Key, Graph]) => ()
// > MY_LISTENER : RemovalNotification[Key,Graph] => Unit = <function1>

val CACHE = CacheBuilder.newBuilder()
  .maximumSize(1000)
  .expireAfterWrite(10, TimeUnit.MINUTES)
  .removalListener(MY_LISTENER)
  .build { (key: Key) => new Graph() }
// > CACHE : LoadingCache[Key,Graph] = <function1>

val animalFromDbSupplier = () => {
  // load from db
  new Animal()
}
// > animalFromDbSupplier  : () => Animal = <function0>

val singleAnimalCache = memoizeWithExpiration(animalFromDbSupplier, 365, TimeUnit.DAYS)
// > singleAnimalCache  : () => Animal = Suppliers.memoizeWithExpiration(<function0>, 365, DAYS)

Answer 2

只需添加一个插入我自己项目的答案，但我推荐使用ScalaCache。

支持Guava，Ehcache，Memcached和Redis（或者如果你愿意，你可以插入自己的实现）
简单，惯用的Scala API
支持每个元素的生存时间（即使对于没有提供开箱即用的番石榴）
支持使用宏魔法自动生成缓存键

https://github.com/cb372/scalacache

Answer 3

Scalaz中是否有一个包装器/皮条客或类似的东西？

在Scalaz 7中有Memo，我在learning Scalaz day 16中介绍了一点。

这是Adam Rosien在scalaz "For the Rest of Us"谈话中所涉及的第一件事，所以也要检查一下。他正在使用Scalaz 6。

Answer 4

在Scala中使用 guava缓存很简单。

import com.google.common.base._
import com.google.common.cache._

object Simple_Guava_Caches_in_Scala {

   def main(args: Array[String]): Unit = {

      // Simple scala guava cache
      val simpleCache1 =
         CacheBuilder
           .newBuilder()
           .build(new CacheLoader[String, String] {
              def load(key: String): String = {
                 println(s"Simple scala guava cache, heavy work calculating $key")
                 s"It's me $key"
              }
           })
      println(simpleCache1.get("1"))
      println(simpleCache1.get("1"))
      println(simpleCache1.get("2"))
      println(simpleCache1.get("2"))
      println(simpleCache1.get("2"))


      // Simple scala guava supplier cache / factory
      println()
      val supplier_cache: Supplier[String] = Suppliers.memoize(
         () => {
            println("Simple scala guava supplier cache / factory, heavy work creating singleton:")
            "It's me"
         }
      )
      println(supplier_cache.get)
      println(supplier_cache.get)
      println(supplier_cache.get)
   }
}

这正在产生

Simple scala guava cache, heavy work calculating 1
It's me 1
It's me 1
Simple scala guava cache, heavy work calculating 2
It's me 2
It's me 2
It's me 2

Simple scala guava supplier cache / factory, heavy work creating singleton:
It's me
It's me
It's me

我已将其添加到build.sbt：

libraryDependencies += "com.github.cb372" %% "scalacache-guava" % "0.26.0"

将上面的编码转换为cb372的scalacache-guava将很有趣。甚至可以更简单/更标准化。

Scala中的轻量级缓存解决方案？

4 个答案: