## Uses of Interface
org.springframework.beans.factory.BeanFactory

- Packages that use BeanFactory
  Package | Description
  --- | ---
  org.springframework.aop.aspectj | AspectJ integration package.
  org.springframework.aop.aspectj.annotation | Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
  org.springframework.aop.config | Support package for declarative AOP configuration, with XML schema being the primary configuration format.
  org.springframework.aop.framework | Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
  org.springframework.aop.framework.autoproxy | Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
  org.springframework.aop.framework.autoproxy.target | Various `TargetSourceCreator` implementations for use with Spring's AOP auto-proxying support.
  org.springframework.aop.interceptor | Provides miscellaneous interceptor implementations.
  org.springframework.aop.scope | Support for AOP-based scoping of target objects, with configurable backend.
  org.springframework.aop.support | Convenience classes for using Spring's AOP API.
  org.springframework.aop.target |
  org.springframework.aop.target.dynamic |
  org.springframework.beans.factory | The core package implementing Spring's lightweight Inversion of Control (IoC) container.
  org.springframework.beans.factory.annotation | Support package for annotation-driven bean configuration.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.beans.factory.wiring | Mechanism to determine bean wiring metadata from a bean instance.
  org.springframework.beans.factory.xml | Contains an abstract XML-based `BeanFactory` implementation, including a standard "spring-beans" XSD.
  org.springframework.cache.interceptor | AOP-based solution for declarative caching demarcation.
  org.springframework.cache.jcache.interceptor | AOP-based solution for declarative caching demarcation using JSR-107 annotations.
  org.springframework.context | This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
  org.springframework.context.annotation | Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.
  org.springframework.context.event | Support classes for application events, like standard context events.
  org.springframework.context.expression | Expression parsing support within a Spring application context.
  org.springframework.context.support | Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
  org.springframework.context.weaving | Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
  org.springframework.dao.annotation | Annotation support for DAOs.
  org.springframework.dao.support | Support classes for DAO implementations, providing miscellaneous utility methods.
  org.springframework.jca.context | Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.
  org.springframework.jdbc.datasource.lookup | Provides a strategy for looking up JDBC DataSources by name.
  org.springframework.jms.annotation | Annotations and support classes for declarative JMS listener endpoints.
  org.springframework.jms.config | Support package for declarative messaging configuration, with Java configuration and XML schema support.
  org.springframework.jms.support.destination | Support classes for Spring's JMS framework.
  org.springframework.jmx.export | This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
  org.springframework.jmx.export.annotation | Annotations for MBean exposure.
  org.springframework.jndi | The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
  org.springframework.jndi.support | Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
  org.springframework.messaging.core | Defines interfaces and implementation classes for messaging templates.
  org.springframework.messaging.handler | Basic abstractions for working with message handler methods.
  org.springframework.messaging.handler.annotation.support | Support classes for working with annotated message-handling methods.
  org.springframework.orm.hibernate5 | Package providing integration of Hibernate 5.x with Spring concepts.
  org.springframework.orm.jpa | Package providing integration of JPA (Java Persistence API) with Spring concepts.
  org.springframework.orm.jpa.support | Classes supporting the `org.springframework.orm.jpa` package.
  org.springframework.r2dbc.connection.lookup | Provides a strategy for looking up R2DBC ConnectionFactories by name.
  org.springframework.remoting.jaxws | Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
  org.springframework.scheduling.annotation | Annotation support for asynchronous method execution.
  org.springframework.scheduling.quartz | Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.
  org.springframework.scripting.groovy | Package providing integration of Groovy into Spring's scripting infrastructure.
  org.springframework.scripting.support | Support classes for Spring's scripting package.
  org.springframework.transaction.interceptor | AOP-based solution for declarative transaction demarcation.
  org.springframework.web.context | Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.
  org.springframework.web.context.request.async | Support for asynchronous request processing.
  org.springframework.web.context.support | Classes supporting the `org.springframework.web.context` package, such as WebApplicationContext implementations and various utility classes.
  org.springframework.web.jsf | Support classes for integrating a JSF web layer with a Spring service layer which is hosted in a Spring root WebApplicationContext.
  org.springframework.web.method | Common infrastructure for handler method processing, as used by Spring MVC's `org.springframework.web.servlet.mvc.method` package.
  org.springframework.web.servlet.mvc.method.annotation | MVC infrastructure for annotation-based handler method processing, building on the `org.springframework.web.method.annotation` package.
  org.springframework.web.servlet.view | Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
  org.springframework.web.socket.client.standard | Client-side classes for use with standard Java WebSocket endpoints.
  org.springframework.web.socket.handler | Convenient `WebSocketHandler` implementations and decorators.
  org.springframework.web.socket.server.standard | Server-side classes for use with standard JSR-356 WebSocket endpoints.

