public class DefaultCacheManager extends Object implements EmbeddedCacheManager
Cache
instance, and is often used as a
starting point to using the Cache
.
CacheManagers are heavyweight objects, and we foresee no more than one CacheManager being used per
JVM (unless specific configuration requirements require more than one; but either way, this would be a minimal and
finite number of instances).
Constructing a CacheManager is done via one of its constructors, which optionally take in a Configuration
or a path or URL to a configuration XML file.
Lifecycle - CacheManagers have a lifecycle (it implements Lifecycle
) and the default constructors
also call DefaultCacheManager.start()
. Overloaded versions of the constructors are available, that do not start the
CacheManager, although it must be kept in mind that CacheManagers need to be started before they
can be used to create Cache instances.
Once constructed, CacheManagers should be made available to any component that requires a Cache,
via JNDI or via some other mechanism such as an IoC container.
You obtain Cache instances from the CacheManager by using one of the overloaded
getCache(), methods. Note that with getCache(), there is no guarantee that the instance you get is
brand-new and empty, since caches are named and shared. Because of this, the CacheManager also acts as a
repository of Caches, and is an effective mechanism of looking up or creating Caches on demand.
When the system shuts down, it should call DefaultCacheManager.stop()
on the CacheManager. This will ensure all caches
within its scope are properly stopped as well.
Sample usage:
CacheManager manager = CacheManager.getInstance("my-config-file.xml");
Cache<String, Person> entityCache = manager.getCache("myEntityCache");
entityCache.put("aPerson", new Person());
ConfigurationBuilder confBuilder = new ConfigurationBuilder();
confBuilder.clustering().cacheMode(CacheMode.REPL_SYNC);
manager.defineConfiguration("myReplicatedCache", confBuilder.build());
Cache<String, String> replicatedCache = manager.getCache("myReplicatedCache");
Modifier and Type | Field and Description |
---|---|
protected Configuration |
defaultConfiguration |
protected GlobalConfiguration |
globalConfiguration |
static String |
OBJECT_NAME |
DEFAULT_CACHE_NAME
Constructor and Description |
---|
DefaultCacheManager()
Constructs and starts a default instance of the CacheManager, using configuration defaults.
|
DefaultCacheManager(boolean start)
Constructs a default instance of the CacheManager, using configuration defaults.
|
DefaultCacheManager(Configuration defaultConfiguration)
Constructs and starts a new instance of the CacheManager, using the default configuration passed in.
|
DefaultCacheManager(Configuration defaultConfiguration,
boolean start)
Constructs a new instance of the CacheManager, using the default configuration passed in.
|
DefaultCacheManager(ConfigurationBuilderHolder holder,
boolean start)
Constructs a new instance of the CacheManager, using the holder passed in to read configuration settings.
|
DefaultCacheManager(GlobalConfiguration globalConfiguration)
Constructs and starts a new instance of the CacheManager, using the global configuration passed in, and system
defaults for the default named cache configuration.
|
DefaultCacheManager(GlobalConfiguration globalConfiguration,
boolean start)
Constructs a new instance of the CacheManager, using the global configuration passed in, and system defaults for
the default named cache configuration.
|
DefaultCacheManager(GlobalConfiguration globalConfiguration,
Configuration defaultConfiguration)
Constructs and starts a new instance of the CacheManager, using the global and default configurations passed in.
|
DefaultCacheManager(GlobalConfiguration globalConfiguration,
Configuration defaultConfiguration,
boolean start)
Constructs a new instance of the CacheManager, using the global and default configurations passed in.
|
DefaultCacheManager(InputStream configurationStream)
Constructs and starts a new instance of the CacheManager, using the input stream passed in to read configuration
file contents.
|
DefaultCacheManager(InputStream configurationStream,
boolean start)
Constructs a new instance of the CacheManager, using the input stream passed in to read configuration file
contents.
|
DefaultCacheManager(String configurationFile)
Constructs and starts a new instance of the CacheManager, using the configuration file name passed in.
|
DefaultCacheManager(String configurationFile,
boolean start)
Constructs a new instance of the CacheManager, using the configuration file name passed in.
|
DefaultCacheManager(String globalConfigurationFile,
String defaultConfigurationFile,
String namedCacheFile,
boolean start)
Deprecated.
|
Modifier and Type | Method and Description |
---|---|
void |
addCacheDependency(String from,
String to)
Add a dependency between two caches.
|
void |
addListener(Object listener)
Adds a listener to the component.
|
boolean |
cacheExists(String cacheName)
A cache is considered to exist if it has been created and started via
one of the
CacheContainer.getCache() methods and has not yet been removed via
EmbeddedCacheManager.removeCache(String) . |
Configuration |
defineConfiguration(String cacheName,
Configuration configuration)
Defines a named cache's configuration using the following algorithm:
Unlike previous versions of Infinispan, this method does not build on an existing configuration (default or named).
|
Configuration |
defineConfiguration(String cacheName,
String templateName,
Configuration configurationOverride)
Defines a named cache's configuration using the following algorithm:
Regardless of whether the cache name has been defined or not, this method creates a clone of the configuration of
the cache whose name matches the given template cache name, then applies a clone of the configuration overrides
passed in and finally returns this configuration instance.
|
Address |
getAddress() |
<K,V> Cache<K,V> |
getCache()
Retrieves the default cache associated with this cache manager.
|
<K,V> Cache<K,V> |
getCache(String cacheName)
Retrieves a named cache from the system.
|
<K,V> Cache<K,V> |
getCache(String cacheName,
boolean createIfAbsent)
Retrieves a named cache from the system in the same way that
CacheContainer.getCache(String) does except that if offers the possibility for the
named cache not to be retrieved if it has not yet been started, or if
it's been removed after being started. |
Configuration |
getCacheConfiguration(String name)
Returns the configuration for the given cache.
|
GlobalConfiguration |
getCacheManagerConfiguration()
Returns global configuration for this CacheManager
|
String |
getCacheManagerStatus() |
Set |
getCacheNames()
This method returns a collection of caches names which contains the
caches that have been defined via XML or programmatically, and the
caches that have been created at runtime via this cache manager
instance.
|
String |
getClusterMembers() |
String |
getClusterName() |
int |
getClusterSize() |
Address |
getCoordinator() |
String |
getCreatedCacheCount() |
Configuration |
getDefaultCacheConfiguration()
Returns default configuration for this CacheManager
|
String |
getDefinedCacheCount() |
String |
getDefinedCacheNames() |
GlobalComponentRegistry |
getGlobalComponentRegistry() |
Properties |
getGlobalConfigurationAsProperties() |
Set |
getListeners() |
List |
getMembers() |
String |
getName() |
String |
getNodeAddress() |
String |
getPhysicalAddresses() |
String |
getRunningCacheCount() |
ComponentStatus |
getStatus() |
Transport |
getTransport() |
String |
getVersion() |
boolean |
isCoordinator() |
boolean |
isDefaultRunning()
Tests whether the default cache is running.
|
boolean |
isRunning(String cacheName)
Tests whether a named cache is running.
|
void |
removeCache(String cacheName)
Removes a cache with the given name from the system.
|
void |
removeListener(Object listener)
Removes a listener from the component.
|
void |
start() |
void |
startCache() |
void |
startCache(String cacheName) |
EmbeddedCacheManager |
startCaches(String... cacheNames)
Starts a set of caches in parallel.
|
void |
stop() |
String |
toString() |
public static final String OBJECT_NAME
protected final GlobalConfiguration globalConfiguration
protected final Configuration defaultConfiguration
public DefaultCacheManager()
Configuration
and GlobalConfiguration
for details of these defaults.public DefaultCacheManager(boolean start)
Configuration
and GlobalConfiguration
for details of these defaults.start
- if true, the cache manager is startedpublic DefaultCacheManager(Configuration defaultConfiguration)
Configuration
and GlobalConfiguration
for details of these defaults.defaultConfiguration
- configuration to use as a template for all caches createdpublic DefaultCacheManager(Configuration defaultConfiguration, boolean start)
GlobalConfiguration
for details of these defaults.defaultConfiguration
- configuration file to use as a template for all caches createdstart
- if true, the cache manager is startedpublic DefaultCacheManager(GlobalConfiguration globalConfiguration)
Configuration
for details of these defaults.globalConfiguration
- GlobalConfiguration to use for all caches createdpublic DefaultCacheManager(GlobalConfiguration globalConfiguration, boolean start)
Configuration
for details of these defaults.globalConfiguration
- GlobalConfiguration to use for all caches createdstart
- if true, the cache manager is started.public DefaultCacheManager(GlobalConfiguration globalConfiguration, Configuration defaultConfiguration)
globalConfiguration
- global configuration to use. If null, a default instance is created.defaultConfiguration
- default configuration to use. If null, a default instance is created.public DefaultCacheManager(GlobalConfiguration globalConfiguration, Configuration defaultConfiguration, boolean start)
globalConfiguration
- global configuration to use. If null, a default instance is created.defaultConfiguration
- default configuration to use. If null, a default instance is created.start
- if true, the cache manager is startedpublic DefaultCacheManager(String configurationFile)
configurationFile
- name of configuration file to use as a template for all caches createdIOException
- if there is a problem with the configuration file.public DefaultCacheManager(String configurationFile, boolean start)
configurationFile
- name of configuration file to use as a template for all caches createdstart
- if true, the cache manager is startedIOException
- if there is a problem with the configuration file.public DefaultCacheManager(InputStream configurationStream)
configurationStream
- stream containing configuration file contents, to use as a template for all caches
createdIOException
- if there is a problem with the configuration stream.public DefaultCacheManager(InputStream configurationStream, boolean start)
configurationStream
- stream containing configuration file contents, to use as a template for all caches
createdstart
- if true, the cache manager is startedIOException
- if there is a problem reading the configuration streampublic DefaultCacheManager(ConfigurationBuilderHolder holder, boolean start)
holder
- holder containing configuration settings, to use as a template for all caches
createdstart
- if true, the cache manager is started@Deprecated public DefaultCacheManager(String globalConfigurationFile, String defaultConfigurationFile, String namedCacheFile, boolean start)
start
- if true, the cache manager is startedglobalConfigurationFile
- name of file that contains the global configurationdefaultConfigurationFile
- name of file that contains the default configurationnamedCacheFile
- name of file that contains the named cache configurationIOException
- if there is a problem with the configuration file.public Configuration defineConfiguration(String cacheName, Configuration configuration)
EmbeddedCacheManager
ConfigurationBuilder.read(org.infinispan.configuration.cache.Configuration)
.
The other way to define named cache's configuration is declaratively, in the XML file passed in to the cache
manager. This method enables you to override certain properties that have previously been defined via XML.
Passing a brand new Configuration instance as configuration override without having called any of its setters will
effectively return the named cache's configuration since no overrides where passed to it.defineConfiguration
in interface EmbeddedCacheManager
cacheName
- name of cache whose configuration is being definedconfiguration
- configuration overrides to usepublic Configuration defineConfiguration(String cacheName, String templateName, Configuration configurationOverride)
EmbeddedCacheManager
EmbeddedCacheManager.defineConfiguration(String, Configuration)
in the sense that the base configuration used is the default cache
configuration.defineConfiguration
in interface EmbeddedCacheManager
cacheName
- name of cache whose configuration is being definedtemplateName
- name of cache to which to which apply overrides if cache name has not been previously
definedconfigurationOverride
- configuration overrides to usepublic <K,V> Cache<K,V> getCache()
DefaultCacheManager.createCache(String)
since it is automatically created lazily when first used.
As such, this method is always guaranteed to return the default cache.getCache
in interface BasicCacheContainer
getCache
in interface CacheContainer
public <K,V> Cache<K,V> getCache(String cacheName)
DefaultCacheManager.defineConfiguration(String, Configuration)
or DefaultCacheManager.defineConfiguration(String, String, Configuration)
methods, or declared in the configuration file.getCache
in interface BasicCacheContainer
getCache
in interface CacheContainer
cacheName
- name of cache to retrievepublic boolean cacheExists(String cacheName)
EmbeddedCacheManager
CacheContainer.getCache()
methods and has not yet been removed via
EmbeddedCacheManager.removeCache(String)
.
In environments when caches are continuously created and removed, this
method offers the possibility to find out whether a cache has either,
not been started, or if it was started, whether it's been removed already
or not.cacheExists
in interface EmbeddedCacheManager
public <K,V> Cache<K,V> getCache(String cacheName, boolean createIfAbsent)
EmbeddedCacheManager
CacheContainer.getCache(String)
does except that if offers the possibility for the
named cache not to be retrieved if it has not yet been started, or if
it's been removed after being started.getCache
in interface EmbeddedCacheManager
cacheName
- name of cache to retrievecreateIfAbsent
- if false, the named cache will not be
retrieved if it hasn't been retrieved previously or if it's been
removed. If true, this methods works just like CacheContainer.getCache(String)
public EmbeddedCacheManager startCaches(String... cacheNames)
EmbeddedCacheManager
startCaches
in interface EmbeddedCacheManager
cacheNames
- the names of the caches to startpublic void removeCache(String cacheName)
EmbeddedCacheManager
removeCache
in interface EmbeddedCacheManager
cacheName
- name of cache to removepublic List getMembers()
getMembers
in interface EmbeddedCacheManager
public Address getAddress()
getAddress
in interface EmbeddedCacheManager
public Address getCoordinator()
getCoordinator
in interface EmbeddedCacheManager
public boolean isCoordinator()
isCoordinator
in interface EmbeddedCacheManager
public void addListener(Object listener)
Listenable
Listener
and
further to that, contain methods annotated appropriately, otherwise the listener will not be registered.
See the Listener
annotation for more information.
addListener
in interface Listenable
listener
- must not be null.public void removeListener(Object listener)
Listenable
removeListener
in interface Listenable
listener
- listener to remove. Must not be null.public Set getListeners()
getListeners
in interface Listenable
public ComponentStatus getStatus()
getStatus
in interface EmbeddedCacheManager
public GlobalConfiguration getCacheManagerConfiguration()
EmbeddedCacheManager
getCacheManagerConfiguration
in interface EmbeddedCacheManager
public Configuration getDefaultCacheConfiguration()
EmbeddedCacheManager
getDefaultCacheConfiguration
in interface EmbeddedCacheManager
public Configuration getCacheConfiguration(String name)
EmbeddedCacheManager
getCacheConfiguration
in interface EmbeddedCacheManager
public Set getCacheNames()
EmbeddedCacheManager
getCacheNames
in interface EmbeddedCacheManager
public boolean isRunning(String cacheName)
EmbeddedCacheManager
isRunning
in interface EmbeddedCacheManager
cacheName
- name of cache to test.public boolean isDefaultRunning()
EmbeddedCacheManager
isDefaultRunning
in interface EmbeddedCacheManager
public String getCacheManagerStatus()
public String getDefinedCacheNames()
public String getDefinedCacheCount()
public String getCreatedCacheCount()
public String getRunningCacheCount()
public String getVersion()
public String getName()
public void startCache()
public void startCache(String cacheName)
public String getNodeAddress()
public String getPhysicalAddresses()
public String getClusterMembers()
public int getClusterSize()
public String getClusterName()
getClusterName
in interface EmbeddedCacheManager
public Transport getTransport()
getTransport
in interface EmbeddedCacheManager
public GlobalComponentRegistry getGlobalComponentRegistry()
getGlobalComponentRegistry
in interface EmbeddedCacheManager
public void addCacheDependency(String from, String to)
EmbeddedCacheManager
addCacheDependency
in interface EmbeddedCacheManager
from
- cache nameto
- cache namepublic Properties getGlobalConfigurationAsProperties()
Copyright © 2015 JBoss, a division of Red Hat. All rights reserved.