org.infinispan.jcache
Class JCacheLoaderAdapter<K,V>

java.lang.Object
  org.infinispan.loaders.AbstractCacheLoader
      org.infinispan.loaders.AbstractCacheStore
          org.infinispan.jcache.JCacheLoaderAdapter<K,V>

All Implemented Interfaces:

CacheLoader, CacheStore

public class JCacheLoaderAdapter<K,V>
extends AbstractCacheStore

Field Summary

Fields inherited from class org.infinispan.loaders.AbstractCacheStore

multiThreadedPurge, purgerService

Fields inherited from class org.infinispan.loaders.AbstractCacheLoader

cache, marshaller, timeService

Constructor Summary

JCacheLoaderAdapter()

Method Summary

void	clear() Clears all entries in the store
void	commit(GlobalTransaction tx) Commits a transaction that has been previously prepared.
void	fromStream(ObjectInput inputStream) Writes contents of the stream to the store.
Class<? extends CacheLoaderConfig>	getConfigurationClass() This method is used by the configuration parser to get a hold of the CacheLoader implementation's corresponding CacheLoaderConfig type.
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.
protected void	purgeInternal()
boolean	remove(Object key) Removes an entry in the store.
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	setCacheLoader(javax.cache.CacheLoader<K,V> delegate)
void	start()
void	stop()
void	store(InternalCacheEntry entry) 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 org.infinispan.loaders.AbstractCacheStore

applyModifications, getCacheStoreConfig, getConcurrencyLevel, getMarshaller, init, removeAll, safeClose, safeClose, supportsMultiThreadedPurge

Methods inherited from class org.infinispan.loaders.AbstractCacheLoader

containsKey

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.infinispan.loaders.CacheLoader

containsKey

Constructor Detail

JCacheLoaderAdapter

public JCacheLoaderAdapter()

Method Detail

setCacheLoader

public void setCacheLoader(javax.cache.CacheLoader<K,V> delegate)

load

public InternalCacheEntry load(Object key)
                        throws CacheLoaderException

Description copied from interface: CacheLoader

Loads an entry mapped to by a given key. Should return null if the entry does not exist. Expired entries are not returned.

Parameters:

key - key

Returns:

an entry

Throws:

CacheLoaderException - in the event of problems reading from source

loadAll

public Set<InternalCacheEntry> loadAll()
                                throws CacheLoaderException

Description copied from interface: CacheLoader

Loads all entries in the loader. Expired entries are not returned.

Returns:

a set of entries, or an empty set if the loader is emptied.

Throws:

CacheLoaderException - in the event of problems reading from source

load

public Set<InternalCacheEntry> load(int numEntries)
                             throws CacheLoaderException

Description copied from interface: CacheLoader

Loads up to a specific number of entries. There is no guarantee as to order of entries loaded. The set returned would contain up to a maximum of numEntries entries, and no more.

Parameters:

numEntries - maximum number of entries to load

Returns:

a set of entries, which would contain between 0 and numEntries entries.

Throws:

CacheLoaderException

loadAllKeys

public Set<Object> loadAllKeys(Set<Object> keysToExclude)
                        throws CacheLoaderException

Description copied from interface: CacheLoader

Loads a set of all keys, excluding a filter set.

Parameters:

keysToExclude - a set of keys to exclude. An empty set or null will indicate that all keys should be returned.

Returns:

A set containing keys of entries stored. An empty set is returned if the loader is empty.

Throws:

CacheLoaderException

start

public void start()
           throws CacheLoaderException

Specified by:

start in interface CacheLoader

Overrides:

start in class AbstractCacheStore

Throws:

CacheLoaderException

stop

public void stop()
          throws CacheLoaderException

Specified by:

stop in interface CacheLoader

Overrides:

stop in class AbstractCacheStore

Throws:

CacheLoaderException

getConfigurationClass

public Class<? extends CacheLoaderConfig> getConfigurationClass()

Description copied from interface: CacheLoader

This method is used by the configuration parser to get a hold of the CacheLoader implementation's corresponding 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.

Returns:

the type of the CacheLoaderConfig bean used to configure this implementation of CacheLoader.

toStream

public void toStream(ObjectOutput outputStream)
              throws CacheLoaderException

Description copied from interface: CacheStore

Loads the entire state into a stream, using whichever format is most efficient for the cache loader implementation. Typically read and parsed by 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.

Parameters:

outputStream - stream to write to

Throws:

CacheLoaderException - in the event of problems reading from the store

store

public void store(InternalCacheEntry entry)
           throws CacheLoaderException

Description copied from interface: CacheStore

Stores an entry

Parameters:

entry - entry to store

Throws:

CacheLoaderException - in the event of problems writing to the store

fromStream

public void fromStream(ObjectInput inputStream)
                throws CacheLoaderException

Description copied from interface: CacheStore

Writes contents of the stream to the store. Implementations should expect that the stream contains data in an implementation-specific format, typically generated using 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.

Parameters:

inputStream - stream to read from

Throws:

CacheLoaderException - in the event of problems writing to the store

clear

public void clear()
           throws CacheLoaderException

Description copied from interface: CacheStore

Clears all entries in the store

Throws:

CacheLoaderException - in the event of problems writing to the store

remove

public boolean remove(Object key)
               throws CacheLoaderException

Description copied from interface: CacheStore

Removes an entry in the store.

Parameters:

key - key to remove

Returns:

true if the entry was removed; false if the entry wasn't found.

Throws:

CacheLoaderException - in the event of problems writing to the store

purgeExpired

public void purgeExpired()

Description copied from interface: CacheStore

Purges expired entries from the store.

Specified by:

purgeExpired in interface CacheStore

Overrides:

purgeExpired in class AbstractCacheStore

commit

public void commit(GlobalTransaction tx)

Description copied from interface: CacheStore

Commits 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). The implementation would need to deal with this case accordingly. 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, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

commit in interface CacheStore

Overrides:

commit in class AbstractCacheStore

Parameters:

tx - tx to commit

rollback

public void rollback(GlobalTransaction tx)

Description copied from interface: CacheStore

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). The implementation would need to deal with this case accordingly. 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, ThreadLocals should not be relied upon to maintain transaction context.

Specified by:

rollback in interface CacheStore

Overrides:

rollback in class AbstractCacheStore

Parameters:

tx - tx to roll back

prepare

public void prepare(List<? extends Modification> list,
                    GlobalTransaction tx,
                    boolean isOnePhase)

Description copied from interface: CacheStore

Issues a prepare call with a set of modifications to be applied to the cache store

Specified by:

prepare in interface CacheStore

Overrides:

prepare in class AbstractCacheStore

Parameters:

list - modifications to be applied

tx - transaction identifier

isOnePhase - if true, there will not be a commit or rollback phase and changes should be flushed immediately

purgeInternal

protected void purgeInternal()
                      throws CacheLoaderException

Specified by:

purgeInternal in class AbstractCacheStore

Throws:

CacheLoaderException