com.helger.commons.scope.singleton

Class AbstractSingleton

java.lang.Object

com.helger.commons.scope.singleton.AbstractSingleton

All Implemented Interfaces:

IScopeDestructionAware

Direct Known Subclasses:

AbstractApplicationSingleton, AbstractGlobalSingleton, AbstractRequestSingleton, AbstractSessionApplicationSingleton, AbstractSessionSingleton

@ThreadSafe
public abstract class AbstractSingleton
extends Object
implements IScopeDestructionAware

Base class for all singletons.

Author:

Philip Helger

Field Summary

Fields

Modifier and Type	Field and Description
protected ReadWriteLock	m_aRWLock

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	AbstractSingleton() Ctor.

Method Summary

Methods

Modifier and Type	Method and Description
static <T extends AbstractSingleton> List<T>	getAllSingletons(IScope aScope, Class<T> aDesiredClass) Get all singleton objects registered in the respective sub-class of this class.
static <T extends AbstractSingleton> T	getSingleton(IScope aScope, Class<T> aClass) Get the singleton object in the passed scope, using the passed class.
static <T extends AbstractSingleton> T	getSingletonIfInstantiated(IScope aScope, Class<T> aClass) Get the singleton object if it is already instantiated inside a scope or null if it is not instantiated.
static String	getSingletonScopeKey(Class<? extends AbstractSingleton> aClass) Create the key which is used to reference the object within the scope.
boolean	isDestroyed()
boolean	isInDestruction()
boolean	isInInstantiation()
boolean	isInPreDestruction()
boolean	isInstantiated()
static boolean	isSingletonInstantiated(IScope aScope, Class<? extends AbstractSingleton> aClass) Check if a singleton is already instantiated inside a scope
boolean	isUsableObject()
protected void	onAfterInstantiation(IScope aScope) Called after the singleton was instantiated.
protected void	onBeforeDestroy(IScope aScopeToBeDestroyed) Called before this singleton is destroyed.
void	onBeforeScopeDestruction(IScope aScopeToBeDestroyed) Called before the owning scope is destroyed.
protected void	onDestroy(IScope aScopeInDestruction) Called when this singleton is destroyed.
void	onScopeDestruction(IScope aScopeInDestruction) Called when the owning scope is destroyed.
protected void	readAbstractSingletonFields(ObjectInputStream aOIS) Set all internal status variables to the values read from the specified ObjectInputStream.
protected void	setDestroyed(boolean bDestroyed)
protected void	setInDestruction(boolean bInDestruction)
protected void	setInInstantiation(boolean bInInstantiation)
protected void	setInPreDestruction(boolean bInPreDestruction)
protected void	setInstantiated(boolean bInstantiated)
String	toString()
protected void	writeAbstractSingletonFields(ObjectOutputStream aOOS) Write the internal status variables to the passed ObjectOutputStream.

Methods inherited from class java.lang.Object

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

Field Detail

m_aRWLock

protected final ReadWriteLock m_aRWLock

Constructor Detail

AbstractSingleton

@UsedViaReflection
protected AbstractSingleton()

Ctor.

Method Detail

writeAbstractSingletonFields

protected final void writeAbstractSingletonFields(@Nonnull
                                ObjectOutputStream aOOS)
                                           throws IOException

Write the internal status variables to the passed ObjectOutputStream. This can be used to make singletons serializable.

Parameters:

aOOS - The output stream to write to. May not be null.

Throws:

IOException - In case writing failed

readAbstractSingletonFields

protected final void readAbstractSingletonFields(@Nonnull
                               ObjectInputStream aOIS)
                                          throws IOException,
                                                 ClassNotFoundException

Set all internal status variables to the values read from the specified ObjectInputStream. This can be used to make singletons serializable.

Parameters:

aOIS - The input stream to read from. May not be null.

Throws:

IOException - In case reading failed

ClassNotFoundException - In case reading failed

onAfterInstantiation

@OverrideOnDemand
protected void onAfterInstantiation(@Nonnull
                                         IScope aScope)

Called after the singleton was instantiated. The constructor has finished, and calling getInstance will work!

Parameters:

aScope - The scope in which the object was instantiated. Never null.

setInInstantiation

protected final void setInInstantiation(boolean bInInstantiation)

isInInstantiation

public final boolean isInInstantiation()

Returns:

true if this singleton is currently in the phase of instantiation, false if it is instantiated or already destroyed.

setInstantiated

protected final void setInstantiated(boolean bInstantiated)

isInstantiated

public final boolean isInstantiated()

Returns:

true if this singleton was already instantiated, false if it is active.

setInPreDestruction

protected final void setInPreDestruction(boolean bInPreDestruction)

isInPreDestruction

public final boolean isInPreDestruction()

Returns:

true if this singleton is currently in the phase of pre destruction, false if it is active or already destroyed.

setInDestruction

protected final void setInDestruction(boolean bInDestruction)

