|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.jboss.cache.loader.AbstractCacheLoader org.jboss.cache.loader.DelegatingCacheLoader
public abstract class DelegatingCacheLoader
CacheLoader implementation which delegates to another CacheImpl. This allows to stack caches on top of each other, allowing for hierarchical cache levels. For example, first level cache delegates to a second level cache, which delegates to a persistent cache.
Field Summary | |
---|---|
static int |
delegateExists
|
static int |
delegateGet
|
static int |
delegateGetChildrenNames
|
static int |
delegateGetKey
|
static int |
delegateLoadEntireState
|
static int |
delegatePut
|
static int |
delegatePutKeyVal
|
static int |
delegateRemove
|
static int |
delegateRemoveData
|
static int |
delegateRemoveKey
|
static int |
delegateStoreEntireState
|
static int |
putList
|
Fields inherited from class org.jboss.cache.loader.AbstractCacheLoader |
---|
cache, regionManager |
Constructor Summary | |
---|---|
DelegatingCacheLoader()
|
Method Summary | |
---|---|
void |
commit(java.lang.Object tx)
Commits the transaction. |
void |
create()
Lifecycle method, called when the cache loader is created. |
protected abstract boolean |
delegateExists(Fqn name)
|
protected abstract java.util.Map |
delegateGet(Fqn name)
|
protected abstract java.util.Set |
delegateGetChildrenNames(Fqn fqn)
|
protected abstract void |
delegateLoadEntireState(java.io.ObjectOutputStream os)
|
protected abstract void |
delegateLoadState(Fqn subtree,
java.io.ObjectOutputStream os)
|
protected abstract void |
delegatePut(Fqn name,
java.util.Map attributes)
|
protected abstract java.lang.Object |
delegatePut(Fqn name,
java.lang.Object key,
java.lang.Object value)
|
protected abstract void |
delegateRemove(Fqn name)
|
protected abstract java.lang.Object |
delegateRemove(Fqn name,
java.lang.Object key)
|
protected abstract void |
delegateRemoveData(Fqn name)
|
protected abstract void |
delegateStoreEntireState(java.io.ObjectInputStream is)
|
protected abstract void |
delegateStoreState(Fqn subtree,
java.io.ObjectInputStream is)
|
void |
destroy()
Lifecycle method, called when the cache loader is destroyed. |
boolean |
exists(Fqn name)
Returns true if the CacheLoader has a node with a Fqn . |
java.util.Map |
get(Fqn name)
Returns all keys and values from the persistent store, given a Fqn |
java.util.Set<java.lang.String> |
getChildrenNames(Fqn fqn)
Returns a set of children node names. |
void |
loadEntireState(java.io.ObjectOutputStream os)
Fetches the entire state for this cache from secondary storage (disk, database) and writes it to a provided ObjectOutputStream. |
void |
loadState(Fqn subtree,
java.io.ObjectOutputStream os)
Fetches a portion of the state for this cache from secondary storage (disk, database) and writes it to a provided ObjectOutputStream. |
void |
prepare(java.lang.Object tx,
java.util.List<Modification> modifications,
boolean one_phase)
Prepares a list of modifications. |
void |
put(Fqn name,
java.util.Map attributes)
Puts all entries of the map into the existing map of the given node, overwriting existing keys, but not clearing the existing map before insertion. |
void |
put(Fqn fqn,
java.util.Map attributes,
boolean erase)
|
java.lang.Object |
put(Fqn name,
java.lang.Object key,
java.lang.Object value)
Puts a key and value into the attribute map of a given node. |
void |
remove(Fqn name)
Removes the given node and all its subnodes, does nothing if the node does not exist. |
java.lang.Object |
remove(Fqn name,
java.lang.Object key)
Removes the given key and value from the attributes of the given node. |
void |
removeData(Fqn name)
Removes all attributes from a given node, but doesn't delete the node itself or any subnodes. |
void |
rollback(java.lang.Object tx)
Rolls the transaction back. |
void |
start()
Lifecycle method, called when the cache loader is started. |
void |
stop()
Lifecycle method, called when the cache loader is stopped. |
void |
storeEntireState(java.io.ObjectInputStream is)
Stores the entire state for this cache by reading it from a provided ObjectInputStream. |
void |
storeState(Fqn subtree,
java.io.ObjectInputStream is)
Stores the given portion of the cache tree's state in secondary storage. |
Methods inherited from class org.jboss.cache.loader.AbstractCacheLoader |
---|
getMarshaller, getNodeDataList, loadStateHelper, put, setCache, setRegionManager |
Methods inherited from class java.lang.Object |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Methods inherited from interface org.jboss.cache.loader.CacheLoader |
---|
getConfig, setConfig |
Field Detail |
---|
public static final int delegateGetChildrenNames
public static final int delegateGetKey
public static final int delegateGet
public static final int delegateExists
public static final int delegatePutKeyVal
public static final int delegatePut
public static final int delegateRemoveKey
public static final int delegateRemove
public static final int delegateRemoveData
public static final int delegateLoadEntireState
public static final int delegateStoreEntireState
public static final int putList
Constructor Detail |
---|
public DelegatingCacheLoader()
Method Detail |
---|
public java.util.Set<java.lang.String> getChildrenNames(Fqn fqn) throws java.lang.Exception
CacheLoader
Fqn
.
Returns null if the named node is not found or there are no children.
The returned set must not be modifiable. Implementors can use
Collections.unmodifiableSet(java.util.Set)
to make the set unmodifiable.
Implementors may impose restrictions on the contents of an Fqn (such as Strings-only) and as such, indirectly
impose the same restriction on the contents of a Set returned by getChildrenNames().
fqn
- The Fqn
of the parent
java.lang.Exception
public java.util.Map get(Fqn name) throws java.lang.Exception
CacheLoader
Fqn
name
- the Fqn
to search for.
public boolean exists(Fqn name) throws java.lang.Exception
CacheLoader
Fqn
.
java.lang.Exception
public java.lang.Object put(Fqn name, java.lang.Object key, java.lang.Object value) throws java.lang.Exception
CacheLoader
java.lang.Exception
public void put(Fqn name, java.util.Map attributes) throws java.lang.Exception
CacheLoader
Map.putAll(java.util.Map extends K, ? extends V>)
.
If the node does not exist, all parent nodes from the root down are created automatically
name
- The fully qualified name of the nodeattributes
- A Map of attributes. Can be null
java.lang.Exception
public void put(Fqn fqn, java.util.Map attributes, boolean erase) throws java.lang.Exception
put
in class AbstractCacheLoader
java.lang.Exception
public java.lang.Object remove(Fqn name, java.lang.Object key) throws java.lang.Exception
CacheLoader
java.lang.Exception
public void remove(Fqn name) throws java.lang.Exception
CacheLoader
name
- the Fqn
of the node
java.lang.Exception
public void removeData(Fqn name) throws java.lang.Exception
CacheLoader
name
- the Fqn
of the node
java.lang.Exception
public void prepare(java.lang.Object tx, java.util.List<Modification> modifications, boolean one_phase) throws java.lang.Exception
CacheLoader
tx
(tx is the key)
tx
- The transaction, indended to be used by implementations as an identifier of the transaction (and not necessarily a JTA Transaction
object)modifications
- A List
containing Modification
s, for the given transactionone_phase
- Persist immediately and (for example) commit the local JDBC transaction as well. When true,
we won't get a CacheLoader.commit(Object)
or CacheLoader.rollback(Object)
method call later
java.lang.Exception
public void commit(java.lang.Object tx) throws java.lang.Exception
CacheLoader
tx
and commit that
transaction. Non-transactional CacheLoaders could simply write the data
that was previously saved transiently under the given tx
key, to (for example) a file system.
Note this only holds if the previous prepare() did not define one_phase=true
tx
- transaction to commit
java.lang.Exception
public void rollback(java.lang.Object tx)
CacheLoader
tx
and roll back that
transaction.
tx
- transaction to roll backpublic void loadEntireState(java.io.ObjectOutputStream os) throws java.lang.Exception
CacheLoader
CacheLoader.storeEntireState(ObjectInputStream)
Implementations of this method should not catch any exception or close the
given ObjectOutputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are written to the ObjectOutputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader
and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.
loadEntireState
in interface CacheLoader
loadEntireState
in class AbstractCacheLoader
os
- ObjectOutputStream to write state
java.lang.Exception
AbstractCacheLoader.loadEntireState(ObjectOutputStream)
,
NodeData
public void loadState(Fqn subtree, java.io.ObjectOutputStream os) throws java.lang.Exception
CacheLoader
CacheLoader.storeState(Fqn,ObjectInputStream)
.
Implementations of this method should not catch any exception or close the
given ObjectOutputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are written to the ObjectOutputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader
and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.
loadState
in interface CacheLoader
loadState
in class AbstractCacheLoader
subtree
- Fqn naming the root (i.e. highest level parent) node of
the subtree for which state is requested.os
- ObjectOutputStream to write state
java.lang.Exception
AbstractCacheLoader.loadState(Fqn,ObjectOutputStream)
,
Region.activate()
,
NodeData
public void storeEntireState(java.io.ObjectInputStream is) throws java.lang.Exception
CacheLoader
CacheLoader.loadEntireState(ObjectOutputStream)
}
on some other cache instance. State currently in storage gets overwritten.
Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader
and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.
storeEntireState
in interface CacheLoader
storeEntireState
in class AbstractCacheLoader
is
- ObjectInputStream to read state
java.lang.Exception
AbstractCacheLoader.storeEntireState(ObjectInputStream)
,
NodeData
public void storeState(Fqn subtree, java.io.ObjectInputStream is) throws java.lang.Exception
CacheLoader
subtree
,
then no special behavior is required. Otherwise, ensure that
the state is integrated under the given subtree
. Typically
in the latter case subtree
would be the Fqn of the buddy
backup region for
a buddy group; e.g.
If the the transferred state had Fqns starting with "/a" and
subtree
was "/_BUDDY_BACKUP_/192.168.1.2:5555" then the
state should be stored in the local persistent store under
"/_BUDDY_BACKUP_/192.168.1.2:5555/a"
Implementations of this method should not catch any exception or close the
given ObjectInputStream parameter. In order to ensure cacheloader interoperability
contents of the cache are read from the ObjectInputStream as a sequence of
NodeData objects.
Default implementation is provided by AbstractCacheLoader
and ensures cacheloader
interoperability. Implementors are encouraged to consider extending AbstractCacheLoader
prior to implementing completely custom cacheloader.
storeState
in interface CacheLoader
storeState
in class AbstractCacheLoader
subtree
- Fqn naming the root (i.e. highest level parent) node of
the subtree included in state
. If the Fqns
of the data included in state
are not
already children of subtree
, then their
Fqns should be altered to make them children of
subtree
before they are persisted.is
- ObjectInputStream to read state
java.lang.Exception
AbstractCacheLoader.storeState(Fqn,ObjectInputStream)
,
NodeData
public void create() throws java.lang.Exception
CacheLoader
java.lang.Exception
public void start() throws java.lang.Exception
CacheLoader
java.lang.Exception
public void stop()
CacheLoader
public void destroy()
CacheLoader
protected abstract java.util.Set delegateGetChildrenNames(Fqn fqn) throws java.lang.Exception
java.lang.Exception
protected abstract java.util.Map delegateGet(Fqn name) throws java.lang.Exception
java.lang.Exception
protected abstract boolean delegateExists(Fqn name) throws java.lang.Exception
java.lang.Exception
protected abstract java.lang.Object delegatePut(Fqn name, java.lang.Object key, java.lang.Object value) throws java.lang.Exception
java.lang.Exception
protected abstract void delegatePut(Fqn name, java.util.Map attributes) throws java.lang.Exception
java.lang.Exception
protected abstract java.lang.Object delegateRemove(Fqn name, java.lang.Object key) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateRemove(Fqn name) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateRemoveData(Fqn name) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateLoadEntireState(java.io.ObjectOutputStream os) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateLoadState(Fqn subtree, java.io.ObjectOutputStream os) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateStoreEntireState(java.io.ObjectInputStream is) throws java.lang.Exception
java.lang.Exception
protected abstract void delegateStoreState(Fqn subtree, java.io.ObjectInputStream is) throws java.lang.Exception
java.lang.Exception
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |