The Spring Framework

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

Packages that use BeanNameAware
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.beans.factory.config: SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.cache.ehcache: Support classes for the open source cache EHCache, allowing to set up an EHCache CacheManager and Caches as beans in a Spring 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.jms.listener: This package contains the base message listener container facility.
org.springframework.jms.listener.serversession: This package contains the ServerSessionMessageListenerContainer implementation, based on the standard JMS ServerSessionPool API.
org.springframework.orm.hibernate3: Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.hibernate3.support: Classes supporting the `org.springframework.orm.hibernate3` package.
org.springframework.orm.jdo.support: Classes supporting the `org.springframework.orm.jdo` package.
org.springframework.orm.jpa.support: Classes supporting the `org.springframework.orm.jpa` package.
org.springframework.scheduling.backportconcurrent: Scheduling convenience classes for the JSR-166 backport Executor mechanism, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as bean in a Spring context.
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.timer: Scheduling convenience classes for the JDK Timer, allowing to set up Timers and ScheduledTimerTasks as beans in a Spring context.
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.multipart.support: Support classes for the multipart resolution framework.
org.springframework.web.portlet.context: Support for Spring's application context concept in a portlet environment, including ApplicationContext implementations and various utility classes.
org.springframework.web.portlet.mvc: Standard controller implementations for the portlet MVC framework that comes with Spring.
org.springframework.web.servlet.mvc: Standard controller implementations for the servlet MVC framework that comes with Spring.
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.freemarker: Support classes for the integration of FreeMarker as Spring web view technology.
org.springframework.web.servlet.view.jasperreports: Support classes for the integration of JasperReports as Spring web view technology.
org.springframework.web.servlet.view.tiles: Support classes for the integration of Tiles (included in Struts) as Spring web view technology.
org.springframework.web.servlet.view.velocity: Support classes for the integration of Velocity as Spring web view technology.
org.springframework.web.servlet.view.xslt: Support classes for XSLT, providing a View implementation for XSLT stylesheets.

Uses of BeanNameAware in org.springframework.aop.framework.autoproxy

Classes in org.springframework.aop.framework.autoproxy that implement BeanNameAware
`class` `DefaultAdvisorAutoProxyCreator` BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory.

Uses of BeanNameAware in org.springframework.beans.factory.config

Classes in org.springframework.beans.factory.config that implement BeanNameAware
`class` `FieldRetrievingFactoryBean` FactoryBean which retrieves a static or non-static field value.
`class` `PreferencesPlaceholderConfigurer` Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API (`java.util.prefs`).
`class` `PropertyPathFactoryBean` `FactoryBean` that evaluates a property path on a given target object.
`class` `PropertyPlaceholderConfigurer` A property resource configurer that resolves placeholders in bean property values of context definitions.

Uses of BeanNameAware in org.springframework.cache.ehcache

Classes in org.springframework.cache.ehcache that implement BeanNameAware
`class` `EhCacheFactoryBean` FactoryBean that creates a named EHCache `Cache` instance (or a decorator that implements the `Ehcache` interface), representing a cache region within an EHCache `CacheManager`.

Uses of BeanNameAware in org.springframework.context.support

Classes in org.springframework.context.support that implement BeanNameAware
`class` `AbstractRefreshableConfigApplicationContext` `AbstractRefreshableApplicationContext` subclass that adds common handling of specified config locations.
`class` `AbstractXmlApplicationContext` Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
`class` `ClassPathXmlApplicationContext` Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.
`class` `FileSystemXmlApplicationContext` Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.

Uses of BeanNameAware in org.springframework.jms.listener

Classes in org.springframework.jms.listener that implement BeanNameAware
`class` `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).
`class` `AbstractMessageListenerContainer` Abstract base class for message listener containers.
`class` `AbstractPollingMessageListenerContainer` Base class for listener container implementations which are based on polling.
`class` `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).
`class` `DefaultMessageListenerContainer102` A subclass of `DefaultMessageListenerContainer` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SimpleMessageListenerContainer itself.
`class` `SimpleMessageListenerContainer` Message listener container that uses the plain JMS client API's `MessageConsumer.setMessageListener()` method to create concurrent MessageConsumers for the specified listeners.
`class` `SimpleMessageListenerContainer102` A subclass of `SimpleMessageListenerContainer` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SimpleMessageListenerContainer itself.

Uses of BeanNameAware in org.springframework.jms.listener.serversession

