Caching arbitrary objects

This page explains how to cache arbitrary objects in Magnolia. You can cache basically every object. This takes caching well beyond page and page fragment caching.

Required modules

The functionality for caching arbitrary objects is provided by at least two modules.

• Module magnolia-cache-core  which defines the cache API.
• A second module which implements the API. Magnolia provides two implementations based on established third-party libraries for the low-level functions.
  • magnolia-cache-ehcache  is the default implementation which uses Ehcache.
  • magnolia-cache-memcached is a high-performance, distributed memory object caching system which uses Memcached. 

Things to note about arbitrary object caching

Speed up services

The main reason to cache objects is to serve data faster and to save resources (cpu, memory, network load, etc.). For instance, use object caching when there is heavy request on a Magnolia "service" which must provide data from a remote source.

Assure data validity

When delivering cached data you will probably need a mechanism to ensure cached data is valid and not outdated! How to handle this depends on the use case.

Restrict the lifetime of cached objects

When putting objects to the cache you can restrict their lifetime. In this case, instead of checking the validity of cached objects, you can simply let them expire over time.

Rebuild the cache on non-persistent implementations after server restart 

Implementations:

Get the cache

Achieve an instance of  Cache .  This is your cache to operate on. Give it a name which must be unique within the system.

Example:

public class MyClass {
    private final Provider<CacheFactoryProvider> cacheFactoryProvider;

    @Inject
    public MyClass(Provider<CacheFactoryProvider> cacheFactoryProvider){
        this.cacheFactoryProvider = cacheFactoryProvider;
    }
    public void fooBar(){
        Cache cache = cacheFactoryProvider.get().get().getCache("fooBarCache"); 
    }
}

• Lines 2, 4-6: Inject  CacheFactoryProvider  and keep it as a final member of your class.
• Line 9: Fetch the Cache  with its name. The cache provider will always return the same instance once it has been created.

All subsequent actions - adding, reading and removing objects - are applied on this Cache object.

Configure the cache

Magnolia allows to configure a cache factory specifically for each cache. For example you could have a specific configuration for fooBarCache. When no specific configuration is defined, the default factory configuration is used.

Example: Extend the default factory and override the persistence strategy with none. This persistence strategy allows to cache non-serializable objects.

 The /modules/cache/config/cacheFactory/caches/fooBarCache node defines the cache name. fooBarCache is the "name" of the cache which was also used above when acquiring the Cache object within Java code.

Cache Interface

public interface Cache {
 
    boolean hasElement(Object key);
 
    void put(Object key, Object value);
 
    void put(Object key, Object value, int timeToLiveInSeconds);
 
    Object get(Object key);
 
    Object getQuiet(Object key);
 
    void remove(Object key);
 
    void clear();
 
    String getName();
 
    int getSize();
 
    Collection<Object> getKeys();
}

Put to cache

Cache  knows two methods to append objects.

void put(Object key, Object value);
 
void put(Object key, Object value, int timeToLiveInSeconds);

Arguments:

Example:

public class MyClass {
    public Object put(Object key, Object value){
        Cache cache = cacheFactoryProvider.get().get().getCache("fooBarCache");
        cache.put(key, value);
        return value;
    }
    public Object put(Object key, Object value, int timeToLiveInSeconds){
        Cache cache = cacheFactoryProvider.get().get().getCache("fooBarCache");
        cache.put(key, value, timeToLiveInSeconds);
        return value;
    }
} 

Retrieve from cache

There are two methods to retrieve an object from cache. 

Object get(Object key);

Object getQuiet(Object key);

get

Returns an object from the cache and blocks all the requests for the same key. 

Example:

public JsonNode getData(String productId) throws Exception {
    Cache cache = cacheFactoryProvider.get().get().getCache(CACHEKEY);
    try {
        JsonNode jsonNode = (JsonNode) cache.get(productId);
        if (jsonNode != null) {
            return jsonNode;
        } else {
            jsonNode = readJson(productId);
            cache.put(productId, jsonNode);
            return jsonNode;
        }
    } catch (Exception e) {
        cache.put(productId, null); //unblock cache!
        throw e;
    }
}

getQuiet

Returns an object from the cache but does NOT block requests for the same key. 

This method is used more to "observe" or manage cached objects than to fetch a specific object. The Magnolia Cache Browser app is using #getQuiet, for instance. 

Example:

public List getCachedObjects() {
    List<Object> cachedObjects = new ArrayList<>();

    Cache cache = cacheFactoryProvider.get().get().getCache(NAME_OF_CACHE);
    Collection<Object> keys = cache.getKeys();

    for (Object key : keys) {
        Object value = cache.getQuiet(key);
        if (value != null) {
            cachedObjects.add(value);
        }
    }

    return cachedObjects;
}

Line 8: Uses #getQuiet 

Delete from cache

Remove a single item

Cache cache = cacheFactoryProvider.get().get().getCache("fooBarCache");
cache.remove("fb-90270240-xyz");

Clear complete cache

#clear deletes all items of a specific  Cache  which is identified by its "name"

cacheFactoryProvider.get().get().getCache("fooBarCache").clear()