play.cache.AsyncCacheApi is bound to JavaRedis instead of DefaultAsyncCacheApi
to fixed value deserialization and support Java HTTP context #140.
Fixed missing binding of play.api.cache.AsyncCacheApi #135.
Introduced support of Redis Cluster in #84.
Implemented increment in maps #112.
Support of named caches #114
Introduced prefix configuration property to apply a namespace on all keys in
the cache instance #118.
Simplified RedisCacheModule and RedisCacheComponents. Internal components are no longer
published, removed Binder class, introduced RedisInstanceProvider instead. Introduced RedisInstanceResolver
and RecoveryPolicyResolver to provide custom implementations. Introduced RedisCaches handler
encapsulating all APIs to a single named cache. #122
Created Wiki with more detailed and structured documentation.
Revamped configuration as a consequence of named cache integration #114. Some properties were removed, instance configuration is now more direct, named caches are supported. See Migration Guide for more details.
Introduced InvocationPolicy implementing Eager and Lazy invocation mechanism handling waiting
for the result of the set operation. Lazy policy (default) does wait for the result, Eager does
not wait and ignores it instead #98.
JavaRedis preserves Http.Context #130.
Introduced support of Redis Cluster in #84.
Implemented increment in maps #112.
Fixed #102, preserved original
exception if extends RedisException and fixed wrong parameters in error messages
Scredis connector replaced by Rediscala implementation due to repository inactivity, no release management, missing support of cluster, and unreleased support of Scala 2.12.
Due to changes in the connector, there are slightly relaxed constraints
of return values in both CacheApi and CacheAsyncApi. For example,
some operations instead of List return Seq and instead of Set also
return Seq. This change was introduced to avoid possibly unnecessary
collection conversion inside the play-redis.
Changed return type Unit in AbstractCacheApi to akka.Done with the same meaning but
but better signalizing the intention.
Cross-compiled for Scala 2.11 and Scala 2.12.
Fixed #102, preserved original
exception if extends RedisException and fixed wrong parameters in error messages
Fixed minor issues #83 and #85.
Implemented RedisCacheComponents to support compile-time DI
Implemented MGET, MSET and MSETNX redis commands.
Exposed RedisConnector, it is publicaly available for injection now.
🔗 1.3.0 (Possibly breaking)
Major internal code refactoring, library has been modularized into several packages. However, public API remained unchanged, although its implementation significantly changed.
Implemented Scala wrapper over List API to use Redis Lists.
Implemented Scala wrapper over Set API to use Redis Sets.
Implemented Scala wrapper over Map API to use Redis Hashes.
Added heroku and heroku-cloud configuration profiles simplifying running on Heroku.
Introduced RecoveryPolicy defining behavior when execution fails. Default
policy is log-and-default. To re-enable previous fail-on-error behavior, set log-and-fail.
See the RecoveryPolicy for more details.
Brando connector replaced by scredis implementation due to Brando repository inactivity and major issues (#44). Scredis seems to be efficient, build over Akka and should not contain any major issues as they are not reported.
Play-redis provides native serialization support to basic data types such as String, Int, etc.
However, for other objects including collections, it used to use default JavaSerializer serializer.
Since Akka 2.4.1, default JavaSerializer is officially considered inefficient for production use.
Nevertheless, to keep things simple, play-redis still uses this inefficient serializer NOT to enforce any serialization
library to end users. Although, it recommends kryo serializer claiming
great performance and small output stream. Any serialization library can be smoothly connected through Akka
configuration, see the official Akka documentation.
This release is focused on library refactoring. While public API remained unchanged, there are several significant
changes to their implementations. Those are consequences of refactoring some functionality into self-standing
units. For example, there has been extracted RedisConnector implementing the Redis protocol
and RedisCache implementing cache API over that. Before, it was tangled together. As consequence, the library has
now layered architecture (facades -> cache implementation -> protocol implementation) with several public facades.
Update to Play 2.5, no significant changes
Redesigned the library from scratch to support Play 2.4.x API and use DI.