public class SingleFileStore<K,V> extends Object implements AdvancedLoadWriteStore<K,V>
CacheLoader
. This file store
stores cache values in a single file <location>/<cache name>.dat,
keys and file positions are kept in memory.
Note: this CacheStore implementation keeps keys and file positions in memory!
The current implementation needs about 100 bytes per cache entry, plus the
memory for the key objects.
So, the space taken by this cache store is both the space in the file
itself plus the in-memory index with the keys and their file positions.
With this in mind and to avoid the cache store leading to
OutOfMemoryExceptions, you can optionally configure the maximum number
of entries to maintain in this cache store, which affects both the size
of the file and the size of the in-memory index. However, setting this
maximum limit results in older entries in the cache store to be eliminated,
and hence, it only makes sense configuring a maximum limit if Infinispan
is used as a cache where loss of data in the cache store does not lead to
data loss, and data can be recomputed or re-queried from the original data
source.
This class is fully thread safe, yet allows for concurrent load / store
of individual cache entries.AdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContext
AdvancedCacheWriter.PurgeListener<K>
Modifier and Type | Field and Description |
---|---|
protected InitializationContext |
ctx |
Constructor and Description |
---|
SingleFileStore() |
Modifier and Type | Method and Description |
---|---|
void |
clear()
Removes all the data from the storage.
|
boolean |
contains(Object key)
The base class implementation calls
load(Object) for this, we can do better because
we keep all keys in memory. |
boolean |
delete(Object key) |
SingleFileStoreConfiguration |
getConfiguration() |
void |
init(InitializationContext ctx)
Used to initialize a cache loader.
|
MarshalledEntry<K,V> |
load(Object key)
Fetches an entry from the storage.
|
void |
process(KeyFilter<? super K> filter,
AdvancedCacheLoader.CacheLoaderTask<K,V> task,
Executor executor,
boolean fetchValue,
boolean fetchMetadata)
Iterates in parallel over the entries in the storage using the threads from the executor pool.
|
void |
purge(Executor threadPool,
AdvancedCacheWriter.PurgeListener task)
Using the thread in the pool, removed all the expired data from the persistence storage.
|
int |
size()
Returns the number of elements in the store.
|
void |
start()
Invoked on component start
|
void |
stop()
Invoked on component stop
|
void |
write(MarshalledEntry<? extends K,? extends V> marshalledEntry)
Persists the entry to the storage.
|
protected InitializationContext ctx
public void init(InitializationContext ctx)
CacheLoader
PersistenceManager
when setting up cache loaders.init
in interface CacheLoader<K,V>
init
in interface CacheWriter<K,V>
public void start()
Lifecycle
public void stop()
Lifecycle
public boolean contains(Object key)
load(Object)
for this, we can do better because
we keep all keys in memory.contains
in interface CacheLoader<K,V>
public void write(MarshalledEntry<? extends K,? extends V> marshalledEntry)
CacheWriter
write
in interface CacheWriter<K,V>
MarshalledEntry
public void clear()
AdvancedCacheWriter
clear
in interface AdvancedCacheWriter<K,V>
public boolean delete(Object key)
delete
in interface CacheWriter<K,V>
public MarshalledEntry<K,V> load(Object key)
CacheLoader
MarshalledEntry
needs to be created here, InitializationContext.getMarshalledEntryFactory()
and InitializationContext.getByteBufferFactory()
should be used.load
in interface CacheLoader<K,V>
public void process(KeyFilter<? super K> filter, AdvancedCacheLoader.CacheLoaderTask<K,V> task, Executor executor, boolean fetchValue, boolean fetchMetadata)
AdvancedCacheLoader
CacheLoaderTask#processEntry(MarshalledEntry, TaskContext)
is
invoked. Before passing an entry to the callback task, the entry should be validated against the filter.
Implementors should build an AdvancedCacheLoader.TaskContext
instance (implementation) that is fed to the AdvancedCacheLoader.CacheLoaderTask
on every invocation. The AdvancedCacheLoader.CacheLoaderTask
might invoke AdvancedCacheLoader.TaskContext.stop()
at any time, so implementors of this method
should verify TaskContext's state for early termination of iteration. The method should only return once the
iteration is complete or as soon as possible in the case TaskContext.stop() is invoked.process
in interface AdvancedCacheLoader<K,V>
filter
- to validate which entries should be feed into the task. Might be null.task
- callback to be invoked in parallel for each stored entry that passes the filter checkexecutor
- an external thread pool to be used for parallel iterationfetchValue
- whether or not to fetch the value from the persistent store. E.g. if the iteration is
intended only over the key set, no point fetching the values from the persistent store as
wellfetchMetadata
- whether or not to fetch the metadata from the persistent store. E.g. if the iteration is
intended only ove the key set, then no pint fetching the metadata from the persistent store
as wellpublic void purge(Executor threadPool, AdvancedCacheWriter.PurgeListener task)
AdvancedCacheWriter
purge
in interface AdvancedCacheWriter<K,V>
public int size()
AdvancedCacheLoader
size
in interface AdvancedCacheLoader<K,V>
public SingleFileStoreConfiguration getConfiguration()
Copyright © 2015 JBoss, a division of Red Hat. All rights reserved.