Interface MemcacheService (2.0.0)

The Java API for the App Engine Memcache service. This offers a fast distributed cache for commonly-used data. The cache is limited both in duration and also in total space, so objects stored in it may be discarded at any time.

Note that null is a legal value to store in the cache, or to use as a cache key. Although the API is written for Objects, both keys and values should be Serializable, although future versions may someday accept specific types of non-Serializable Objects.

The values returned from this API are mutable copies from the cache; altering them has no effect upon the cached value itself until assigned with one of the put methods. Likewise, the methods returning collections return mutable collections, but changes do not affect the cache.

Methods that operate on single entries, including #increment, are atomic, while batch methods such as #getAll, #putAll, and #deleteAll do not provide atomicity. Arbitrary operations on single entries can be performed atomically by using #putIfUntouched in combination with #getIdentifiable.

Increment has a number of caveats to its use; please consult the method documentation.

An ErrorHandler configures how errors are treated. The default error handler is an instance of LogAndContinueErrorHandler. In most cases this will log the underlying error condition and emulate cache-miss behavior instead of throwing an error to the calling code. For example, it returns null from #get(Object).

A less permissive alternative is StrictErrorHandler, which will instead throw a MemcacheServiceException to expose any errors for application code to resolve.

To guarantee that all MemcacheServiceException are directed to the error handler use a ConsistentErrorHandler such as ErrorHandlers#getConsistentLogAndContinue(Level) or ErrorHandlers#getStrict().

Batch version of #delete(Object).

Batch version of #delete(Object, long).

Performs a get of multiple keys at once. This is more efficient than multiple separate calls to #get(Object), and allows a single call to both test for #contains(Object) and also fetch the value, because the return will not include mappings for keys not found.

If an error deserializing the value occurs, this passes an InvalidValueException to the service's ErrorHandler. If a service error occurs, this passes a MemcacheServiceException. See BaseMemcacheService#setErrorHandler(ErrorHandler).

Performs a getIdentifiable for multiple keys at once. This is more efficient than multiple separate calls to #getIdentifiable(Object).

If an error deserializing the value occurs, this passes an InvalidValueException to the service's ErrorHandler. If a service error occurs, this passes a MemcacheServiceException. See BaseMemcacheService#setErrorHandler(ErrorHandler).

Performs a getItemForPeek for multiple keys at once. This is more efficient than multiple separate calls to #getItemForPeek(Object).

If an error deserializing the value occurs, this passes an InvalidValueException to the service's ErrorHandler. If a service error occurs, this passes a MemcacheServiceException. See BaseMemcacheService#setErrorHandler(ErrorHandler).

Like normal increment, but increments a batch of separate keys in parallel by the same delta. See Also: #increment(Object, long)

Like normal increment, but increments a batch of separate keys in parallel by the same delta and potentially sets a starting value. See Also: #increment(Object, long)

Like normal increment, but accepts a mapping of separate controllable offsets for each key individually. Good for incrementing by a sum and a count in parallel. See Also: #increment(Object, long)

Like normal increment, but accepts a mapping of separate controllable offsets for each key individually. Good for incrementing by a sum and a count in parallel. Callers may also pass an initial value for the keys to take on if they are not already present in the cache. See Also: #increment(Object, long)

A batch-processing variant of #put. This is more efficiently implemented by the service than multiple calls.

Convenience shortcut, equivalent to Parameter Name Description values Map<T,CasValues>

the key/values mappings to compare and swap

putIfUntouched(Map values, Expiration expiration)

public abstract Set <T>putIfUntouched(Map,MemcacheService.CasValues> values, Expiration expiration)

clearAll()

public abstract void clearAll()

contains(Object key)

public abstract boolean contains(Object key)

   if (memcache.contains("key")) {
     foo = memcache.get("key");
     if (foo == null) {
       // continue, assuming foo had the real value null
     }
   }
  

   foo = memcache.get("key");
   if (foo == null) {
     if (memcache.contains("key")) {
       // continue, assuming foo had the real value null
     } else {
       // continue; foo may have had a real null, but has been dropped now
     }
   }
  

public abstract boolean delete(Object key)

public abstract boolean delete(Object key, long millisNoReAdd)

public abstract Object get(Object key)

public abstract MemcacheService.IdentifiableValue getIdentifiable(Object key)

public default MemcacheService.ItemForPeek getItemForPeek(Object key)

public abstract Stats getStatistics()

public abstract Long increment(Object key, long delta)

public abstract Long increment(Object key, long delta, Long initialValue)

public abstract void put(Object key, Object value)

public abstract void put(Object key, Object value, Expiration expires)

public abstract boolean put(Object key, Object value, Expiration expires, MemcacheService.SetPolicy policy)

public abstract void putAll(Map<?,?> values)

public abstract void putAll(Map<?,?> values, Expiration expires)

public abstract boolean putIfUntouched(Object key, MemcacheService.IdentifiableValue oldValue, Object newValue)

public abstract boolean putIfUntouched(Object key, MemcacheService.IdentifiableValue oldValue, Object newValue, Expiration expires)

public abstract void setNamespace(String newNamespace)