Uses of Interface
org.springframework.beans.factory.BeanNameAware
Package
Description
Bean post-processors for use in ApplicationContexts to simplify AOP usage
by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
SPI interfaces and configuration-related convenience classes for bean factories.
Implementation package for
java.util.concurrent
based caches.Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
This package provides a facility for generic JCA message endpoint management.
This package contains the base message listener container facility.
This package provides JCA-based endpoint management for JMS message listeners.
Support classes for working with annotated message-handling methods with
non-blocking, reactive contracts.
Common infrastructure for invoking message handler methods with non-blocking,
and reactive contracts.
Support classes for working with annotated RSocket stream handling methods.
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.Classes supporting the
org.springframework.orm.hibernate5
package.Package providing integration of JPA (Java Persistence API) with Spring concepts.
Classes supporting the
org.springframework.orm.jpa
package.Annotation support for asynchronous method execution.
Scheduling convenience classes for the
java.util.concurrent
and jakarta.enterprise.concurrent
packages, allowing to set up a
ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring
context.Support package for declarative scheduling configuration,
with XML schema being the primary configuration format.
Support classes for the open source scheduler
Quartz,
allowing to set up Quartz Schedulers, JobDetails and
Triggers as beans in a Spring context.
Classes supporting the
org.springframework.web.context
package,
such as WebApplicationContext implementations and various utility classes.Provides generic filter base classes allowing for bean-style configuration.
Support classes for the multipart resolution framework.
Classes supporting the
org.springframework.web.reactive.function.server
package.Provides HandlerMapping implementations including abstract base classes.
Infrastructure for handler method processing.
Infrastructure for annotation-based handler method processing.
Support for result handling through view resolution.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Classes supporting the
org.springframework.web.servlet.function
package.Provides standard HandlerMapping implementations,
including abstract base classes for custom implementations.
Standard controller implementations for the Servlet MVC framework that comes with
Spring.
Servlet-based infrastructure for handler method processing,
building on the
org.springframework.web.method
package.MVC infrastructure for annotation-based handler method processing, building on the
org.springframework.web.method.annotation
package.Support classes for serving static resources.
Provides standard View and ViewResolver implementations,
including abstract base classes for custom implementations.
Support classes for document generation,
providing View implementations for PDF and Excel.
Support classes for feed generation, providing View implementations for Atom and RSS.
Support classes for the integration of
FreeMarker
as Spring web view technology.
Support classes for the integration of
Groovy Templates as Spring web view technology.
Support classes for providing a View implementation based on JSON serialization.
Support classes for views based on the JSR-223 script engine abstraction
(as included in Java 6+), e.g.
Support classes for providing a View implementation based on XML Marshalling.
Support classes for XSLT,
providing a View implementation for XSLT stylesheets.
Server-side support classes including container-specific strategies
for upgrading a request.
-
Uses of BeanNameAware in org.springframework.aop.framework.autoproxy
Modifier and TypeClassDescriptionclass
BeanPostProcessor
implementation that creates AOP proxies based on all candidateAdvisor
s in the currentBeanFactory
. -
Uses of BeanNameAware in org.springframework.beans.factory.config
Modifier and TypeClassDescriptionclass
FactoryBean
which retrieves a static or non-static field value.class
Abstract base class for property resource configurers that resolve placeholders in bean definition property values.class
Deprecated.class
FactoryBean
that evaluates a property path on a given target object.class
Deprecated.as of 5.2; useorg.springframework.context.support.PropertySourcesPlaceholderConfigurer
instead which is more flexible through taking advantage of theEnvironment
andPropertySource
mechanisms. -
Uses of BeanNameAware in org.springframework.cache.concurrent
Modifier and TypeClassDescriptionclass
FactoryBean
for easy configuration of aConcurrentMapCache
when used within a Spring container. -
Uses of BeanNameAware in org.springframework.context.support
Modifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass that adds common handling of specified config locations.class
Convenient base class forApplicationContext
implementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader
.class
Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.class
Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.class
Specialization ofPlaceholderConfigurerSupport
that resolves ${...} placeholders within bean definition property values and@Value
annotations against the current SpringEnvironment
and its set ofPropertySources
. -
Uses of BeanNameAware in org.springframework.jca.endpoint
Modifier and TypeClassDescriptionclass
Abstract base implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.class
Generic implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for any kind of message listener object (e.g. -
Uses of BeanNameAware in org.springframework.jms.listener
Modifier and TypeClassDescriptionclass
Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).class
Abstract base class for Spring message listener container implementations.class
Base class for listener container implementations which are based on polling.class
Message listener container variant that uses plain JMS client APIs, specifically a loop ofMessageConsumer.receive()
calls that also allow for transactional reception of messages (registering them with XA transactions).class
Message listener container that uses the plain JMS client API'sMessageConsumer.setMessageListener()
method to create concurrent MessageConsumers for the specified listeners. -
Uses of BeanNameAware in org.springframework.jms.listener.endpoint
Modifier and TypeClassDescriptionclass
JMS-specific implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for a JMS listener object (e.g.class
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration. -
Uses of BeanNameAware in org.springframework.messaging.handler.annotation.reactive
Modifier and TypeClassDescriptionclass
Extension ofAbstractMethodMessageHandler
for reactive, non-blocking handling of messages via@MessageMapping
methods. -
Uses of BeanNameAware in org.springframework.messaging.handler.invocation.reactive
Modifier and TypeClassDescriptionclass
Abstract base class for reactive HandlerMethod-based message handling. -
Uses of BeanNameAware in org.springframework.messaging.rsocket.annotation.support
Modifier and TypeClassDescriptionclass
Extension ofMessageMappingMessageHandler
for handling RSocket requests with@ConnectMapping
and@MessageMapping
methods. -
Uses of BeanNameAware in org.springframework.messaging.support
Modifier and TypeClassDescriptionclass
Abstract base class forMessageChannel
implementations.class
Abstract base class forSubscribableChannel
implementations.class
ASubscribableChannel
that sends messages to each of its subscribers. -
Uses of BeanNameAware in org.springframework.orm.hibernate5.support
Modifier and TypeClassDescriptionclass
Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request. -
Uses of BeanNameAware in org.springframework.orm.jpa
Modifier and TypeClassDescriptionclass
AbstractFactoryBean
that creates a local JPAEntityManagerFactory
instance within a Spring application context.class
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard container bootstrap contract.class
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard standalone bootstrap contract. -
Uses of BeanNameAware in org.springframework.orm.jpa.support
Modifier and TypeClassDescriptionclass
Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request. -
Uses of BeanNameAware in org.springframework.scheduling.annotation
Modifier and TypeClassDescriptionclass
Bean post-processor that registers methods annotated with@Scheduled
to be invoked by aTaskScheduler
according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation. -
Uses of BeanNameAware in org.springframework.scheduling.concurrent
Modifier and TypeClassDescriptionclass
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorService
type.class
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor
.class
A standard implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
and providing all applicable configuration options for it. -
Uses of BeanNameAware in org.springframework.scheduling.config
Modifier and TypeClassDescriptionclass
FactoryBean
for creatingThreadPoolTaskExecutor
instances, primarily used behind the XML task namespace. -
Uses of BeanNameAware in org.springframework.scheduling.quartz
Modifier and TypeClassDescriptionclass
A SpringFactoryBean
for creating a QuartzCronTrigger
instance, supporting bean-style usage for trigger configuration.class
A SpringFactoryBean
for creating a QuartzJobDetail
instance, supporting bean-style usage for JobDetail configuration.class
FactoryBean
that exposes aJobDetail
object which delegates job execution to a specified (static or non-static) method.class
FactoryBean
that creates and configures a QuartzScheduler
, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.class
A SpringFactoryBean
for creating a QuartzSimpleTrigger
instance, supporting bean-style usage for trigger configuration. -
Uses of BeanNameAware in org.springframework.web.context.support
Modifier and TypeClassDescriptionclass
AbstractRefreshableApplicationContext
subclass which implements theConfigurableWebApplicationContext
interface for web environments.class
WebApplicationContext
implementation which accepts component classes as input — in particular@Configuration
classes, but also plain@Component
classes as well as JSR-330 compliant classes usingjakarta.inject
annotations.class
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
. -
Uses of BeanNameAware in org.springframework.web.filter
Modifier and TypeClassDescriptionclass
Base class forFilter
s that perform logging operations before and after a request is processed.class
Servlet Filter that allows one to specify a character encoding for requests.class
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.class
Filter
to handle CORS pre-flight requests and intercept CORS simple and actual requests with aCorsProcessor
, and to update the response, e.g.class
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.class
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.class
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods:getServerName()
getServerPort()
getScheme()
isSecure()
sendRedirect(String)
.class
Simple base implementation ofFilter
which treats its config parameters (init-param
entries within thefilter
tag inweb.xml
) as bean properties.class
Filter
that converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod()
.class
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.class
OverridesHttpServletResponse.sendRedirect(String)
and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.class
Servlet Filter that exposes the request to the current thread, through bothLocaleContextHolder
andRequestContextHolder
.class
Filter
that createsobservations
for HTTP exchanges.class
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.class
Filter
that generates anETag
value based on the content on the response. -
Uses of BeanNameAware in org.springframework.web.multipart.support
Modifier and TypeClassDescriptionclass
Servlet Filter that resolves multipart requests via aMultipartResolver
. -
Uses of BeanNameAware in org.springframework.web.reactive.function.server.support
Modifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
. -
Uses of BeanNameAware in org.springframework.web.reactive.handler
Modifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations.class
Abstract base class for URL-mappedHandlerMapping
implementations.class
Implementation of theHandlerMapping
interface to map from URLs to request handler beans. -
Uses of BeanNameAware in org.springframework.web.reactive.result.method
Modifier and TypeClassDescriptionclass
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method. -
Uses of BeanNameAware in org.springframework.web.reactive.result.method.annotation
Modifier and TypeClassDescriptionclass
An extension ofRequestMappingInfoHandlerMapping
that createsRequestMappingInfo
instances from class-level and method-level@RequestMapping
annotations. -
Uses of BeanNameAware in org.springframework.web.reactive.result.view
Modifier and TypeClassDescriptionclass
Abstract base class for URL-based views.class
Base class forView
implementations.class
View that redirects to an absolute or context relative URL. -
Uses of BeanNameAware in org.springframework.web.reactive.result.view.freemarker
Modifier and TypeClassDescriptionclass
AView
implementation that uses the FreeMarker template engine. -
Uses of BeanNameAware in org.springframework.web.reactive.result.view.script
Modifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine. -
Uses of BeanNameAware in org.springframework.web.servlet.function.support
Modifier and TypeClassDescriptionclass
HandlerMapping
implementation that supportsRouterFunctions
. -
Uses of BeanNameAware in org.springframework.web.servlet.handler
Modifier and TypeClassDescriptionclass
Abstract implementation of theHandlerMapping
interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.class
Abstract base class forHandlerMapping
implementations.class
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
Abstract base class for URL-mappedHandlerMapping
implementations.class
Implementation of theHandlerMapping
interface that maps from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.class
Implementation of theHandlerMapping
interface that maps from URLs to request handler beans. -
Uses of BeanNameAware in org.springframework.web.servlet.mvc
Modifier and TypeClassDescriptionclass
Spring Controller implementation that forwards to a named servlet, i.e.class
Spring Controller implementation that wraps a servlet instance which it manages internally. -
Uses of BeanNameAware in org.springframework.web.servlet.mvc.method
Modifier and TypeClassDescriptionclass
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method. -
Uses of BeanNameAware in org.springframework.web.servlet.mvc.method.annotation
Modifier and TypeClassDescriptionclass
CreatesRequestMappingInfo
instances from type and method-level@RequestMapping
annotations in@Controller
classes. -
Uses of BeanNameAware in org.springframework.web.servlet.resource
Modifier and TypeClassDescriptionclass
A filter that wraps theHttpServletResponse
and overrides itsencodeURL
method in order to translate internal resource request URLs into public URL paths for external use. -
Uses of BeanNameAware in org.springframework.web.servlet.view
Modifier and TypeClassDescriptionclass
Adapter base class for template-based view technologies such as FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's FreeMarker macro library.class
Abstract base class for URL-based views.class
Abstract base class forView
implementations.class
Wrapper for a JSP or other resource within the same web application.class
Specialization ofInternalResourceView
for JSTL pages, i.e.class
View that redirects to an absolute, context relative, or current request relative URL. -
Uses of BeanNameAware in org.springframework.web.servlet.view.document
Modifier and TypeClassDescriptionclass
Abstract superclass for PDF views that operate on an existing document with an AcroForm.class
Abstract superclass for PDF views.class
Convenient superclass for Excel document views in traditional XLS format.class
Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.class
Convenient superclass for Excel document views in the Office 2007 XLSX format (as supported by POI-OOXML). -
Uses of BeanNameAware in org.springframework.web.servlet.view.feed
Modifier and TypeClassDescriptionclass
Abstract superclass for Atom Feed views, using the ROME package.class
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the ROME package.class
Abstract superclass for RSS Feed views, using the ROME package. -
Uses of BeanNameAware in org.springframework.web.servlet.view.freemarker
-
Uses of BeanNameAware in org.springframework.web.servlet.view.groovy
Modifier and TypeClassDescriptionclass
AnAbstractTemplateView
subclass based on Groovy XML/XHTML markup templates. -
Uses of BeanNameAware in org.springframework.web.servlet.view.json
Modifier and TypeClassDescriptionclass
Abstract base class for Jackson based and content type independentAbstractView
implementations.class
Spring MVCView
that renders JSON content by serializing the model for the current request using Jackson 2'sObjectMapper
. -
Uses of BeanNameAware in org.springframework.web.servlet.view.script
Modifier and TypeClassDescriptionclass
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine. -
Uses of BeanNameAware in org.springframework.web.servlet.view.xml
Modifier and TypeClassDescriptionclass
Spring MVCView
that renders XML content by serializing the model for the current request using Jackson 2'sXmlMapper
.class
Spring-MVCView
that allows for response context to be rendered as the result of marshalling by aMarshaller
. -
Uses of BeanNameAware in org.springframework.web.servlet.view.xslt
Modifier and TypeClassDescriptionclass
XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation. -
Uses of BeanNameAware in org.springframework.web.socket.server.support
Modifier and TypeClassDescriptionclass
Extension ofSimpleUrlHandlerMapping
with support for more precise mapping of WebSocket handshake requests to handlers of typeWebSocketHttpRequestHandler
.
PropertyPlaceholderConfigurer