|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.jboss.cache.factories.ComponentRegistry
public class ComponentRegistry
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 usinggetComponent(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 CacheStatus
enumeration. In terms of the cache,
state changes in the following manner:
Cache.create()
is called, the components are rewired.Cache.start()
is calledCache.stop()
is calledCache.destroy()
is called.CacheStatus.STARTED
state.
Nested Class Summary | |
---|---|
class |
ComponentRegistry.Component
A wrapper representing a component in the registry |
Field Summary | |
---|---|
protected static Object |
NULL_COMPONENT
|
Constructor Summary | |
---|---|
ComponentRegistry(Configuration configuration,
CacheSPI cache)
Creates an instance of the component registry. |
Method Summary | ||
---|---|---|
protected void |
addComponentDependencies(ComponentRegistry.Component c)
Adds component dependencies for a given component, by populating ComponentRegistry.Component.injectionMethods . |
|
void |
create()
Creates the components needed by a cache instance and sets the cache status to CacheStatus.CREATED
when it is done. |
|
void |
destroy()
Destroys the cache and frees up any resources. |
|
|
getComponent(Class<T> type)
Retrieves a component of a specified type from the registry, or null if it cannot be found. |
|
protected Configuration |
getConfiguration()
Retrieves the configuration component. |
|
protected ComponentFactory |
getFactory(Class componentClass)
Retrieves a component factory instance capable of constructing components of a specified type. |
|
protected
|
getFromConfiguration(Class<T> componentClass)
Retrieves a component from the Configuration or RuntimeConfig . |
|
protected
|
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). |
|
Set<ComponentRegistry.Component> |
getRegiteredComponents()
Returns an immutable set contating all the components that exists in the reporsitory at this moment. |
|
CacheStatus |
getState()
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)
|
|
void |
registerComponent(Object component,
Class type)
Registers a component in the registry under the given type, and injects any dependencies needed. |
|
void |
registerDefaultClassLoader(ClassLoader loader)
Registers the default class loader. |
|
void |
resetNonVolatile()
Removes any components not annotated as @NonVolatile. |
|
void |
rewire()
Rewires components. |
|
void |
setBlockInStarting(boolean blockInStarting)
|
|
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 CacheStatus.STOPPED 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 |
---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
Field Detail |
---|
protected static final Object NULL_COMPONENT
Constructor Detail |
---|
public ComponentRegistry(Configuration configuration, CacheSPI cache)
configuration
- configuration with which this is createdMethod Detail |
---|
public CacheStatus getState()
public void wireDependencies(Object target) throws ConfigurationException
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 Nodes.
target
- object to wire
ConfigurationException
- if there is a problem wiring the instancepublic void registerDefaultClassLoader(ClassLoader loader)
loader
- a class loader to use by default. If this is null, the class loader used to load this instance of ComponentRegistry is used.public void registerComponent(Object component, Class type)
component
- component to registertype
- type of componentprotected void addComponentDependencies(ComponentRegistry.Component c)
ComponentRegistry.Component.injectionMethods
.
c
- component to add dependencies toprotected void invokeInjectionMethod(Object o, Method m)
protected <T> T getOrCreateComponent(Class<T> componentClass)
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: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
)
componentClass
- type of component to be retrieved. Should not be null.
ConfigurationException
- if there is a problem with consructing or wiring the instance.protected ComponentFactory getFactory(Class componentClass)
componentClass
- type of component to construct
protected <T> T getFromConfiguration(Class<T> componentClass)
Configuration
or RuntimeConfig
.
componentClass
- component type
protected Configuration getConfiguration()
public <T> T getComponent(Class<T> type)
type
- type to find
public void rewire()
public void resetNonVolatile()
public void create()
CacheStatus.CREATED
when it is done.
create
in interface Lifecycle
public void start()
CacheStatus.CREATED
state, create()
will be invoked first.
start
in interface Lifecycle
public void stop()
CacheStatus.STOPPED
once it is done. If the cache is not in
the CacheStatus.STARTED
state, this is a no-op.
stop
in interface Lifecycle
public void destroy()
CacheStatus.DESTROYED
when it is done.
If the cache is in CacheStatus.STARTED
when this method is called, it will first call stop()
to stop the cache.
destroy
in interface Lifecycle
public boolean invocationsAllowed(boolean originLocal)
CacheStatus.STARTING
,
this method will block for up to Configuration.getStateRetrievalTimeout()
millis, checking
for a valid state.
originLocal
- true if the call originates locally (i.e., from the CacheInvocationDelegate
or false if it originates remotely, i.e., from the CommandAwareRpcDispatcher
.
public Set<ComponentRegistry.Component> getRegiteredComponents()
public void setBlockInStarting(boolean blockInStarting)
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |