Interface BeanContext

  • All Known Implementing Classes:
    BeanContextWrapper, DefaultBeanContext

    public interface BeanContext

    Definition of an interface that allows access to the beans managed by the dependency injection framework.

    This interface serves as the top-level entry point into the dependency injection framework. It allows querying beans from a specified BeanStore or a default BeanStore by name or by type. Listing the available beans is also possible.

    When objects are dynamically created, class loader issues have to be taken into account. A BeanContext allows the registration of class loaders by name. In the configuration, it can then be specified, which bean is to be created using which class loader. For the context class loader there is a special constant.

    Version:
    $Id: BeanContext.java 205 2012-01-29 18:29:57Z oheger $
    Author:
    Oliver Heger
    • Method Detail

      • getBean

        Object getBean​(String name)
        Returns the bean with the specified name from the default BeanStore.
        Parameters:
        name - the name of the bean to be retrieved
        Returns:
        the bean with this name
        Throws:
        InjectionException - if the bean cannot be resolved or its creation or initialization causes an error
      • getBean

        Object getBean​(String name,
                       BeanStore store)
        Returns the bean with the specified name from the given BeanStore. This method can be used if a child bean store of the default bean store is to be accessed.
        Parameters:
        name - the name of the bean to be retrieved
        store - the BeanStore to query
        Returns:
        the bean with this name
        Throws:
        InjectionException - if the bean cannot be resolved or its creation or initialization causes an error
        IllegalArgumentException - if the passed in bean store is null
      • getBean

        <T> T getBean​(Class<T> beanCls)
        Returns the bean with the specified class from the default BeanStore. An implementation of this method has to iterate over the beans defined in the bean store to find out, whether the specified class is assignable from their class. Then the first fitting bean will be returned. So it is for instance possible to query for an interface and find a bean that is a concrete implementation of this interface. If there are multiple bean definitions that are compatible with this class, it is up to a concrete implementation of this interface to choose one. Defining beans based on a class (or interface) allows to abstract from the concrete naming of beans and focuses more on the beans' semantics.
        Type Parameters:
        T - the type of the bean to be fetched
        Parameters:
        beanCls - the class of the bean to be fetched
        Returns:
        the bean with this class
        Throws:
        InjectionException - if the bean cannot be resolved or its creation or initialization causes an error
      • getBean

        <T> T getBean​(Class<T> beanCls,
                      BeanStore store)
        Returns the bean with the specified class from the given BeanStore. Works like the overloaded method, but operates on the given bean store.
        Type Parameters:
        T - the type of the bean to be fetched
        Parameters:
        beanCls - the class of the bean to be fetched
        store - the BeanStore to use
        Returns:
        the bean with this class
        Throws:
        InjectionException - if the bean cannot be resolved or its creation or initialization causes an error
        IllegalArgumentException - if the passed in bean store is null
      • beanNames

        Set<String> beanNames()
        Returns a set with the names of all beans defined in the default BeanStore.
        Returns:
        a set with the names of the defined beans
      • beanNames

        Set<String> beanNames​(BeanStore store)
        Returns a set with the names of all beans defined in the given BeanStore. This list will also contain beans that are defined in one of the bean store's parents.
        Parameters:
        store - the bean store (must not be null)
        Returns:
        a set with the names of the defined beans
        Throws:
        IllegalArgumentException - if the passed in bean store is null
      • beanClasses

        Set<Class<?>> beanClasses()
        Returns a set with the classes of all beans defined in the default BeanStore (or one of its parents).
        Returns:
        a set with the classes of the defined beans
      • beanClasses

        Set<Class<?>> beanClasses​(BeanStore store)
        Returns a set with the classes of all beans defined in the given BeanStore. This list will also contain beans that are defined in one of the bean store's parents.
        Parameters:
        store - the bean store (must not be null)
        Returns:
        a set with the classes of the defined beans
        Throws:
        IllegalArgumentException - if the passed in bean store is null
      • containsBean

        boolean containsBean​(String name)
        Checks whether the default BeanStore contains a bean with the given name. If necessary the bean store's parents will also be searched.
        Parameters:
        name - the name of the searched bean
        Returns:
        a flag whether this bean can be found
      • containsBean

        boolean containsBean​(String name,
                             BeanStore store)
        Checks whether the specified BeanStore contains a bean with the given name. If necessary the bean store's parents will also be searched.
        Parameters:
        name - the name of the searched bean
        store - the bean store
        Returns:
        a flag whether this bean can be found
      • containsBean

        boolean containsBean​(Class<?> beanClass)
        Checks whether the default BeanStore contains a bean with the given class. If necessary the bean store's parents will also be searched.
        Parameters:
        beanClass - the class of the searched bean
        Returns:
        a flag whether this bean can be found
      • containsBean

        boolean containsBean​(Class<?> beanClass,
                             BeanStore store)
        Checks whether the specified BeanStore contains a bean with the given class. If necessary the bean store's parents will also be searched.
        Parameters:
        beanClass - the class of the searched bean
        store - the bean store
        Returns:
        a flag whether this bean can be found
      • getDefaultBeanStore

        BeanStore getDefaultBeanStore()
        Returns the default bean store.
        Returns:
        the default bean store
      • setDefaultBeanStore

        void setDefaultBeanStore​(BeanStore store)
        Sets the default bean store. This bean store is used as starting point for all lookup-operations if no specific bean store is specified.
        Parameters:
        store - the new default bean store
      • beanNameFor

        String beanNameFor​(BeanProvider beanProvider)
        Returns the name of the bean that is managed by the specified BeanProvider, starting search with the default BeanStore.
        Parameters:
        beanProvider - the BeanProvider
        Returns:
        the name, under which this BeanProvider is registered in one of the accessible bean stores or null if it cannot be resolved
        See Also:
        beanNameFor(BeanProvider, BeanStore)
      • beanNameFor

        String beanNameFor​(BeanProvider beanProvider,
                           BeanStore store)
        Returns the name of the bean that is managed by the specified BeanProvider, starting search in the specified BeanStore. This method can be used for performing a "reverse lookup": when a bean provider is known, but the corresponding bean name is searched. A use case would be the processing of a BeanCreationEvent. The event object contains the BeanProvider that created the bean, but the name of this bean is not part of the event.
        Parameters:
        beanProvider - the BeanProvider
        store - the BeanStore
        Returns:
        the name, under which this BeanProvider is registered in one of the accessible bean stores or null if it cannot be resolved
      • addBeanCreationListener

        void addBeanCreationListener​(BeanCreationListener l)
        Adds a new BeanCreationListener to this context. This listener will receive notifications about newly created beans.
        Parameters:
        l - the listener to be added (must not be null)
        Throws:
        IllegalArgumentException - if the listener is null
      • removeBeanCreationListener

        void removeBeanCreationListener​(BeanCreationListener l)
        Removes the specified BeanCreationListener from this context. If the listener is not registered, this method has no effect.
        Parameters:
        l - the listener to remove
      • close

        void close()
        Closes this bean context. This method should be called when the context is no more needed. An implementation can free resources or perform other clean up. Note that the BeanStore associated with this context is not closed by this method (this is because a BeanStore could be shared by multiple contexts, and there is not necessary a 1:1 relationship between a BeanStore and a BeanContext).
      • getClassLoaderProvider

        ClassLoaderProvider getClassLoaderProvider()
        Returns the ClassLoaderProvider used by this context.
        Returns:
        the ClassLoaderProvider
      • setClassLoaderProvider

        void setClassLoaderProvider​(ClassLoaderProvider clp)
        Sets the ClassLoaderProvider to be used by this context. This object is needed when classes have to be loaded through reflection.
        Parameters:
        clp - the ClassLoaderProvider