Oracle Coherence 3.5

Table of Contents

• Preface

• Chapter 1: Achieving Performance, Scalability, and Availability Objectives
  • Achieving performance objectives
    • Dealing with latency
    • Minimizing bandwidth usage
    • Coherence and performance
  • Achieving scalability
    • Stateless services do not exist
    • Scaling a database is hard
    • Database scale-out approaches
      • Master-slave replication
      • Database clustering
      • Database sharding
    • Return of the state
    • Using Coherence to reduce database load
      • Coherence and master-slave databases
      • Coherence and database clusters
      • Coherence and database sharding
    • Coherence and scalability
  • Achieving high availability
    • Adding redundancy to the system
    • Redundancy is not enough
    • Coherence and availability
  • Putting it all together
    • Design for performance and scalability
    • Set performance goals at each level
    • Measure and monitor
    • Educate your team
  • Summary

• Chapter 2: Getting Started
  • Installing Coherence
  • What's in the box?
  • Starting up the Coherence cluster
    • Troubleshooting cluster start-up
      • Multicast issues
      • Binding issues
  • Accessing the data grid
    • Coherence console
      • Creating caches
      • Working with the cache
    • Configuring the development environment
      • Referencing necessary JAR files
      • Enabling IntelliSense for configuration files
      • Starting Coherence nodes within the IDE
      • Creating a private cluster
    • Configuring Coherence
      • Operational configuration
      • Configuring logging
      • Configuring a private cluster
    • Using the Coherence API
      • The basics: NamedCache and CacheFactory
      • The "Hello World" example
      • Coherence API in action: Implementing the cache loader
  • Testing and debugging Coherence applications
  • Summary

• Chapter 3: Planning Your Caches
  • Anatomy of a clustered cache
  • Clustered cache topologies
    • Replicated Cache service
      • Read performance
      • Write performance
      • Data set size
      • Fault tolerance
      • When to use it?
    • Partitioned Cache service
      • Read performance
      • Write performance
      • Data set size
      • Fault tolerance
      • When to use it?
    • Near cache
      • Near cache invalidation strategies
      • When to use it?
    • Continuous Query Cache
  • Backing maps
    • Local cache
    • External backing map
    • Paged external backing map
    • Overflow backing map
    • Read-write backing map
    • Partitioned backing map
  • Cache configuration
    • Caching schemes
      • Distributed cache scheme
      • Local cache scheme
      • Near cache scheme
      • Read-write backing map scheme
      • Partitioned backing map
      • Partitioned read-write backing map
    • Cache mappings
    • Sample cache configuration
  • Summary

• Chapter 4: Implementing Domain Objects
  • Introducing the Coherent Bank sample application
    • Coherent Bank requirements
    • Coherent Bank domain model
  • Domain model building blocks
    • Entities and aggregates
      • Implementing entities
    • Value objects
      • Implementing the Money value object
      • Value objects as identifiers
    • Services
      • Implementing the CurrencyConverter service
    • Factories
    • Repositories
  • Implementing object serialization
    • POF basics
    • POF context
      • ConfigurablePofContext
    • Implementing serialization code
    • PortableObject or PofSerializer?
    • Collection serialization with POF
  • Adding support for schema evolution
    • Implementing Evolvable objects
    • Implementing serialization for Evolvable objects
  • Summary

• Chapter 5: Querying the Data Grid
  • Built-in filters
  • Value extractors
    • Reflection extractor
    • Other built-in value extractors
      • IdentityExtractor
      • ChainedExtractor and MultiExtractor
      • PofExtractor
    • Implementing a custom value extractor
  • Simplifying Coherence queries
    • Filter builder
  • Obtaining query results
    • Controlling query scope using data affinity
    • Querying near cache
    • Sorting the results
    • Paging over query results
  • Using indexes to improve query performance
    • Anatomy of an Index
    • Creating indexes
  • Coherence query limitations
  • Aggregators
    • Built-in aggregators
    • Using aggregators
    • Implementing LookupValuesAggregator
  • Summary

• Chapter 6: Parallel and In-Place Processing
  • Entry processors
    • In-place processing
      • Implementing WithdrawalProcessor
    • Cache service re-entrancy
      • Accessing the backing map directly
    • Built-in entry processors
      • VersionedPut and VersionedPutAll
      • PriorityProcessor
      • ExtractorProcessor
      • UpdaterProcessor
  • Invocation service
    • Configuring the invocation service
    • Implementing agents
    • Executing agents
  • CommonJ Work Manager
    • Work Manager API basics
      • Defining work
      • Scheduling work
      • Processing the results
    • Coherence Work Manager limitations
  • Coherence Incubator
  • Summary

