Developing Remote Clients for Oracle Coherence
Table of Contents
Show All | Collapse- List of Examples
- List of Figures
- List of Tables
- Title and Copyright Information
- Preface
- What's New in This Guide
- Part I Getting Started
- 1 Introduction to Coherence*Extend
- 2 Installing a Client Distribution
- 3 Building Your First Extend Client
- 4 Setting Up Coherence*Extend
- 4.1 Overview
- 4.2 Configuring the Cluster Side
- 4.3 Configuring the Client Side
- 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.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.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
- 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.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.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
- 9 Using the Coherence for C++ Client API
- 10 Building Integration Objects (C++)
- 10.1 Overview of Building Integration Objects (C++)
- 10.2 POF Intrinsics
- 10.3 Serialization Options
- 10.4 Using POF Object References
- 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
- 11 Querying a Cache (C++)
- 12 Performing Continuous Queries (C++)
- 12.1 Overview of Performing Continuous Queries (C++)
- 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.6 Listening to a Continuous Query Cache
- 12.7 Making a Continuous Query Cache Read-Only
- 13 Performing Remote Invocations (C++)
- 14 Using Cache Events (C++)
- 14.1 Overview of Map Events (C++)
- 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
- 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.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.9 Using POF Annotations to Serialize Objects
- 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.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.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.7 Making a Continuous Query Cache Read-Only
- 20 Performing Remote Invocations (.NET)
- 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
- Part V Using Coherence REST
- 23 Introducing Coherence REST
- 24 Building Your First Coherence REST Application
- 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.6 Performing Aggregations with REST
- 25.7 Performing Entry Processing with REST
- 25.8 Understanding Concurrency Control
- 25.9 Specifying Cache Aliases
- 26 Deploying Coherence REST
- 27 Modifying the Default REST Implementation
- A REST Configuration Elements
- B Integrating with F5 BIG-IP LTM