org.springframework.beans.factory

## Interface ObjectProvider<T>

- Type Parameters:
    `T` - the object type
  All Superinterfaces:
    Iterable<T>, ObjectFactory<T>

      public interface ObjectProvider<T>
      extends ObjectFactory<T>, Iterable<T>

  A variant of `ObjectFactory` designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.

  As of 5.1, this interface extends `Iterable` and provides `Stream` support. It can be therefore be used in `for` loops, provides `Iterable.forEach(java.util.function.Consumer<? super T>)` iteration and allows for collection-style `stream()` access.

  Since:
    4.3
  Author:
    Juergen Hoeller
  See Also:
    `BeanFactory.getBeanProvider(java.lang.Class<T>)`, `Autowired`

- - ### Method Summary

    All Methods Instance Methods Abstract Methods Default Methods
    Modifier and Type | Method and Description
    --- | ---
    `T` | `getIfAvailable()` Return an instance (possibly shared or independent) of the object managed by this factory.
    `default T` | `getIfAvailable(Supplier<T> defaultSupplier)` Return an instance (possibly shared or independent) of the object managed by this factory.
    `T` | `getIfUnique()` Return an instance (possibly shared or independent) of the object managed by this factory.
    `default T` | `getIfUnique(Supplier<T> defaultSupplier)` Return an instance (possibly shared or independent) of the object managed by this factory.
    `T` | `getObject(Object... args)` Return an instance (possibly shared or independent) of the object managed by this factory.
    `default void` | `ifAvailable(Consumer<T> dependencyConsumer)` Consume an instance (possibly shared or independent) of the object managed by this factory, if available.
    `default void` | `ifUnique(Consumer<T> dependencyConsumer)` Consume an instance (possibly shared or independent) of the object managed by this factory, if unique.
    `default Iterator<T>` | `iterator()` Return an `Iterator` over all matching object instances, without specific ordering guarantees (but typically in registration order).
    `default Stream<T>` | `orderedStream()` Return a sequential `Stream` over all matching object instances, pre-ordered according to the factory's common order comparator.
    `default Stream<T>` | `stream()` Return a sequential `Stream` over all matching object instances, without specific ordering guarantees (but typically in registration order).

    - ### Methods inherited from interface org.springframework.beans.factory.ObjectFactory

      `getObject`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach, spliterator`

- - ### Method Detail

    - #### getObject

          T getObject(Object... args)
               throws BeansException

      Return an instance (possibly shared or independent) of the object managed by this factory.

      Allows for specifying explicit construction arguments, along the lines of `BeanFactory.getBean(String, Object...)`.

      Parameters:
        `args` - arguments to use when creating a corresponding instance
      Returns:
        an instance of the bean
      Throws:
        `BeansException` - in case of creation errors
      See Also:
        `ObjectFactory.getObject()`

    - #### getIfAvailable

          @Nullable
          T getIfAvailable()
                              throws BeansException

      Return an instance (possibly shared or independent) of the object managed by this factory.
      Returns:
        an instance of the bean, or `null` if not available
      Throws:
        `BeansException` - in case of creation errors
      See Also:
        `ObjectFactory.getObject()`

    - #### getIfAvailable

          default T getIfAvailable(Supplier<T> defaultSupplier)
                            throws BeansException

      Return an instance (possibly shared or independent) of the object managed by this factory.
      Parameters:
        `defaultSupplier` - a callback for supplying a default object if none is present in the factory
      Returns:
        an instance of the bean, or the supplied default object if no such bean is available
      Throws:
        `BeansException` - in case of creation errors
      Since:
        5.0
      See Also:
        `getIfAvailable()`

    - #### ifAvailable

          default void ifAvailable(Consumer<T> dependencyConsumer)
                            throws BeansException

      Consume an instance (possibly shared or independent) of the object managed by this factory, if available.
      Parameters:
        `dependencyConsumer` - a callback for processing the target object if available (not called otherwise)
      Throws:
        `BeansException` - in case of creation errors
      Since:
        5.0
      See Also:
        `getIfAvailable()`

    - #### getIfUnique

          @Nullable
          T getIfUnique()
                           throws BeansException

      Return an instance (possibly shared or independent) of the object managed by this factory.
      Returns:
        an instance of the bean, or `null` if not available or not unique (i.e. multiple candidates found with none marked as primary)
      Throws:
        `BeansException` - in case of creation errors
      See Also:
        `ObjectFactory.getObject()`

    - #### getIfUnique

          default T getIfUnique(Supplier<T> defaultSupplier)
                         throws BeansException

      Return an instance (possibly shared or independent) of the object managed by this factory.
      Parameters:
        `defaultSupplier` - a callback for supplying a default object if no unique candidate is present in the factory
      Returns:
        an instance of the bean, or the supplied default object if no such bean is available or if it is not unique in the factory (i.e. multiple candidates found with none marked as primary)
      Throws:
        `BeansException` - in case of creation errors
      Since:
        5.0
      See Also:
        `getIfUnique()`

    - #### ifUnique

          default void ifUnique(Consumer<T> dependencyConsumer)
                         throws BeansException

      Consume an instance (possibly shared or independent) of the object managed by this factory, if unique.
      Parameters:
        `dependencyConsumer` - a callback for processing the target object if unique (not called otherwise)
      Throws:
        `BeansException` - in case of creation errors
      Since:
        5.0
      See Also:
        `getIfAvailable()`

    - #### iterator

          default Iterator<T> iterator()

      Return an `Iterator` over all matching object instances, without specific ordering guarantees (but typically in registration order).
      Specified by:
        `iterator` in interface `Iterable<T>`
      Since:
        5.1
      See Also:
        `stream()`

    - #### stream

          default Stream<T> stream()

      Return a sequential `Stream` over all matching object instances, without specific ordering guarantees (but typically in registration order).
      Since:
        5.1
      See Also:
        `iterator()`, `orderedStream()`

    - #### orderedStream

          default Stream<T> orderedStream()

      Return a sequential `Stream` over all matching object instances, pre-ordered according to the factory's common order comparator.

      In a standard Spring application context, this will be ordered according to `Ordered` conventions, and in case of annotation-based configuration also considering the `Order` annotation, analogous to multi-element injection points of list/array type.

      Since:
        5.1
      See Also:
        `stream()`, `OrderComparator`