ModuleCacheProvider (Jahia Server Implementation 8.0.0.0 API)

java.lang.Object
- org.jahia.services.render.filter.cache.ModuleCacheProvider

All Implemented Interfaces:

EventListener, org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationListener<JahiaTemplateManagerService.TemplatePackageRedeployedEvent>
```
public class ModuleCacheProvider
extends Object
implements org.springframework.beans.factory.InitializingBean, org.springframework.context.ApplicationListener<JahiaTemplateManagerService.TemplatePackageRedeployedEvent>
```
Instantiates and provides access to the module output and dependency caches.

Author:

Cedric Mailleux, Sergiy Shyrkov

Constructor Summary

Constructors
Constructor and Description

ModuleCacheProvider()

Constructors
Constructor and Description
`ModuleCacheProvider()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addNonCacheableFragment(String key)` Set the given fragment key as non-cacheable
`void`	`afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`void`	`flushCaches()`
`void`	`flushChildrenDependenciesOfPath(String path, boolean propagateToOtherClusterNodes)` Flush Children dependencies of a specific path
`void`	`flushNonCacheableFragments()` Flush the non-cacheable fragments list
`void`	`flushRegexpDependenciesOfPath(String path, boolean propagateToOtherClusterNodes)` Flushes dependencies if the provided node path matches the corresponding key in the `REGEXPDEPS_CACHE_NAME`} cache.
`net.sf.ehcache.Cache`	`getCache()`
`net.sf.ehcache.Cache`	`getDependenciesCache()`
`static ModuleCacheProvider`	`getInstance()`
`CacheKeyGenerator`	`getKeyGenerator()`
`net.sf.ehcache.Cache`	`getRegexpDependenciesCache()`
`net.sf.ehcache.Cache`	`getSyncCache()`
`void`	`invalidate(Collection<String> nodePathOrIdentifiers, boolean propagateToOtherClusterNodes)`
`void`	`invalidate(String nodePathOrIdentifier)` Flushes all the cache entries, related to the specified node.
`void`	`invalidate(String nodePathOrIdentifier, boolean propagateToOtherClusterNodes)` Flushes all the cache entries, related to the specified node.
`void`	`invalidateRegexp(String key)`
`void`	`invalidateRegexp(String key, boolean propagateToOtherClusterNodes)`
`boolean`	`isNonCacheableFragment(String key)` Check if fragment key is known as non-cacheable
`void`	`onApplicationEvent(JahiaTemplateManagerService.TemplatePackageRedeployedEvent templatePackageRedeployedEvent)`
`void`	`propagateChildrenDependenciesFlushToCluster(String path, boolean propagateToOtherClusterNodes)`
`void`	`propagateFlushRegexpDependenciesOfPath(String key, boolean propagateToOtherClusterNodes)`
`void`	`propagatePathFlushToCluster(String nodePathOrIdentifier)`
`void`	`removeNonCacheableFragmentsByEncodedPath(String key)` Remove keys from the non-cacheable fragments list by path encoded in the cache key given as parameter
`void`	`setAggregateCacheFilter(AggregateCacheFilter aggregateCacheFilter)`
`void`	`setCacheProvider(EhCacheProvider cacheProvider)`
`void`	`setJcrSessionFactory(JCRSessionFactory jcrSessionFactory)` Deprecated.
`void`	`setKeyGenerator(CacheKeyGenerator keyGenerator)` Injects the cache key generator implementation.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ModuleCacheProvider
```
public ModuleCacheProvider()
```
- Method Detail
  - getInstance
```
public static ModuleCacheProvider getInstance()
```
    Returns:
    
    an instance of this class
  - afterPropertiesSet
```
public void afterPropertiesSet()
                        throws Exception
```
    Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
    This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.
    
    Specified by:
    
    afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean
    
    Throws:
    
    Exception - in the event of misconfiguration (such as failure to set an essential property) or if initialization fails.
  - invalidate
```
public void invalidate(String nodePathOrIdentifier)
```
    Flushes all the cache entries, related to the specified node.
    
    Parameters:
    
    nodePathOrIdentifier - the node path or node uuid to be invalidated.
  - invalidate
```
public void invalidate(String nodePathOrIdentifier,
                       boolean propagateToOtherClusterNodes)
```
    Flushes all the cache entries, related to the specified node.
    
    Parameters:
    
    nodePathOrIdentifier - the node path or node uuid to be invalidated.
    
    propagateToOtherClusterNodes - do notify replicators of this event
  - invalidate
```
public void invalidate(Collection<String> nodePathOrIdentifiers,
                       boolean propagateToOtherClusterNodes)
