Class AbstractComponentRegistry

  • All Implemented Interfaces:
    Cloneable, org.infinispan.commons.api.Lifecycle
    Direct Known Subclasses:
    ComponentRegistry, GlobalComponentRegistry

    public abstract class AbstractComponentRegistry
    extends Object
    implements org.infinispan.commons.api.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 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
    • Field Detail

      • DEBUG_DEPENDENCIES

        public static final boolean DEBUG_DEPENDENCIES
        Set the system property
      • infinispan.debugDependencies
      • to
      • true
      • to enable some extra information to errors generated by the component factory.
  • Constructor Detail

    • AbstractComponentRegistry

      public AbstractComponentRegistry()
  • Method Detail

    • getStatus

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

      protected abstract ClassLoader getClassLoader()
    • getLog

      protected abstract Log getLog()
    • wireDependencies

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

      public final 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 final void registerComponent​(Object component,
                                          String name)
    • registerComponent

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

      protected final void registerNonVolatileComponent​(Object component,
                                                        String name)
    • registerNonVolatileComponent

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

      protected void registerComponentInternal​(Object component,
                                               String name,
                                               boolean nameIsFQCN)
    • 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:
      org.infinispan.commons.CacheConfigurationException - if there is a problem with constructing or wiring the instance.
    • getOrCreateComponent

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

      protected <T> T getOrCreateComponent​(Class<T> componentClass,
                                           String name,
                                           boolean nameIsFQCN)
    • 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
    • registerNullComponent

      protected final void registerNullComponent​(String name)
      registers a special "null" component that has no dependencies.
      Parameters:
      name - name of component to register as a null
    • 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​(String componentClassName)
    • getComponent

      public <T> T getComponent​(String componentClassName,
                                String name)
    • getComponent

      public <T> T getComponent​(Class<T> componentClass,
                                String name)
    • getComponent

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

      public <T> Optional<T> getOptionalComponent​(Class<T> type)
    • registerDefaultClassLoader

      protected ClassLoader 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.

    • resetVolatileComponents

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

      public void start()
      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 org.infinispan.commons.api.Lifecycle
    • postStart

      protected void postStart()
    • stop

      public void stop()
      Stops the component and sets its status to ComponentStatus.TERMINATED once it is done. If the component is not in the ComponentStatus.RUNNING state, this is a no-op.
      Specified by:
      stop in interface org.infinispan.commons.api.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 StateTransferConfiguration.timeout() millis, checking for a valid state.
      Parameters:
      originLocal - true if the call originates locally (i.e., from the CacheImpl 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
    • getTimeService

      public abstract TimeService getTimeService()
    • throwStackAwareConfigurationException

      protected void throwStackAwareConfigurationException​(String message)