com.atlassian.cache.memory

Class MemoryCacheManager

java.lang.Object

com.atlassian.cache.impl.AbstractCacheManager

com.atlassian.cache.memory.MemoryCacheManager

All Implemented Interfaces:

CacheFactory, CacheManager

Direct Known Subclasses:

JMXMemoryCacheManager

public class MemoryCacheManager
extends AbstractCacheManager

Maintains a mapping of name -> Cache and provides factory methods for creating and getting caches.

Since:

2.0

Field Summary

Fields inherited from class com.atlassian.cache.impl.AbstractCacheManager

cacheCreationLocks, caches, cacheSettingsDefaultsProvider

Constructor Summary

Constructors

Constructor and Description
MemoryCacheManager()
MemoryCacheManager(CacheSettingsDefaultsProvider cacheSettingsDefaultsProvider)

Method Summary

Modifier and Type	Method and Description
protected <K,V> ManagedCache	createComputingCache(String name, CacheSettings settings, CacheLoader<K,V> loader) Creates a cache that upon a miss is able to populate itself using the loader.
protected <K,V> ManagedCache	createComputingCache(String name, CacheSettings settings, CacheLoader<K,V> loader, DelegatingCache.CreateFunction createFunction)
protected ManagedCache	createSimpleCache(String name, CacheSettings settings) Creates a cache with no loader, i.e.
protected <K,V> ManagedCache	createSimpleCache(String name, CacheSettings settings, DelegatingCache.CreateFunction createFunction)
<K,V> Cache<K,V>	getCache(String name, CacheLoader<K,V> loader, CacheSettings settings) Returns the cache with the given name, loader and required cache settings, creates it if necessary.
<K,V> Cache<K,V>	getCache(String name, CacheLoader<K,V> loader, CacheSettings settings, DelegatingCache.CreateFunction createFunction)
<V> CachedReference<V>	getCachedReference(String name, Supplier<V> supplier, CacheSettings settings) Returns a Cached Reference, creating it if necessary.
<V> CachedReference<V>	getCachedReference(String name, Supplier<V> supplier, CacheSettings settings, DelegatingCachedReference.CreateFunction createFunction)
protected void	putCacheInMap(String name, Supplier<ManagedCache> supplier) Use this method to store values in caches map to allow read/write synchronization in @JMXMemoryCacheManager

Methods inherited from class com.atlassian.cache.impl.AbstractCacheManager

flushCaches, getCache, getCache, getCache, getCache, getCachedReference, getCachedReference, getCachedReference, getCaches, getManagedCache, getManagedCaches, mergeSettings, shutdown

Methods inherited from class java.lang.Object

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

Constructor Detail

MemoryCacheManager

@Nonnull
public MemoryCacheManager()

MemoryCacheManager

public MemoryCacheManager(CacheSettingsDefaultsProvider cacheSettingsDefaultsProvider)

Method Detail

getCache

@Nonnull
public <K,V> Cache<K,V> getCache(@Nonnull
                                          String name,
                                          @Nullable
                                          CacheLoader<K,V> loader,
                                          @Nonnull
                                          CacheSettings settings)

Description copied from interface: CacheFactory

Returns the cache with the given name, loader and required cache settings, creates it if necessary.

Specified by:

getCache in interface CacheFactory

Overrides:

getCache in class AbstractCacheManager

Parameters:

name - the name of the cache

loader - the loader that will be used to provide values for keys that will be added to the cache. null indicates no loader

settings - the cache settings that are required to be set if the cache is created.

Returns:

a Cache

getCache

@Nonnull
public <K,V> Cache<K,V> getCache(@Nonnull
                                          String name,
                                          @Nullable
                                          CacheLoader<K,V> loader,
                                          @Nonnull
                                          CacheSettings settings,
                                          @Nonnull
                                          DelegatingCache.CreateFunction createFunction)

getCachedReference

@Nonnull
public <V> CachedReference<V> getCachedReference(@Nonnull
                                                          String name,
                                                          @Nonnull
                                                          Supplier<V> supplier,
                                                          @Nonnull
                                                          CacheSettings settings)

Description copied from interface: CacheFactory

Returns a Cached Reference, creating it if necessary.

Parameters:

name - the name of the Cached Reference

supplier - the supplier for value to be cached, called if the value needs to be generated

settings - specifies the required cache settings

Returns:

the Cached Reference

getCachedReference

public <V> CachedReference<V> getCachedReference(@Nonnull
                                                 String name,
                                                 @Nonnull
                                                 Supplier<V> supplier,
                                                 @Nonnull
                                                 CacheSettings settings,
                                                 @Nonnull
                                                 DelegatingCachedReference.CreateFunction createFunction)

createSimpleCache

protected ManagedCache createSimpleCache(@Nonnull
                                         String name,
                                         @Nonnull
                                         CacheSettings settings)

Description copied from class: AbstractCacheManager

Creates a cache with no loader, i.e. one populated via explicit puts.

Specified by:

createSimpleCache in class AbstractCacheManager

Parameters:

name - the name to give the cache (required)

Returns:

a non-null cache

createSimpleCache

protected <K,V> ManagedCache createSimpleCache(@Nonnull
                                               String name,
                                               @Nonnull
                                               CacheSettings settings,
                                               @Nonnull
                                               DelegatingCache.CreateFunction createFunction)

createComputingCache

protected <K,V> ManagedCache createComputingCache(@Nonnull
                                                  String name,
                                                  @Nonnull
                                                  CacheSettings settings,
                                                  @Nullable
                                                  CacheLoader<K,V> loader)

Description copied from class: AbstractCacheManager

Creates a cache that upon a miss is able to populate itself using the loader.

Specified by:

createComputingCache in class AbstractCacheManager

Returns:

a non-null cache

createComputingCache

protected <K,V> ManagedCache createComputingCache(@Nonnull
                                                  String name,
                                                  @Nonnull
                                                  CacheSettings settings,
                                                  CacheLoader<K,V> loader,
                                                  @Nonnull
                                                  DelegatingCache.CreateFunction createFunction)

putCacheInMap

protected void putCacheInMap(@Nonnull
                             String name,
                             @Nonnull
                             Supplier<ManagedCache> supplier)

Use this method to store values in caches map to allow read/write synchronization in @JMXMemoryCacheManager

Parameters:

name - cache name

supplier - supplier containing cache to add