Overview

GigaSpaces allows applications to interact with the space using the Map API (JCache). Accessing the space via the Map API can be done using the com.j_spaces.javax.cache.Cache or via the com.j_spaces.map.IMap interfaces.

The com.j_spaces.map.IMap is extension of the com.j_spaces.javax.cache.Cache interface and includes enhanced options such as transaction support, timeout operations (blocking read) and versioning.

Map API vs. JavaSpaces API

Expand this...

Feature	Space API	Map API
Batch Operations		Limited.
Master-Worker Pattern
Continuous Query
Custom Query Pattern
Externalizable Support		– The value object should implement Externalizable.
FIFO Support
Indexing
Inheritance Support
Iterator
Unicast Notifications		– Limited.
Multicast Notifications
Tokenized Notifications
POJO Support
Jini Distributed Transaction Support
Local Transaction Support
XA Transaction Support
UID Support
Lease
Partial Update
Simple Matching
Complex Entry Attribute Query Support
Regular Expression Query Support
SQL Query Support
Administration API
Exclusive Read Lock		*
Optimistic Locking
Pessimistic Locking
Timeout operations (read/take with timeout > 0)
Spring Support		– Via the declarative cache
Local Cache
Local View
Replicated Space
Partitioned Space
Service Grid Support		** – No injection of IMap.
IWorker Support		**
ISpaceFilter Support		**

* via IMap.getMasterSpace()
** via CacheFinder.find(String url, IJSpace space)

CacheFinder: Cache Instance Factory & Connection Method

Use the gsInstance command to start a remote space or the com.j_spaces.map.CacheFinder.find to start an embedded space.

The com.j_spaces.map.CacheFinder is a factory class that generates space/cache proxies or start a space within the application process (embedded mode). It includes static methods that return the desired space/cache proxy. When running the space within the application process you can determine the space cluster topology (replicated , partitioned) using the Space URL that is provided as an argument to CacheFinder methods.

CacheFinder Methods

Expand this...

com.j_spaces.map.IMap: the Map Interface

The IMap interface (com.j_spaces.map.IMap; see Javadoc) is the returned object from the CacheFinder.find() method. Based on the URL provided and the configuration, the returned IMap object can encapsulate access to a remote space/cache, embedded space/cache, replicated cache, or partitioned cache.

The IMap interface exposes the familiar Map APIs put(), get(), and remove(); the setTransaction() method is used to encapsulate Map operations in a transaction (see Map Transactions).

com.j_spaces.javax.cache.Cache: JCache Interface

Expand this...

RDBMS Read-Through and Write-Through

Expand this...

When the cache stores database data, you may want to load objects from the database to the cache implicitly. The CacheLoader interface allows you to instruct the cache to load data when the desired key is not found in the cache. CacheLoader.load() is called when the IMap.get() method is called and the specified key cannot be found in the cache – when implementing the former method, you can specify how to retrieve the data from the database. The CacheStore interface works in a similar manner, allows you to implicitly write objects to a database when they are written to the cache.

For more details on CacheLoader and CacheStore, refer to the Read-Through and Write-Through section.

Evicting objects from the cache can be done explicitly using a time-to-live parameter, or implicitly via an LRU eviction mechanism, which evicts objects from the cache based on the percentage of available free memory and an upper threshold of total cache objects.

Section Contents

• Map Exceptions — The two main exceptions thrown for cache problems: EntryVersionConflictException and CacheTimeoutException.
• Map Iterator — Used to get objects matching multiple templates in one call.
• Map Notifications — How to register to be notified when objects are put to or removed from the space/cache.
• Map Optimistic Locking — How to you write applications under the assumption that put operations may fail, if the updated object is changed by someone else since it was read.
• Map Pessimistic Locking — How to explicitly prevent multiple users from from performing get, put or remove operations with the same key under a transaction.
• Map Transactions — Performing distributed and 'local' transactions on space/cache instances.
• Writing Your First Map API Application — Environment setup and writing a Map hello world application.