org.infinispan.loaders.jdbc.mixed
Class JdbcMixedCacheStore

java.lang.Object
  org.infinispan.loaders.AbstractCacheLoader
      org.infinispan.loaders.AbstractCacheStore
          org.infinispan.loaders.jdbc.mixed.JdbcMixedCacheStore

All Implemented Interfaces:

CacheLoader, CacheStore

public class JdbcMixedCacheStore
extends AbstractCacheStore

Cache store that combines functionality of JdbcBinaryCacheStore and JdbcStringBasedCacheStore. It aggregates an instance of JdbcBinaryCacheStore and JdbcStringBasedCacheStore, delegating work to one of them (sometimes both, see below) based on the passed in key. In order to determine which store to use it will rely on the configured Key2StringMapper )(see configuration).

The advantage it brings is the possibility of efficiently storing string(able) keyed InternalCacheEntrys, and at the same time being able to store any other keys, a la JdbcBinaryCacheStore.

There will only be a performance cost for the aggregate operations: loadAll, fromStream, toStream and clear. For these operations there will be two distinct database call, one for each JdbcStore implementation. Most of application are only using these operations at lifecycles changes (e.g. fromStream and toStream at cluster join time, loadAll at startup for warm caches), so performance drawback shouldn't be significant (again, most of the cases).

Resource sharing - both aggregated cache loaders have locks and connection pools. The locking is not shared, each loader keeping its own StripedLock instance. Also the tables (even though similar as definition) are different in order to avoid key collision. On the other hand, the connection pooling is a shared resource.

Author:

Mircea.Markus@jboss.com

See Also:

JdbcMixedCacheStoreConfig, JdbcBinaryCacheStore, JdbcStringBasedCacheStore

Field Summary

Fields inherited from class org.infinispan.loaders.AbstractCacheStore

cache, marshaller, multiThreadedPurge, purgerService

Constructor Summary

JdbcMixedCacheStore()

Method Summary

void	clear() Clears all entries in the store
void	fromStream(ObjectInput inputStream) Writes contents of the stream to the store.
JdbcBinaryCacheStore	getBinaryCacheStore()
Class<? extends CacheLoaderConfig>	getConfigurationClass()
ConnectionFactory	getConnectionFactory()
JdbcStringBasedCacheStore	getStringBasedCacheStore()
void	init(CacheLoaderConfig config, Cache cache, Marshaller m) Used to initialize a cache loader.
InternalCacheEntry	load(Object key) Loads an entry mapped to by a given key.
Set<InternalCacheEntry>	loadAll() Loads all entries in the loader.
protected void	purgeInternal()
boolean	remove(Object key) Removes an entry in the store.
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 org.infinispan.loaders.AbstractCacheStore

applyModifications, commit, getCacheStoreConfig, getConcurrencyLevel, getMarshaller, prepare, purgeExpired, removeAll, rollback, 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

JdbcMixedCacheStore

public JdbcMixedCacheStore()

Method Detail

init

public void init(CacheLoaderConfig config,
                 Cache cache,
                 Marshaller m)
          throws CacheLoaderException

Description copied from interface: CacheLoader

Used to initialize a cache loader. Typically invoked by the CacheLoaderManager when setting up cache loaders.

Specified by:

init in interface CacheLoader

Overrides:

init in class AbstractCacheStore

Parameters:

config - the cache loader configuration bean

cache - 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.

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

purgeInternal

protected void purgeInternal()
                      throws CacheLoaderException

Specified by:

purgeInternal in class AbstractCacheStore

Throws:

CacheLoaderException

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

store

public void store(InternalCacheEntry ed)
           throws CacheLoaderException

Description copied from interface: CacheStore

Stores an entry

Parameters:

ed - 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 Marshaller 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

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 Marshaller 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

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

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

getConfigurationClass

public Class<? extends CacheLoaderConfig> getConfigurationClass()

Returns:

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

getConnectionFactory

public ConnectionFactory getConnectionFactory()

getBinaryCacheStore

public JdbcBinaryCacheStore getBinaryCacheStore()

getStringBasedCacheStore

public JdbcStringBasedCacheStore getStringBasedCacheStore()