- - ### Uses of BeanFactory in org.springframework.aop.aspectj

    Methods in org.springframework.aop.aspectj with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AspectJExpressionPointcut.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AspectJExpressionPointcutAdvisor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.aspectj.annotation

    Constructors in org.springframework.aop.aspectj.annotation with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name)` Create a BeanFactoryAspectInstanceFactory.
    `BeanFactoryAspectInstanceFactory(BeanFactory beanFactory, String name, Class<?> type)` Create a BeanFactoryAspectInstanceFactory, providing a type that AspectJ should introspect to create AJType metadata.
    `PrototypeAspectInstanceFactory(BeanFactory beanFactory, String name)` Create a PrototypeAspectInstanceFactory.
    `ReflectiveAspectJAdvisorFactory(BeanFactory beanFactory)` Create a new `ReflectiveAspectJAdvisorFactory`, propagating the given `BeanFactory` to the created `AspectJExpressionPointcut` instances, for bean pointcut handling as well as consistent `ClassLoader` resolution.

  - ### Uses of BeanFactory in org.springframework.aop.config

    Methods in org.springframework.aop.config with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | MethodLocatingFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | SimpleBeanFactoryAwareAspectInstanceFactory.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.framework

    Methods in org.springframework.aop.framework with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | ProxyFactoryBean.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.framework.autoproxy

    Methods in org.springframework.aop.framework.autoproxy that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | AbstractAutoProxyCreator.`getBeanFactory()` Return the owning `BeanFactory`.

    Methods in org.springframework.aop.framework.autoproxy with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractAutoProxyCreator.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractBeanFactoryAwareAdvisingPostProcessor.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractAdvisorAutoProxyCreator.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.framework.autoproxy.target

    Methods in org.springframework.aop.framework.autoproxy.target that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | AbstractBeanFactoryBasedTargetSourceCreator.`getBeanFactory()` Return the BeanFactory that this TargetSourceCreators runs in.

    Methods in org.springframework.aop.framework.autoproxy.target with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractBeanFactoryBasedTargetSourceCreator.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.interceptor

    Methods in org.springframework.aop.interceptor with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected Executor` | AsyncExecutionAspectSupport.`findQualifiedExecutor(BeanFactory beanFactory, String qualifier)` Retrieve a target executor for the given qualifier.
    `protected Executor` | AsyncExecutionInterceptor.`getDefaultExecutor(BeanFactory beanFactory)` This implementation searches for a unique `TaskExecutor` bean in the context, or for an `Executor` bean named "taskExecutor" otherwise.
    `protected Executor` | AsyncExecutionAspectSupport.`getDefaultExecutor(BeanFactory beanFactory)` Retrieve or build a default executor for this advice instance.
    `void` | AsyncExecutionAspectSupport.`setBeanFactory(BeanFactory beanFactory)` Set the `BeanFactory` to be used when looking up executors by qualifier or when relying on the default executor lookup algorithm.

  - ### Uses of BeanFactory in org.springframework.aop.scope

    Methods in org.springframework.aop.scope with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | ScopedProxyFactoryBean.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.support

    Methods in org.springframework.aop.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractBeanFactoryPointcutAdvisor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.aop.target

    Methods in org.springframework.aop.target that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `BeanFactory` | AbstractBeanFactoryBasedTargetSource.`getBeanFactory()` Return the owning BeanFactory.

    Methods in org.springframework.aop.target with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractPoolingTargetSource.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractPrototypeBasedTargetSource.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractBeanFactoryBasedTargetSource.`setBeanFactory(BeanFactory beanFactory)` Set the owning BeanFactory.

  - ### Uses of BeanFactory in org.springframework.aop.target.dynamic

    Methods in org.springframework.aop.target.dynamic with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | BeanFactoryRefreshableTargetSource.`obtainFreshBean(BeanFactory beanFactory, String beanName)` A template method that subclasses may override to provide a fresh target object for the given bean factory and bean name.

    Constructors in org.springframework.aop.target.dynamic with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryRefreshableTargetSource(BeanFactory beanFactory, String beanName)` Create a new BeanFactoryRefreshableTargetSource for the given bean factory and bean name.

  - ### Uses of BeanFactory in org.springframework.beans.factory

    Subinterfaces of BeanFactory in org.springframework.beans.factory
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `HierarchicalBeanFactory` Sub-interface implemented by bean factories that can be part of a hierarchy.
    `interface` | `ListableBeanFactory` Extension of the `BeanFactory` interface to be implemented by bean factories that can enumerate all their bean instances, rather than attempting bean lookup by name one by one as requested by clients.

    Methods in org.springframework.beans.factory that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `BeanFactory` | HierarchicalBeanFactory.`getParentBeanFactory()` Return the parent bean factory, or `null` if there is none.

    Methods in org.springframework.beans.factory with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanFactoryAware.`setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.

  - ### Uses of BeanFactory in org.springframework.beans.factory.annotation

    Methods in org.springframework.beans.factory.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `static boolean` | BeanFactoryAnnotationUtils.`isQualifierMatch(Predicate<String> qualifier, String beanName, BeanFactory beanFactory)` Check whether the named bean declares a qualifier of the given name.
    `static <T> T` | BeanFactoryAnnotationUtils.`qualifiedBeanOfType(BeanFactory beanFactory, Class<T> beanType, String qualifier)` Obtain a bean of type `T` from the given `BeanFactory` declaring a qualifier (e.g.
    `void` | RequiredAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)` Deprecated.
    `void` | AutowiredAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.beans.factory.config

    Subinterfaces of BeanFactory in org.springframework.beans.factory.config
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `AutowireCapableBeanFactory` Extension of the `BeanFactory` interface to be implemented by bean factories that are capable of autowiring, provided that they want to expose this functionality for existing bean instances.
    `interface` | `ConfigurableBeanFactory` Configuration interface to be implemented by most bean factories.
    `interface` | `ConfigurableListableBeanFactory` Configuration interface to be implemented by most listable bean factories.

    Methods in org.springframework.beans.factory.config that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | AbstractFactoryBean.`getBeanFactory()` Return the BeanFactory that this bean runs in.

    Methods in org.springframework.beans.factory.config with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `Object` | DependencyDescriptor.`resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory)` Resolve the specified bean name, as a candidate result of the matching algorithm for this dependency, to a bean instance from the given factory.
    `Object` | DependencyDescriptor.`resolveShortcut(BeanFactory beanFactory)` Resolve a shortcut for this dependency against the given factory, for example taking some pre-resolved information into account.
    `void` | PropertyPathFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | PlaceholderConfigurerSupport.`setBeanFactory(BeanFactory beanFactory)` Only necessary to check that we're not parsing our own bean definition, to avoid failing on unresolvable placeholders in properties file locations.
    `void` | ServiceLocatorFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | MethodInvokingBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | ConfigurableBeanFactory.`setParentBeanFactory(BeanFactory parentBeanFactory)` Set the parent of this bean factory.

  - ### Uses of BeanFactory in org.springframework.beans.factory.support

    Classes in org.springframework.beans.factory.support that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractAutowireCapableBeanFactory` Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the `RootBeanDefinition` class.
    `class` | `AbstractBeanFactory` Abstract base class for `BeanFactory` implementations, providing the full capabilities of the `ConfigurableBeanFactory` SPI.
    `class` | `DefaultListableBeanFactory` Spring's default implementation of the `ConfigurableListableBeanFactory` and `BeanDefinitionRegistry` interfaces: a full-fledged bean factory based on bean definition metadata, extensible through post-processors.
    `class` | `StaticListableBeanFactory` Static `BeanFactory` implementation which allows one to register existing singleton instances programmatically.

    Methods in org.springframework.beans.factory.support that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | GenericTypeAwareAutowireCandidateResolver.`getBeanFactory()`
    `BeanFactory` | AbstractBeanFactory.`getParentBeanFactory()`

    Methods in org.springframework.beans.factory.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `Object` | SimpleInstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner)`
    `Object` | InstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner)` Return an instance of the bean with the given name in this factory.
    `Object` | SimpleInstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Constructor<?> ctor, Object... args)`
    `Object` | InstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Constructor<?> ctor, Object... args)` Return an instance of the bean with the given name in this factory, creating it via the given constructor.
    `Object` | SimpleInstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object... args)`
    `Object` | InstantiationStrategy.`instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner, Object factoryBean, Method factoryMethod, Object... args)` Return an instance of the bean with the given name in this factory, creating it via the given factory method.
    `protected Object` | SimpleInstantiationStrategy.`instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner)` Subclasses can override this method, which is implemented to throw UnsupportedOperationException, if they can instantiate an object with the Method Injection specified in the given RootBeanDefinition.
    `protected Object` | CglibSubclassingInstantiationStrategy.`instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner)`
    `protected Object` | SimpleInstantiationStrategy.`instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner, Constructor<?> ctor, Object... args)` Subclasses can override this method, which is implemented to throw UnsupportedOperationException, if they can instantiate an object with the Method Injection specified in the given RootBeanDefinition.
    `protected Object` | CglibSubclassingInstantiationStrategy.`instantiateWithMethodInjection(RootBeanDefinition bd, String beanName, BeanFactory owner, Constructor<?> ctor, Object... args)`
    `void` | GenericTypeAwareAutowireCandidateResolver.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AbstractBeanFactory.`setParentBeanFactory(BeanFactory parentBeanFactory)`

    Constructors in org.springframework.beans.factory.support with parameters of type BeanFactory
    Constructor and Description
    `AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory)` Create a new AbstractAutowireCapableBeanFactory with the given parent.
    `AbstractBeanFactory(BeanFactory parentBeanFactory)` Create a new AbstractBeanFactory with the given parent.
    `DefaultListableBeanFactory(BeanFactory parentBeanFactory)` Create a new DefaultListableBeanFactory with the given parent.

  - ### Uses of BeanFactory in org.springframework.beans.factory.wiring

    Methods in org.springframework.beans.factory.wiring with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanConfigurerSupport.`setBeanFactory(BeanFactory beanFactory)` Set the `BeanFactory` in which this aspect must configure beans.

  - ### Uses of BeanFactory in org.springframework.beans.factory.xml

    Classes in org.springframework.beans.factory.xml that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `XmlBeanFactory` Deprecated. as of Spring 3.1 in favor of `DefaultListableBeanFactory` and `XmlBeanDefinitionReader`

    Constructors in org.springframework.beans.factory.xml with parameters of type BeanFactory
    Constructor and Description
    `XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory)` Deprecated. Create a new XmlBeanFactory with the given input stream, which must be parsable using DOM.

  - ### Uses of BeanFactory in org.springframework.cache.interceptor

    Methods in org.springframework.cache.interceptor with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | CacheAspectSupport.`setBeanFactory(BeanFactory beanFactory)` Set the containing `BeanFactory` for `CacheManager` and other service lookups.
    `void` | CacheProxyFactoryBean.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.cache.jcache.interceptor

    Methods in org.springframework.cache.jcache.interceptor with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | DefaultJCacheOperationSource.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.context

    Subinterfaces of BeanFactory in org.springframework.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ApplicationContext` Central interface to provide configuration for an application.
    `interface` | `ConfigurableApplicationContext` SPI interface to be implemented by most if not all application contexts.

  - ### Uses of BeanFactory in org.springframework.context.annotation

    Classes in org.springframework.context.annotation that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AnnotationConfigApplicationContext` Standalone application context, accepting component classes as input — in particular `@Configuration`-annotated classes, but also plain `@Component` types and JSR-330 compliant classes using `javax.inject` annotations.

    Methods in org.springframework.context.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | CommonAnnotationBeanPostProcessor.`autowireResource(BeanFactory factory, CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain a resource object for the given name and type through autowiring based on the given factory.
    `void` | MBeanExportConfiguration.`setBeanFactory(BeanFactory beanFactory)`
    `void` | CommonAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)`
    `void` | CommonAnnotationBeanPostProcessor.`setJndiFactory(BeanFactory jndiFactory)` Specify the factory for objects to be injected into `@Resource` / `@WebServiceRef` / `@EJB` annotated fields and setter methods, for `mappedName` attributes that point directly into JNDI.
    `void` | CommonAnnotationBeanPostProcessor.`setResourceFactory(BeanFactory resourceFactory)` Specify the factory for objects to be injected into `@Resource` / `@WebServiceRef` / `@EJB` annotated fields and setter methods, for `name` attributes and default names.

  - ### Uses of BeanFactory in org.springframework.context.event

    Methods in org.springframework.context.event with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractApplicationEventMulticaster.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.context.event with parameters of type BeanFactory
    Constructor and Description
    `SimpleApplicationEventMulticaster(BeanFactory beanFactory)` Create a new SimpleApplicationEventMulticaster for the given BeanFactory.

  - ### Uses of BeanFactory in org.springframework.context.expression

    Constructors in org.springframework.context.expression with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryResolver(BeanFactory beanFactory)` Create a new `BeanFactoryResolver` for the given factory.

  - ### Uses of BeanFactory in org.springframework.context.support

    Classes in org.springframework.context.support that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractApplicationContext` Abstract implementation of the `ApplicationContext` interface.
    `class` | `AbstractRefreshableApplicationContext` Base class for `ApplicationContext` implementations which are supposed to support multiple calls to `AbstractApplicationContext.refresh()`, creating a new internal bean factory instance every time.
    `class` | `AbstractRefreshableConfigApplicationContext` `AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
    `class` | `AbstractXmlApplicationContext` Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
    `class` | `ClassPathXmlApplicationContext` Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
    `class` | `FileSystemXmlApplicationContext` Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.
    `class` | `GenericApplicationContext` Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
    `class` | `GenericGroovyApplicationContext` An `ApplicationContext` implementation that extends `GenericApplicationContext` and implements `GroovyObject` such that beans can be retrieved with the dot de-reference syntax instead of using `AbstractApplicationContext.getBean(java.lang.String)`.
    `class` | `GenericXmlApplicationContext` Convenient application context with built-in XML support.
    `class` | `StaticApplicationContext` `ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.

    Methods in org.springframework.context.support that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | AbstractApplicationContext.`getInternalParentBeanFactory()` Return the internal bean factory of the parent context if it implements ConfigurableApplicationContext; else, return the parent context itself.
    `BeanFactory` | AbstractApplicationContext.`getParentBeanFactory()`

    Methods in org.springframework.context.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | DefaultLifecycleProcessor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.context.weaving

    Methods in org.springframework.context.weaving with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | LoadTimeWeaverAwareProcessor.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.context.weaving with parameters of type BeanFactory
    Constructor and Description
    `LoadTimeWeaverAwareProcessor(BeanFactory beanFactory)` Create a new `LoadTimeWeaverAwareProcessor`.

  - ### Uses of BeanFactory in org.springframework.dao.annotation

    Methods in org.springframework.dao.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | PersistenceExceptionTranslationPostProcessor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.dao.support

    Methods in org.springframework.dao.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | PersistenceExceptionTranslationInterceptor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.jca.context

    Classes in org.springframework.jca.context that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ResourceAdapterApplicationContext` `ApplicationContext` implementation for a JCA ResourceAdapter.

  - ### Uses of BeanFactory in org.springframework.jdbc.datasource.lookup

    Methods in org.springframework.jdbc.datasource.lookup with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanFactoryDataSourceLookup.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.jdbc.datasource.lookup with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryDataSourceLookup(BeanFactory beanFactory)` Create a new instance of the `BeanFactoryDataSourceLookup` class.

  - ### Uses of BeanFactory in org.springframework.jms.annotation

    Methods in org.springframework.jms.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | JmsListenerAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)` Making a `BeanFactory` available is optional; if not set, `JmsListenerConfigurer` beans won't get autodetected and an `endpoint registry` has to be explicitly configured.

  - ### Uses of BeanFactory in org.springframework.jms.config

    Methods in org.springframework.jms.config with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | MethodJmsListenerEndpoint.`setBeanFactory(BeanFactory beanFactory)` Set the `BeanFactory` to use to resolve expressions (may be `null`).
    `void` | JmsListenerEndpointRegistrar.`setBeanFactory(BeanFactory beanFactory)` A `BeanFactory` only needs to be available in conjunction with `JmsListenerEndpointRegistrar.setContainerFactoryBeanName(java.lang.String)`.

  - ### Uses of BeanFactory in org.springframework.jms.support.destination

    Methods in org.springframework.jms.support.destination with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanFactoryDestinationResolver.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.jms.support.destination with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryDestinationResolver(BeanFactory beanFactory)` Create a new instance of the `BeanFactoryDestinationResolver` class.

  - ### Uses of BeanFactory in org.springframework.jmx.export

    Methods in org.springframework.jmx.export with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | MBeanExporter.`setBeanFactory(BeanFactory beanFactory)` This callback is only required for resolution of bean names in the `"beans"` `Map` and for autodetection of MBeans (in the latter case, a `ListableBeanFactory` is required).

  - ### Uses of BeanFactory in org.springframework.jmx.export.annotation

    Methods in org.springframework.jmx.export.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AnnotationMBeanExporter.`setBeanFactory(BeanFactory beanFactory)`
    `void` | AnnotationJmxAttributeSource.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.jndi

    Methods in org.springframework.jndi with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | JndiObjectFactoryBean.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.jndi.support

    Classes in org.springframework.jndi.support that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `SimpleJndiBeanFactory` Simple JNDI-based implementation of Spring's `BeanFactory` interface.

  - ### Uses of BeanFactory in org.springframework.messaging.core

    Methods in org.springframework.messaging.core with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanFactoryMessageChannelDestinationResolver.`setBeanFactory(BeanFactory beanFactory)`
    `void` | GenericMessagingTemplate.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.messaging.core with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryMessageChannelDestinationResolver(BeanFactory beanFactory)` A constructor that accepts a `BeanFactory` useful if instantiating this resolver manually rather than having it defined as a Spring-managed bean.

  - ### Uses of BeanFactory in org.springframework.messaging.handler

    Constructors in org.springframework.messaging.handler with parameters of type BeanFactory
    Constructor and Description
    `HandlerMethod(String beanName, BeanFactory beanFactory, Method method)` Create an instance from a bean name, a method, and a `BeanFactory`.

  - ### Uses of BeanFactory in org.springframework.messaging.handler.annotation.support

    Methods in org.springframework.messaging.handler.annotation.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | DefaultMessageHandlerMethodFactory.`setBeanFactory(BeanFactory beanFactory)` A `BeanFactory` only needs to be available for placeholder resolution in handler method arguments; it's optional otherwise.

  - ### Uses of BeanFactory in org.springframework.orm.hibernate5

    Methods in org.springframework.orm.hibernate5 with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | HibernateTransactionManager.`setBeanFactory(BeanFactory beanFactory)` The bean factory just needs to be known for resolving entity interceptor bean names.
    `void` | LocalSessionFactoryBean.`setBeanFactory(BeanFactory beanFactory)` Accept the containing `BeanFactory`, registering corresponding Hibernate `BeanContainer` integration for it if possible.

  - ### Uses of BeanFactory in org.springframework.orm.jpa

    Methods in org.springframework.orm.jpa with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractEntityManagerFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | EntityManagerFactoryAccessor.`setBeanFactory(BeanFactory beanFactory)` Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.
    `void` | JpaTransactionManager.`setBeanFactory(BeanFactory beanFactory)` Retrieves an EntityManagerFactory by persistence unit name, if none set explicitly.

  - ### Uses of BeanFactory in org.springframework.orm.jpa.support

    Methods in org.springframework.orm.jpa.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | PersistenceAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.r2dbc.connection.lookup

    Methods in org.springframework.r2dbc.connection.lookup with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanFactoryConnectionFactoryLookup.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.r2dbc.connection.lookup with parameters of type BeanFactory
    Constructor and Description
    `BeanFactoryConnectionFactoryLookup(BeanFactory beanFactory)` Create a new instance of the `BeanFactoryConnectionFactoryLookup` class.

  - ### Uses of BeanFactory in org.springframework.remoting.jaxws

    Methods in org.springframework.remoting.jaxws with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AbstractJaxWsServiceExporter.`setBeanFactory(BeanFactory beanFactory)` Obtains all web service beans and publishes them as JAX-WS endpoints.

  - ### Uses of BeanFactory in org.springframework.scheduling.annotation

    Methods in org.springframework.scheduling.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AsyncAnnotationAdvisor.`setBeanFactory(BeanFactory beanFactory)` Set the `BeanFactory` to be used when looking up executors by qualifier.
    `void` | ScheduledAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)` Making a `BeanFactory` available is optional; if not set, `SchedulingConfigurer` beans won't get autodetected and a `scheduler` has to be explicitly configured.
    `void` | AsyncAnnotationBeanPostProcessor.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.scheduling.quartz

    Methods in org.springframework.scheduling.quartz with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | MethodInvokingJobDetailFactoryBean.`setBeanFactory(BeanFactory beanFactory)`
    `void` | SchedulerAccessorBean.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.scripting.groovy

    Methods in org.springframework.scripting.groovy with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | GroovyScriptFactory.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.scripting.support

    Methods in org.springframework.scripting.support with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected Object` | RefreshableScriptTargetSource.`obtainFreshBean(BeanFactory beanFactory, String beanName)` Obtain a fresh target object, retrieving a FactoryBean if necessary.
    `void` | ScriptFactoryPostProcessor.`setBeanFactory(BeanFactory beanFactory)`

    Constructors in org.springframework.scripting.support with parameters of type BeanFactory
    Constructor and Description
    `RefreshableScriptTargetSource(BeanFactory beanFactory, String beanName, ScriptFactory scriptFactory, ScriptSource scriptSource, boolean isFactoryBean)` Create a new RefreshableScriptTargetSource.

  - ### Uses of BeanFactory in org.springframework.transaction.interceptor

    Methods in org.springframework.transaction.interceptor that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | TransactionAspectSupport.`getBeanFactory()` Return the BeanFactory to use for retrieving `TransactionManager` beans.

    Methods in org.springframework.transaction.interceptor with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | TransactionAspectSupport.`setBeanFactory(BeanFactory beanFactory)` Set the BeanFactory to use for retrieving `TransactionManager` beans.
    `void` | TransactionProxyFactoryBean.`setBeanFactory(BeanFactory beanFactory)` This callback is optional: If running in a BeanFactory and no transaction manager has been set explicitly, a single matching bean of type `PlatformTransactionManager` will be fetched from the BeanFactory.

  - ### Uses of BeanFactory in org.springframework.web.context

    Subinterfaces of BeanFactory in org.springframework.web.context
    Modifier and Type | Interface and Description
    --- | ---
    `interface` | `ConfigurableWebApplicationContext` Interface to be implemented by configurable web application contexts.
    `interface` | `WebApplicationContext` Interface to provide configuration for a web application.

  - ### Uses of BeanFactory in org.springframework.web.context.request.async

    Methods in org.springframework.web.context.request.async with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | WebAsyncTask.`setBeanFactory(BeanFactory beanFactory)` A `BeanFactory` to use for resolving an executor name.

  - ### Uses of BeanFactory in org.springframework.web.context.support

    Classes in org.springframework.web.context.support that implement BeanFactory
    Modifier and Type | Class and Description
    --- | ---
    `class` | `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
    `class` | `AnnotationConfigWebApplicationContext` `WebApplicationContext` implementation which accepts component classes as input — in particular `@Configuration` classes, but also plain `@Component` classes as well as JSR-330 compliant classes using `javax.inject` annotations.
    `class` | `GenericWebApplicationContext` Subclass of `GenericApplicationContext`, suitable for web environments.
    `class` | `GroovyWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a `GroovyBeanDefinitionReader`.
    `class` | `StaticWebApplicationContext` Static `WebApplicationContext` implementation for testing.
    `class` | `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

  - ### Uses of BeanFactory in org.springframework.web.jsf

    Methods in org.springframework.web.jsf that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | DelegatingNavigationHandlerProxy.`getBeanFactory(FacesContext facesContext)` Retrieve the Spring BeanFactory to delegate bean name resolution to.

  - ### Uses of BeanFactory in org.springframework.web.method

    Constructors in org.springframework.web.method with parameters of type BeanFactory
    Constructor and Description
    `ControllerAdviceBean(String beanName, BeanFactory beanFactory)` Create a `ControllerAdviceBean` using the given bean name and `BeanFactory`.
    `ControllerAdviceBean(String beanName, BeanFactory beanFactory, ControllerAdvice controllerAdvice)` Create a `ControllerAdviceBean` using the given bean name, `BeanFactory`, and `@ControllerAdvice` annotation.
    `HandlerMethod(String beanName, BeanFactory beanFactory, MessageSource messageSource, Method method)` Variant of `HandlerMethod(String, BeanFactory, Method)` that also accepts a `MessageSource`.
    `HandlerMethod(String beanName, BeanFactory beanFactory, Method method)` Create an instance from a bean name, a method, and a `BeanFactory`.

  - ### Uses of BeanFactory in org.springframework.web.servlet.mvc.method.annotation

    Methods in org.springframework.web.servlet.mvc.method.annotation with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | RequestMappingHandlerAdapter.`setBeanFactory(BeanFactory beanFactory)` A `ConfigurableBeanFactory` is expected for resolving expressions in method argument default values.

    Constructors in org.springframework.web.servlet.mvc.method.annotation with parameters of type BeanFactory
    Constructor and Description
    `AsyncTaskMethodReturnValueHandler(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.web.servlet.view

    Methods in org.springframework.web.servlet.view that return BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `protected BeanFactory` | XmlViewResolver.`initFactory()` Deprecated. Initialize the view bean factory from the XML file.
    `protected BeanFactory` | ResourceBundleViewResolver.`initFactory(Locale locale)` Deprecated. Initialize the View `BeanFactory` from the `ResourceBundle`, for the given `locale`.

  - ### Uses of BeanFactory in org.springframework.web.socket.client.standard

    Methods in org.springframework.web.socket.client.standard with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | AnnotatedEndpointConnectionManager.`setBeanFactory(BeanFactory beanFactory)`
    `void` | EndpointConnectionManager.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.web.socket.handler

    Methods in org.springframework.web.socket.handler with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | BeanCreatingHandlerProvider.`setBeanFactory(BeanFactory beanFactory)`
    `void` | PerConnectionWebSocketHandler.`setBeanFactory(BeanFactory beanFactory)`

  - ### Uses of BeanFactory in org.springframework.web.socket.server.standard

    Methods in org.springframework.web.socket.server.standard with parameters of type BeanFactory
    Modifier and Type | Method and Description
    --- | ---
    `void` | ServerEndpointRegistration.`setBeanFactory(BeanFactory beanFactory)`