BeanNameAware

implements Aware

org.springframework.beans.factory.BeanNameAware

Known Indirect Subclasses

AbstractAtomFeedView, AbstractEntityManagerFactoryBean, AbstractExcelView, AbstractFeedView<T extends WireFeed>, AbstractJExcelView, AbstractJasperReportsSingleFormatView, AbstractJasperReportsView, AbstractJmsListeningContainer, AbstractMessageListenerContainer, AbstractPdfStamperView, AbstractPdfView, AbstractPollingMessageListenerContainer, AbstractRefreshableConfigApplicationContext, AbstractRefreshablePortletApplicationContext, AbstractRefreshableWebApplicationContext, and 78 others.

AbstractAtomFeedView	Abstract superclass for Atom Feed views, using java.net's ROME package.
AbstractEntityManagerFactoryBean	Abstract `FactoryBean` that creates a local JPA javax.persistence.EntityManagerFactory instance within a Spring application context.
AbstractExcelView	Convenient superclass for Excel document views.
AbstractFeedView<T extends WireFeed>	Abstract base class for Atom and RSS Feed views, using java.net's ROME package.
AbstractJExcelView	Convenient superclass for Excel document views.
AbstractJasperReportsSingleFormatView	Extends `AbstractJasperReportsView` to provide basic rendering logic for views that use a fixed format, e.g.
AbstractJasperReportsView	Base class for all JasperReports views.
AbstractJmsListeningContainer	Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).
AbstractMessageListenerContainer	Abstract base class for message listener containers.
AbstractPdfStamperView	Abstract superclass for PDF views that operate on an existing document with an AcroForm.
AbstractPdfView	Abstract superclass for PDF views, using Bruno Lowagie's iText package.
AbstractPollingMessageListenerContainer	Base class for listener container implementations which are based on polling.
AbstractRefreshableConfigApplicationContext	`AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
AbstractRefreshablePortletApplicationContext	`AbstractRefreshableApplicationContext` subclass which implements the `ConfigurablePortletApplicationContext` interface for portlet environments.
AbstractRefreshableWebApplicationContext	`AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
AbstractRequestLoggingFilter	Base class for `Filter`s that perform logging operations before and after a request is processed.
AbstractRssFeedView	Abstract superclass for RSS Feed views, using java.net's ROME package.
AbstractTemplateView	Adapter base class for template-based view technologies such as Velocity and FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's Velocity/FreeMarker macro library.
AbstractUrlBasedView	Abstract base class for URL-based views.
AbstractView	Abstract base class for `View` implementations.
AbstractXmlApplicationContext	Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
AbstractXsltView	This class is deprecated. since Spring 2.5; superseded by `XsltView` and its more flexible `locateSource(Map)` mechanism
AnnotationConfigWebApplicationContext	`WebApplicationContext` implementation which accepts annotated classes as input - in particular `@Configuration`-annotated classes, but also plain `@Components` and JSR-330 compliant classes using `javax.inject` annotations.
CharacterEncodingFilter	Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests.
ClassPathXmlApplicationContext	Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
CommonsRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
ConcurrentCacheFactoryBean<K, V>	Factory bean for easy configuration of `ConcurrentCache` through Spring.
ConfigurableJasperReportsView	Configurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name.
CronTriggerBean	Convenience subclass of Quartz's org.quartz.CronTrigger class, making bean-style usage easier.
DefaultAdvisorAutoProxyCreator	BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory.
DefaultMessageListenerContainer	Message listener container variant that uses plain JMS client API, specifically a loop of `MessageConsumer.receive()` calls that also allow for transactional reception of messages (registering them with XA transactions).
DefaultMessageListenerContainer102	This class is deprecated. as of Spring 3.0, in favor of the JMS 1.1 based `DefaultMessageListenerContainer`
DelegatingFilterProxy	Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface.
EhCacheFactoryBean	`FactoryBean` that creates a named EHCache net.sf.ehcache.Cache instance (or a decorator that implements the net.sf.ehcache.Ehcache interface), representing a cache region within an EHCache net.sf.ehcache.CacheManager.
ExecutorConfigurationSupport	Base class for classes that are setting up a `java.util.concurrent.ExecutorService` (typically a java.util.concurrent.ThreadPoolExecutor).
FieldRetrievingFactoryBean	`FactoryBean` which retrieves a static or non-static field value.
FileSystemXmlApplicationContext	Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.
FilterDefinitionFactoryBean	Convenient FactoryBean for defining Hibernate FilterDefinitions.
FreeMarkerView	View using the FreeMarker template engine.
GenericFilterBean	Simple base implementation of javax.servlet.Filter which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
HiddenHttpMethodFilter	javax.servlet.Filter that converts posted method parameters into HTTP methods, retrievable via `getMethod()`.
InternalResourceView	Wrapper for a JSP or other resource within the same web application.
JasperReportsCsvView	Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in CSV format.
JasperReportsHtmlView	Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in HTML format.
JasperReportsMultiFormatView	Jasper Reports view class that allows for the actual rendering format to be specified at runtime using a parameter contained in the model.
JasperReportsPdfView	Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in PDF format.
JasperReportsXlsView	Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in XLS format.
JobDetailBean	Convenience subclass of Quartz's org.quartz.JobDetail class, making bean-style usage easier.
JstlView	Specialization of `InternalResourceView` for JSTL pages, i.e.
LocalContainerEntityManagerFactoryBean	`FactoryBean` that creates a JPA javax.persistence.EntityManagerFactory according to JPA's standard container bootstrap contract.
LocalEntityManagerFactoryBean	`FactoryBean` that creates a JPA javax.persistence.EntityManagerFactory according to JPA's standard standalone bootstrap contract.
Log4jNestedDiagnosticContextFilter	Request logging filter that adds the request log message to the Log4J nested diagnostic context (NDC) before the request is processed, removing it again after the request is processed.
MappingJacksonJsonView	Spring-MVC `View` that renders JSON content by serializing the model for the current request using Jackson's ObjectMapper.
MarshallingView	Spring-MVC `View` that allows for response context to be rendered as the result of marshalling by a `Marshaller`.
MethodInvokingJobDetailFactoryBean	`FactoryBean` that exposes a org.quartz.JobDetail object which delegates job execution to a specified (static or non-static) method.
MultipartFilter	Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
OncePerRequestFilter	Filter base class that guarantees to be just executed once per request, on any servlet container.
OpenEntityManagerInViewFilter	Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request.
OpenPersistenceManagerInViewFilter	Servlet 2.3 Filter that binds a JDO PersistenceManager to the thread for the entire processing of the request.
OpenSessionInViewFilter	Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire processing of the request.
PlaceholderConfigurerSupport	Abstract base class for property resource configurers that resolve placeholders in bean definition property values.
PortletWrappingController	`Controller` implementation that wraps a portlet instance which it manages internally.
PreferencesPlaceholderConfigurer	Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API (`java.util.prefs`).
PropertyPathFactoryBean	`FactoryBean` that evaluates a property path on a given target object.
PropertyPlaceholderConfigurer	`PlaceholderConfigurerSupport` subclass that resolves ${...} placeholders against `local` `properties` and/or system properties and environment variables.
PropertySourcesPlaceholderConfigurer	Specialization of `PlaceholderConfigurerSupport` Local properties are added as a property source in any case.
RedirectView	View that redirects to an absolute, context relative, or current request relative URL.
RequestContextFilter	Servlet 2.3 Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
ScheduledExecutorFactoryBean	`FactoryBean` that sets up a JDK 1.5 java.util.concurrent.ScheduledExecutorService (by default: a java.util.concurrent.ScheduledThreadPoolExecutor) and exposes it for bean references.
SchedulerFactoryBean	`FactoryBean` that creates and configures a Quartz org.quartz.Scheduler, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
ServletContextPropertyPlaceholderConfigurer	This class is deprecated. in Spring 3.1 in favor of `PropertySourcesPlaceholderConfigurer` in conjunction with `DefaultWebEnvironment`.
ServletContextRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
ServletForwardingController	Spring Controller implementation that forwards to a named servlet, i.e.
ServletWrappingController	Spring Controller implementation that wraps a servlet instance which it manages internally.
ShallowEtagHeaderFilter	javax.servlet.Filter that generates an `ETag` value based on the content on the response.
SimpleMessageListenerContainer	Message listener container that uses the plain JMS client API's `MessageConsumer.setMessageListener()` method to create concurrent MessageConsumers for the specified listeners.
SimpleMessageListenerContainer102	This class is deprecated. as of Spring 3.0, in favor of the JMS 1.1 based `SimpleMessageListenerContainer`
SimpleTriggerBean	Convenience subclass of Quartz's org.quartz.SimpleTrigger class, making bean-style usage easier.
TaskExecutorFactoryBean	FactoryBean for creating ThreadPoolTaskExecutor instances, choosing between the standard concurrent and the backport-concurrent variant.
ThreadPoolExecutorFactoryBean	JavaBean that allows for configuring a JDK 1.5 java.util.concurrent.ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native java.util.concurrent.ExecutorService type.
ThreadPoolTaskExecutor	JavaBean that allows for configuring a JSR-166 backport edu.emory.mathcs.backport.java.util.concurrent.ThreadPoolExecutor in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties), exposing it as a Spring `TaskExecutor`.
ThreadPoolTaskScheduler	Implementation of Spring's `TaskScheduler` interface, wrapping a native java.util.concurrent.ScheduledThreadPoolExecutor.
TilesJstlView	This class is deprecated. as of Spring 3.0
TilesView	This class is deprecated. as of Spring 3.0
TimerFactoryBean	This class is deprecated. as of Spring 3.0, in favor of the `scheduling.concurrent` package which is based on Java 5's `java.util.concurrent.ExecutorService`
TimerTaskExecutor	This class is deprecated. as of Spring 3.0, in favor of the `scheduling.concurrent` package which is based on Java 5's `java.util.concurrent.ExecutorService`
TypeDefinitionBean	Bean that encapsulates a Hibernate type definition.
VelocityLayoutView	VelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates.
VelocityToolboxView	`VelocityView` subclass which adds support for Velocity Tools toolboxes and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods.
VelocityView	View using the Velocity template engine.
XmlPortletApplicationContext	Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.
XmlWebApplicationContext	`WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.
XsltView	XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.

Class Overview

Interface to be implemented by beans that want to be aware of their bean name in a bean factory. Note that it is not usually recommended that an object depend on its bean name, as this represents a potentially brittle dependence on external configuration, as well as a possibly unnecessary dependence on a Spring API.

For a list of all bean lifecycle methods, see the BeanFactory javadocs.

Summary

Public Methods
abstract void	setBeanName(String name) Set the name of the bean in the bean factory that created this bean.

Public Methods

public abstract void setBeanName (String name)

Also: SpringBeans

Set the name of the bean in the bean factory that created this bean.

Invoked after population of normal bean properties but before an init callback such as afterPropertiesSet() or a custom init-method.

Parameters

name	the name of the bean in the factory. Note that this name is the actual bean name used in the factory, which may differ from the originally specified name: in particular for inner bean names, the actual bean name might have been made unique through appending "#..." suffixes. Use the `originalBeanName(String)` method to extract the original bean name (without suffix), if desired.

Interfaces

Classes

Exceptions