Oracle Coherence 3.5. Create Internet-scale applications using Oracle’s high-performance data grid Patrick Peralta, Mark Falco, Aleksandar Seovic

Spis treści książki

• 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
    • Whats 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

pokaż cały spis treści

ukryj recenzje