|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Objectorg.infinispan.loaders.decorators.ChainingCacheStore
public class ChainingCacheStore
A chaining cache loader that allows us to configure > 1 cache loader.
READ operations are directed to each of the cache loaders (in the order which they were configured) until a non-null (or non-empty in the case of retrieving collection objects) result is achieved. WRITE operations are propagated to ALL registered cache stores specified, that set ignoreModifications to false.
Constructor Summary | |
---|---|
ChainingCacheStore()
|
Method Summary | |
---|---|
void |
addCacheLoader(CacheLoader loader,
CacheLoaderConfig config)
|
void |
clear()
Clears all entries in the store |
void |
commit(GlobalTransaction tx)
Commits a transaction that has been previously prepared. |
boolean |
containsKey(Object key)
|
void |
fromStream(ObjectInput inputStream)
Writes contents of the stream to the store. |
CacheStoreConfig |
getCacheStoreConfig()
Returns the configuration object associated to this cache store config. |
Class<? extends CacheLoaderConfig> |
getConfigurationClass()
This method is used by the configuration parser to get a hold of the CacheLoader implementation's corresponding CacheLoaderConfig type. |
LinkedHashMap<CacheStore,CacheLoaderConfig> |
getStores()
|
void |
init(CacheLoaderConfig config,
Cache cache,
StreamingMarshaller m)
Used to initialize a cache loader. |
Set<InternalCacheEntry> |
load(int numEntries)
Loads up to a specific number of entries. |
InternalCacheEntry |
load(Object key)
Loads an entry mapped to by a given key. |
Set<InternalCacheEntry> |
loadAll()
Loads all entries in the loader. |
Set<Object> |
loadAllKeys(Set<Object> keysToExclude)
Loads a set of all keys, excluding a filter set. |
void |
prepare(List<? extends Modification> list,
GlobalTransaction tx,
boolean isOnePhase)
Issues a prepare call with a set of modifications to be applied to the cache store |
void |
purgeExpired()
Purges expired entries from the store. |
void |
purgeIfNecessary()
|
boolean |
remove(Object key)
Removes an entry in the store. |
void |
removeAll(Set<Object> keys)
Bulk remove operation |
void |
rollback(GlobalTransaction tx)
Rolls back a transaction that has been previously prepared This method may be invoked on a transaction for which there is no prior CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean) . |
void |
start()
|
void |
stop()
|
void |
store(InternalCacheEntry ed)
Stores an entry |
void |
toStream(ObjectOutput outputStream)
Loads the entire state into a stream, using whichever format is most efficient for the cache loader implementation. |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Constructor Detail |
---|
public ChainingCacheStore()
Method Detail |
---|
public void store(InternalCacheEntry ed) throws CacheLoaderException
CacheStore
store
in interface CacheStore
ed
- entry to store
CacheLoaderException
- in the event of problems writing to the storepublic void fromStream(ObjectInput inputStream) throws CacheLoaderException
CacheStore
CacheStore.toStream(java.io.ObjectOutput)
. While not a
requirement, it is recommended that implementations make use of the StreamingMarshaller
when dealing with the stream to make use of efficient marshalling.
It is imperative that implementations do not close the stream after finishing with it.
It is also recommended that implementations use their own start and end markers on the stream since
other processes may write additional data to the stream after the cache store has written to it. As such, either
markers or some other mechanism to prevent the store from reading too much information should be employed when
writing to the stream in CacheStore.fromStream(java.io.ObjectInput)
to prevent data corruption.
It can be assumed that the stream passed in already performs buffering such that the cache store implementation
doesn't have to.
fromStream
in interface CacheStore
inputStream
- stream to read from
CacheLoaderException
- in the event of problems writing to the storepublic void toStream(ObjectOutput outputStream) throws CacheLoaderException
CacheStore
CacheStore.fromStream(java.io.ObjectInput)
.
While not a requirement, it is recommended that implementations make use of the StreamingMarshaller
when dealing with the stream to make use of efficient marshalling.
It is imperative that implementations do not flush or close the stream after finishing with it.
It is also recommended that implementations use their own start and end markers on the stream since
other processes may write additional data to the stream after the cache store has written to it. As such, either
markers or some other mechanism to prevent the store from reading too much information in CacheStore.fromStream(java.io.ObjectInput)
should be employed, to prevent data corruption.
It can be assumed that the stream passed in already performs buffering such that the cache store implementation
doesn't have to.
toStream
in interface CacheStore
outputStream
- stream to write to
CacheLoaderException
- in the event of problems reading from the storepublic void clear() throws CacheLoaderException
CacheStore
clear
in interface CacheStore
CacheLoaderException
- in the event of problems writing to the storepublic boolean remove(Object key) throws CacheLoaderException
CacheStore
remove
in interface CacheStore
key
- key to remove
CacheLoaderException
- in the event of problems writing to the storepublic void removeAll(Set<Object> keys) throws CacheLoaderException
CacheStore
removeAll
in interface CacheStore
keys
- to remove
CacheLoaderException
- in the event of problems writing to the storepublic void purgeExpired() throws CacheLoaderException
CacheStore
purgeExpired
in interface CacheStore
CacheLoaderException
- in the event of problems writing to the storepublic void commit(GlobalTransaction tx) throws CacheLoaderException
CacheStore
CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean)
. The implementation would
need to deal with this case acordingly. Typically, this would be a no-op, after ensuring any resources attached
to the transaction are cleared up.
Also note that this method may be invoked on a thread which is different from the CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean)
invocation. As such, ThreadLocal
s should not be relied upon to maintain transaction context.
commit
in interface CacheStore
tx
- tx to commit
CacheLoaderException
- in the event of problems writing to the storepublic void rollback(GlobalTransaction tx)
CacheStore
CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean)
. The implementation would
need to deal with this case acordingly. Typically, this would be a no-op, after ensuring any resources attached
to the transaction are cleared up.
Also note that this method may be invoked on a thread which is different from the CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean)
invocation. As such, ThreadLocal
s should not be relied upon to maintain transaction context.
rollback
in interface CacheStore
tx
- tx to roll backpublic void prepare(List<? extends Modification> list, GlobalTransaction tx, boolean isOnePhase) throws CacheLoaderException
CacheStore
prepare
in interface CacheStore
list
- modifications to be appliedtx
- transaction identifierisOnePhase
- if true, there will not be a commit or rollback phase and changes should be flushed
immediately
CacheLoaderException
- in the event of problems writing to the storepublic void init(CacheLoaderConfig config, Cache cache, StreamingMarshaller m) throws CacheLoaderException
CacheLoader
CacheLoaderManager
when setting up cache loaders.
init
in interface CacheLoader
config
- the cache loader configuration beancache
- cache associated with this cache loader. Implementations may use this to determine cache name when
selecting where refer to state in storage, for example, a different database table name.m
- marshaller to use when loading state from a stream, if supported by the implementation.
CacheLoaderException
public InternalCacheEntry load(Object key) throws CacheLoaderException
CacheLoader
load
in interface CacheLoader
key
- key
CacheLoaderException
- in the event of problems reading from sourcepublic Set<InternalCacheEntry> loadAll() throws CacheLoaderException
CacheLoader
loadAll
in interface CacheLoader
CacheLoaderException
- in the event of problems reading from sourcepublic Set<InternalCacheEntry> load(int numEntries) throws CacheLoaderException
CacheLoader
load
in interface CacheLoader
numEntries
- maximum number of entries to load
CacheLoaderException
public Set<Object> loadAllKeys(Set<Object> keysToExclude) throws CacheLoaderException
CacheLoader
loadAllKeys
in interface CacheLoader
keysToExclude
- a set of keys to exclude. An empty set or null will indicate that all keys should be returned.
CacheLoaderException
public boolean containsKey(Object key) throws CacheLoaderException
containsKey
in interface CacheLoader
key
- key to test
CacheLoaderException
- in the event of problems reading from sourcepublic Class<? extends CacheLoaderConfig> getConfigurationClass()
CacheLoader
CacheLoaderConfig
type. This is usually done by instantiating the CacheLoader
and then calling this method. This may result in 2 instances being created, however, since the instance
created to get a hold of the configuration type is then discarded and another instance is created for actual
use as a CacheLoader when the cache starts.
Since Infinispan 4.1, you can also annotate your CacheLoader implementation with CacheLoaderMetadata
and provide this information via the annotation, which will prevent unnecessary instances being created.
getConfigurationClass
in interface CacheLoader
CacheLoaderConfig
bean used to configure this
implementation of CacheLoader
.public void start() throws CacheLoaderException
start
in interface CacheLoader
CacheLoaderException
public void stop() throws CacheLoaderException
stop
in interface CacheLoader
CacheLoaderException
public void addCacheLoader(CacheLoader loader, CacheLoaderConfig config)
public void purgeIfNecessary() throws CacheLoaderException
CacheLoaderException
public LinkedHashMap<CacheStore,CacheLoaderConfig> getStores()
public CacheStoreConfig getCacheStoreConfig()
CacheStore
getCacheStoreConfig
in interface CacheStore
|
Google Analytics | |||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |