org.infinispan.factories
Class AbstractComponentRegistry

java.lang.Object
  extended by 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:

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

Google Analytics

Copyright © 2010 JBoss, a division of Red Hat. All Rights Reserved.