Package org.springframework.context.support

Class GenericApplicationContext

java.lang.Object
org.springframework.core.io.DefaultResourceLoader
org.springframework.context.support.AbstractApplicationContext
org.springframework.context.support.GenericApplicationContext
All Implemented Interfaces:
Closeable, AutoCloseable, org.springframework.beans.factory.BeanFactory, org.springframework.beans.factory.HierarchicalBeanFactory, org.springframework.beans.factory.ListableBeanFactory, org.springframework.beans.factory.support.BeanDefinitionRegistry, ApplicationContext, ApplicationEventPublisher, ConfigurableApplicationContext, Lifecycle, MessageSource, org.springframework.core.AliasRegistry, org.springframework.core.env.EnvironmentCapable, org.springframework.core.io.ResourceLoader, org.springframework.core.io.support.ResourcePatternResolver
Direct Known Subclasses:
AnnotationConfigApplicationContext, GenericGroovyApplicationContext, GenericXmlApplicationContext, StaticApplicationContext
public class GenericApplicationContext extends AbstractApplicationContext implements org.springframework.beans.factory.support.BeanDefinitionRegistry
Generic ApplicationContext implementation that holds a single internal DefaultListableBeanFactory instance and does not assume a specific bean definition format. Implements the BeanDefinitionRegistry interface in order to allow for applying any bean definition readers to it.

Typical usage is to register a variety of bean definitions via the BeanDefinitionRegistry interface and then call AbstractApplicationContext.refresh() to initialize those beans with application context semantics (handling ApplicationContextAware, auto-detecting BeanFactoryPostProcessors, etc).

In contrast to other ApplicationContext implementations that create a new internal BeanFactory instance for each refresh, the internal BeanFactory of this context is available right from the start, to be able to register bean definitions on it. AbstractApplicationContext.refresh() may only be called once.

This ApplicationContext implementation is suitable for Ahead of Time processing, using refreshForAotProcessing(org.springframework.aot.hint.RuntimeHints) as an alternative to the regular AbstractApplicationContext.refresh().

Usage example: 

 GenericApplicationContext ctx = new GenericApplicationContext();
 XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(ctx);
 xmlReader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
 PropertiesBeanDefinitionReader propReader = new PropertiesBeanDefinitionReader(ctx);
 propReader.loadBeanDefinitions(new ClassPathResource("otherBeans.properties"));
 ctx.refresh();

 MyBean myBean = (MyBean) ctx.getBean("myBean");
 ...