isInDestruction

public final boolean isInDestruction()

Returns:

true if this singleton is currently in the phase of destruction, false if it is active or already destroyed.

setDestroyed

protected final void setDestroyed(boolean bDestroyed)

isDestroyed

public final boolean isDestroyed()

Returns:

true if this singleton was already destroyed, false if it is active.

onBeforeDestroy

@OverrideOnDemand
protected void onBeforeDestroy(@Nonnull
                                    IScope aScopeToBeDestroyed)
                        throws Exception

Called before this singleton is destroyed. This method is called when "inPreDestruction" is true, "inDestruction" is still false and "isDestroyed" is false.

Parameters:

aScopeToBeDestroyed - The scope that will be destroyed. Never null.

Throws:

Exception - If something goes wrong

onBeforeScopeDestruction

public final void onBeforeScopeDestruction(@Nonnull
                            IScope aScopeToBeDestroyed)
                                    throws Exception

Description copied from interface: IScopeDestructionAware

Called before the owning scope is destroyed. You may perform some last actions before the scope is really destroyed. This method is called after the IScope.preDestroy() callback is invoked and before the scope is set as being "in destruction".

Specified by:

onBeforeScopeDestruction in interface IScopeDestructionAware

Parameters:

aScopeToBeDestroyed - The scope that will be destroyed. Never null.

Throws:

Exception - in case of an error

onDestroy

@OverrideOnDemand
protected void onDestroy(@Nonnull
                              IScope aScopeInDestruction)
                  throws Exception

Called when this singleton is destroyed. Perform all cleanup in this method. This method is called when "inPreDestruction" is false , "inDestruction" is true and "isDestroyed" is false.

Parameters:

aScopeInDestruction - The scope in destruction. Never null.

Throws:

Exception - If something goes wrong

onScopeDestruction

public final void onScopeDestruction(@Nonnull
                      IScope aScopeInDestruction)
                              throws Exception

Description copied from interface: IScopeDestructionAware

Called when the owning scope is destroyed. You may perform some cleanup work in here. This is method is called when the scope is already "in destruction".

Specified by:

onScopeDestruction in interface IScopeDestructionAware

Parameters:

aScopeInDestruction - The scope in destruction. Never null.

Throws:

Exception - in case of an error

isUsableObject

public final boolean isUsableObject()

Returns:

true if the object is instantiated and neither in destruction nor destroyed.

getSingletonScopeKey

@Nonnull
public static final String getSingletonScopeKey(@Nonnull
                                  Class<? extends AbstractSingleton> aClass)

Create the key which is used to reference the object within the scope.

Parameters:

aClass - The class for which the key is to be created. May not be null.

Returns:

The non-null key.

getSingletonIfInstantiated

@Nullable
public static final <T extends AbstractSingleton> T getSingletonIfInstantiated(@Nullable
                                                                  IScope aScope,
                                                                  @Nonnull
                                                                  Class<T> aClass)

Get the singleton object if it is already instantiated inside a scope or null if it is not instantiated.

Type Parameters:

T - The type to be returned

Parameters:

aScope - The scope to check. May be null to avoid constructing a scope.

aClass - The class to be checked. May not be null.

Returns:

The singleton for the specified class is already instantiated, null otherwise.

isSingletonInstantiated

public static final boolean isSingletonInstantiated(@Nullable
                              IScope aScope,
                              @Nonnull
                              Class<? extends AbstractSingleton> aClass)

Check if a singleton is already instantiated inside a scope

Parameters:

aScope - The scope to check. May be null to avoid constructing a scope.

aClass - The class to be checked. May not be null.

Returns:

true if the singleton for the specified class is already instantiated, false otherwise.

getSingleton

@Nonnull
public static final <T extends AbstractSingleton> T getSingleton(@Nonnull
                                                   IScope aScope,
                                                   @Nonnull
                                                   Class<T> aClass)

Get the singleton object in the passed scope, using the passed class. If the singleton is not yet instantiated, a new instance is created.

Type Parameters:

T - The singleton type

Parameters:

aScope - The scope to be used. May not be null.

aClass - The class to be used. May not be null. The class must be public as needs to have a public no-argument constructor.

Returns:

The singleton object and never null.

getAllSingletons

@Nonnull
@ReturnsMutableCopy
public static final <T extends AbstractSingleton> List<T> getAllSingletons(@Nullable
                                                                                IScope aScope,
                                                                                @Nonnull
                                                                                Class<T> aDesiredClass)

Get all singleton objects registered in the respective sub-class of this class.

Type Parameters:

T - The singleton type to be retrieved

Parameters:

aScope - The scope to use. May be null to avoid creating a new scope.

aDesiredClass - The desired sub-class of this class. May not be null.

Returns:

A non-null list with all instances of the passed class in the passed scope.

toString

@Nonnull
public String toString()

Overrides:

toString in class Object