Uses of Package org.springframework.beans.factory (Spring Framework 5.1.8.RELEASE API)

Packages that use org.springframework.beans.factory
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.aspectj.autoproxy	Base classes enabling auto-proxying based on AspectJ.
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
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.groovy	Support package for Groovy-based bean definitions.
org.springframework.beans.factory.parsing	Support infrastructure for bean definition parsing.
org.springframework.beans.factory.serviceloader	Support package for the Java 6 ServiceLoader facility.
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.annotation	Annotations and supporting classes for declarative cache management.
org.springframework.cache.aspectj
org.springframework.cache.concurrent	Implementation package for `java.util.concurrent` based caches.
org.springframework.cache.ehcache	Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.
org.springframework.cache.interceptor	AOP-based solution for declarative caching demarcation.
org.springframework.cache.jcache	Implementation package for JSR-107 (javax.cache aka "JCache") based caches.
org.springframework.cache.jcache.config	Support package for declarative JSR-107 caching configuration.
org.springframework.cache.jcache.interceptor	AOP-based solution for declarative caching demarcation using JSR-107 annotations.
org.springframework.cache.support	Support classes for the org.springframework.cache package.
org.springframework.cache.transaction	Transaction-aware decorators for the org.springframework.cache package.
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.ejb.access	This package contains classes that allow easy access to EJBs.
org.springframework.format.datetime	Formatters for `java.util.Date` properties.
org.springframework.format.datetime.joda	Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.
org.springframework.format.datetime.standard	Integration with the JSR-310 `java.time` package in JDK 8.
org.springframework.format.number	Formatters for `java.lang.Number` properties.
org.springframework.format.number.money	Integration with the JSR-354 `javax.money` package.
org.springframework.format.support	Support classes for the formatting package, providing common implementations as well as adapters.
org.springframework.http.client	Contains an abstraction over client-side HTTP.
org.springframework.http.client.reactive	Abstractions for reactive HTTP client support including `ClientHttpRequest` and `ClientHttpResponse` as well as a `ClientHttpConnector`.
org.springframework.http.client.support	This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.
org.springframework.http.converter.json	Provides HttpMessageConverter implementations for handling JSON.
org.springframework.jca.cci.connection	Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.
org.springframework.jca.cci.core.support	Classes supporting the `org.springframework.jca.cci.core` package.
org.springframework.jca.cci.object	The classes in this package represent EIS operations as threadsafe, reusable objects.
org.springframework.jca.context	Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.
org.springframework.jca.endpoint	This package provides a facility for generic JCA message endpoint management.
org.springframework.jca.support	Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.
org.springframework.jca.work	Convenience classes for scheduling based on the JCA WorkManager facility, as supported within ResourceAdapters.
org.springframework.jdbc.config	Defines the Spring JDBC configuration namespace.
org.springframework.jdbc.core	Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.
org.springframework.jdbc.core.namedparam	JdbcTemplate variant with named parameter support.
org.springframework.jdbc.core.support	Classes supporting the `org.springframework.jdbc.core` package.
org.springframework.jdbc.datasource	Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jdbc.datasource.embedded	Provides extensible support for creating embedded database instances.
org.springframework.jdbc.datasource.init	Provides extensible support for initializing databases through scripts.
org.springframework.jdbc.datasource.lookup	Provides a strategy for looking up JDBC DataSources by name.
org.springframework.jdbc.object	The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.
org.springframework.jdbc.support	Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.
org.springframework.jdbc.support.incrementer	Provides a support framework for incrementing database table values via sequences, with implementations for various databases.
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.connection	Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
org.springframework.jms.core	Core package of the JMS support.
org.springframework.jms.core.support	Classes supporting the `org.springframework.jms.core` package.
org.springframework.jms.listener	This package contains the base message listener container facility.
org.springframework.jms.listener.endpoint	This package provides JCA-based endpoint management for JMS message listeners.
org.springframework.jms.remoting	Remoting classes for transparent Java-to-Java remoting via a JMS provider.
org.springframework.jms.support	This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.
org.springframework.jms.support.converter	Provides a MessageConverter abstraction to convert between Java objects and JMS messages.
org.springframework.jms.support.destination	Support classes for Spring's JMS framework.
org.springframework.jmx.access	Provides support for accessing remote MBean resources.
org.springframework.jmx.export	This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation	Java 5 annotations for MBean exposure.
org.springframework.jmx.export.assembler	Provides a strategy for MBeanInfo assembly.
org.springframework.jmx.export.naming	Provides a strategy for ObjectName creation.
org.springframework.jmx.export.notification	Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.
org.springframework.jmx.support	Contains support classes for connecting to local and remote `MBeanServer`s and for exposing an `MBeanServer` to remote clients.
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.mail.javamail	JavaMail support for Spring's mail infrastructure.
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.messaging.handler.invocation	Common infrastructure for invoking message handler methods.
org.springframework.messaging.simp	Generic support for Simple Messaging Protocols including protocols such as STOMP.
org.springframework.messaging.simp.annotation.support	Support classes for handling messages from simple messaging protocols (like STOMP).
org.springframework.messaging.simp.broker	Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.
org.springframework.messaging.simp.config	Configuration support for WebSocket messaging using higher level messaging protocols.
org.springframework.messaging.simp.stomp	Generic support for simple messaging protocols (like STOMP).
org.springframework.messaging.support	Provides implementations of `Message` along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various `MessageChannel` implementations and channel interceptor support.
org.springframework.orm.hibernate5	Package providing integration of Hibernate 5.x with Spring concepts.
org.springframework.orm.hibernate5.support	Classes supporting the `org.springframework.orm.hibernate5` package.
org.springframework.orm.jpa	Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.persistenceunit	Internal support for managing JPA persistence units.
org.springframework.orm.jpa.support	Classes supporting the `org.springframework.orm.jpa` package.
org.springframework.orm.jpa.vendor	Support classes for adapting to specific JPA vendors.
org.springframework.oxm.castor	Package providing integration of Castor within Spring's O/X Mapping support.
org.springframework.oxm.jaxb	Package providing integration of JAXB with Spring's O/X Mapping support.
org.springframework.oxm.jibx	Package providing integration of JiBX with Spring's O/X Mapping support.
org.springframework.oxm.xstream	Package providing integration of XStream with Spring's O/X Mapping support.
org.springframework.remoting.caucho	This package provides remoting classes for Caucho's Hessian protocol: a proxy factory for accessing Hessian services, and an exporter for making beans available to Hessian clients.
org.springframework.remoting.httpinvoker	Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
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.remoting.rmi	Remoting classes for conventional RMI and transparent remoting via RMI invokers.
org.springframework.remoting.support	Generic support classes for remoting implementations.
org.springframework.scheduling.annotation	Java 5 annotation for asynchronous method execution.
org.springframework.scheduling.aspectj
org.springframework.scheduling.commonj	Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.
org.springframework.scheduling.concurrent	Scheduling convenience classes for the `java.util.concurrent` and `javax.enterprise.concurrent` packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.
org.springframework.scheduling.config	Support package for declarative scheduling configuration, with XML schema being the primary configuration format.
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.scheduling.support	Generic support classes for scheduling.
org.springframework.scripting.bsh	Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.
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.test.context.junit4	Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.
org.springframework.test.context.testng	Support classes for ApplicationContext-based and transactional tests run with TestNG and the Spring TestContext Framework.
org.springframework.transaction.annotation	Spring's support for annotation-based transaction demarcation.
org.springframework.transaction.aspectj
org.springframework.transaction.config	Support package for declarative transaction configuration, with XML schema being the primary configuration format.
org.springframework.transaction.interceptor	AOP-based solution for declarative transaction demarcation.
org.springframework.transaction.jta	Transaction SPI implementation for JTA.
org.springframework.transaction.support	Support classes for the org.springframework.transaction package.
org.springframework.ui.context.support	Classes supporting the org.springframework.ui.context package.
org.springframework.ui.freemarker	Support classes for setting up FreeMarker within a Spring application context.
org.springframework.validation.beanvalidation	Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.
org.springframework.web.accept	This package contains classes used to determine the requested the media types in a request.
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	Support for generic request context holding, in particular for scoping of application objects per HTTP request or HTTP session.
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.filter	Provides generic filter base classes allowing for bean-style configuration.
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.multipart.commons	MultipartResolver implementation for Apache Commons FileUpload.
org.springframework.web.multipart.support	Support classes for the multipart resolution framework.
org.springframework.web.reactive	Top-level package for the `spring-webflux` module that contains `DispatcherHandler`, the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
org.springframework.web.reactive.config	Spring WebFlux configuration infrastructure.
org.springframework.web.reactive.function.server.support	Classes supporting the `org.springframework.web.reactive.function.server` package.
org.springframework.web.reactive.handler	Provides HandlerMapping implementations including abstract base classes.
org.springframework.web.reactive.resource	Support classes for serving static resources.
org.springframework.web.reactive.result.method	Infrastructure for handler method processing.
org.springframework.web.reactive.result.method.annotation	Infrastructure for annotation-based handler method processing.
org.springframework.web.reactive.result.view	Support for result handling through view resolution.
org.springframework.web.reactive.result.view.freemarker	Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.reactive.result.view.script	Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g.
org.springframework.web.servlet	Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.
org.springframework.web.servlet.config.annotation	Annotation-based setup for Spring MVC.
org.springframework.web.servlet.handler	Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.mvc	Standard controller implementations for the Servlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc.annotation	Support package for annotation-based Servlet MVC controllers.
org.springframework.web.servlet.mvc.method	Servlet-based infrastructure for handler method processing, building on the `org.springframework.web.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.resource	Support classes for serving static resources.
org.springframework.web.servlet.support	Support classes for Spring's web MVC framework.
org.springframework.web.servlet.view	Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.
org.springframework.web.servlet.view.document	Support classes for document generation, providing View implementations for PDF and Excel.
org.springframework.web.servlet.view.feed	Support classes for feed generation, providing View implementations for Atom and RSS.
org.springframework.web.servlet.view.groovy	Support classes for the integration of Groovy Templates as Spring web view technology.
org.springframework.web.servlet.view.json	Support classes for providing a View implementation based on JSON serialization.
org.springframework.web.servlet.view.tiles3	Support classes for the integration of Tiles 3 (the standalone version of Tiles) as Spring web view technology.
org.springframework.web.servlet.view.xml	Support classes for providing a View implementation based on XML Marshalling.
org.springframework.web.servlet.view.xslt	Support classes for XSLT, providing a View implementation for XSLT stylesheets.
org.springframework.web.socket.client.standard	Client-side classes for use with standard Java WebSocket endpoints.
org.springframework.web.socket.config.annotation	Support for annotation-based WebSocket setup in configuration classes.
org.springframework.web.socket.handler	Convenient `WebSocketHandler` implementations and decorators.
org.springframework.web.socket.messaging	WebSocket integration for Spring's messaging module.
org.springframework.web.socket.server.jetty	Server-side support for the Jetty 9+ WebSocket API.
org.springframework.web.socket.server.standard	Server-side classes for use with standard JSR-356 WebSocket endpoints.
org.springframework.web.socket.server.support	Server-side support classes including container-specific strategies for upgrading a request.
org.springframework.web.socket.sockjs.support	Support classes for SockJS including an `AbstractSockJsService` implementation.
org.springframework.web.socket.sockjs.transport.handler	`TransportHandler` implementation classes as well as a concrete `SockJsService`.

Classes in org.springframework.beans.factory used by org.springframework.aop.aspectj
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.aop.aspectj.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
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.

Classes in org.springframework.beans.factory used by org.springframework.aop.aspectj.autoproxy
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.aop.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.

Classes in org.springframework.beans.factory used by org.springframework.aop.framework
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.aop.framework.autoproxy
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.aop.framework.autoproxy.target
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.

Classes in org.springframework.beans.factory used by org.springframework.aop.interceptor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.aop.scope
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.

Classes in org.springframework.beans.factory used by org.springframework.aop.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.aop.target
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.

Classes in org.springframework.beans.factory used by org.springframework.aop.target.dynamic
Class and Description
BeanFactory The root interface for accessing a Spring bean container.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanCreationException Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
BeanFactory The root interface for accessing a Spring bean container.
BeanNotOfRequiredTypeException Thrown when a bean doesn't match the expected type.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InjectionPoint A simple descriptor for an injection point, pointing to a method/constructor parameter or a field.
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.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectProvider A variant of `ObjectFactory` designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanCreationException Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
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.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
InjectionPoint A simple descriptor for an injection point, pointing to a method/constructor parameter or a field.
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.
NamedBean Counterpart of `BeanNameAware`.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.groovy
Class and Description
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.parsing
Class and Description
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.serviceloader
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanCreationException Exception thrown when a BeanFactory encounters an error when attempting to create a bean from a bean definition.
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
CannotLoadBeanClassException Exception thrown when the BeanFactory cannot load the specified class of a given bean.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectProvider A variant of `ObjectFactory` designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.
UnsatisfiedDependencyException Exception thrown when a bean depends on other beans or simple properties that were not specified in the bean factory definition, although dependency checking was enabled.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.wiring
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.beans.factory.xml
Class and Description
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanFactory The root interface for accessing a Spring bean container.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.

Classes in org.springframework.beans.factory used by org.springframework.cache.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.cache.aspectj
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.cache.concurrent
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.cache.ehcache
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.cache.interceptor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.cache.jcache
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.cache.jcache.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.cache.jcache.interceptor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.cache.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.cache.transaction
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.context
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.

Classes in org.springframework.beans.factory used by org.springframework.context.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.

Classes in org.springframework.beans.factory used by org.springframework.context.event
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.context.expression
Class and Description
BeanFactory The root interface for accessing a Spring bean container.

Classes in org.springframework.beans.factory used by org.springframework.context.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanDefinitionStoreException Exception thrown when a BeanFactory encounters an invalid bean definition: e.g.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
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.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.
ObjectProvider A variant of `ObjectFactory` designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.

Classes in org.springframework.beans.factory used by org.springframework.context.weaving
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.

Classes in org.springframework.beans.factory used by org.springframework.dao.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.dao.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanInitializationException Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
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.

Classes in org.springframework.beans.factory used by org.springframework.ejb.access
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.format.datetime
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.format.datetime.joda
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.format.datetime.standard
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.format.number
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.format.number.money
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.format.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.http.client
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.http.client.reactive
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.http.client.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.http.converter.json
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.cci.connection
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.cci.core.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.cci.object
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.context
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.

Classes in org.springframework.beans.factory used by org.springframework.jca.endpoint
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.support
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jca.work
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.core
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.core.namedparam
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.core.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.datasource
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.datasource.embedded
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.datasource.init
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.datasource.lookup
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.object
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jdbc.support.incrementer
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.jms.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.connection
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.core
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.core.support
Class and Description
BeanInitializationException Exception that a bean implementation is suggested to throw if its own factory-aware initialization code fails.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.listener
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.listener.endpoint
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.remoting
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.support.converter
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jms.support.destination
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jmx.access
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jmx.export
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
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.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.jmx.export.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.jmx.export.assembler
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jmx.export.naming
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jmx.export.notification
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.jmx.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jndi
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.jndi.support
Class and Description
BeanFactory The root interface for accessing a Spring bean container.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.
ObjectProvider A variant of `ObjectFactory` designed specifically for injection points, allowing for programmatic optionality and lenient not-unique handling.

Classes in org.springframework.beans.factory used by org.springframework.mail.javamail
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.messaging.core
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.messaging.handler
Class and Description
BeanFactory The root interface for accessing a Spring bean container.

Classes in org.springframework.beans.factory used by org.springframework.messaging.handler.annotation.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.messaging.handler.invocation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.messaging.simp
Class and Description
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.

Classes in org.springframework.beans.factory used by org.springframework.messaging.simp.annotation.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.messaging.simp.broker
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.messaging.simp.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.messaging.simp.stomp
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.messaging.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.orm.hibernate5
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.orm.hibernate5.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.orm.jpa
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
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.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.

Classes in org.springframework.beans.factory used by org.springframework.orm.jpa.persistenceunit
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.orm.jpa.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
NoSuchBeanDefinitionException Exception thrown when a `BeanFactory` is asked for a bean instance for which it cannot find a definition.

Classes in org.springframework.beans.factory used by org.springframework.orm.jpa.vendor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.

Classes in org.springframework.beans.factory used by org.springframework.oxm.castor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.oxm.jaxb
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.oxm.jibx
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.oxm.xstream
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.remoting.caucho
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.remoting.httpinvoker
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.remoting.jaxws
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.remoting.rmi
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.remoting.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.aspectj
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.commonj
Class and Description
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.concurrent
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.quartz
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.scheduling.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.scripting.bsh
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.

Classes in org.springframework.beans.factory used by org.springframework.scripting.groovy
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.scripting.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.

Classes in org.springframework.beans.factory used by org.springframework.test.context.junit4
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.test.context.testng
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.transaction.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.transaction.aspectj
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.transaction.config
Class and Description
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.

Classes in org.springframework.beans.factory used by org.springframework.transaction.interceptor
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.transaction.jta
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.transaction.support
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.

Classes in org.springframework.beans.factory used by org.springframework.ui.context.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.

Classes in org.springframework.beans.factory used by org.springframework.ui.freemarker
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.validation.beanvalidation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanClassLoaderAware Callback that allows a bean to be aware of the bean `class loader`; that is, the class loader used by the present bean factory to load bean classes.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.accept
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.context
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
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.

Classes in org.springframework.beans.factory used by org.springframework.web.context.request
Class and Description
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.

Classes in org.springframework.beans.factory used by org.springframework.web.context.request.async
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.web.context.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
HierarchicalBeanFactory Sub-interface implemented by bean factories that can be part of a hierarchy.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
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.
ObjectFactory Defines a factory which can return an Object instance (possibly shared or independent) when invoked.

Classes in org.springframework.beans.factory used by org.springframework.web.filter
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.jsf
Class and Description
BeanFactory The root interface for accessing a Spring bean container.
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.

Classes in org.springframework.beans.factory used by org.springframework.web.method
Class and Description
BeanFactory The root interface for accessing a Spring bean container.

Classes in org.springframework.beans.factory used by org.springframework.web.multipart.commons
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.multipart.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.config
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.function.server.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.handler
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.resource
Class and Description
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.result.method
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.result.method.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.result.view
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.result.view.freemarker
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.reactive.result.view.script
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.config.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.handler
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.mvc
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.mvc.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.mvc.method
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.mvc.method.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.resource
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.document
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.feed
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.groovy
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.json
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.tiles3
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
DisposableBean Interface to be implemented by beans that want to release resources on destruction.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.xml
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.web.servlet.view.xslt
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.client.standard
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.config.annotation
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.handler
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.messaging
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.server.jetty
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.server.standard
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanFactory The root interface for accessing a Spring bean container.
BeanFactoryAware Interface to be implemented by beans that wish to be aware of their owning `BeanFactory`.
FactoryBean Interface to be implemented by objects used within a `BeanFactory` which are themselves factories for individual objects.
InitializingBean Interface to be implemented by beans that need to react once all their properties have been set by a `BeanFactory`: e.g.
SmartInitializingSingleton Callback interface triggered at the end of the singleton pre-instantiation phase during `BeanFactory` bootstrap.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.server.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.
BeanNameAware Interface to be implemented by beans that want to be aware of their bean name in a bean factory.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.sockjs.support
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Classes in org.springframework.beans.factory used by org.springframework.web.socket.sockjs.transport.handler
Class and Description
Aware A marker superinterface indicating that a bean is eligible to be notified by the Spring container of a particular framework object through a callback-style method.

Uses of Packageorg.springframework.beans.factory

Uses of Package
org.springframework.beans.factory