documentation/manual/working/scalaGuide/main/cache/ScalaCache.md
Caching data is a typical optimization in modern applications, and so Play provides a global cache.
Note: An important point about the cache is that it behaves just like a cache should: the data you just stored may just go missing.
For any data stored in the cache, a regeneration strategy needs to be put in place in case the data goes missing. This philosophy is one of the fundamentals behind Play, and is different from Java EE, where the session is expected to retain values throughout its lifetime.
Play provides a CacheApi implementation based on Caffeine and a legacy implementation based on Ehcache 2.x. For in-process caching Caffeine is typically the best choice. If you need distributed caching, there are third-party plugins for memcached and redis.
Play provides separate dependencies for the Cache API and for the Caffeine and Ehcache implementations.
To get the Caffeine implementation, add caffeine to your dependencies list:
This will also automatically set up the bindings for runtime DI so the components are injectable.
To get the EhCache implementation, add ehcache to your dependencies list:
This will also automatically set up the bindings for runtime DI so the components are injectable.
To add only the API, add cacheApi to your dependencies list.
The API dependency is useful if you'd like to define your own bindings for the Cached helper and AsyncCacheApi, etc., without having to depend on any specific cache implementation. If you're writing a custom cache module you should use this.
The cache API is defined by the AsyncCacheApi and SyncCacheApi traits, depending on whether you want an asynchronous or synchronous implementation, and can be injected into your component like any other dependency. For example:
Note: The API is intentionally minimal to allow several implementation to be plugged in. If you need a more specific API, use the one provided by your Cache plugin.
Using this simple API you can store data in cache:
And then retrieve it later:
There is also a convenient helper to retrieve from cache or set the value in cache if it was missing:
Note: getOrElseUpdate is not an atomic operation in EhCache and is implemented as a get followed by computing the value, then a set. This means it's possible for the value to be computed multiple times if multiple threads are calling getOrElse simultaneously.
You can specify an expiry duration by passing a duration, by default the duration is infinite:
To remove an item from the cache use the remove method:
To remove all items from the cache use the removeAll method:
removeAll() is only available on AsyncCacheApi, since removing all elements of the cache is rarely something you want to do synchronously. The expectation is that removing all items from the cache should only be needed as an admin operation in special cases, not part of the normal operation of your app.
Note that the SyncCacheApi has the same API, except it returns the values directly instead of using futures.
It is possible to define and use different caches with different configurations by their name. To access different caches, when you inject them, use the NamedCache qualifier on your dependency, for example:
If you want to access multiple different caches, then you'll need to tell Play to bind them in application.conf, like so:
play.cache.bindCaches = ["db-cache", "user-cache", "session-cache"]
Defining and configuring named caches depends on the cache implementation you are using, examples of configuring named caches with Caffeine are given below.
If you want to pass a default custom configuration that will be used as a fallback for all your caches you can do it by specifying:
play.cache.caffeine.defaults = {
initial-capacity = 200
...
}
You can also pass custom configuration data for specific caches by doing:
play.cache.caffeine.user-cache = {
initial-capacity = 200
...
}
With EhCache implementation, the default cache is called play, and can be configured by creating a file called ehcache.xml. Additional caches may be configured with different configurations, or even implementations.
By default, Play will try to create caches with names from play.cache.bindCaches for you. If you would like to define them yourself in ehcache.xml, you can set:
play.cache.createBoundCaches = false
By default, Caffeine and EhCache store elements in memory. Therefore reads from and writes to the cache should be very fast, because there is hardly any blocking I/O.
However, depending on how a cache was configured (e.g. by using EhCache's DiskStore), there might be blocking I/O which can become too costly, because even the async implementations will block threads in the default execution context.
For such a case you can configure a different Pekko dispatcher and set it via play.cache.dispatcher so the cache plugin makes use of it:
play.cache.dispatcher = "contexts.blockingCacheDispatcher"
contexts {
blockingCacheDispatcher {
fork-join-executor {
parallelism-factor = 3.0
}
}
}
When using Caffeine, this will set Caffeine's internal executor. Actually, setting play.cache.dispatcher sets play.cache.caffeine.defaults.executor. Like described above you can therefore set different executors for different caches:
play.cache.caffeine.user-cache = {
executor = "contexts.anotherBlockingCacheDispatcher"
...
}
For EhCache, Play will run any EhCache operation in a Future on a thread of the given dispatcher.
You can easily create smart cached actions using standard Action composition.
Note: Play HTTP
Resultinstances are safe to cache and reuse later.
The Cached class helps you build cached actions.
You can cache the result of an action using a fixed key like "homePage".
If results vary, you can cache each result using a different key. In this example, each user has a different cached result.
You can easily control what you want to cache or what you want to exclude from the cache.
You may want to only cache 200 Ok results.
Or cache 404 Not Found only for a couple of minutes
It is possible to provide a custom implementation of the cache API. Make sure that you have the cacheApi dependency.
You can then implement AsyncCacheApi and bind it in the DI container. You can also bind SyncCacheApi to DefaultSyncCacheApi, which simply wraps the async implementation.
Note that the removeAll method may not be supported by your cache implementation, either because it is not possible or because it would be unnecessarily inefficient. If that is the case, you can throw an UnsupportedOperationException in the removeAll method.
To provide an implementation of the cache API in addition to the default implementation, you can either create a custom qualifier, or reuse the NamedCache qualifier to bind the implementation.
To use the default implementations of Caffeine you will need the caffeine dependency and you will have to disable Caffeine module from automatically binding it in application.conf:
play.modules.disabled += "play.api.cache.caffeine.CaffeineCacheModule"
To use the default implementations of EhCache you will need the ehcache dependency and you will have to disable EhCache module from automatically binding it in application.conf:
play.modules.disabled += "play.api.cache.ehcache.EhCacheModule"