# Uses of Package
org.springframework.beans.factory

- 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 | Various `TargetSourceCreator` implementations for use with Spring's AOP auto-proxying support.
  org.springframework.aop.interceptor | Provides miscellaneous interceptor implementations.
  org.springframework.aop.scope | Support for AOP-based scoping of target objects, with configurable backend.
  org.springframework.aop.support | Convenience classes for using Spring's AOP API.
  org.springframework.aop.target |
  org.springframework.aop.target.dynamic |
  org.springframework.beans.factory | The core package implementing Spring's lightweight Inversion of Control (IoC) container.
  org.springframework.beans.factory.annotation | Support package for annotation-driven bean configuration.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.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 `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 | 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.reactive | Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.
  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.handler.invocation.reactive | Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.
  org.springframework.messaging.rsocket.annotation.support | Support classes for working with annotated RSocket stream handling 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.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.r2dbc.connection | Provides a utility class for easy ConnectionFactory access, a ReactiveTransactionManager for a single ConnectionFactory, and various simple ConnectionFactory implementations.
  org.springframework.r2dbc.connection.init | Provides extensible support for initializing databases through scripts.
  org.springframework.r2dbc.connection.lookup | Provides a strategy for looking up R2DBC ConnectionFactories by name.
  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 | Annotation support 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 integrating the Spring TestContext Framework with TestNG.
  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 | Configuration support for WebSocket request handling.
  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.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.
  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.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.handler.invocation.reactive
  Class and Description
  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.messaging.rsocket.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.
  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.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.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.r2dbc.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.r2dbc.connection.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.r2dbc.connection.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.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.
  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.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
  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.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
  Class and Description
  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.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.