Interface BeanDefinitionRegistry

    • Method Detail

      • containsBean

        <T> boolean containsBean​(@NonNull
                                 java.lang.Class<T> beanType,
                                 @Nullable
                                 Qualifier<T> qualifier)
        Return whether the bean of the given type is contained within this context.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        qualifier - The qualifier for the bean
        Returns:
        True if it is
      • containsBean

        default <T> boolean containsBean​(@NonNull
                                         io.micronaut.core.type.Argument<T> beanType,
                                         @Nullable
                                         Qualifier<T> qualifier)
        Return whether the bean of the given type is contained within this context.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        qualifier - The qualifier for the bean
        Returns:
        True if it is
        Since:
        3.0.0
      • containsBean

        default <T> boolean containsBean​(@NonNull
                                         io.micronaut.core.type.Argument<T> beanType)
        Return whether the bean of the given type is contained within this context.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        Returns:
        True if it is
        Since:
        3.0.0
      • registerBeanDefinition

        @NonNull
        default <B> BeanDefinitionRegistry registerBeanDefinition​(@NonNull
                                                                  RuntimeBeanDefinition<B> definition)
        Registers a new reference at runtime. Not that registering beans can impact the object graph therefore should this should be done as soon as possible prior to the creation of other beans preferably with a high priority Context scope bean.
        Type Parameters:
        B - The bean type
        Parameters:
        definition - The reference.
        Returns:
        The registry
        Since:
        3.6.0
      • registerSingleton

        @NonNull
        <T> BeanDefinitionRegistry registerSingleton​(@NonNull
                                                     java.lang.Class<T> type,
                                                     @NonNull
                                                     T singleton,
                                                     @Nullable
                                                     Qualifier<T> qualifier,
                                                     boolean inject)

        Registers a new singleton bean at runtime. This method expects that the bean definition data will have been compiled ahead of time.

        If bean definition data is found the method will perform dependency injection on the instance followed by invoking any PostConstruct hooks.

        If no bean definition data is found the bean is registered as is.

        Type Parameters:
        T - The concrete type
        Parameters:
        type - The bean type
        singleton - The singleton bean
        qualifier - The bean qualifier
        inject - Whether the singleton should be injected (defaults to true)
        Returns:
        This bean context
      • findBeanConfiguration

        @NonNull
        java.util.Optional<BeanConfiguration> findBeanConfiguration​(@NonNull
                                                                    java.lang.String configurationName)
        Obtain a bean configuration by name.
        Parameters:
        configurationName - The configuration name
        Returns:
        An optional with the configuration either present or not
      • findBeanDefinition

        @NonNull
        <T> java.util.Optional<BeanDefinition<T>> findBeanDefinition​(@NonNull
                                                                     java.lang.Class<T> beanType,
                                                                     @Nullable
                                                                     Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • findBeanDefinition

        @NonNull
        default <T> java.util.Optional<BeanDefinition<T>> findBeanDefinition​(@NonNull
                                                                             io.micronaut.core.type.Argument<T> beanType,
                                                                             @Nullable
                                                                             Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The potentially parameterized type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        Since:
        3.0.0
      • findBeanDefinition

        @NonNull
        default <T> java.util.Optional<BeanDefinition<T>> findBeanDefinition​(@NonNull
                                                                             io.micronaut.core.type.Argument<T> beanType)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The potentially parameterized type
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        Since:
        3.0.0
      • findBeanRegistration

        @NonNull
        <T> java.util.Optional<BeanRegistration<T>> findBeanRegistration​(@NonNull
                                                                         T bean)
        Obtain a BeanDefinition for the given bean.
        Type Parameters:
        T - The concrete type
        Parameters:
        bean - The bean
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • getBeanDefinitions

        @NonNull
        <T> java.util.Collection<BeanDefinition<T>> getBeanDefinitions​(@NonNull
                                                                       java.lang.Class<T> beanType)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • getBeanDefinitions

        @NonNull
        default <T> java.util.Collection<BeanDefinition<T>> getBeanDefinitions​(@NonNull
                                                                               io.micronaut.core.type.Argument<T> beanType)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        Since:
        3.0.0
      • getBeanDefinitions

        @NonNull
        <T> java.util.Collection<BeanDefinition<T>> getBeanDefinitions​(@NonNull
                                                                       java.lang.Class<T> beanType,
                                                                       @Nullable
                                                                       Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • getBeanDefinitions

        @NonNull
        default <T> java.util.Collection<BeanDefinition<T>> getBeanDefinitions​(@NonNull
                                                                               io.micronaut.core.type.Argument<T> beanType,
                                                                               @Nullable
                                                                               Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        Since:
        3.0.0
      • getBeanDefinitions

        @NonNull
        java.util.Collection<BeanDefinition<?>> getBeanDefinitions​(@NonNull
                                                                   Qualifier<java.lang.Object> qualifier)
        Get all of the BeanDefinition for the given qualifier.
        Parameters:
        qualifier - The qualifier
        Returns:
        The bean definitions
      • getAllBeanDefinitions

        @NonNull
        java.util.Collection<BeanDefinition<?>> getAllBeanDefinitions()
        Get all of the registered BeanDefinition.
        Returns:
        The bean definitions
      • getActiveBeanRegistrations

        @NonNull
        java.util.Collection<BeanRegistration<?>> getActiveBeanRegistrations​(@NonNull
                                                                             Qualifier<?> qualifier)
        Find active Singleton beans for the given qualifier. Note that this method can return multiple registrations for a given singleton bean instance since each bean may have multiple qualifiers.
        Parameters:
        qualifier - The qualifier
        Returns:
        The beans
      • getActiveBeanRegistrations

        @NonNull
        <T> java.util.Collection<BeanRegistration<T>> getActiveBeanRegistrations​(@NonNull
                                                                                 java.lang.Class<T> beanType)
        Find active Singleton beans for the given bean type. Note that this method can return multiple registrations for a given singleton bean instance since each bean may have multiple qualifiers.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        Returns:
        The beans
      • getBeanRegistrations

        @NonNull
        <T> java.util.Collection<BeanRegistration<T>> getBeanRegistrations​(@NonNull
                                                                           java.lang.Class<T> beanType)
        Find and if necessary initialize Singleton beans for the given bean type, returning all the active registrations. Note that this method can return multiple registrations for a given singleton bean instance since each bean may have multiple qualifiers.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        Returns:
        The beans
      • getBeanRegistrations

        @NonNull
        <T> java.util.Collection<BeanRegistration<T>> getBeanRegistrations​(@NonNull
                                                                           java.lang.Class<T> beanType,
                                                                           @Nullable
                                                                           Qualifier<T> qualifier)
        Find and if necessary initialize Singleton beans for the given bean type, returning all the active registrations. Note that this method can return multiple registrations for a given singleton bean instance since each bean may have multiple qualifiers.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        qualifier - The qualifier
        Returns:
        The beans
        Since:
        2.4.0
      • getBeanRegistrations

        @NonNull
        default <T> java.util.Collection<BeanRegistration<T>> getBeanRegistrations​(@NonNull
                                                                                   io.micronaut.core.type.Argument<T> beanType,
                                                                                   @Nullable
                                                                                   Qualifier<T> qualifier)
        Find and if necessary initialize Singleton beans for the given bean type, returning all the active registrations. Note that this method can return multiple registrations for a given singleton bean instance since each bean may have multiple qualifiers.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        qualifier - The qualifier
        Returns:
        The beans
        Since:
        3.0.0
      • getBeanRegistration

        @NonNull
        <T> BeanRegistration<T> getBeanRegistration​(@NonNull
                                                    java.lang.Class<T> beanType,
                                                    @Nullable
                                                    Qualifier<T> qualifier)
        Find a bean registration for the given bean type and optional qualifier.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The bean type
        qualifier - The qualifier
        Returns:
        The bean registration
        Throws:
        NoSuchBeanException - if the bean doesn't exist
        Since:
        2.4.0
      • getBeanRegistration

        @NonNull
        default <T> BeanRegistration<T> getBeanRegistration​(@NonNull
                                                            io.micronaut.core.type.Argument<T> beanType,
                                                            @Nullable
                                                            Qualifier<T> qualifier)
        Find a bean registration for the given bean type and optional qualifier.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The potentially parameterized bean type
        qualifier - The qualifier
        Returns:
        The bean registration
        Throws:
        NoSuchBeanException - if the bean doesn't exist
        Since:
        3.0.0
      • getBeanRegistration

        @NonNull
        <T> BeanRegistration<T> getBeanRegistration​(@NonNull
                                                    BeanDefinition<T> beanDefinition)
        Find a bean registration for the given bean definition.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanDefinition - The bean definition
        Returns:
        The bean registration
        Throws:
        NoSuchBeanException - if the bean doesn't exist
        Since:
        3.5.0
      • findProxyTargetBeanDefinition

        @NonNull
        <T> java.util.Optional<BeanDefinition<T>> findProxyTargetBeanDefinition​(@NonNull
                                                                                java.lang.Class<T> beanType,
                                                                                @Nullable
                                                                                Qualifier<T> qualifier)
        Obtain the original BeanDefinition for a ProxyBeanDefinition.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • findProxyTargetBeanDefinition

        @NonNull
        default <T> java.util.Optional<BeanDefinition<T>> findProxyTargetBeanDefinition​(@NonNull
                                                                                        io.micronaut.core.type.Argument<T> beanType,
                                                                                        @Nullable
                                                                                        Qualifier<T> qualifier)
        Obtain the original BeanDefinition for a ProxyBeanDefinition.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • findProxyTargetBeanDefinition

        @NonNull
        default <T> java.util.Optional<BeanDefinition<T>> findProxyTargetBeanDefinition​(@NonNull
                                                                                        BeanDefinition<T> proxyBeanDefinition)
        Obtain the original BeanDefinition for a ProxyBeanDefinition.
        Type Parameters:
        T - The concrete type
        Parameters:
        proxyBeanDefinition - The proxy bean definition
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        Since:
        3.5.0
      • findProxyBeanDefinition

        @NonNull
        <T> java.util.Optional<BeanDefinition<T>> findProxyBeanDefinition​(@NonNull
                                                                          java.lang.Class<T> beanType,
                                                                          @Nullable
                                                                          Qualifier<T> qualifier)
        Obtain the proxy BeanDefinition for the bean of type and qualifier.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • findProxyBeanDefinition

        @NonNull
        <T> java.util.Optional<BeanDefinition<T>> findProxyBeanDefinition​(@NonNull
                                                                          io.micronaut.core.type.Argument<T> beanType,
                                                                          @Nullable
                                                                          Qualifier<T> qualifier)
        Obtain the proxy BeanDefinition for the bean of type and qualifier.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • registerSingleton

        @NonNull
        default <T> BeanDefinitionRegistry registerSingleton​(@NonNull
                                                             java.lang.Class<T> type,
                                                             @NonNull
                                                             T singleton,
                                                             @Nullable
                                                             Qualifier<T> qualifier)

        Registers a new singleton bean at runtime. This method expects that the bean definition data will have been compiled ahead of time.

        If bean definition data is found the method will perform dependency injection on the instance followed by invoking any PostConstruct hooks.

        If no bean definition data is found the bean is registered as is.

        Type Parameters:
        T - The concrete type
        Parameters:
        type - The bean type
        singleton - The singleton bean
        qualifier - The bean qualifier
        Returns:
        This bean context
      • registerSingleton

        default <T> BeanDefinitionRegistry registerSingleton​(@NonNull
                                                             java.lang.Class<T> type,
                                                             @NonNull
                                                             T singleton)

        Registers a new singleton bean at runtime. This method expects that the bean definition data will have been compiled ahead of time.

        If bean definition data is found the method will perform dependency injection on the instance followed by invoking any PostConstruct hooks.

        If no bean definition data is found the bean is registered as is.

        Type Parameters:
        T - The concrete type
        Parameters:
        type - the bean type
        singleton - The singleton bean
        Returns:
        This bean context
      • getBeanDefinition

        @NonNull
        default <T> BeanDefinition<T> getBeanDefinition​(@NonNull
                                                        java.lang.Class<T> beanType,
                                                        @Nullable
                                                        Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        qualifier - The qualifier
        Returns:
        The BeanDefinition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        NoSuchBeanException - If the bean cannot be found
      • getBeanDefinition

        @NonNull
        default <T> BeanDefinition<T> getBeanDefinition​(@NonNull
                                                        io.micronaut.core.type.Argument<T> beanType,
                                                        @Nullable
                                                        Qualifier<T> qualifier)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The potentially parameterized type type
        qualifier - The qualifier
        Returns:
        The BeanDefinition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        NoSuchBeanException - If the bean cannot be found
        Since:
        3.0.
      • getBeanDefinition

        @NonNull
        default <T> BeanDefinition<T> getBeanDefinition​(@NonNull
                                                        io.micronaut.core.type.Argument<T> beanType)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        Returns:
        The BeanDefinition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
        NoSuchBeanException - If the bean cannot be found
        Since:
        3.0.0
      • findBeanDefinition

        @NonNull
        default <T> java.util.Optional<BeanDefinition<T>> findBeanDefinition​(@NonNull
                                                                             java.lang.Class<T> beanType)
        Obtain a BeanDefinition for the given type.
        Type Parameters:
        T - The concrete type
        Parameters:
        beanType - The type
        Returns:
        An Optional of the bean definition
        Throws:
        NonUniqueBeanException - When multiple possible bean definitions exist for the given type
      • registerSingleton

        @NonNull
        default BeanDefinitionRegistry registerSingleton​(@NonNull
                                                         java.lang.Object singleton)

        Registers a new singleton bean at runtime. This method expects that the bean definition data will have been compiled ahead of time.

        If bean definition data is found the method will perform dependency injection on the instance followed by invoking any PostConstruct hooks.

        If no bean definition data is found the bean is registered as is.

        Parameters:
        singleton - The singleton bean
        Returns:
        This bean context
      • registerSingleton

        @NonNull
        default BeanDefinitionRegistry registerSingleton​(@NonNull
                                                         java.lang.Object singleton,
                                                         boolean inject)

        Registers a new singleton bean at runtime. This method expects that the bean definition data will have been compiled ahead of time.

        If bean definition data is found the method will perform dependency injection on the instance followed by invoking any PostConstruct hooks.

        If no bean definition data is found the bean is registered as is.

        Parameters:
        singleton - The singleton bean
        inject - Whether the singleton should be injected (defaults to true)
        Returns:
        This bean context
      • containsBean

        default boolean containsBean​(@NonNull
                                     java.lang.Class<?> beanType)
        Return whether the bean of the given type is contained within this context.
        Parameters:
        beanType - The bean type
        Returns:
        True if it is