The technology field is home to an unpredictable and ever changing landscape. Something heralded as an “industry game changer” today can be reduced to little more than an afterthought in just a few years’ time. Alternatively, other tech that is brushed aside as nothing more than a novelty item can quickly bloom into a massive business. Since no one can accurately predict what will succeed, and what will fail, it’s important to keep up to date on the new technology.
We all know that time is money and when repeatable transactions take up a bulk of system resources, your business could be losing cash. If this is your situation, now is the time to save that cash with cache. There are many variations of cache implementation but in general, a caching mechanism stores the result of system operations from a request so those operations are not repeated when the same request happens again. This saves companies both time and system resources.
There are many technology options for key value pair cache implementations which do save time and resources when dealing with simple topologies and data processing requirements. These solutions fall short when it comes to complex environments with large data caching and processing requirements. Enter Oracle’s Coherence In-Memory Data Grid.
Simple to Complex Caching
Oracle Coherence supports simple caching of objects, but it’s also able to cache a multitude of data sources. Coherence supports transparent read/write caching of any data source, including databases, web services, packaged applications and file systems; however, databases are the most common in use. This is achieved by using Cache Stores that are configured to use your custom, written interface to the data source you choose to cache.
Simple to Complex Environments
Oracle Coherence provides configuration options that satisfy requirements from very simple, single instance applications, to large, clustered environments. Applications that are deployed in clustered environments need to have the ability to access cached objects from each application instance, on every cluster node. This can provide a synchronization challenge when the cached object is changed by one of the application instances. Developers using a simple cache mechanism may be required to create processes that detect cache changes and then distribute that change to the other cache instances throughout the cluster. Coherence solves this issue by managing cache changes dynamically as they happen. In a replicated configuration, Coherence will automatically push cache object changes to the other coherence nodes. In a distributed configuration, Coherence eliminates the need to push changes to all nodes because the cached object only resides on one primary node, as well as that node’s defined backup.
Oracle Coherence also supports configuration of tiered caches. As an example, an application can have access to a “near” cache living in the same JVM, but is configured to be backed by a remote cache that is part of a completely different cache cluster and JVM. When memory size might be an issue on the application JVM, this configuration allows the near cache size to be controlled differently from the remote cache.
Coherence will also manage the migration of cached objects to other nodes in the cluster when a node fails. This operation happens with no human intervention, preserving continuous availability.
In Cache Data Processing
In addition to retrieving data from cache, consider the time and resource savings when processing is pushed to the data, instead of the other way around. Oracle Coherence supports “in cache” data processing where you pass “agents” to a Coherence map to perform targeted, parallel and query-based processing. For many processing purposes, it is much more efficient to move the serialized form of the agent (at most a few hundred bytes) than to handle distributed concurrency control, coherency and data updates.
- Targeted Processing – Coherence provides for the ability to execute an agent against an entry in any map of data managed by a data grid. In the case of partitioned data, the agent executes on the grid node that owns the data.
- Parallel Processing – Coherence provides map-reduce functionality, which allows agents to be executed in parallel against a collection of entries across all nodes in the grid. Parallel execution allows large amounts of data to be processed by balancing the work across the grid.
- Query Based Processing – Coherence supports the ability to query across the entire data grid.
Coherence also supports entry aggregators that perform operations against a subset of entries to obtain a single result. Entry aggregation occurs in parallel across the grid to provide map-reduce support when working with large amounts of data.
In addition to the above, Oracle Coherence provides these high level features:
- Coherence Management Options (Basic JMX or Oracles Coherence Management Pack for Enterprise Manager Cloud Control)
- CohQL query language
- Java, C++ and .Net integration
- Remote cache access (Coherence*Extend)
- HTTP Session Management (Coherence*Web)
- Support for JPA, Hibernate, Spring
- 12c introduces support for JSR-107 JCACHE
In conclusion, Oracle’s Coherence In-Memory Data Grid is a robust, flexible solution for many scenarios and comes in three different editions to support your specific implementation needs. This post highlights only a few of the capabilities but should help provide some insight to Coherence and how it might be used.