This is an example implementation of Function Objects (Wikipedia) or as it is also known, the Functor Pattern, built with Coherence.
The Functor Pattern is an extension to the Command Pattern. In fact the semantics are identical with the exception that the Functor Pattern additionally provides a mechanism to return values (or re-throw exceptions) to the Submitter (using Java 5+ Futures) where as the Command Pattern does not provide such capabilities. Consequently in order to use Functor Pattern it is highly recommended that you understand the Command Pattern.
This project (like other Coherence Incubator projects) uses Apache Ivy for dependency specification and management. While a standard ivy.xml definition file ships with the source and documentation distribution, the following diagram visually indicates the current dependencies.
The Functor Pattern provides a useful alternative to Oracle Coherence EntryProcessors with the advantage that Functors are executed asynchronously, instead of synchronously as is the case with EntryProcessors.
Changes made as a part of version 1.4.3:
Changes made as a part of version 1.4.2:
The following changes have been made since the Functor Pattern 1.4.0 release:
The following changes have been made since the Functor Pattern 1.3.0 release:
Let's start with a simple example where we use the Functor Pattern to asynchronously increment and return the value of a Counter
First, we'll start by writing a simple Counter:
Second, let's write a Functor that will increment the value of a Counter
Lastly, let's write a simple example to test our Functor.
What is the relationship between the Functor Pattern, Command Pattern, Entry Processors and the Invocation Service for performing work in a cluster?
The following table outlines the main differences.
|Functor Pattern||Command Pattern||EntryProcessors||InvocationService|
|Processing Target||A Context||A Context||A Cache Entry||A Cluster Member|
|Submission Behavior||Non-Blocking||Non-Blocking||Blocking||Blocking and Non-Blocking|
|Execution Order||Order of Submission||Order of Submission||Order of Submission (unless using PriorityTasks)||Order of Submission|
| Supports Return Values?
(and re-throwing Exceptions)
| Guaranteed to Execute?
(if Submitter terminates after submission)
|Yes||Yes||Yes (submitter blocks)||Yes (for blocking), No (for non-blocking)|
| Guaranteed to Execute?
(if Target JVM terminates during execution)
|Yes||Yes||Yes (submitter automatically retries)||No (retry up to developer)|
|Submitted requests recoverable from disk?||Yes (when using Cache Store)||Yes (when using Cache Store)||No||No|
|Request may be cancelled?||Yes||Yes||No||Yes (for non-blocking)|
Can Functors and Commands be submitted to the same Context?
Yes. Functors and Commands may be submitted for execution against the same Context. They will be executed in the order of submission from the Submitter. Further, FunctorSubmitters may be used instead of CommandSubmitters (as the FunctorSubmitter interface is a sub-interface of the CommandSubmitter interface)
How do I monitor the execution of Functors ?
As the Functor Pattern uses the Command Pattern for the internal implementation (and that is JMX enabled), all you need to do is simply enable JMX.