public class SingleFileStore<K,V> extends Object implements AdvancedLoadWriteStore<K,V>
AdvancedLoadWriteStore. 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.TaskContextAdvancedCacheWriter.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.
|
boolean |
isAvailable() |
MarshalledEntry<K,V> |
load(Object key)
Fetches an entry from the storage.
|
io.reactivex.Flowable<MarshalledEntry<K,V>> |
publishEntries(Predicate<? super K> filter,
boolean fetchValue,
boolean fetchMetadata)
Publishes all entries from this store.
|
io.reactivex.Flowable<K> |
publishKeys(Predicate<? super K> filter)
Publishes all the keys from this store.
|
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.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitprocessdeleteBatch, writeBatchprotected InitializationContext ctx
public void init(InitializationContext ctx)
CacheLoaderPersistenceManager
when setting up cache loaders.init in interface CacheLoader<K,V>init in interface CacheWriter<K,V>public void start()
Lifecyclepublic void stop()
Lifecyclepublic boolean isAvailable()
isAvailable in interface CacheLoader<K,V>isAvailable in interface CacheWriter<K,V>isAvailable in interface ExternalStore<K,V>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)
CacheWriterwrite in interface CacheWriter<K,V>MarshalledEntrypublic void clear()
AdvancedCacheWriterclear in interface AdvancedCacheWriter<K,V>public boolean delete(Object key)
delete in interface CacheWriter<K,V>public MarshalledEntry<K,V> load(Object key)
CacheLoaderMarshalledEntry needs to be created here, InitializationContext.getMarshalledEntryFactory() and InitializationContext.getByteBufferFactory() should be used.load in interface CacheLoader<K,V>public io.reactivex.Flowable<K> publishKeys(Predicate<? super K> filter)
AdvancedCacheLoaderSubscribers as desired. Keys are not retrieved until a given Subscriber requests
them from the Subscription.
Stores will return only non expired keys
publishKeys in interface AdvancedCacheLoader<K,V>filter - a filterpublic io.reactivex.Flowable<MarshalledEntry<K,V>> publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
AdvancedCacheLoaderSubscribers as desired. Entries are not retrieved until a given Subscriber requests
them from the Subscription.
If fetchMetadata is true this store must guarantee to not return any expired entries.
publishEntries in interface AdvancedCacheLoader<K,V>public void purge(Executor threadPool, AdvancedCacheWriter.PurgeListener task)
AdvancedCacheWriterWhen this method returns all entries will be purged and no tasks will be running due to this loader in the provided executor. If however an exception is thrown there could be tasks still pending or running in the executor.
purge in interface AdvancedCacheWriter<K,V>public int size()
AdvancedCacheLoadersize in interface AdvancedCacheLoader<K,V>public SingleFileStoreConfiguration getConfiguration()
Copyright © 2020 JBoss, a division of Red Hat. All rights reserved.