For the typical case of XML bean definitions, you may also use ClassPathXmlApplicationContext or FileSystemXmlApplicationContext, which are easier to set up - but less flexible, since you can just use standard resource locations for XML bean definitions, rather than mixing arbitrary bean definition formats. For a custom application context implementation supposed to read a specific bean definition format in a refreshable manner, consider deriving from the AbstractRefreshableApplicationContext base class.
Since:
1.1.2
Author:
Juergen Hoeller, Chris Beams, Stephane Nicoll, Sam Brannen
See Also:

  • Constructor Details

  • Method Details

    • setParent

      public void setParent(@Nullable ApplicationContext parent)
      Set the parent of this application context, also setting the parent of the internal BeanFactory accordingly.
      Specified by:
      setParent in interface ConfigurableApplicationContext
      Overrides:
      setParent in class AbstractApplicationContext
      Parameters:
      parent - the parent context
      See Also:
      • ConfigurableBeanFactory.setParentBeanFactory(org.springframework.beans.factory.BeanFactory)

    • setApplicationStartup

      public void setApplicationStartup(org.springframework.core.metrics.ApplicationStartup applicationStartup)
      Description copied from interface: ConfigurableApplicationContext
      Set the ApplicationStartup for this application context.

      This allows the application context to record metrics during startup.

      Specified by:
      setApplicationStartup in interface ConfigurableApplicationContext
      Overrides:
      setApplicationStartup in class AbstractApplicationContext
      Parameters:
      applicationStartup - the new context event factory

    • setAllowBeanDefinitionOverriding

      public void setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding)
      Set whether it should be allowed to override bean definitions by registering a different definition with the same name, automatically replacing the former. If not, an exception will be thrown. Default is "true".
      Since:
      3.0
      See Also:
      • DefaultListableBeanFactory.setAllowBeanDefinitionOverriding(boolean)

    • setAllowCircularReferences

      public void setAllowCircularReferences(boolean allowCircularReferences)
      Set whether to allow circular references between beans - and automatically try to resolve them.

      Default is "true". Turn this off to throw an exception when encountering a circular reference, disallowing them completely.

      Since:
      3.0
      See Also:
      • AbstractAutowireCapableBeanFactory.setAllowCircularReferences(boolean)

    • setResourceLoader

      public void setResourceLoader(org.springframework.core.io.ResourceLoader resourceLoader)
      Set a ResourceLoader to use for this context. If set, the context will delegate all getResource calls to the given ResourceLoader. If not set, default resource loading will apply.

      The main reason to specify a custom ResourceLoader is to resolve resource paths (without URL prefix) in a specific fashion. The default behavior is to resolve such paths as class path locations. To resolve resource paths as file system locations, specify a FileSystemResourceLoader here.

      You can also pass in a full ResourcePatternResolver, which will be autodetected by the context and used for getResources calls as well. Else, default resource pattern matching will apply.

      See Also:

    • getResource

      public org.springframework.core.io.Resource getResource(String location)
      This implementation delegates to this context's ResourceLoader if set, falling back to the default superclass behavior otherwise.

      As of Spring Framework 5.3.22, this method also honors registered protocol resolvers when a custom ResourceLoader has been set.

      Specified by:
      getResource in interface org.springframework.core.io.ResourceLoader
      Overrides:
      getResource in class org.springframework.core.io.DefaultResourceLoader
      See Also:

    • getResources

      public org.springframework.core.io.Resource[] getResources(String locationPattern) throws IOException
      This implementation delegates to this context's ResourceLoader if it implements the ResourcePatternResolver interface, falling back to the default superclass behavior otherwise.
      Specified by:
      getResources in interface org.springframework.core.io.support.ResourcePatternResolver
      Overrides:
      getResources in class AbstractApplicationContext
      Throws:
      IOException
      See Also:

    • setClassLoader

      public void setClassLoader(@Nullable ClassLoader classLoader)
      Description copied from interface: ConfigurableApplicationContext
      Specify the ClassLoader to load class path resources and bean classes with.

      This context class loader will be passed to the internal bean factory.

      Specified by:
      setClassLoader in interface ConfigurableApplicationContext
      Overrides:
      setClassLoader in class org.springframework.core.io.DefaultResourceLoader
      See Also:
      • DefaultResourceLoader(ClassLoader)
      • ConfigurableBeanFactory.setBeanClassLoader(java.lang.ClassLoader)

    • getClassLoader

      @Nullable public ClassLoader getClassLoader()
      Specified by:
      getClassLoader in interface org.springframework.core.io.ResourceLoader
      Overrides:
      getClassLoader in class org.springframework.core.io.DefaultResourceLoader

    • refreshBeanFactory

      protected final void refreshBeanFactory() throws IllegalStateException
      Do nothing: We hold a single internal BeanFactory and rely on callers to register beans through our public methods (or the BeanFactory's).
      Specified by:
      refreshBeanFactory in class AbstractApplicationContext
      Throws:
      IllegalStateException - if already initialized and multiple refresh attempts are not supported
      See Also:

    • cancelRefresh

      protected void cancelRefresh(Throwable ex)
      Description copied from class: AbstractApplicationContext
      Cancel this context's refresh attempt, resetting the active flag after an exception got thrown.
      Overrides:
      cancelRefresh in class AbstractApplicationContext
      Parameters:
      ex - the exception that led to the cancellation

    • closeBeanFactory

      protected final void closeBeanFactory()
      Not much to do: We hold a single internal BeanFactory that will never get released.
      Specified by:
      closeBeanFactory in class AbstractApplicationContext

    • getBeanFactory

      public final org.springframework.beans.factory.config.ConfigurableListableBeanFactory getBeanFactory()
      Return the single internal BeanFactory held by this context (as ConfigurableListableBeanFactory).
      Specified by:
      getBeanFactory in interface ConfigurableApplicationContext
      Specified by:
      getBeanFactory in class AbstractApplicationContext
      Returns:
      this application context's internal bean factory (never null)
      See Also:

    • getDefaultListableBeanFactory

      public final org.springframework.beans.factory.support.DefaultListableBeanFactory getDefaultListableBeanFactory()
      Return the underlying bean factory of this context, available for registering bean definitions.

      NOTE: You need to call AbstractApplicationContext.refresh() to initialize the bean factory and its contained beans with application context semantics (autodetecting BeanFactoryPostProcessors, etc).

      Returns:
      the internal bean factory (as DefaultListableBeanFactory)

    • getAutowireCapableBeanFactory

      public org.springframework.beans.factory.config.AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException
      Description copied from class: AbstractApplicationContext
      Return this context's internal bean factory as AutowireCapableBeanFactory, if already available.
      Specified by:
      getAutowireCapableBeanFactory in interface ApplicationContext
      Overrides:
      getAutowireCapableBeanFactory in class AbstractApplicationContext
      Returns:
      the AutowireCapableBeanFactory for this context
      Throws:
      IllegalStateException - if the context does not support the AutowireCapableBeanFactory interface, or does not hold an autowire-capable bean factory yet (for example, if refresh() has never been called), or if the context has been closed already
      See Also:

    • registerBeanDefinition

      public void registerBeanDefinition(String beanName, org.springframework.beans.factory.config.BeanDefinition beanDefinition) throws org.springframework.beans.factory.BeanDefinitionStoreException
      Specified by:
      registerBeanDefinition in interface org.springframework.beans.factory.support.BeanDefinitionRegistry
      Throws:
      org.springframework.beans.factory.BeanDefinitionStoreException

    • removeBeanDefinition

      public void removeBeanDefinition(String beanName) throws org.springframework.beans.factory.NoSuchBeanDefinitionException
      Specified by:
      removeBeanDefinition in interface org.springframework.beans.factory.support.BeanDefinitionRegistry
      Throws:
      org.springframework.beans.factory.NoSuchBeanDefinitionException

    • getBeanDefinition

      public org.springframework.beans.factory.config.BeanDefinition getBeanDefinition(String beanName) throws org.springframework.beans.factory.NoSuchBeanDefinitionException
      Specified by:
      getBeanDefinition in interface org.springframework.beans.factory.support.BeanDefinitionRegistry
      Throws:
      org.springframework.beans.factory.NoSuchBeanDefinitionException

    • isBeanDefinitionOverridable

      public boolean isBeanDefinitionOverridable(String beanName)
      Specified by:
      isBeanDefinitionOverridable in interface org.springframework.beans.factory.support.BeanDefinitionRegistry

    • isBeanNameInUse

      public boolean isBeanNameInUse(String beanName)
      Specified by:
      isBeanNameInUse in interface org.springframework.beans.factory.support.BeanDefinitionRegistry

    • registerAlias

      public void registerAlias(String beanName, String alias)
      Specified by:
      registerAlias in interface org.springframework.core.AliasRegistry

    • removeAlias

      public void removeAlias(String alias)
      Specified by:
      removeAlias in interface org.springframework.core.AliasRegistry

    • isAlias

      public boolean isAlias(String beanName)
      Specified by:
      isAlias in interface org.springframework.core.AliasRegistry

    • refreshForAotProcessing

      public void refreshForAotProcessing(org.springframework.aot.hint.RuntimeHints runtimeHints)
      Load or refresh the persistent representation of the configuration up to a point where the underlying bean factory is ready to create bean instances.

      This variant of AbstractApplicationContext.refresh() is used by Ahead of Time (AOT) processing that optimizes the application context, typically at build time.

      In this mode, only BeanDefinitionRegistryPostProcessor and MergedBeanDefinitionPostProcessor are invoked.

      Parameters:
      runtimeHints - the runtime hints
      Throws:
      org.springframework.beans.BeansException - if the bean factory could not be initialized
      IllegalStateException - if already initialized and multiple refresh attempts are not supported
      Since:
      6.0

    • registerBean

      public <T> void registerBean(Class<T> beanClass, Object... constructorArgs)
      Register a bean from the given bean class, optionally providing explicit constructor arguments for consideration in the autowiring process.
      Parameters:
      beanClass - the class of the bean
      constructorArgs - custom argument values to be fed into Spring's constructor resolution algorithm, resolving either all arguments or just specific ones, with the rest to be resolved through regular autowiring (may be null or empty)
      Since:
      5.2 (since 5.0 on the AnnotationConfigApplicationContext subclass)

    • registerBean

      public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, Object... constructorArgs)
      Register a bean from the given bean class, optionally providing explicit constructor arguments for consideration in the autowiring process.
      Parameters:
      beanName - the name of the bean (may be null)
      beanClass - the class of the bean
      constructorArgs - custom argument values to be fed into Spring's constructor resolution algorithm, resolving either all arguments or just specific ones, with the rest to be resolved through regular autowiring (may be null or empty)
      Since:
      5.2 (since 5.0 on the AnnotationConfigApplicationContext subclass)

    • registerBean

      public final <T> void registerBean(Class<T> beanClass, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
      Register a bean from the given bean class, optionally customizing its bean definition metadata (typically declared as a lambda expression).
      Parameters:
      beanClass - the class of the bean (resolving a public constructor to be autowired, possibly simply the default constructor)
      customizers - one or more callbacks for customizing the factory's BeanDefinition, for example, setting a lazy-init or primary flag
      Since:
      5.0
      See Also:

    • registerBean

      public final <T> void registerBean(@Nullable String beanName, Class<T> beanClass, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
      Register a bean from the given bean class, optionally customizing its bean definition metadata (typically declared as a lambda expression).
      Parameters:
      beanName - the name of the bean (may be null)
      beanClass - the class of the bean (resolving a public constructor to be autowired, possibly simply the default constructor)
      customizers - one or more callbacks for customizing the factory's BeanDefinition, for example, setting a lazy-init or primary flag
      Since:
      5.0
      See Also:

    • registerBean

      public final <T> void registerBean(Class<T> beanClass, Supplier<T> supplier, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
      Register a bean from the given bean class, using the given supplier for obtaining a new instance (typically declared as a lambda expression or method reference), optionally customizing its bean definition metadata (again typically declared as a lambda expression).
      Parameters:
      beanClass - the class of the bean
      supplier - a callback for creating an instance of the bean
      customizers - one or more callbacks for customizing the factory's BeanDefinition, for example, setting a lazy-init or primary flag
      Since:
      5.0
      See Also:

    • registerBean

      public <T> void registerBean(@Nullable String beanName, Class<T> beanClass, @Nullable Supplier<T> supplier, org.springframework.beans.factory.config.BeanDefinitionCustomizer... customizers)
      Register a bean from the given bean class, using the given supplier for obtaining a new instance (typically declared as a lambda expression or method reference), optionally customizing its bean definition metadata (again typically declared as a lambda expression).

      This method can be overridden to adapt the registration mechanism for all registerBean methods (since they all delegate to this one).

      Parameters:
      beanName - the name of the bean (may be null)
      beanClass - the class of the bean
      supplier - a callback for creating an instance of the bean (in case of null, resolving a public constructor to be autowired instead)
      customizers - one or more callbacks for customizing the factory's BeanDefinition, for example, setting a lazy-init or primary flag
      Since:
      5.0