Coherence CE 21.06 Released

We are pleased to announce immediate availability of Coherence CE 21.06, the third major release since Coherence CE was open sourced in June of last year.

And what a busy year it has been… Coherence CE 21.06 contains a number of brand new features, such as Repository API, Durable Events, Non-Blocking Entry Stores, and Partition Events Logging.

Repository API

The Repository API implements Repository pattern and enables another way of accessing data stored in Coherence. It provides a higher-level API on top of the existing NamedMap API, effectively making many common data access operations one-liners. It is particularly well suited for applications that use Domain Driven Design (DDD), although it is certainly not limited only to those.

It provides both a synchronous implementation, and an asynchronous, CompletableFuture-based repository implementation, which allows you to access data managed by Coherence in a non-blocking fashion, as well as to stream potentially large result sets without incurring the cost of accumulating all the results in a single process.

The Repository API was introduced to make the implementation of data access layer within the applications easier, regardless of which framework you use to implement applications that use Coherence as a data store. It works equally well for plain Java applications and applications that use CDI, making repository implementations trivial. It is also the foundation for our Micronaut Data and Spring Data repository implementations.

Durable Events

Coherence is an observable data source, which allows client applications to observe data changes as they occur, via map listeners. Customers love this feature, and use it to implement all kinds of functionality within their applications, from basic data synchronization across processes, to sophisticated real-time updates of the application UI.

However, the client-side events, until now, have been transient in nature: if a client disconnects, it is likely that it will miss some of the events, and will only receive new events that occurred after the re-connection and subsequent event listener re-registration.

Durable Events eliminate lost events by allowing clients to replay events from a particular version, or even from the very beginning of the event stream! The memory pressure in the case of slow consumers is also reduced, as the events are persisted to disk, within the same partition that the event occurred in.

The feature is currently experimental and we do not recommend using it in production. There are a number of enhancements that we will be working on in the upcoming releases to make this feature production grade, including persistent backups, Extend and gRPC client support, and configurable retention polices.

However, we encourage you to try it out and provide feedback that will allow us to make it rock solid and production-ready for one of the upcoming releases.

Non-Blocking Entry Stores

Coherence supports integration with other data sources via cache or entry stores, allowing you to lazily load data into Coherence from an external system of record, and to update the external system whenever the data in Coherence itself changes.

Most backend systems that you would want to integrate with have traditionally provided only blocking APIs, so the existing entry store contracts are tailored for that use case and assume that a blocking API is used to both load and store the data, tying up Coherence worker threads in the process.

However, in recent years many of these traditional data stores have added support for reactive and non-blocking APIs, and systems that are non-blocking by their very nature, such as Apache Kafka, have become increasingly popular, making traditional Coherence contracts for interfacing with external systems less than ideal.

Coherence CE 21.06 allows you to implement non-blocking entry stores that seamlessly integrate with modern, non-blocking data stores. This eliminates the overhead of queuing writes, and frees up Coherence worker threads to perform other tasks.

We hope you’ll find the new features useful, and that they will make implementation of your Coherence applications even easier. For more details on each of the features above, check out the latest documentation.

There were also a number of improvements and bug fixes that went into 21.06 release. One standout is the significant refactoring of the Topics feature, which now allow you to explicitly acknowledge messages as processed by committing the offsets, making the usage easier for anyone who is familiar with Apache Kafka. Unfortunately, this required a breaking change, so Topics in 21.06 are not backwards compatible with the implementation in older releases, and the rolling upgrade across Coherence versions is not supported.

For the complete list of bug fixes and improvements, please refer to the release notes on GitHub.