```
  - getCache
```
public net.sf.ehcache.Cache getCache()
```
  - getDependenciesCache
```
public net.sf.ehcache.Cache getDependenciesCache()
```
  - getKeyGenerator
```
public CacheKeyGenerator getKeyGenerator()
```
  - setCacheProvider
```
public void setCacheProvider(EhCacheProvider cacheProvider)
```
  - setKeyGenerator
```
public void setKeyGenerator(CacheKeyGenerator keyGenerator)
```
    Injects the cache key generator implementation.
    
    Parameters:
    
    keyGenerator - the cache key generator implementation to use
  - flushCaches
```
public void flushCaches()
```
  - getRegexpDependenciesCache
```
public net.sf.ehcache.Cache getRegexpDependenciesCache()
```
  - invalidateRegexp
```
public void invalidateRegexp(String key)
```
  - invalidateRegexp
```
public void invalidateRegexp(String key,
                             boolean propagateToOtherClusterNodes)
```
  - propagateFlushRegexpDependenciesOfPath
```
public void propagateFlushRegexpDependenciesOfPath(String key,
                                                   boolean propagateToOtherClusterNodes)
```
  - propagateChildrenDependenciesFlushToCluster
```
public void propagateChildrenDependenciesFlushToCluster(String path,
                                                        boolean propagateToOtherClusterNodes)
```
  - flushChildrenDependenciesOfPath
```
public void flushChildrenDependenciesOfPath(String path,
                                            boolean propagateToOtherClusterNodes)
```
    Flush Children dependencies of a specific path
    
    Parameters:
    
    path - path to flush all its children cache
    
    propagateToOtherClusterNodes - true if it should propagate to other cluster nodes
  - flushRegexpDependenciesOfPath
```
public void flushRegexpDependenciesOfPath(String path,
                                          boolean propagateToOtherClusterNodes)
```
    Flushes dependencies if the provided node path matches the corresponding key in the REGEXPDEPS_CACHE_NAME} cache.
    
    Parameters:
    
    path - the concerned node path
    
    propagateToOtherClusterNodes - true in case the flush event should be propagated to other cluster nodes
  - addNonCacheableFragment
```
public void addNonCacheableFragment(String key)
```
    Set the given fragment key as non-cacheable
    
    Parameters:
    
    key - fragment key
  - removeNonCacheableFragmentsByEncodedPath
```
public void removeNonCacheableFragmentsByEncodedPath(String key)
```
    Remove keys from the non-cacheable fragments list by path encoded in the cache key given as parameter
    
    Parameters:
    
    key - fragment key of the fragment
  - flushNonCacheableFragments
```
public void flushNonCacheableFragments()
```
    Flush the non-cacheable fragments list
  - isNonCacheableFragment
```
public boolean isNonCacheableFragment(String key)
```
    Check if fragment key is known as non-cacheable
    
    Parameters:
    
    key - fragment key
    
    Returns:
    
    whether the fragment is known as non-cacheable
  - propagatePathFlushToCluster
```
public void propagatePathFlushToCluster(String nodePathOrIdentifier)
```
  - setJcrSessionFactory
```
@Deprecated
public void setJcrSessionFactory(JCRSessionFactory jcrSessionFactory)
```
    Deprecated.
  - getSyncCache
```
public net.sf.ehcache.Cache getSyncCache()
```
  - setAggregateCacheFilter
```
public void setAggregateCacheFilter(AggregateCacheFilter aggregateCacheFilter)
```
  - onApplicationEvent
```
public void onApplicationEvent(JahiaTemplateManagerService.TemplatePackageRedeployedEvent templatePackageRedeployedEvent)
```
    Specified by:
    
    onApplicationEvent in interface org.springframework.context.ApplicationListener<JahiaTemplateManagerService.TemplatePackageRedeployedEvent>

Class ModuleCacheProvider

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ModuleCacheProvider

Method Detail

getInstance

afterPropertiesSet

invalidate

invalidate

invalidate

getCache

getDependenciesCache

getKeyGenerator

setCacheProvider

setKeyGenerator

flushCaches

getRegexpDependenciesCache

invalidateRegexp

invalidateRegexp

propagateFlushRegexpDependenciesOfPath

propagateChildrenDependenciesFlushToCluster

flushChildrenDependenciesOfPath

flushRegexpDependenciesOfPath

addNonCacheableFragment

removeNonCacheableFragmentsByEncodedPath

flushNonCacheableFragments

isNonCacheableFragment

propagatePathFlushToCluster

setJcrSessionFactory

getSyncCache

setAggregateCacheFilter

onApplicationEvent