org.alfresco.repo.cache

Class AbstractAsynchronouslyRefreshedCache

java.lang.Object

org.alfresco.repo.cache.AbstractAsynchronouslyRefreshedCache

All Implemented Interfaces:

java.util.concurrent.Callable, AsynchronouslyRefreshedCache, RefreshableCache, RefreshableCacheListener, TransactionListener, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean

Direct Known Subclasses:

AuthorityBridgeTableAsynchronouslyRefreshedCache, ConfigDataCache

public abstract class AbstractAsynchronouslyRefreshedCache
extends java.lang.Object
implements AsynchronouslyRefreshedCache, RefreshableCacheListener, java.util.concurrent.Callable, org.springframework.beans.factory.BeanNameAware, org.springframework.beans.factory.InitializingBean, TransactionListener

The base implementation for an asynchronously refreshed cache. Currently supports one value per tenant. Implementors just need to provide buildCache(String tenanaId)

Since:

4.1.3

Constructor Summary

Constructors

Constructor and Description
AbstractAsynchronouslyRefreshedCache()

Method Summary

Methods

Modifier and Type	Method and Description
void	afterCommit() Invoked after transaction commit.
void	afterPropertiesSet()
void	afterRollback() Invoked after transaction rollback.
void	beforeCommit(boolean readOnly) Called before a transaction is committed.
void	beforeCompletion() Invoked before transaction commit/rollback.
void	broadcastEvent(RefreshableCacheEvent event)
protected abstract java.lang.Object	buildCache(java.lang.String tenantId) Build the cache entry for the specific tenant.
java.lang.Void	call()
void	flush()
void	forceInChangesForThisUncommittedTransaction()
java.lang.Object	get() Get the cache.
java.lang.String	getCacheId() Get the cache id
void	init()
boolean	isUpToDate() Determine if the cache is up to date
void	onRefreshableCacheEvent(RefreshableCacheEvent refreshableCacheEvent) Callback made when a cache refresh occurs
void	refresh() Refresh the cache asynchronously.
void	register(RefreshableCacheListener listener) Register to be informed when the cache is updated in the background.
void	setBeanName(java.lang.String name)
void	setRegistry(AsynchronouslyRefreshedCacheRegistry registry)
void	setTenantService(org.alfresco.repo.tenant.TenantService tenantService)
void	setThreadPoolExecutor(java.util.concurrent.ThreadPoolExecutor threadPoolExecutor)
protected void	waitForBuild(org.alfresco.repo.cache.AbstractAsynchronouslyRefreshedCache.Refresh refresh)

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractAsynchronouslyRefreshedCache

public AbstractAsynchronouslyRefreshedCache()

Method Detail

register

public void register(RefreshableCacheListener listener)

Description copied from interface: RefreshableCache

Register to be informed when the cache is updated in the background. Note: it is up to the implementation to provide any transactional wrapping. Transactional wrapping is not required to invalidate a shared cache entry directly via a transactional cache

Specified by:

register in interface RefreshableCache

setThreadPoolExecutor

public void setThreadPoolExecutor(java.util.concurrent.ThreadPoolExecutor threadPoolExecutor)

Parameters:

threadPool - the threadPool to set

setRegistry

public void setRegistry(AsynchronouslyRefreshedCacheRegistry registry)

Parameters:

registry - the registry to set

setTenantService

public void setTenantService(org.alfresco.repo.tenant.TenantService tenantService)

Parameters:

tenantService - the tenantService to set

init

public void init()

get

public java.lang.Object get()

Description copied from interface: RefreshableCache

Get the cache. If there is no cache value this call will block. If the underlying cache is being refreshed, the old cache value will be returned until the refresh is complete.

Specified by:

get in interface RefreshableCache

Returns:

forceInChangesForThisUncommittedTransaction

public void forceInChangesForThisUncommittedTransaction()

waitForBuild

protected void waitForBuild(org.alfresco.repo.cache.AbstractAsynchronouslyRefreshedCache.Refresh refresh)

refresh

public void refresh()

Description copied from interface: RefreshableCache

Refresh the cache asynchronously.

Specified by:

refresh in interface RefreshableCache

onRefreshableCacheEvent

public void onRefreshableCacheEvent(RefreshableCacheEvent refreshableCacheEvent)

Description copied from interface: RefreshableCacheListener

Callback made when a cache refresh occurs

Specified by:

onRefreshableCacheEvent in interface RefreshableCacheListener

isUpToDate

public boolean isUpToDate()

Description copied from interface: AsynchronouslyRefreshedCache

Determine if the cache is up to date

Specified by:

isUpToDate in interface AsynchronouslyRefreshedCache

Returns:

true if the cache is not currently refreshing itself

call

public java.lang.Void call()

Specified by:

call in interface java.util.concurrent.Callable

setBeanName

public void setBeanName(java.lang.String name)

Specified by:

setBeanName in interface org.springframework.beans.factory.BeanNameAware

getCacheId

public java.lang.String getCacheId()

Description copied from interface: AsynchronouslyRefreshedCache

Get the cache id

Specified by:

getCacheId in interface AsynchronouslyRefreshedCache

Specified by:

getCacheId in interface RefreshableCacheListener

Returns:

the cache ID

buildCache

protected abstract java.lang.Object buildCache(java.lang.String tenantId)

Build the cache entry for the specific tenant. This method is called in a thread-safe manner i.e. it is only ever called by a single thread.

afterPropertiesSet

public void afterPropertiesSet()
                        throws java.lang.Exception

Specified by:

afterPropertiesSet in interface org.springframework.beans.factory.InitializingBean

Throws:

java.lang.Exception

broadcastEvent

public void broadcastEvent(RefreshableCacheEvent event)

flush

public void flush()

Specified by:

flush in interface TransactionListener

beforeCommit

public void beforeCommit(boolean readOnly)

Description copied from interface: TransactionListener

Called before a transaction is committed.

All transaction resources are still available.

Specified by:

beforeCommit in interface TransactionListener

Parameters:

readOnly - true if the transaction is read-only

beforeCompletion

public void beforeCompletion()

Description copied from interface: TransactionListener

Invoked before transaction commit/rollback. Will be called after TransactionListener.beforeCommit(boolean) even if TransactionListener.beforeCommit(boolean) failed.

All transaction resources are still available.

Specified by:

beforeCompletion in interface TransactionListener

afterCommit

public void afterCommit()

Description copied from interface: TransactionListener

Invoked after transaction commit.

Any exceptions generated here will only be logged and will have no effect on the state of the transaction.

Although all transaction resources are still available, this method should be used only for cleaning up resources after a commit has occured.

Specified by:

afterCommit in interface TransactionListener

afterRollback

public void afterRollback()

Description copied from interface: TransactionListener

Invoked after transaction rollback.

Any exceptions generated here will only be logged and will have no effect on the state of the transaction.

Although all transaction resources are still available, this method should be used only for cleaning up resources after a rollback has occured.

Specified by:

afterRollback in interface TransactionListener