Classes in org.springframework.jms.listener.serversession that implement BeanNameAware
`class` `ServerSessionMessageListenerContainer` Deprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0.
`class` `ServerSessionMessageListenerContainer102` Deprecated. as of Spring 2.5, in favor of DefaultMessageListenerContainer and JmsMessageEndpointManager. To be removed in Spring 3.0.

Uses of BeanNameAware in org.springframework.orm.hibernate3

Classes in org.springframework.orm.hibernate3 that implement BeanNameAware
`class` `FilterDefinitionFactoryBean` Convenient FactoryBean for defining Hibernate FilterDefinitions.
`class` `TypeDefinitionBean` Bean that encapsulates a Hibernate type definition.

Uses of BeanNameAware in org.springframework.orm.hibernate3.support

Classes in org.springframework.orm.hibernate3.support that implement BeanNameAware
`class` `OpenSessionInViewFilter` Servlet 2.3 Filter that binds a Hibernate Session to the thread for the entire processing of the request.

Uses of BeanNameAware in org.springframework.orm.jdo.support

Classes in org.springframework.orm.jdo.support that implement BeanNameAware
`class` `OpenPersistenceManagerInViewFilter` Servlet 2.3 Filter that binds a JDO PersistenceManager to the thread for the entire processing of the request.

Uses of BeanNameAware in org.springframework.orm.jpa.support

Classes in org.springframework.orm.jpa.support that implement BeanNameAware
`class` `OpenEntityManagerInViewFilter` Servlet 2.3 Filter that binds a JPA EntityManager to the thread for the entire processing of the request.

Uses of BeanNameAware in org.springframework.scheduling.backportconcurrent

Classes in org.springframework.scheduling.backportconcurrent that implement BeanNameAware
`class` `ScheduledExecutorFactoryBean` `FactoryBean` that sets up a JSR-166 backport `ScheduledExecutorService` (by default: `ScheduledThreadPoolExecutor` as implementation) and exposes it for bean references.
`class` `ThreadPoolTaskExecutor` JavaBean that allows for configuring a JSR-166 backport `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties), exposing it as a Spring `TaskExecutor`.

Uses of BeanNameAware in org.springframework.scheduling.quartz

Classes in org.springframework.scheduling.quartz that implement BeanNameAware
`class` `CronTriggerBean` Convenience subclass of Quartz's `CronTrigger` class, making bean-style usage easier.
`class` `JobDetailBean` Convenience subclass of Quartz' JobDetail class that eases bean-style usage.
`class` `MethodInvokingJobDetailFactoryBean` `FactoryBean` that exposes a `JobDetail` object which delegates job execution to a specified (static or non-static) method.
`class` `SimpleTriggerBean` Convenience subclass of Quartz's `SimpleTrigger` class, making bean-style usage easier.

Uses of BeanNameAware in org.springframework.scheduling.timer

Classes in org.springframework.scheduling.timer that implement BeanNameAware
`class` `TimerFactoryBean` FactoryBean that sets up a `Timer` and exposes it for bean references.

Uses of BeanNameAware in org.springframework.web.context.support

Classes in org.springframework.web.context.support that implement BeanNameAware
`class` `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
`class` `ServletContextPropertyPlaceholderConfigurer` Subclass of PropertyPlaceholderConfigurer that resolves placeholders as ServletContext init parameters (that is, `web.xml` context-param entries).
`class` `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Uses of BeanNameAware in org.springframework.web.filter

Classes in org.springframework.web.filter that implement BeanNameAware
`class` `AbstractRequestLoggingFilter` Base class for `Filter`s that perform logging operations before and after a request is processed.
`class` `CharacterEncodingFilter` Servlet 2.3/2.4 Filter that allows one to specify a character encoding for requests.
`class` `CommonsRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
`class` `DelegatingFilterProxy` Proxy for a standard Servlet 2.3 Filter, delegating to a Spring-managed bean that implements the Filter interface.
`class` `GenericFilterBean` Simple base implementation of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
`class` `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.
`class` `OncePerRequestFilter` Filter base class that guarantees to be just executed once per request, on any servlet container.
`class` `RequestContextFilter` Servlet 2.3 Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
`class` `ServletContextRequestLoggingFilter` Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.

Uses of BeanNameAware in org.springframework.web.multipart.support

Classes in org.springframework.web.multipart.support that implement BeanNameAware
`class` `MultipartFilter` Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.

Uses of BeanNameAware in org.springframework.web.portlet.context

Classes in org.springframework.web.portlet.context that implement BeanNameAware
`class` `AbstractRefreshablePortletApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurablePortletApplicationContext` interface for portlet environments.
`class` `XmlPortletApplicationContext` Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Uses of BeanNameAware in org.springframework.web.portlet.mvc

Classes in org.springframework.web.portlet.mvc that implement BeanNameAware
`class` `PortletWrappingController` `Controller` implementation that wraps a portlet instance which it manages internally.

Uses of BeanNameAware in org.springframework.web.servlet.mvc

Classes in org.springframework.web.servlet.mvc that implement BeanNameAware
`class` `ServletForwardingController` Spring Controller implementation that forwards to a named servlet, i.e. the "servlet-name" in web.xml rather than a URL path mapping.
`class` `ServletWrappingController` Spring Controller implementation that wraps a servlet instance which it manages internally.

Uses of BeanNameAware in org.springframework.web.servlet.view

Classes in org.springframework.web.servlet.view that implement BeanNameAware
`class` `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.
`class` `AbstractUrlBasedView` Abstract base class for URL-based views.
`class` `AbstractView` Abstract base class for `View` implementations.
`class` `InternalResourceView` Wrapper for a JSP or other resource within the same web application.
`class` `JstlView` Specialization of `InternalResourceView` for JSTL pages, i.e.
`class` `RedirectView` View that redirects to an absolute, context relative, or current request relative URL, by default exposing all model attributes as HTTP query parameters.

