JCache and CacheLoader

JCache is the standard API for cache libraries. One common need is to
link the cache with another data source like a database (RDBMS or
NoSQL).

Of course JCache handles both access types: reader and writer.

This post is about readers.

To define the link between your datasource and the cache you need to
define a javax.cache.integration.CacheLoader. It is configured in the
cache configuration. If you use default cache configuration
implementation provided by the API you use:

CompleteConfiguration<MyKey, MyValue> configuration = new MutableConfiguration<MyKey, MyValue>()
	.setStoreByValue(false) // avoid local serialization
	.setReadThrough(true) // use CacheLoader when an entry is missing
	.setCacheLoaderFactory(
		new FactoryBuilder.SingletonFactory<CacheLoader<MyKey, MyValue>>(
			new CacheLoaderImpl()
		)
	);

Configuration is quite simple:

• the cache is configured not stored by value to avoid to
  serialize key/values locally each time
• we set the cache to be read through which means the CacheLoader
  will be asked when an entry is not found
• we set a singleton CacheLoader to be used

Once you have the configuration just create the cache:

Cache<MyKey, MyValue> cache = manager.createCache("my-values", configuration);

Let say you have in the database an entry matching key “159875” and
the cache doesn’t have it yet, when you’ll do:

cache.get(new MyKey("159875"))

the cache will trigger the CacheLoader to find it and will put it in memory.

Note that the CacheLoader API defines two main methods:

V load(K key) throws CacheLoaderException;
Map<K, V> loadAll(Iterable<? extends K> keys) throws CacheLoaderException;

First is the commonly used method and second one is the one used for
bulk loading (depending on the backing datasource it is or not
interesting).

For JPA a CacheLoader can look like:

import java.util.HashMap;
import java.util.Map;

import javax.cache.integration.CacheLoader;
import javax.cache.integration.CacheLoaderException;
import javax.persistence.EntityManager;

public class JPACacheLoader<K, E> implements CacheLoader<K, E> {
	private final Class<E> entity;
	private final EntityManager em;

	public JPACacheLoader(final Class<E> entity, final EntityManager em) {
		this.entity = entity;
		this.em = em;
	}

	@Override
	public E load(final K key) throws CacheLoaderException {
		try {
			return em.find(entity, key);
		}
		catch (final Exception e) {
			return null;
		}
	}

	@Override
	public Map<K, E> loadAll(final Iterable<? extends K> keys) throws CacheLoaderException {
		// could use a bulk select but for the demo this is enough
		final Map<K, E> loaded = new HashMap<K, E>();
		for (final K k : keys) {
			final E value = load(k);
			if (value != null) {
				loaded.put(k, value);
			}
		}
		return loaded;
	}
}

Advertisement