Understanding the Session Interface and the CacheFactory Class

The Session interface and the CacheFactory class are the main entry point for Coherence applications. Both APIs are used to manage NamedCache instances and are most often used for creating, releasing, and destroying cache instances. See Getting a Cache Instance.

Understanding the NamedCache Interface

A NamedCache is a Map implementation that holds resources that are shared among members of a cluster. The resources are expected to be managed in memory and are typically composed of data that are often stored persistently in a database or data that have been assembled or calculated at some significant cost.

The NamedCache interface provides many methods for performing cache operations and extends many different Map operations that add features for querying cache, processing cache entries, registering listeners for cache events, and controlling concurrent access to cache entries.

The AsyncNamedCache interface is an asynchronous version of the NamedCache Interface. The interface makes use of the CompleteableFuture API from the Java java.util.concurrent package to asynchronously perform cache operations.

See Performing Basic Cache Operations.

API for Queries

The QueryMap interface provides the ability to query a cache using various filters that operate on values that are extracted from cache entries. The interface also includes the ability to add and remove indexes. Indexes are used to correlate values stored in the cache to their corresponding keys and can dramatically increase performance. See Querying Data in a Cache.

API for Cache Processing

The InvocableMap interface provides the ability to invoke both entry-targeted processing and aggregating operations on a cache. The operations against the cache contents are executed by (and thus within the localized context of) a cache. This is particularly useful in a distributed environment, because it enables the processing to be moved to the location at which the entries-to-be-processed are being managed, thus providing efficiency by localization of processing.

An entry processor is an agent that operates against the entry objects within a cache. Coherence includes many predefined entry processors that can be used to perform many common operations. The processors are defined in the com.tangosol.util.processor package.

An entry aggregator represents processing that can be directed to occur against some subset of the entries resulting in an aggregated result. Common examples of aggregation include functions such as minimum, maximum, sum and average. However, the concept of aggregation applies to any process that must evaluate a group of entries to come up with a single answer. Aggregation is explicitly capable of being run in parallel in a distributed environment.

See Processing Data In a Cache.

API for Events

Coherence provides two programming models for processing events. The ObservableMap interface enables an application to receive events when the contents of a cache changes. To register interest in change events, an application adds a Listener implementation to the cache that receives events that include information about the event type (inserted, updated, deleted), the key of the modified entry, and the old and new values of the entry. See Using Map Events.

The live event model uses event interceptors to listen for specific events that occur within the cluster. The interceptors are created specific to the event types and can be chained together. Event types are defined for partitioned cache and server events, lifecycle events, and federated caching events. See Using Live Events.

API for Transactions

Coherence offers various transaction options that provide different transaction guarantees. The ConcurrentMap API is locking API that provides explicit locking. Entry processors also provide a lock-free programming model that minimizes contention and latency and improves system throughput, without compromising the fault-tolerance of data operations. Lastly the Transaction Framework API is a connection-based API that provides atomic transaction guarantees across partitions and caches even with a client failure. See Performing Transactions.

Serialization in Coherence

Coherence caches value objects. These objects may represent data from any source, either internal (such as session data, transient data, and so on) or external (such as a database, mainframe, and so on).

Objects placed in the cache must be serializable. Because serialization is often the most expensive part of clustered data management, Coherence provides different options for serializing/deserializing data:

• com.tangosol.io.pof.PofSerializer – The Portable Object Format (also referred to as POF) is a language agnostic binary format. POF was designed to be efficient in both space and time and is the recommended serialization option in Coherence. See Using Portable Object Format.

• java.io.Serializable – The simplest, but slowest option.

• java.io.Externalizable – This option requires developers to implement serialization manually, but can provide significant performance benefits. As compared to java.io.Serializable, serialized data sizes can be minimized by a factor of two or more. Smaller data sizes is especially helpful with Distributed caches, as they generally cache data in serialized form. Most importantly, CPU usage is dramatically reduced.

• com.tangosol.io.ExternalizableLite – This option is very similar to java.io.Externalizable, but offers better performance and less memory usage by using a more efficient I/O stream implementation.

• com.tangosol.run.xml.XmlBean – A default implementation of ExternalizableLite.