Uses of BeanNameAware in org.springframework.web.servlet.view.document

Classes in org.springframework.web.servlet.view.document that implement BeanNameAware
`class` `AbstractExcelView` Convenient superclass for Excel document views.
`class` `AbstractJExcelView` Convenient superclass for Excel document views.
`class` `AbstractPdfStamperView` Abstract superclass for PDF views that operate on an existing document with an AcroForm.
`class` `AbstractPdfView` Abstract superclass for PDF views, using Bruno Lowagie's iText package.

Uses of BeanNameAware in org.springframework.web.servlet.view.freemarker

Classes in org.springframework.web.servlet.view.freemarker that implement BeanNameAware
`class` `FreeMarkerView` View using the FreeMarker template engine.

Uses of BeanNameAware in org.springframework.web.servlet.view.jasperreports

Classes in org.springframework.web.servlet.view.jasperreports that implement BeanNameAware
`class` `AbstractJasperReportsSingleFormatView` Extends `AbstractJasperReportsView` to provide basic rendering logic for views that use a fixed format, e.g. always PDF or always HTML.
`class` `AbstractJasperReportsView` Base class for all JasperReports views.
`class` `ConfigurableJasperReportsView` Configurable JasperReports View, allowing to specify the JasperReports exporter to be specified through bean properties rather than through the view class name.
`class` `JasperReportsCsvView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in CSV format.
`class` `JasperReportsHtmlView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in HTML format.
`class` `JasperReportsMultiFormatView` Jasper Reports view class that allows for the actual rendering format to be specified at runtime using a parameter contained in the model.
`class` `JasperReportsPdfView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in PDF format.
`class` `JasperReportsXlsView` Implementation of `AbstractJasperReportsSingleFormatView` that renders report results in XLS format.

Uses of BeanNameAware in org.springframework.web.servlet.view.tiles

Classes in org.springframework.web.servlet.view.tiles that implement BeanNameAware
`class` `TilesJstlView` Specialization of `TilesView` for JSTL pages, i.e.
`class` `TilesView` View implementation that retrieves a Tiles definition.

Uses of BeanNameAware in org.springframework.web.servlet.view.velocity

Classes in org.springframework.web.servlet.view.velocity that implement BeanNameAware
`class` `VelocityLayoutView` VelocityLayoutView emulates the functionality offered by Velocity's VelocityLayoutServlet to ease page composition from different templates.
`class` `VelocityToolboxView` `VelocityView` subclass which adds support for Velocity Tools toolboxes and Velocity Tools ViewTool callbacks / Velocity Tools 1.3 init methods.
`class` `VelocityView` View using the Velocity template engine.

Uses of BeanNameAware in org.springframework.web.servlet.view.xslt

Classes in org.springframework.web.servlet.view.xslt that implement BeanNameAware
`class` `AbstractXsltView` Convenient superclass for views rendered using an XSLT stylesheet.
`class` `XsltView` XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.