Package org.onehippo.cms7.services

Class WhiteboardProxiedServiceRegistry<T>

  • Type Parameters:
    T - service interface type
    public abstract class WhiteboardProxiedServiceRegistry<T>
extends Object
    WhiteboardProxiedServiceRegistry<T> is an abstract base class for implementing and using the Whiteboard Patternfor decoupled lookup/wiring of multiple service objects by a common (main) interface.

    This WhiteboardProxiedServiceRegistry base class supports (un)registering service objects, and ProxiedServiceTrackers to retrieve those currently registered as well as be notified on future (un)registrations. Also currently registered service entries can be retrieved through getEntries().

    All service objects registered through a WhiteboardProxiedServiceRegistry implementation must implement a common interface of generic type T.

    For example with the following (complete) org.onehippo.repository.events.PersistedHippoEventListenerRegistry implementation from the hippo-repository-api module using interface type org.onehippo.repository.events.PersistedHippoEventListener, service objects implementing that interface can be registered: 

    
     public final class PersistedHippoEventListenerRegistry extends WhiteboardProxiedServiceRegistry<PersistedHippoEventListener> {

         private static final PersistedHippoEventListenerRegistry INSTANCE = new PersistedHippoEventListenerRegistry();

         private HippoEventListenerRegistry() {
             super(PersistedHippoEventListener.class);
         }

         public static PersistedHippoEventListenerRegistry get() { return INSTANCE; }
     }

    For a typical usage of a WhiteboardProxiedServiceRegistry see the javadoc for the org.onehippo.repository.events.PersistedHippoEventListenerRegistry and org.onehippo.repository.events.PersistedHippoEventListener service interface in the hippo-repository-api module.

    For each registered service object a ProxiedServiceHolder is created and passed on to the ProxiedServiceTracker(s), storing the service object itself together with the context classloader used to register the service object. Furthermore it provides access to a dynamically created service proxy for the service exposing only the service interface and optionally extra interfaces. When using the service proxy all method invocation will be executed with the context classloader set to its registration classloader. Also, the serviceRegistered and serviceUnregistered callback methods provided by the service tracker will be invoked using the context classloader of the service tracker.

    When a service object should be used as a singleton then use HippoServiceRegistry instead.

    When only the registration and tracking of one or more service objects of a certain (base) type (class or interface) is needed nor a service proxy with automatic enforcing of its context classloader during method invocation, use the WhiteboardServiceRegistry<T> base class instead, Note that it then requires manual enforcement of the current context classloader in case of cross-context usage of the service objects.

    • Constructor Detail

      • WhiteboardProxiedServiceRegistry

        public WhiteboardProxiedServiceRegistry​(Class<T> serviceInterface)
        Constructor needed for storing the required common interface of generic type T which must be implemented by all service objects registered.
        Parameters:
        serviceInterface - common interface

    • Method Detail

      • getEntriesList

        protected List<ProxiedServiceHolder<T>> getEntriesList()
        Returns:
        a new copied List of current service entries to guard against potential concurrent service (un)registrations

      • register

        public void register​(T serviceObject,
                     Class<?>... extraInterfaces)
        Register a service object implementing interface type <T> and optionally some additional interfaces which all will be exposed by the service proxy created for this service object.
        Parameters:
        serviceObject - the service object
        extraInterfaces - additional interfaces implemented by the service object to be exposed by the service proxy
        Throws:
        HippoServiceException - when the service object was already registered

      • unregister

        public boolean unregister​(T serviceObject)
        Unregister a previously registered service object
        Parameters:
        serviceObject - the service object
        Returns:
        true if the service object was registered before and now removed, false otherwise

      • removeTracker

        public boolean removeTracker​(ProxiedServiceTracker<T> tracker)
        Remove a previously added ProxiedServiceTracker<T>.
        Parameters:
        tracker - the service tracker
        Returns:
        true if the service tracker was added before and now removed, false otherwise

      • getServices

        public Stream<T> getServices()
        Returns:
        the registered services (proxied)

      • size

        public int size()
        Returns:
        the number of registered services