org.infinispan.factories
Class AbstractComponentRegistry

java.lang.Object
  org.infinispan.factories.AbstractComponentRegistry

All Implemented Interfaces:

Cloneable, Lifecycle

Direct Known Subclasses:

ComponentRegistry, GlobalComponentRegistry

public abstract class AbstractComponentRegistry
extends Object
implements Lifecycle, Cloneable

A registry where components which have been created are stored. Components are stored as singletons, registered under a specific name.

Components can be retrieved from the registry using getComponent(Class).

Components can be registered using registerComponent(Object, Class), which will cause any dependencies to be wired in as well. Components that need to be created as a result of wiring will be done using getOrCreateComponent(Class), which will look up the default factory for the component type (factories annotated with the appropriate DefaultFactoryFor annotation.

Default factories are treated as components too and will need to be wired before being used.

The registry can exist in one of several states, as defined by the ComponentStatus enumeration. In terms of the cache, state changes in the following manner:

• INSTANTIATED - when first constructed
• CONSTRUCTED - when created using the DefaultCacheFactory
• STARTED - when Lifecycle.start() is called
• STOPPED - when Lifecycle.stop() is called

Cache configuration can only be changed and will only be re-injected if the cache is not in the ComponentStatus.RUNNING state.

Since:

4.0

Author:

Manik Surtani, Galder Zamarreño

Nested Class Summary

class

AbstractComponentRegistry.Component A wrapper representing a component in the registry

Field Summary

static boolean	DEBUG_DEPENDENCIES
protected static List<ModuleLifecycle>	moduleLifecycles
protected static Object	NULL_COMPONENT

Constructor Summary

AbstractComponentRegistry()

Method Summary

protected void	addComponentDependencies(AbstractComponentRegistry.Component c) Adds component dependencies for a given component, by populating AbstractComponentRegistry.Component.injectionMethods.
protected void	addShutdownHook()
AbstractComponentRegistry	clone()
<T> T	getComponent(Class<T> type) Retrieves a component of a specified type from the registry, or null if it cannot be found.
<T> T	getComponent(Class<T> type, String name)
protected Configuration	getConfiguration() Retrieves the configuration component.
protected Map<Class,Class<? extends AbstractComponentFactory>>	getDefaultFactoryMap()
protected AbstractComponentFactory	getFactory(Class componentClass) Retrieves a component factory instance capable of constructing components of a specified type.
protected <T> T	getFromConfiguration(Class<T> componentClass) Retrieves a component from the Configuration
protected abstract Log	getLog()
protected <T> T	getOrCreateComponent(Class<T> componentClass) Retrieves a component if one exists, and if not, attempts to find a factory capable of constructing the component (factories annotated with the DefaultFactoryFor annotation that is capable of creating the component class).
protected <T> T	getOrCreateComponent(Class<T> componentClass, String name)
Set<AbstractComponentRegistry.Component>	getRegisteredComponents() Returns an immutable set containing all the components that exists in the repository at this moment.
ComponentStatus	getStatus() Retrieves the state of the registry
boolean	invocationsAllowed(boolean originLocal) Asserts whether invocations are allowed on the cache or not.
protected void	invokeInjectionMethod(Object o, Method m)
protected AbstractComponentRegistry.Component	lookupComponent(Class type, String componentName)
void	registerComponent(Object component, Class type) Registers a component in the registry under the given type, and injects any dependencies needed.
void	registerComponent(Object component, String name)
void	registerDefaultClassLoader(ClassLoader loader) Registers the default class loader.
protected void	removeShutdownHook()
void	resetNonVolatile() Removes any components not annotated as @NonVolatile.
void	rewire() Rewires components.
void	start() This starts the components in the cache, connecting to channels, starting service threads, etc.
void	stop() Stops the cache and sets the cache status to ComponentStatus.TERMINATED once it is done.
void	wireDependencies(Object target) Wires an object instance with dependencies annotated with the Inject annotation, creating more components as needed based on the Configuration passed in if these additional components don't exist in the ComponentRegistry.

Methods inherited from class java.lang.Object

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

Field Detail

DEBUG_DEPENDENCIES

public static final boolean DEBUG_DEPENDENCIES

See Also:

Constant Field Values

NULL_COMPONENT

protected static final Object NULL_COMPONENT

moduleLifecycles

protected static List<ModuleLifecycle> moduleLifecycles

Constructor Detail

AbstractComponentRegistry

public AbstractComponentRegistry()

Method Detail

getStatus

public ComponentStatus getStatus()

Retrieves the state of the registry

Returns:

state of the registry

getLog

protected abstract Log getLog()

wireDependencies

public void wireDependencies(Object target)
                      throws ConfigurationException

Wires an object instance with dependencies annotated with the Inject annotation, creating more components as needed based on the Configuration passed in if these additional components don't exist in the ComponentRegistry. Strictly for components that don't otherwise live in the registry and have a lifecycle, such as Commands.

Parameters:

target - object to wire

Throws:

ConfigurationException - if there is a problem wiring the instance

registerComponent

public void registerComponent(Object component,
                              Class type)

Registers a component in the registry under the given type, and injects any dependencies needed. If a component of this type already exists, it is overwritten.

Parameters:

component - component to register

type - type of component

registerComponent

public void registerComponent(Object component,
                              String name)

addComponentDependencies

protected void addComponentDependencies(AbstractComponentRegistry.Component c)

Adds component dependencies for a given component, by populating AbstractComponentRegistry.Component.injectionMethods.

Parameters:

c - component to add dependencies to

invokeInjectionMethod

protected void invokeInjectionMethod(Object o,
                                     Method m)

getOrCreateComponent

protected <T> T getOrCreateComponent(Class<T> componentClass)

Retrieves a component if one exists, and if not, attempts to find a factory capable of constructing the component (factories annotated with the DefaultFactoryFor annotation that is capable of creating the component class).

If an instance needs to be constructed, dependencies are then automatically wired into the instance, based on methods on the component type annotated with Inject.

Summing it up, component retrieval happens in the following order:
1. Look for a component that has already been created and registered. 2. Look for an appropriate component that exists in the Configuration that may be injected from an external system. 3. Look for a class definition passed in to the Configuration - such as an EvictionPolicy implementation 4. Attempt to create it by looking for an appropriate factory (annotated with DefaultFactoryFor)

Parameters:

componentClass - type of component to be retrieved. Should not be null.

Returns:

a fully wired component instance, or null if one cannot be found or constructed.

Throws:

ConfigurationException - if there is a problem with constructing or wiring the instance.

getOrCreateComponent

protected <T> T getOrCreateComponent(Class<T> componentClass,
                                     String name)

getFactory

protected AbstractComponentFactory getFactory(Class componentClass)

Retrieves a component factory instance capable of constructing components of a specified type. If the factory doesn't exist in the registry, one is created.

Parameters:

componentClass - type of component to construct

Returns:

component factory capable of constructing such components

lookupComponent

protected AbstractComponentRegistry.Component lookupComponent(Class type,
                                                              String componentName)

getDefaultFactoryMap

protected Map<Class,Class<? extends AbstractComponentFactory>> getDefaultFactoryMap()

getFromConfiguration

protected <T> T getFromConfiguration(Class<T> componentClass)

Retrieves a component from the Configuration

Parameters:

componentClass - component type

Returns:

component, or null if it cannot be found

getConfiguration

protected Configuration getConfiguration()

Retrieves the configuration component.

Returns:

a Configuration object

getComponent

public <T> T getComponent(Class<T> type)

Retrieves a component of a specified type from the registry, or null if it cannot be found.

Parameters:

type - type to find

Returns:

component, or null

getComponent

public <T> T getComponent(Class<T> type,
                          String name)

registerDefaultClassLoader

public void registerDefaultClassLoader(ClassLoader loader)

Registers the default class loader. This method *must* be called before any other components are registered, typically called by bootstrap code. Defensively, it is called in the constructor of ComponentRegistry with a null parameter.

Parameters:

loader - a class loader to use by default. If this is null, the class loader used to load this instance of ComponentRegistry is used.

rewire

public void rewire()

Rewires components. Used to rewire components in the CR if a cache has been stopped (moved to state TERMINATED), which would (almost) empty the registry of components. Rewiring will re-inject all dependencies so that the cache can be started again.

resetNonVolatile

public void resetNonVolatile()

Removes any components not annotated as @NonVolatile.

start

public void start()

This starts the components in the cache, connecting to channels, starting service threads, etc. If the cache is not in the ComponentStatus.INITIALIZING state, it will be initialized first.

Specified by:

start in interface Lifecycle

stop

public void stop()

Stops the cache and sets the cache status to ComponentStatus.TERMINATED once it is done. If the cache is not in the ComponentStatus.RUNNING state, this is a no-op.

Specified by:

stop in interface Lifecycle

addShutdownHook

protected void addShutdownHook()

removeShutdownHook

protected void removeShutdownHook()

invocationsAllowed

public boolean invocationsAllowed(boolean originLocal)

Asserts whether invocations are allowed on the cache or not. Returns true if invocations are to be allowed, false otherwise. If the origin of the call is remote and the cache status is ComponentStatus.INITIALIZING, this method will block for up to Configuration.getStateRetrievalTimeout() millis, checking for a valid state.

Parameters:

originLocal - true if the call originates locally (i.e., from the CacheDelegate or false if it originates remotely, i.e., from the InboundInvocationHandler.

Returns:

true if invocations are allowed, false otherwise.

getRegisteredComponents

public Set<AbstractComponentRegistry.Component> getRegisteredComponents()

Returns an immutable set containing all the components that exists in the repository at this moment.

Returns:

a set of components

clone

public AbstractComponentRegistry clone()
                                throws CloneNotSupportedException

Overrides:

clone in class Object

Throws:

CloneNotSupportedException