javax.cache.integration.CacheLoader
loads cache entries from any external backend resource. If the cache is
configured to be read-through
, then CacheLoader::load
is called transparently from the cache when the key or the value is not
yet found in the cache. If no value is found for a given key, it returns null.
If the cache is not configured to be read-through
, nothing is loaded automatically. However, the user code must call javax.cache.Cache::loadAll
to load data for the given set of keys into the cache.
For the bulk load operation (loadAll()
), some keys may not be found in the returned result set. In this case, a javax.cache.integration.CompletionListener
parameter can be used as an asynchronous callback after all the key-value pairs are loaded because loading many key-value pairs can take lots of time.
Let's look at the UserCacheLoader
implementation.
public class UserCacheLoader
implements CacheLoader<Integer, User>, Serializable {
private final UserDao userDao;
public UserCacheLoader( UserDao userDao ) {
// Store the dao instance created externally
this.userDao = userDao;
}
@Override
public User load( Integer key ) throws CacheLoaderException {
// Just call through into the dao
return userDao.findUserById( key );
}
@Override
public Map<Integer, User> loadAll( Iterable<? extends Integer> keys )
throws CacheLoaderException {
// Create the resulting map
Map<Integer, User> loaded = new HashMap<Integer, User>();
// For every key in the given set of keys
for ( Integer key : keys ) {
// Try to retrieve the user
User user = userDao.findUserById( key );
// If user is not found do not add the key to the result set
if ( user != null ) {
loaded.put( key, user );
}
}
return loaded;
}
}
The implementation is quite straight forward. An important note is that
any kind of exception has to be wrapped into javax.cache.integration.CacheLoaderException
.