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 the ObservableMap 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 the PriorityTask 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 the java.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 as NamedMap, NamedCache, and Session 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.