Part V Performing Data Grid Operations
Learn how to interact with Coherence caches, serialize data using POF, query cache data, process and aggregate cache data, handle events, and perform transactions.
Part V contains the following chapters:
- Introduction to Coherence Programming
Read through a list of essential Coherence Java APIs and learn about Coherence support for generics, lambdas, streams, and default methods. - Performing Basic Cache Operations
You can use the Coherence APIs to perform basic cache operations. - Performing Basic Topic Publish and Subscribe Operations
You can use the Coherence APIs to perform basic topic publish and subscribe operations. - Using Portable Object Format
You can use Portable Object Format (POF) to serialize Java objects for use in Coherence. - Querying Data in a Cache
You can perform queries and use indexes to retrieve data in a cache that matches certain criteria. - Using Continuous Query Caching
You can use continuous query caching to ensure that a query always retrieves the latest results from a cache in real-time. - Processing Data In a Cache
You can use entry processors and aggregators to perform data grid processing across a cluster. - Using Map Events
You can use map event listeners to receive cache events and events from any class in Coherence that implements theObservableMap
interface. - Controlling Map Operations with Triggers
You can use map triggers to validate, reject, or modify map operations before a change is committed to a map entry. - Using Live Events
You can be notified of events using event interceptors. - Using Coherence Query Language
You can use Coherence Query Language (CohQL) to interact with Coherence caches. - Performing Transactions
Coherence provides several transaction and data concurrency features that can be used as required. - Working with Partitions
You can use data affinity with Coherence and also change the default partition setup. - Managing Thread Execution
You can control the execution behavior of Coherence service threads using task timeouts and thePriorityTask
API for custom execution processing. - Constraints on Re-Entrant Calls
There are constraints on service re-entrant calls and guidelines for making calls between service threads. - Using Timeout with Cache Operations
When many threads access Coherence caches concurrently, callers to Coherence cache operations can be blocked on common locks. This blockage may lead to the accumulation of stuck threads. To help avoid these stuck threads, Coherence uses an interruptible lock so operations can be interrupted after a specified timeout interval. - Using the Repository API
Coherence Repository API provides a higher-level, DDD-friendly way to access data managed in Coherence. - Implementing Concurrency in a Distributed Environment
The Coherence Concurrent module provides distributed implementations of the concurrency primitives from thejava.util.concurrent
package such as executors, atomics, locks, semaphores, and latches. - Using Contexts and Dependency Injection
Coherence provides support for Contexts and Dependency Injection (CDI) within the Coherence cluster members. This feature enables you to inject Coherence-managed resources, such asNamedMap
,NamedCache
, andSession
instances into CDI managed beans; to inject CDI beans into Coherence-managed resources, such as event interceptors and cache stores; and to handle Coherence server-side events using the CDI observer methods.