Oracle Coherence 3.5电子书

Oracle Coherence 3.5

Table of Contents

Oracle Coherence 3.5

Credits

Foreword

A word about the author

About the author

Acknowledgements

About the co-authors

About the reviewers

Preface

Introducing Oracle Coherence

Distributed caching

Distributed queries

In-place and parallel processing

Cache events

Coherence within the Oracle ecosystem

Coherence usage scenarios

Oracle Coherence editions

What this book covers

What you need for this book

Who this book is for

Who this book is not for

Conventions

Reader feedback

Customer support

Errata

Piracy

Questions

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

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

Loader design

Implementing CsvSource

Implementing CoherenceTarget

Testing the Cache loader

Testing and debugging Coherence applications

Summary

3. Planning Your Caches

Anatomy of a clustered cache

Clustered cache topologies

Replicated Cache service

Read performance

Write performance

Data set size

Coherence node size on modern JVMs

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

None

Present

All

Auto

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

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

Identity management

Creating entity instances

Managing entity relationships

Dealing with dependencies

Specifying data affinity

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

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

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

7. Processing Data Grid Events

Cache events

Registering map listeners

Programmatic listener registration

Listening to specific events

Listening for specific property changes

Transforming map events

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

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

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

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

Resource abstraction

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

Implementing PropertyExtractor in C#

Executing the aggregators and entry processors

Listening for cache events

Cache listeners

Event marshalling in Windows Forms applications

Continuous Query Cache

Data binding with Windows Presentation Foundation (WPF)

Summary

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

Extracting values from locally cached objects

PofExtractor

Implementing PropertyExtractor in C++

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

12. The Right Tool for the Job

A. Coherent Bank Sample Application

Prerequisites

Sun Java JDK 1.6

Microsoft Visual Studio 2008

Oracle Coherence 3.5.3

Ant 1.7+

NAnt 0.86

Installation

Deploying the Java Application

Deploying the C++ Application

Deploying the .NET Application

Shutting everything down

Review the code

Index