info.magnolia.module.cache.cachepolicy

Class Default

java.lang.Object

info.magnolia.module.cache.cachepolicy.Default

All Implemented Interfaces:

CachePolicy

public class Default
extends Object
implements CachePolicy

A basic CachePolicy driven by shouldBypassVoters. This policy implementation uses DefaultCacheKey to identify each cache entry.

Field Summary

Fields

Modifier and Type	Field and Description
static String	UUID_KEY_MAP_KEY

Constructor Summary

Constructors

Constructor and Description
Default(CacheModule cacheModule, javax.inject.Provider<CacheInstructor> cacheInstructorProvider)

Method Summary

Modifier and Type	Method and Description
CacheKeyGenerator<?>	getCacheKeyGenerator()
info.magnolia.voting.voters.VoterSet	getShouldBypassVoters()
info.magnolia.voting.voters.VoterSet<CacheResponseWrapper>	getTtlVoters()
boolean	isRefreshOnNoCacheRequests()
void	persistCacheKey(String repo, String uuid, Object key) Persists mapping between uuid and cache key in case the given cache policy implementation cares about such details.
Object[]	removeCacheKeys(String uuid, String repository) Returns cache keys for the given item or null if such keys can't be obtained or policy doesn't want to share it.
Object	retrieveCacheKey(info.magnolia.cms.core.AggregationState aggregationState) Returns cache key for the given item or null if such key can't be obtained or policy doesn't want to share it.
Object[]	retrieveCacheKeys(String uuid, String repository) Returns cache keys for the given item or null if such keys can't be obtained or policy doesn't want to share it.
void	setCacheKeyGenerator(CacheKeyGenerator<?> cacheKeyGenerator)
void	setRefreshOnNoCacheRequests(boolean allowNoCacheHeader)
void	setShouldBypassVoters(info.magnolia.voting.voters.VoterSet shouldBypassVoters)
void	setTtlVoters(info.magnolia.voting.voters.VoterSet<CacheResponseWrapper> ttlVoters)
protected boolean	shouldBypass(info.magnolia.cms.core.AggregationState aggregationState, Object key)
CachePolicyResult	shouldCache(Cache cache, info.magnolia.cms.core.AggregationState aggregationState, FlushPolicy flushPolicy) Implementations can chose whether to cache or not - but note that the aggregationState might not be completely populated.
protected boolean	shouldRefresh(info.magnolia.cms.core.AggregationState aggregationState, Object key) Checks whether requested content should be served from cache or refreshed instead.

Methods inherited from class java.lang.Object

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

Field Detail

UUID_KEY_MAP_KEY

public static final String UUID_KEY_MAP_KEY

See Also:

Constant Field Values

Constructor Detail

Default

@Inject
public Default(CacheModule cacheModule,
                       javax.inject.Provider<CacheInstructor> cacheInstructorProvider)

Method Detail

shouldCache

public CachePolicyResult shouldCache(Cache cache,
                                     info.magnolia.cms.core.AggregationState aggregationState,
                                     FlushPolicy flushPolicy)

Description copied from interface: CachePolicy

Implementations can chose whether to cache or not - but note that the aggregationState might not be completely populated. Every request should be cacheable, not only those processed through Magnolia's RenderingFilter.

Specified by:

shouldCache in interface CachePolicy

shouldRefresh

protected boolean shouldRefresh(info.magnolia.cms.core.AggregationState aggregationState,
                                Object key)

Checks whether requested content should be served from cache or refreshed instead.

Returns:

True if cache entry for the key should be recreated, false otherwise.

shouldBypass

protected boolean shouldBypass(info.magnolia.cms.core.AggregationState aggregationState,
                               Object key)

retrieveCacheKey

public Object retrieveCacheKey(info.magnolia.cms.core.AggregationState aggregationState)

Description copied from interface: CachePolicy

Returns cache key for the given item or null if such key can't be obtained or policy doesn't want to share it. When using aggregationState, key is expected to be composed with aggregated request in mind and policy has to choose only one such key denoting item to return to the client, if such an item indeed exists and can be served. When not existing key might be used to store the cache entry. Since only one version of the content can be streamed back to the client, it makes sense to create only one cache entry for the such a key as well.

Specified by:

retrieveCacheKey in interface CachePolicy

retrieveCacheKeys

public Object[] retrieveCacheKeys(String uuid,
                                  String repository)

Description copied from interface: CachePolicy

Returns cache keys for the given item or null if such keys can't be obtained or policy doesn't want to share it. Since in this case uuid is used to retrieve the cache key, it is quite possible that multiple different representations of the content denoted by uuid exist and all such keys should be returned leaving it up to requesting object to deal with such a multiplicity. Please note that returned keys might not be necessary multiple representations of the content denoted by provided uuid, but also quite possibly all the content deemed related or partially used to construct any of the returned cache keys.

Specified by:

retrieveCacheKeys in interface CachePolicy

persistCacheKey

public void persistCacheKey(String repo,
                            String uuid,
                            Object key)

Description copied from interface: CachePolicy

Persists mapping between uuid and cache key in case the given cache policy implementation cares about such details.

Specified by:

persistCacheKey in interface CachePolicy

removeCacheKeys

public Object[] removeCacheKeys(String uuid,
                                String repository)

Description copied from interface: CachePolicy

Returns cache keys for the given item or null if such keys can't be obtained or policy doesn't want to share it. Since in this case uuid is used to retrieve the cache key, it is quite possible that multiple different representations of the content denoted by uuid exist and all such keys should be returned leaving it up to requesting object to deal with such a multiplicity. Please note that returned keys might not be necessary multiple representations of the content denoted by provided uuid, but also quite possibly all the content deemed related or partially used to construct any of the returned cache keys. At the call to this method, cache policy should not only return the keys associated with the uuid, but also remove all returned uuid-cahce key mappings.

Specified by:

removeCacheKeys in interface CachePolicy

isRefreshOnNoCacheRequests

public boolean isRefreshOnNoCacheRequests()

setRefreshOnNoCacheRequests

public void setRefreshOnNoCacheRequests(boolean allowNoCacheHeader)

getTtlVoters

public info.magnolia.voting.voters.VoterSet<CacheResponseWrapper> getTtlVoters()

Specified by:

getTtlVoters in interface CachePolicy

setTtlVoters

public void setTtlVoters(info.magnolia.voting.voters.VoterSet<CacheResponseWrapper> ttlVoters)

getShouldBypassVoters

public info.magnolia.voting.voters.VoterSet getShouldBypassVoters()

setShouldBypassVoters

public void setShouldBypassVoters(info.magnolia.voting.voters.VoterSet shouldBypassVoters)

getCacheKeyGenerator

public CacheKeyGenerator<?> getCacheKeyGenerator()

setCacheKeyGenerator

public void setCacheKeyGenerator(CacheKeyGenerator<?> cacheKeyGenerator)