• Chapter 7: Processing Data Grid Events
  • Cache events
    • Registering map listeners
      • Programmatic listener registration
      • Registering listeners within the cache configuration file
    • Making any map observable
  • Backing map events
    • Implementing a low-balance listener
      • AbstractBackingMapListener
      • Low-balance listener
    • Registering a backing map listener
  • Map triggers
    • Using map triggers for data validation
      • Data validation framework
      • Implementing validation trigger
      • Registering map triggers
  • Continuous query cache
    • Observing a continuous query cache
    • Using a continuous query cache as a substitute for a replicated cache
  • Summary

• Chapter 8: Implementing the Persistence Layer
  • Cache aside
  • Read-through caching
  • Implementing read through
    • Introducing the read-write backing map
    • Using Spring Framework with a read-write backing map
    • Refresh ahead
      • Using refresh ahead to pre-fetch exchange rates
    • Additional considerations
  • Write through
  • Write behind
    • Using write behind for accounts and transactions
  • Write behind and storeAll
  • Handling write-through/write-behind failures
    • Cluster member failures
    • Store failures
  • Write behind and eviction
  • Write behind and deletes

• Configuring backup with a read-write backing map
  • Backup with read through
  • Backup with write behind

• Built-in CacheStore implementations
  • Using the Coherence JPA CacheStore

• Summary

• Chapter 9: Bridging Platform and Network Boundaries
  • Coherence networking
  • Coherence*Extend overview
  • Configuring Coherence*Extend
    • Configuring proxy servers
    • Configuring clients
      • Configuring remote cache scheme
      • Mapping cache names to caches
      • Configuring a remote invocation service
      • Address providers
      • Handling connection or proxy server failure
  • Coherence*Extend limitations
    • Explicit concurrency control
    • Executing invocable agents via Coherence*Extend
  • Securing proxy servers
  • Using network filters
    • Built-in network filters
      • Compression filter
      • Symmetric encryption filter
    • Implementing a custom network filter
  • Summary

• Chapter 10: Accessing Coherence from .NET
  • .NET client configuration
    • Coherence configuration files in .NET
      • Operational descriptor
      • Cache configuration
      • POF configuration
    • Resource loading in Coherence for .NET
      • Protocols and resource loader
    • Approaches to .NET client configuration
      • Convention-based configuration
      • Explicit configuration
      • Programmatic configuration
  • Implementing the client application
    • Basic Cache Operations
    • Implementing data objects
      • Implementing the IPortableObject interface
      • Implementing the external serializer
    • Executing queries
      • Implementing filters and value extractors
    • Executing the aggregators and entry processors
    • Listening for cache events
      • Cache listeners
      • Event marshalling in Windows Forms applications
      • Continuous Query Cache
  • Summary

• Chapter 11: Accessing Coherence from C++
  • Configuring Coherence C++
  • Managed object model
    • Handles, Views, and Holders
    • Managed object creation
    • Casting and type checking
    • Handling exceptions
    • Class hierarchy namespaces
  • Implementing a Coherence C++ client application
    • Implementing Cacheable C++ Data Objects
      • Managed adapter
      • Data object serialization
    • Implementing managed classes
      • Understanding specifications
      • Factory methods
      • Member variables
      • Implementing constructors
      • Implementing methods
      • Implementing the PortableObject interface
      • Implementing external serializer
    • Executing queries
      • Value extractors
      • Filters
      • Performing a query in C++
    • Executing aggregators and entry processors
      • Implementing DepositProcessor in C++
    • Listening for cache events
      • Cache listeners
    • Standard type integration
  • Summary

• Chapter 12: The Right Tool for the Job

• Appendix: Coherent Bank Sample Application
  • Prerequisites
  • Installation
  • Deploying the Java Application
  • Deploying the C++ Application
  • Deploying the .NET Application
  • Shutting everything down
  • Review the code

• Index

Aleksandar Seovic

Mark Falco

Patrick Peralta

Code Downloads

Download the code and support files for this book.

Submit Errata

Please let us know if you have found any errors not listed on this list by completing our errata submission form. Our editors will check them and add them to this list. Thank you.

Sample chapters

You can view our sample chapters and prefaces of this title on PacktLib or download sample chapters in PDF format.