Class AbstractComponentRegistry

  • All Implemented Interfaces:
    java.lang.Cloneable, Lifecycle
    Direct Known Subclasses:
    ComponentRegistry, GlobalComponentRegistry

    @Deprecated
    public abstract class AbstractComponentRegistry
    extends java.lang.Object
    implements Lifecycle, java.lang.Cloneable
    Deprecated.
    Since 9.4, please use BasicComponentRegistry instead.
    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 Cache.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. Thread Safety: instances of GlobalComponentRegistry can be concurrently updated so all the write operations are serialized through class intrinsic lock.

    Since:
    4.0
    Author:
    Manik Surtani, Galder ZamarreƱo
    • Constructor Detail

      • AbstractComponentRegistry

        protected AbstractComponentRegistry​(ComponentMetadataRepo componentMetadataRepo,
                                            java.lang.ClassLoader classLoader,
                                            Scopes scope,
                                            org.infinispan.factories.impl.BasicComponentRegistry nextBasicComponentRegistry)
        Deprecated.
    • Method Detail

      • getStatus

        public ComponentStatus getStatus()
        Deprecated.
        Retrieves the state of the registry
        Returns:
        state of the registry
      • getClassLoader

        protected abstract java.lang.ClassLoader getClassLoader()
        Deprecated.
      • getLog

        protected abstract org.infinispan.util.logging.Log getLog()
        Deprecated.
      • getComponentMetadataRepo

        public abstract ComponentMetadataRepo getComponentMetadataRepo()
        Deprecated.
      • wireDependencies

        public void wireDependencies​(java.lang.Object target)
                              throws CacheConfigurationException
        Deprecated.
        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:
        CacheConfigurationException - if there is a problem wiring the instance
      • registerComponent

        public final void registerComponent​(java.lang.Object component,
                                            java.lang.Class<?> type)
        Deprecated.
        Registers a component in the registry under the given type, and injects any dependencies needed. Note: Until 9.4, if a component of this type already existed, it was overwritten.
        Parameters:
        component - component to register
        type - type of component
        Throws:
        CacheConfigurationException - If a component is already registered with that name, or if a dependency cannot be resolved
      • registerComponent

        public final void registerComponent​(java.lang.Object component,
                                            java.lang.String name)
        Deprecated.
      • registerComponent

        public final void registerComponent​(java.lang.Object component,
                                            java.lang.String name,
                                            boolean nameIsFQCN)
        Deprecated.
      • registerNonVolatileComponent

        protected final void registerNonVolatileComponent​(java.lang.Object component,
                                                          java.lang.String name)
        Deprecated.
      • registerNonVolatileComponent

        protected final void registerNonVolatileComponent​(java.lang.Object component,
                                                          java.lang.Class<?> type)
        Deprecated.
      • registerComponentInternal

        protected void registerComponentInternal​(java.lang.Object component,
                                                 java.lang.String name,
                                                 boolean nameIsFQCN)
        Deprecated.
      • getOrCreateComponent

        protected <T> T getOrCreateComponent​(java.lang.Class<T> componentClass)
        Deprecated.
        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:
        CacheConfigurationException - if there is a problem with constructing or wiring the instance.
      • getOrCreateComponent

        protected <T> T getOrCreateComponent​(java.lang.Class<T> componentClass,
                                             java.lang.String name)
        Deprecated.
      • getOrCreateComponent

        protected <T> T getOrCreateComponent​(java.lang.Class<T> componentClass,
                                             java.lang.String name,
                                             boolean nameIsFQCN)
        Deprecated.
      • getFactory

        protected AbstractComponentFactory getFactory​(java.lang.Class<?> componentClass)
        Deprecated.
        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
      • createComponentFactoryInternal

        protected AbstractComponentFactory createComponentFactoryInternal​(java.lang.Class<?> componentClass,
                                                                          java.lang.String cfClass)
        Deprecated.
      • lookupComponent

        protected AbstractComponentRegistry.Component lookupComponent​(java.lang.String componentClassName,
                                                                      java.lang.String componentName,
                                                                      boolean nameIsFQCN)
        Deprecated.
      • registerNullComponent

        protected final void registerNullComponent​(java.lang.String name)
        Deprecated.
        registers a special "null" component that has no dependencies.
        Parameters:
        name - name of component to register as a null
      • getConfiguration

        protected Configuration getConfiguration()
        Deprecated.
        Retrieves the configuration component.
        Returns:
        a Configuration object
      • getComponent

        public <T> T getComponent​(java.lang.Class<T> type)
        Deprecated.
        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​(java.lang.String componentClassName)
        Deprecated.
      • getComponent

        public <T> T getComponent​(java.lang.String componentClassName,
                                  java.lang.String name)
        Deprecated.
      • getComponent

        public <T> T getComponent​(java.lang.Class<T> componentClass,
                                  java.lang.String name)
        Deprecated.
      • getComponent

        public <T> T getComponent​(java.lang.String componentClassName,
                                  java.lang.String name,
                                  boolean nameIsFQCN)
        Deprecated.
      • getOptionalComponent

        public <T> java.util.Optional<T> getOptionalComponent​(java.lang.Class<T> type)
        Deprecated.
      • registerDefaultClassLoader

        protected java.lang.ClassLoader registerDefaultClassLoader​(java.lang.ClassLoader loader)
        Deprecated.
        Since 9.4, not used
      • rewire

        public void rewire()
        Deprecated.
        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.

      • resetVolatileComponents

        public void resetVolatileComponents()
        Deprecated.
        Removes any components not annotated as @SurvivesRestarts.
      • start

        public void start()
        Deprecated.
        This starts the components in the registry, connecting to channels, starting service threads, etc. If the component is not in the ComponentStatus.INITIALIZING state, it will be initialized first.
        Specified by:
        start in interface Lifecycle
      • preStart

        protected abstract void preStart()
        Deprecated.
      • postStart

        protected abstract void postStart()
        Deprecated.
      • postStop

        protected abstract void postStop()
        Deprecated.
      • preStop

        protected abstract void preStop()
        Deprecated.
      • addShutdownHook

        protected void addShutdownHook()
        Deprecated.
      • removeShutdownHook

        protected void removeShutdownHook()
        Deprecated.
      • getRegisteredComponents

        public java.util.Set<AbstractComponentRegistry.Component> getRegisteredComponents()
        Deprecated.
        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 java.lang.CloneNotSupportedException
        Deprecated.
        Overrides:
        clone in class java.lang.Object
        Throws:
        java.lang.CloneNotSupportedException
      • getTimeService

        public abstract TimeService getTimeService()
        Deprecated.
      • throwStackAwareConfigurationException

        protected void throwStackAwareConfigurationException​(java.lang.String message)
        Deprecated.