Package com.tangosol.net

Class ExtensibleConfigurableCacheFactory

java.lang.Object
com.tangosol.util.Base
com.tangosol.net.ExtensibleConfigurableCacheFactory
All Implemented Interfaces:
ConfigurableCacheFactory
public class ExtensibleConfigurableCacheFactory extends Base implements ConfigurableCacheFactory
ExtensibleConfigurableCacheFactory provides a facility to access caches declared in a "coherence-cache-config.xsd" compliant configuration file.

It is strongly recommended that developers get a ConfigurableCacheFactory instance via CacheFactory.getCacheFactoryBuilder().getConfigurableCacheFactory(), rather than instantiate an ExtensibleConfigurableCacheFactory instance directly.

There are various ways of using this factory: 

   ExtensibleConfigurableCacheFactory.Dependencies deps =
       ExtensibleConfigurableCacheFactory.DependenciesHelper.newInstance("my-cache-config.xml");
   ExtensibleConfigurableCacheFactory factory =
       new ExtensibleConfigurableCacheFactory(deps);
   ...
   ClassLoader loader  = getClass().getClassLoader();
   NamedCache cacheOne = factory.ensureCache("one", loader);
   NamedCache cacheTwo = factory.ensureCache("two", loader);
Another option is using the static version of the "ensureCache" call: 
   ClassLoader loader  = getClass().getClassLoader();
   NamedCache cacheOne = CacheFactory.getCache("one", loader);
which uses an instance of ConfigurableCacheFactory obtained by CacheFactory.getConfigurableCacheFactory().
Since:
Coherence 12.1.2
Author:
gg 2003.05.26, pfm 2012.12.19
See Also:

  • Field Details

    • FILE_CFG_CACHE

      public static final String FILE_CFG_CACHE
      The default configuration file name.
      See Also:

    • CACHE_NAME

      public static final String CACHE_NAME
      The name of the replaceable parameter representing the cache name.
      See Also:

    • CLASS_LOADER

      public static final String CLASS_LOADER
      The name of the replaceable parameter representing the class loader.
      See Also:

    • MGR_CONTEXT

      public static final String MGR_CONTEXT
      The name of the replaceable parameter representing the backing map manager context.
      See Also:

    • SCHEME_REF

      public static final String SCHEME_REF
      The name of the replaceable parameter representing a scheme reference.
      See Also:

    • CACHE_REF

      public static final String CACHE_REF
      The name of the replaceable parameter representing a cache reference.
      See Also:

    • CACHE_FACTORY

      public static final String CACHE_FACTORY
      The name of the replaceable parameter representing a cache factory.
      See Also:

    • SCHEME_UNKNOWN

      public static final int SCHEME_UNKNOWN
      The unknown scheme type.
      See Also:

    • SCHEME_REPLICATED

      public static final int SCHEME_REPLICATED
      The replicated cache scheme.
      See Also:

    • SCHEME_OPTIMISTIC

      public static final int SCHEME_OPTIMISTIC
      The optimistic cache scheme.
      See Also:

    • SCHEME_DISTRIBUTED

      public static final int SCHEME_DISTRIBUTED
      The distributed cache scheme.
      See Also:

    • SCHEME_NEAR

      public static final int SCHEME_NEAR
      The near cache scheme.
      See Also:

    • SCHEME_VERSIONED_NEAR

      public static final int SCHEME_VERSIONED_NEAR
      The versioned near cache scheme.
      See Also:

    • SCHEME_LOCAL

      public static final int SCHEME_LOCAL
      The local cache scheme.
      See Also:

    • SCHEME_OVERFLOW

      public static final int SCHEME_OVERFLOW
      The overflow map scheme.
      See Also:

    • SCHEME_DISK

      public static final int SCHEME_DISK
      Deprecated.
      As of Coherence 3.0, replaced by SCHEME_EXTERNAL and SCHEME_EXTERNAL_PAGED
      The disk scheme.
      See Also:

    • SCHEME_EXTERNAL

      public static final int SCHEME_EXTERNAL
      The external scheme.
      See Also:

    • SCHEME_EXTERNAL_PAGED

      public static final int SCHEME_EXTERNAL_PAGED
      The paged-external scheme.
      See Also:

    • SCHEME_CLASS

      public static final int SCHEME_CLASS
      The custom class scheme.
      See Also:

    • SCHEME_READ_WRITE_BACKING

      public static final int SCHEME_READ_WRITE_BACKING
      The read write backing map scheme.
      See Also:

    • SCHEME_VERSIONED_BACKING

      public static final int SCHEME_VERSIONED_BACKING
      The versioned backing map scheme.
      See Also:

    • SCHEME_INVOCATION

      public static final int SCHEME_INVOCATION
      The invocation service scheme.
      See Also:

    • SCHEME_PROXY

      public static final int SCHEME_PROXY
      The proxy service scheme.
      See Also:

    • SCHEME_REMOTE_CACHE

      public static final int SCHEME_REMOTE_CACHE
      The remote cache scheme.
      See Also:

    • SCHEME_REMOTE_INVOCATION

      public static final int SCHEME_REMOTE_INVOCATION
      The remote invocation scheme.
      See Also:

    • SCHEME_TRANSACTIONAL

      public static final int SCHEME_TRANSACTIONAL
      The transactional cache scheme.
      See Also:

    • SCHEME_FLASHJOURNAL

      public static final int SCHEME_FLASHJOURNAL
      The flash journal cache scheme.
      See Also:

    • SCHEME_RAMJOURNAL

      public static final int SCHEME_RAMJOURNAL
      The ram journal cache scheme.
      See Also:

    • MAP_SCHEMETYPE_BY_SCHEMENAME

      public static final HashMap<String,Integer> MAP_SCHEMETYPE_BY_SCHEMENAME
      The mappings from scheme name to scheme type.

    • f_store

      protected final com.tangosol.net.internal.ScopedCacheReferenceStore f_store
      Store that holds cache references scoped by class loader and optionally, if configured, Subject.

    • f_storeTopics

      protected final com.tangosol.net.internal.ScopedReferenceStore<NamedTopic> f_storeTopics
      Store that holds NamedTopic references scoped by class loader and optionally, if configured, Subject.

    • f_dispatcher

      protected final com.tangosol.net.events.internal.ConfigurableCacheFactoryDispatcher f_dispatcher
      ConfigurableCacheFactoryDispatcher linked to this cache factory.

    • m_mapServices

      protected Map<Service,String> m_mapServices
      Map used to hold references to services that are ensured by this factory where values are non-scoped service names.

    • m_setManager

      protected Set<BackingMapManager> m_setManager
      A Set of BackingMapManager instances registered by this factory.

      Note: we rely on the BackingMapManager classes *not* to override the hashCode() and equals() methods.

    • m_fActivated

      protected boolean m_fActivated
      Indicates whether this factory has been activated.

    • m_fDisposed

      protected boolean m_fDisposed
      Indicates whether this factory has been disposed.

  • Constructor Details

  • Method Details

    • ensureCache

      public <K, V> NamedCache<K,V> ensureCache(String sCacheName, ClassLoader loader, NamedMap.Option... options)
      Description copied from interface: ConfigurableCacheFactory
      Ensure an cache for the given name, classloader and options.
      Specified by:
      ensureCache in interface ConfigurableCacheFactory
      Parameters:
      sCacheName - the cache name
      loader - ClassLoader that should be used to deserialize objects in the cache
      options - the NamedMap.Options
      Returns:
      a NamedCache created

    • releaseCache

      public void releaseCache(NamedCache cache)
      Release a cache and its associated resources.

      Releasing a cache makes it no longer usable, but does not affect the cache itself. In other words, all other references to the cache will still be valid, and the cache data is not affected by releasing the reference. Any attempt to use the released cache reference afterword will result in an exception.

      Specified by:
      releaseCache in interface ConfigurableCacheFactory
      Parameters:
      cache - the cache to release

    • destroyCache

      public void destroyCache(NamedCache cache)
      Release and destroy this instance of NamedCache.

      Warning: This method is used to completely destroy the specified cache across the cluster. All references in the entire cluster to this cache will be invalidated, the cached data will be cleared, and all internal and associated resources will be released.

      Specified by:
      destroyCache in interface ConfigurableCacheFactory
      Parameters:
      cache - the cache to release

    • ensureTopic

      public <V> NamedTopic<V> ensureTopic(String sName, ClassLoader loader, NamedCollection.Option... options)
      Ensure an Object-based topic for the given name.
      Specified by:
      ensureTopic in interface ConfigurableCacheFactory
      Parameters:
      sName - the topic name
      loader - ClassLoader that should be used to deserialize objects in the cache
      options - the NamedCollection.Options to control any optional topic configuration
      Returns:
      a NamedTopic created

    • ensureService

      public Service ensureService(String sServiceName)
      Ensure a service for the given name.
      Specified by:
      ensureService in interface ConfigurableCacheFactory
      Parameters:
      sServiceName - the service name
      Returns:
      a Service created

    • activate

      public void activate()
      Activate prepares the factory to be used within a container and should be called before any other factory method.
      Specified by:
      activate in interface ConfigurableCacheFactory

    • dispose

      public void dispose()
      Dispose of this factory. This will stop all services that were started by this factory and dispose of all resources registered via ConfigurableCacheFactory.getResourceRegistry(). This factory may not be used after invoking dispose.
      Specified by:
      dispose in interface ConfigurableCacheFactory

    • getResourceRegistry

      public ResourceRegistry getResourceRegistry()
      Return the ResourceRegistry for this factory.
      Specified by:
      getResourceRegistry in interface ConfigurableCacheFactory
      Returns:
      the ResourceRegistry for this factory

    • getInterceptorRegistry

      public InterceptorRegistry getInterceptorRegistry()
      Return the InterceptorRegistry for this factory. EventInterceptors registered with this registry will be scoped to services and caches created by this factory.
      Specified by:
      getInterceptorRegistry in interface ConfigurableCacheFactory
      Returns:
      the InterceptorRegistry for this factory

    • isActive

      public boolean isActive()
      Returns true if this ExtensibleConfigurableCacheFactory is activated.
      Specified by:
      isActive in interface ConfigurableCacheFactory
      Returns:
      true if this ExtensibleConfigurableCacheFactory is activated

    • getScopeName

      public String getScopeName()
      Return the scope name for this ConfigurableCacheFactory. If specified, this name will be used as a prefix for the name of all services created by this factory.
      Specified by:
      getScopeName in interface ConfigurableCacheFactory
      Returns:
      the scope name for this ConfigurableCacheFactory; may be null

    • getRequestTimeout

      protected long getRequestTimeout(ServiceScheme scheme)
      Return the request timeout determined by the ServiceScheme.
      Parameters:
      scheme - the scheme that determines the request timeout
      Returns:
      the request timeout

    • isDisposed

      public boolean isDisposed()
      Return true if this factory has been disposed via invocation of dispose().
      Specified by:
      isDisposed in interface ConfigurableCacheFactory
      Returns:
      true if this factory has been disposed

    • assertNotDisposed

      protected void assertNotDisposed()
      Throws IllegalStateException if this factory has been disposed via invocation of dispose().

    • configure

      protected void configure()
      Performs final configuration of an ExtensibleConfigurableCacheFactory instance prior to it being used by Coherence.

      This method is called by the ExtensibleConfigurableCacheFactory constructor, just after the internal state has been initialized and before the ExtensibleConfigurableCacheFactory instance is returned to the caller.

      This method allows those that need to sub-class an ExtensibleConfigurableCacheFactory to override the final stages of configuration. Anyone overriding this method must be sure to call super.configure() in order to ensure correction configuration semantics.

    • ensureService

      public Service ensureService(ServiceScheme scheme)
      Ensure the service for the specified scheme then start the service if it isn't running.
      Parameters:
      scheme - the scheme referring to the service
      Returns:
      the corresponding Service

    • getCacheConfig

      public CacheConfig getCacheConfig()
      Return the CacheConfig that contains the configuration used by this factory.
      Returns:
      the CacheConfig

    • translateStandardSchemeType

      protected static int translateStandardSchemeType(String sScheme)
      Translate the scheme name into the scheme type. Valid scheme types are any of the SCHEME_* constants.
      Parameters:
      sScheme - the scheme name
      Returns:
      the scheme type

    • startServices

      public void startServices()
      Start all services that are declared as requiring an "autostart".

    • getServiceMap

      public Map<Service,String> getServiceMap()
      Return a map of services that were successfully started by this factory where values are corresponding non-scoped service names.

      Note, that this method returns a copy of the underlying map

    • startService

      protected void startService(Service service)
      Start the given Service. Extensions of this class can override this method to provide pre/post start functionality.
      Parameters:
      service - the Service to start

    • setConfigClassLoader

      protected void setConfigClassLoader(ClassLoader loader)
      Set the class loader used to load the configuration for this factory.
      Parameters:
      loader - the class loader to use for loading the configuration

    • getConfigClassLoader

      protected ClassLoader getConfigClassLoader()
      Return the class loader used to load the configuration for this factory.
      Returns:
      the class loader to use for loading the configuration

    • checkPermission

      protected static void checkPermission(NamedCache cache)
      Check if the current user is allowed to "join" the cache.
      Parameters:
      cache - the cache

    • checkPermission

      protected static void checkPermission(NamedCollection collection)
      Check if the current user is allowed to "join" to the collection.
      Parameters:
      collection - the collection

    • checkPermission

      protected static void checkPermission(Service service, String sName)
      Check if the current user is allowed to "join" the data structure with the specified name.
      Parameters:
      service - the service
      sName - the data structure name

    • getParameterResolver

      public ParameterResolver getParameterResolver(String sCacheName, ClassLoader loader, BackingMapManagerContext ctxBMM)
      Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined in the cache mapping needed to translate those expressions into values.
      Parameters:
      sCacheName - the cache name
      loader - the ClassLoader
      ctxBMM - the BackingMapManagerContext
      Returns:
      the ParameterResolver

    • getParameterResolver

      public <M extends ResourceMapping> ParameterResolver getParameterResolver(String sResourceName, Class<M> clzResourceMapping, ClassLoader loader, BackingMapManagerContext ctxBMM)
      Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined in the cache mapping needed to translate those expressions into values.
      Parameters:
      sResourceName - the resource name
      clzResourceMapping - resource type
      loader - the ClassLoader
      ctxBMM - the BackingMapManagerContext
      Returns:
      the ParameterResolver
      Since:
      14.1.1.0

    • createParameterResolver

      public ParameterResolver createParameterResolver(ClassLoader loader, BackingMapManagerContext ctxBMM)
      Return the ParameterResolver that has been initialized with the built-in Coherence parameters. Schemes may use expressions (macros) and the resolver contains the parameters that are defined for components defined at a scheme level and not a cache level.
      Parameters:
      loader - the ClassLoader
      ctxBMM - the BackingMapManagerContext
      Returns:
      the ParameterResolver

    • registerBackingMapManager

      protected void registerBackingMapManager(BackingMapManager mgr)
      Register the specified BackingMapManager as a "valid" one. That registry is used to identify services configured and started by this factory and prevent accidental usage of (potentially incompatible) cache services with the same name created by other factories.
      Parameters:
      mgr - a BackingMapManager instance instantiated by this factory

    • validateBackingMapManager

      protected void validateBackingMapManager(CacheService service) throws IllegalStateException
      Ensures that the backing map manager of the specified service was configured by this (or equivalent) factory. This validation is performed to prevent accidental usage of (potentially incompatible) cache services with the same name created by other factories.
      Parameters:
      service - the CacheService to validate
      Throws:
      IllegalStateException - if the backing map for the provided service does not reference the expected factory

    • release

      protected void release(Map map, Map mapListeners)
      Release all resources associated with the specified backing map.
      Parameters:
      map - the map being released
      mapListeners - map of registered map listeners keyed by the corresponding map references

    • release

      protected void release(CacheLoader loader)
      Release all resources associated with the specified loader.
      Parameters:
      loader - the cache loader being released

    • release

      protected void release(BinaryStore store)
      Release all resources associated with the specified binary store.
      Parameters:
      store - the binary store being released

    • releaseCache

      protected void releaseCache(NamedCache cache, boolean fDestroy)
      Release a cache managed by this factory, optionally destroying it.
      Parameters:
      cache - the cache to release
      fDestroy - true to destroy the cache as well

    • releaseTopic

      public void releaseTopic(NamedTopic<?> topic)
      Release a NamedTopic and its associated resources.

      Releasing a topic makes it no longer usable, but does not affect the topic itself. In other words, all other references to the topic will still be valid, and the topic data is not affected by releasing the reference. Any attempt to use the released topic reference afterword will result in an exception.

      Specified by:
      releaseTopic in interface ConfigurableCacheFactory
      Parameters:
      topic - the topic to release

    • destroyTopic

      public void destroyTopic(NamedTopic<?> topic)
      Release and destroy this instance of NamedTopic.

      Warning: This method is used to completely destroy the specified topic across the cluster. All references in the entire cluster to this topic will be invalidated, the topic data will be cleared, and all internal and associated resources will be released.

      Specified by:
      destroyTopic in interface ConfigurableCacheFactory
      Parameters:
      topic - the topic to release

    • isCacheActive

      public boolean isCacheActive(String sCacheName, ClassLoader loader)
      Validate whether a cache with the given name is active in the context of the given ClassLoader. The ClassLoader should be the same as provided to a previous call to ConfigurableCacheFactory.ensureCache(String, ClassLoader, NamedCache.Option...).
      Specified by:
      isCacheActive in interface ConfigurableCacheFactory
      Parameters:
      sCacheName - the cache name
      loader - the ClassLoader used to originally obtain the cache
      Returns:
      true if cache is active in context of the provided ClassLoader

    • isTopicActive

      public boolean isTopicActive(String sTopicName, ClassLoader loader)
      Validate whether a topic with the given name is active in the context of the given ClassLoader. The ClassLoader should be the same as provided to a previous call to ConfigurableCacheFactory.ensureTopic(String, ClassLoader, NamedTopic.Option...).
      Specified by:
      isTopicActive in interface ConfigurableCacheFactory
      Parameters:
      sTopicName - the topic name
      loader - the ClassLoader used to originally obtain the topic
      Returns:
      true if topic is active in context of the provided ClassLoader