Package com.vaadin.flow.di

Interface Lookup

  • All Known Implementing Classes:
    LookupInitializer.LookupImpl
    public interface Lookup
    Provides a way to discover services used by Flow (SPI).

    A lookup instance may be created based on a service, see of(Object, Class...). Several lookup instances may be combined via compose(Lookup, Lookup) method which allows to make a lookup instance based on a number of services. The resulting lookup instance may be used in internal Flow code to transfer data in the unified way which allows to change the available data types during the code evolution without changing the internal API (like arguments in methods and constructors).

    There is the "global" application Lookup instance and the VaadinContext. It has one to one mapping and is available even before a DeploymentConfiguration (and VaadinServlet) is created. So this is kind of a singleton for a Web Application. As a consequence it provides and may return only web app singleton services. Dependency injection frameworks can provide an implementation for the application Lookup which manages instances according to the conventions of that framework.

    The application Lookup is similar to the Instantiator class but a Lookup instance is available even before a VaadinService instance is created (and as a consequence there is no yet an Instantiator instance).

    This is the code which one may use to get the application Lookup instance: 

     
     VaadinContext context = ...;
     Lookup lookup = context.getAttribute(Lookup.class);

    This SPI is mostly for internal framework usage since Instantiator provides all required services for the application developer.

    Since:
    Author:
    Vaadin Ltd
    See Also:
    Instantiator

    • Method Summary

      All Methods Static Methods Instance Methods Abstract Methods 
      Modifier and Type Method Description
      static Lookup compose​(Lookup lookup1, Lookup lookup2)
      Make a composite lookup which contains the services from both lookup1 and lookup2.
      <T> T lookup​(Class<T> serviceClass)
      Lookup for a service of the given type.
      <T> Collection<T> lookupAll​(Class<T> serviceClass)
      Lookup for all services by the provided serviceClass.
      static <T> Lookup of​(T service, Class<? super T>... serviceTypes)
      Creates a lookup which contains (only) the provided service as instance of given serviceTypes.

    • Method Detail

      • lookup

        <T> T lookup​(Class<T> serviceClass)
        Lookup for a service of the given type.

        The serviceClass is usually an interface (though it doesn't have to be) and the returned value is some implementation of this interface.

        Type Parameters:
        T - a service type
        Parameters:
        serviceClass - a service SPI class
        Returns:
        a service which implements the serviceClass, may be null if no services are registered for this SPI
        See Also:
        lookupAll(Class)

      • lookupAll

        <T> Collection<T> lookupAll​(Class<T> serviceClass)
        Lookup for all services by the provided serviceClass.

        The serviceClass is usually an interface class (though it doesn't have to be) and the returned value is all implementations of this interface.

        Type Parameters:
        T - a service type
        Parameters:
        serviceClass - a service SPI class
        Returns:
        all services which implement the serviceClass, if no services found an empty list is returned (so null is not returned)

      • of

        @SafeVarargs
static <T> Lookup of​(T service,
                     Class<? super T>... serviceTypes)
        Creates a lookup which contains (only) the provided service as instance of given serviceTypes.

        This method may be used to create a temporary lookup which then can be used to extend an existing lookup via compose(Lookup, Lookup).

        Type Parameters:
        T - the service type
        Parameters:
        service - the service object
        serviceTypes - the supertypes of the service which may be used to access the service
        Returns:
        a lookup initialized with the given service

      • compose

        static Lookup compose​(Lookup lookup1,
                      Lookup lookup2)
        Make a composite lookup which contains the services from both lookup1 and lookup2.

        lookup(Class) method will return the service from the first lookup if it's not null and fallbacks to the lookup2 otherwise. So the first lookup takes precedence. The method lookupAll(Class) simply combines all the services from both lookups.

        The resulting lookup is intended to be a "temporary" (short living) lookup to extend an existing lookup with some additional data which is required only in some isolated object.

        Parameters:
        lookup1 - the first lookup to compose
        lookup2 - the second lookup to compose
        Returns:
        the composite lookup