Home
/
Middleware
/
Oracle Coherence
1/41
Contents
List of Examples
List of Figures
List of Tables
Title and Copyright Information
Preface
Audience
Documentation Accessibility
Related Documents
Conventions
What's New in This Guide
New and Changed Features for 12
c
(12.1.2)
Other Significant Changes in This Document for 12
c
(12.1.2)
Part I Getting Started
1
Introduction to Coherence*Extend
1.1
Overview of Coherence*Extend
1.2
Types Of Clients
1.2.1
Data Clients
1.2.2
Real Time Clients
1.3
Client APIs
1.4
POF Serialization
1.5
Understanding Client Configuration Files
2
Installing a Client Distribution
2.1
Installing Coherence for Java
2.2
Installing the C++ Client Distribution
2.2.1
Supported Environments
2.2.2
Microsoft-Specific Requirements
2.2.3
Extracting the Coherence for C++ Distribution
2.3
Installing the .NET Client Distribution
2.3.1
Prerequisites
2.3.2
Running the Installer
2.3.3
Coherence .NET Version Number Mapping
2.3.4
Deploying Coherence for .NET
2.4
Compatibility Between Coherence*Extend Versions
3
Building Your First Extend Client
3.1
Overview of the Extend Example
3.2
Step 1: Configure the Cluster Side
3.3
Step 2: Configure the Client Side
3.4
Step 3: Create the Sample Client
3.5
Step 4: Start the Cache Server Process
3.6
Step 5: Run the Application
4
Setting Up Coherence*Extend
4.1
Overview
4.2
Configuring the Cluster Side
4.2.1
Setting Up Extend Proxy Services
4.2.1.1
Defining a Proxy Service
4.2.1.2
Defining Multiple Proxy Service Instances
4.2.1.3
Defining Multiple Proxy Services
4.2.1.4
Disabling Cluster Service Proxies
4.2.1.5
Specifying Read-Only NamedCache Access
4.2.1.6
Specifying NamedCache Locking
4.2.2
Defining Caches for Use By Extend Clients
4.2.3
Disabling Storage on a Proxy Server
4.3
Configuring the Client Side
4.3.1
Defining a Remote Cache
4.3.2
Using a Remote Cache as a Back Cache
4.3.3
Defining Remote Invocation Schemes
4.3.4
Defining Multiple Remote Addresses
4.3.5
Detecting Connection Errors
4.3.6
Disabling TCMP Communication
4.4
Using Address Provider References for TCP Addresses
4.5
Using the Name Service Acceptor to Connect to a Proxy
4.6
Using a Custom Address Provider for TCP Addresses
4.7
Load Balancing Connections
4.7.1
Using Proxy-Based Load Balancing
4.7.1.1
Understanding the Proxy-Based Load Balancing Default Algorithm
4.7.1.2
Implementing a Custom Proxy-Based Load Balancing Strategy
4.7.2
Using Client-Based Load Balancing
4.8
Using Network Filters with Extend Clients
5
Best Practices for Coherence*Extend
5.1
Run Proxy Servers with Local Storage Disabled
5.2
Do Not Run a Near Cache on a Proxy Server
5.3
Configure Heap NIO Space to be Equal to the Max Heap Size
5.4
Configure Proxy Service Thread Pooling
5.4.1
Understanding Proxy Service Threading
5.4.2
Setting Proxy Service Thread Pooling Thresholds
5.4.3
Setting an Exact Number of Threads
5.5
Be Careful When Making InvocationService Calls
5.6
Be Careful When Placing Collection Classes in the Cache
5.7
Configure POF Serializers for Cache Servers
5.8
Use Node Locking Instead of Thread Locking
Part II Creating Java Extend Clients
Part III Creating C++ Extend Clients
6
Setting Up C++ Application Builds
6.1
Setting up the Compiler for Coherence-Based Applications
6.2
Including Coherence Header Files
6.3
Linking the Coherence Library
6.4
Setting the run-time Library and Search Path
6.5
Deploying Coherence for C++
7
Configuration and Usage for C++ Clients
7.1
General Instructions
7.2
Implementing the C++ Application
7.3
Compiling and Linking the Application
7.4
Configure Paths
7.5
Configure Coherence*Extend
7.5.1
Configure Coherence*Extend in the Cluster
7.5.2
Configuring Coherence*Extend on the Client
7.5.2.1
Defining a Local Cache for C++ Clients
7.5.2.2
Defining a Near Cache for C++ Clients
7.5.3
Connection Error Detection and Failover
7.6
Obtaining a Cache Reference with C++
7.7
Cleaning up Resources Associated with a Cache
7.8
Configuring and Using the Coherence for C++ Client Library
7.8.1
Setting the Configuration File Location with an Environment Variable
7.8.2
Setting the Configuration File Location Programmatically
7.9
Operational Configuration File (tangosol-coherence-override.xml)
7.10
Configuring a Logger
7.11
Launching a Coherence DefaultCacheServer Proxy
8
Using the Coherence C++ Object Model
8.1
Using the Object Model
8.1.1
Coherence Namespaces
8.1.2
Understanding the Base Object
8.1.3
Automatically Managed Memory
8.1.3.1
Referencing Managed Objects
8.1.3.2
Using handles
8.1.3.3
Managed Object Instantiation
8.1.4
Managed Strings
8.1.4.1
String Instantiation
8.1.4.2
Auto-Boxed Strings
8.1.5
Type Safe Casting
8.1.5.1
Down Casting
8.1.6
Managed Arrays
8.1.7
Collection Classes
8.1.8
Managed Exceptions
8.1.9
Object Immutability
8.1.10
Integrating Existing Classes into the Object Model
8.2
Writing New Managed Classes
8.2.1
Specification-Based Managed Class Definition
8.2.2
Equality, Hashing, Cloning, Immutability, and Serialization
8.2.3
Threading
8.2.4
Weak References
8.2.5
Virtual Constructors
8.2.6
Advanced Handle Types
8.2.7
Thread Safety
8.2.7.1
Synchronization and Notification
8.2.7.2
Thread Safe Handles
8.2.7.3
Escape Analysis
8.2.7.4
Thread-Local Allocator
8.3
Diagnostics and Troubleshooting
8.3.1
Thread Dumps
8.3.2
Memory Leak Detection
8.3.3
Memory Corruption Detection
8.4
Application Launcher - Sanka
8.4.1
Command line syntax
8.4.2
Built-in Executables
8.4.3
Sample Custom Executable Class
9
Using the Coherence for C++ Client API
9.1
CacheFactory
9.2
NamedCache
9.3
QueryMap
9.4
ObservableMap
9.5
InvocableMap
9.6
Filter
9.7
Value Extractors
9.8
Entry Processors
9.9
Entry Aggregators
10
Building Integration Objects (C++)
10.1
Overview of Building Integration Objects (C++)
10.2
POF Intrinsics
10.3
Serialization Options
10.3.1
Managed<T> (Free-Function Serialization)
10.3.2
PortableObject (Self-Serialization)
10.3.3
PofSerializer (External Serialization)
10.4
Using POF Object References
10.4.1
Enabling POF Object References
10.4.2
Registering POF Object Identities for Circular and Nested Objects
10.5
Registering Custom C++ Types
10.6
Implementing a Java Version of a C++ Object
10.7
Understanding Serialization Performance
10.8
Using POF Annotations to Serialize Objects
10.8.1
Annotating Objects for POF Serialization
10.8.2
Registering POF Annotated Objects
10.8.3
Enabling Automatic Indexing
10.8.4
Providing a Custom Codec
11
Querying a Cache (C++)
11.1
Overview of Query Functionality
11.2
Performing Simple Queries
11.2.1
Querying Partitioned Caches
11.2.2
Querying Near Caches
11.3
Understanding Query Concepts
11.4
Performing Queries Involving Multi-Value Attributes
11.5
Using a Chained Extractor in a Query
11.6
Using a Query Recorder
12
Performing Continuous Queries (C++)
12.1
Overview of Performing Continuous Queries (C++)
12.1.1
Understanding the Use Cases for Continuous Query Caching
12.2
Understanding Continuous Query Caching Implementation
12.3
Defining a Continuous Query Cache
12.4
Cleaning up Continuous Query Cache Resources
12.5
Caching Only Keys Versus Keys and Values
12.5.1
CacheValues Property and Event Listeners
12.5.2
Using ReflectionExtractor with Continuous Query Caches
12.6
Listening to a Continuous Query Cache
12.6.1
Avoiding Unexpected Results
12.6.2
Achieving a Stable Materialized View
12.6.3
Support for Synchronous and Asynchronous Listeners
12.7
Making a Continuous Query Cache Read-Only
13
Performing Remote Invocations (C++)
13.1
Overview of Performing Remote Invocations (C++)
13.2
Configuring and Using the Remote Invocation Service
13.3
Registering Invocable Implementation Classes
14
Using Cache Events (C++)
14.1
Overview of Map Events (C++)
14.1.1
Caches and Classes that Support Events
14.2
Signing Up for all Events
14.3
Using a Multiplexing Map Listener
14.4
Configuring a MapListener for a Cache
14.5
Signing Up for Events on Specific Identities
14.6
Filtering Events
14.7
Using Lite Events
14.8
Listening to Queries
14.9
Using Synthetic Events
14.10
Using Backing Map Events
14.11
Using Synchronous Event Listeners
15
Performing Transactions (C++)
15.1
Using the Transaction API within an Entry Processor
15.2
Creating a Stub Class for a Transactional Entry Processor
15.3
Registering a Transactional Entry Processor User Type
15.4
Configuring the Cluster-Side Transactional Caches
15.5
Configuring the Client-Side Remote Cache
15.6
Using a Transactional Entry Processor from a C++ Client
Part IV Creating .NET Extend Clients
16
Configuration and Usage for .NET Clients
16.1
General Instructions
16.2
Configuring Coherence*Extend
16.2.1
Configuring Coherence*Extend in the Cluster
16.2.2
Configuring Coherence*Extend on the Client
16.2.2.1
Defining a Local Cache for .NET Clients
16.2.2.2
Defining a Near Cache for .NET Clients
16.2.3
Connection Error Detection and Failover
16.3
Starting a Coherence DefaultCacheServer Process
16.4
Obtaining a Cache Reference with .NET
16.5
Cleaning Up Resources Associated with a Cache
16.6
Using Network Filters
16.6.1
Custom Filters
16.6.2
Configuring Filters
17
Building Integration Objects (.NET)
17.1
Overview of Building Integration Objects (.NET)
17.2
Creating an IPortableObject Implementation
17.3
Implementing a Java Version of a .NET Object
17.3.1
Creating a PortableObject Implementation (Java)
17.4
Registering Custom Types on the .NET Client
17.5
Registering Custom Types in the Cluster
17.6
Evolvable Portable User Types
17.7
Making Types Portable Without Modification
17.8
Using POF Object References
17.8.1
Enabling POF Object References
17.8.2
Registering POF Object Identities for Circular and Nested Objects
17.9
Using POF Annotations to Serialize Objects
17.9.1
Annotating Objects for POF Serialization
17.9.2
Registering POF Annotated Objects
17.9.3
Enabling Automatic Indexing
17.9.4
Providing a Custom Codec
18
Using the Coherence .NET Client Library
18.1
Setting Up the Coherence .NET Client Library
18.2
Using the Coherence .NET APIs
18.2.1
CacheFactory
18.2.2
IConfigurableCacheFactory
18.2.3
DefaultConfigurableCacheFactory
18.2.4
Logger
18.2.5
Using the Common.Logging Library
18.2.6
INamedCache
18.2.7
IQueryCache
18.2.8
QueryRecorder
18.2.9
IObservableCache
18.2.9.1
Responding to Cache Events
18.2.10
IInvocableCache
18.2.11
Filters
18.2.12
Value Extractors
18.2.13
Entry Processors
18.2.14
Entry Aggregators
19
Performing Continuous Queries (.NET)
19.1
Overview of Performing Continuous Queries (.NET)
19.1.1
Understanding Use Cases for Continuous Query Caching
19.2
Understanding the Continuous Query Caching Implementation
19.3
Constructing a Continuous Query Cache
19.4
Cleaning Up Continuous Query Cache Resources
19.5
Caching Only Keys Versus Keys and Values
19.6
Listening to a Continuous Query Cache
19.6.1
Achieving a Stable Materialized View
19.6.2
Support for Synchronous and Asynchronous Listeners
19.7
Making a Continuous Query Cache Read-Only
20
Performing Remote Invocations (.NET)
20.1
Overview of Performing Remote Invocations
20.2
Configuring and Using the Remote Invocation Service
21
Performing Transactions (.NET)
21.1
Using the Transaction API within an Entry Processor
21.2
Creating a Stub Class for a Transactional Entry Processor
21.3
Registering a Transactional Entry Processor User Type
21.4
Configuring the Cluster-Side Transactional Caches
21.5
Configuring the Client-Side Remote Cache
21.6
Using a Transactional Entry Processor from a .NET Client
22
Managing ASP.NET Session State
22.1
Overview
22.2
Setting Up Coherence Session Management
22.2.1
Enable the Coherence Session Provider
22.2.2
Configure the Cluster-Side ASP Session Caches
22.2.3
Configure a Client-Side ASP Session Remote Cache
22.2.4
Overriding the Default Session Cache Name
22.3
Selecting a Session Model
22.3.1
Specify the Session Model
22.3.1.1
Registering the Backing Map Listener
22.4
Specifying a Serializer
22.4.1
Using POF for Session Serialization
22.5
Sharing Session State Across Applications
Part V Using Coherence REST
23
Introducing Coherence REST
23.1
Overview of Coherence REST
23.2
Dependencies for Coherence REST
23.3
Overview of Configuration for Coherence REST
23.4
Understanding Data Format Support
23.4.1
Using XML as the Data Format
23.4.2
Using JSON as the Data Format
23.5
Authenticating and Authorizing Coherence REST Clients
24
Building Your First Coherence REST Application
24.1
Overview of the Coherence REST Example
24.2
Step 1: Configure the Cluster Side
24.3
Step 2: Create a User Type
24.4
Step 3: Configure REST Services
24.5
Step 4: Start the Cache Sever Process
24.6
Step 5: Access REST Services From a Client
25
Performing Grid Operations with REST
25.1
Specifying Key and Value Types
25.2
Performing Single-Object REST Operations
25.3
Performing Multi-Object REST Operations
25.4
Performing Partial-Object REST Operations
25.5
Performing Queries with REST
25.5.1
Using Direct Queries
25.5.2
Using Named Queries
25.5.3
Specifying a Query Sort Order
25.5.4
Limiting the Size of a Query
25.5.5
Retrieving Only Keys
25.5.6
Using Custom Query Engines
25.5.6.1
Implementing Custom Query Engines
25.5.6.2
Enabling Custom Query Engines
25.6
Performing Aggregations with REST
25.6.1
Aggregation Syntax for REST
25.6.2
Listing of Pre-Defined Aggregators
25.6.3
Creating Custom Aggergators
25.7
Performing Entry Processing with REST
25.7.1
Entry Processor Syntax for REST
25.7.2
Listing of Pre-defined Entry Processors
25.7.3
Creating Custom Entry Processors
25.8
Understanding Concurrency Control
25.9
Specifying Cache Aliases
26
Deploying Coherence REST
26.1
Deploying with the Embedded HTTP Server
26.2
Deploying to WebLogic Server
26.2.1
Task 1: Configure a WebLogic Server Domain for Coherence REST
26.2.2
Task 2: Package the Coherence REST Web Application
26.2.3
Task 3: Package the Coherence Application
26.2.4
Task 4: Package the Enterprise Application
26.2.5
Task 5: Deploy the Enterprise Application
26.3
Deploying to a Java EE Server (Generic)
26.3.1
Packaging Coherence REST for Deployment
26.3.2
Deploying to GlassFish
26.3.3
Deploying to a Servlet Container
27
Modifying the Default REST Implementation
27.1
Using Custom Providers and Resources
27.2
Changing the Embedded HTTP Server
27.2.1
Using Grizzly HTTP Server
27.2.2
Using Simple HTTP Server
A
REST Configuration Elements
A.1
REST Configuration File
Element Reference
aggregator
aggregators
engine
marshaller
processor
processors
query
query-engines
resource
resources
rest
B
Integrating with F5 BIG-IP LTM
B.1
Basic Concepts
B.2
Creating Nodes
B.3
Configuring a Load Balancing Pool
B.3.1
Creating a Load Balancing Pool
B.3.2
Adding a Load Balancing Pool Member
B.4
Configuring a Virtual Server
B.5
Configuring Coherence*Extend to Use BIG-IP LTM
B.6
Using Advanced Health Monitoring
B.6.1
Creating a Custom Health Monitor to Ping Coherence
B.6.2
Associating a Custom Health Monitor With a Load Balancing Pool
B.7
Enabling SSL Offloading
B.7.1
Import the Server's SSL Certificate and Key
B.7.2
Create the Client SSL Profile
B.7.3
Associate the Client SSL Profile
Scripting on this page enhances content navigation, but does not change the content in any way.