§The Play cache API
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.
§Importing the Cache API
Play provides separate dependencies for the Cache API and for the Caffeine and Ehcache implementations.
§Caffeine
To get the Caffeine implementation, add caffeine to your dependencies list:
libraryDependencies ++= Seq(
caffeine
)This will also automatically set up the bindings for runtime DI so the components are injectable.
§EhCache
To get the EhCache implementation, add ehcache to your dependencies list:
libraryDependencies ++= Seq(
ehcache
)This will also automatically set up the bindings for runtime DI so the components are injectable.
§Custom Cache Implementation
To add only the API, add cacheApi to your dependencies list.
libraryDependencies ++= Seq(
cacheApi
)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.
§Accessing the Cache API
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:
import javax.inject.Inject
import play.api.cache._
import play.api.mvc._
class Application @Inject() (cache: AsyncCacheApi, cc: ControllerComponents) extends AbstractController(cc) {}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:
val result: Future[Done] = cache.set("item.key", connectedUser)And then retrieve it later:
val futureMaybeUser: Future[Option[User]] = cache.get[User]("item.key")There is also a convenient helper to retrieve from cache or set the value in cache if it was missing:
val futureUser: Future[User] = cache.getOrElseUpdate[User]("item.key") {
User.findById(connectedUser)
}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:
import scala.concurrent.duration._
val result: Future[Done] = cache.set("item.key", connectedUser, 5.minutes)To remove an item from the cache use the remove method:
val removeResult: Future[Done] = cache.remove("item.key")To remove all items from the cache use the removeAll method:
val removeAllResult: Future[Done] = cache.removeAll()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.
§Accessing different caches
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:
import javax.inject.Inject
import play.api.cache._
import play.api.mvc._
class Application @Inject() (
@NamedCache("session-cache") sessionCache: AsyncCacheApi,
cc: ControllerComponents
) extends AbstractController(cc) {}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.
§Configuring named caches with Caffeine
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
...
}
§Configuring named caches with EhCache
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
§Setting the execution context
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 Akka 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
}
}
}
§Caffeine
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"
...
}
§EhCache
For EhCache, Play will run any EhCache operation in a Future on a thread of the given dispatcher.
§Caching HTTP responses
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.
import javax.inject.Inject
import play.api.cache.Cached
class Application @Inject() (cached: Cached, cc: ControllerComponents) extends AbstractController(cc) {}You can cache the result of an action using a fixed key like "homePage".
def index = cached("homePage") {
Action {
Ok("Hello world")
}
}If results vary, you can cache each result using a different key. In this example, each user has a different cached result.
def userProfile = WithAuthentication(_.session.get("username")) { userId =>
cached(req => "profile." + userId) {
Action.async {
User.find(userId).map { user => Ok(views.html.profile(user)) }
}
}
}§Control caching
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.
def get(index: Int) = cached.status(_ => "/resource/" + index, 200) {
Action {
if (index > 0) {
Ok(Json.obj("id" -> index))
} else {
NotFound
}
}
}Or cache 404 Not Found only for a couple of minutes
def get(index: Int) = {
val caching = cached
.status(_ => "/resource/" + index, 200)
.includeStatus(404, 600)
caching {
Action {
if (index % 2 == 1) {
Ok(Json.obj("id" -> index))
} else {
NotFound
}
}
}
}§Custom implementations
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.
§Using Caffeine alongside your custom 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"
§Using EhCache alongside your custom implementation
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"
Found an error in this documentation? The source code for this page can be found here. After reading the documentation guidelines, please feel free to contribute a pull request. Have questions or advice to share? Go to our community forums to start a conversation with the community.