The Spring Framework

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

Packages that use DisposableBean
org.springframework.aop.framework.autoproxy.target: Generic support classes for target source creation.
org.springframework.aop.target: This package contains implementations of the org.springframework.aop.TargetSource interface.
org.springframework.beans.factory.config: SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.beans.factory.serviceloader: Support package for the JDK 1.6 ServiceLoader facility.
org.springframework.beans.factory.support: Classes supporting the `org.springframework.beans.factory` package.
org.springframework.beans.factory.wiring: Mechanism to determine bean wiring metadata from a bean instance.
org.springframework.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.context.weaving: Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
org.springframework.ejb.access: This package contains classes that allow easy access to EJBs.
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.context: Integration package that allows for deploying a Spring application context as a JCA 1.5 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.jdbc.datasource: Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.
org.springframework.jms.connection: Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.
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.listener.serversession: This package contains the ServerSessionMessageListenerContainer implementation, based on the standard JMS ServerSessionPool API.
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: JDK 1.5+ annotations for MBean exposure.
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.orm.hibernate3: Package providing integration of Hibernate3 with Spring concepts.
org.springframework.orm.hibernate3.annotation: Support package for the Hibernate3 Annotation add-on, which supports EJB3-compliant JDK 1.5+ annotations for mappings.
org.springframework.orm.hibernate3.support: Classes supporting the `org.springframework.orm.hibernate3` package.
org.springframework.orm.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jdo.support: Classes supporting the `org.springframework.orm.jdo` package.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.orm.jpa.support: Classes supporting the `org.springframework.orm.jpa` package.
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.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.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.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.scripting.support: Support classes for Spring's scripting package.
org.springframework.transaction.jta: Transaction SPI implementation for JTA.
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.tiles2: Support classes for the integration of Tiles2 (the standalone version of Tiles) as Spring web view technology.

Uses of DisposableBean in org.springframework.aop.framework.autoproxy.target

Classes in org.springframework.aop.framework.autoproxy.target that implement DisposableBean
`class` `AbstractBeanFactoryBasedTargetSourceCreator` Convenient superclass for `TargetSourceCreator` implementations that require creating multiple instances of a prototype bean.
`class` `LazyInitTargetSourceCreator` TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init".
`class` `QuickTargetSourceCreator` Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPoolTargetSource % ThreadLocalTargetSource !

Uses of DisposableBean in org.springframework.aop.target

Classes in org.springframework.aop.target that implement DisposableBean
`class` `AbstractPoolingTargetSource` Abstract base class for pooling `TargetSource` implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.
`class` `CommonsPoolTargetSource` TargetSource implementation that holds objects in a configurable Jakarta Commons Pool.
`class` `ThreadLocalTargetSource` Alternative to an object pool.

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

Classes in org.springframework.beans.factory.config that implement DisposableBean
`class` `AbstractFactoryBean` Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
`class` `ListFactoryBean` Simple factory for shared List instances.
`class` `MapFactoryBean` Simple factory for shared Map instances.
`class` `ObjectFactoryCreatingFactoryBean` A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
`class` `SetFactoryBean` Simple factory for shared Set instances.

Uses of DisposableBean in org.springframework.beans.factory.serviceloader

Classes in org.springframework.beans.factory.serviceloader that implement DisposableBean
`class` `AbstractServiceLoaderBasedFactoryBean` Abstract base class for FactoryBeans operating on the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceFactoryBean` `FactoryBean` that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceListFactoryBean` `FactoryBean` that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 `ServiceLoader` facility.
`class` `ServiceLoaderFactoryBean` `FactoryBean` that exposes the JDK 1.6 `ServiceLoader` for the configured service class.

Uses of DisposableBean in org.springframework.beans.factory.support

Methods in org.springframework.beans.factory.support with parameters of type DisposableBean
`protected void` `DefaultSingletonBeanRegistry.destroyBean(String beanName, DisposableBean bean)` Destroy the given bean.
`void` `DefaultSingletonBeanRegistry.registerDisposableBean(String beanName, DisposableBean bean)` Add the given bean to the list of disposable beans in this registry.

Uses of DisposableBean in org.springframework.beans.factory.wiring

Classes in org.springframework.beans.factory.wiring that implement DisposableBean
`class` `BeanConfigurerSupport` Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created).

Uses of DisposableBean in org.springframework.cache.ehcache

Classes in org.springframework.cache.ehcache that implement DisposableBean
`class` `EhCacheManagerFactoryBean` FactoryBean that exposes an EHCache `CacheManager` instance (independent or shared), configured from a specified config location.

Uses of DisposableBean in org.springframework.context.support

Classes in org.springframework.context.support that implement DisposableBean
`class` `AbstractApplicationContext` Abstract implementation of the `ApplicationContext` interface.
`class` `AbstractRefreshableApplicationContext` Base class for `ApplicationContext` implementations which are supposed to support multiple refreshs, creating a new internal bean factory instance every time.
`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.
`class` `GenericApplicationContext` Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
`class` `StaticApplicationContext` `ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.

Uses of DisposableBean in org.springframework.context.weaving

Classes in org.springframework.context.weaving that implement DisposableBean
`class` `DefaultContextLoadTimeWeaver` Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.

Uses of DisposableBean in org.springframework.ejb.access

Classes in org.springframework.ejb.access that implement DisposableBean
`class` `SimpleRemoteSlsbInvokerInterceptor` Basic invoker for a remote Stateless Session Bean.
`class` `SimpleRemoteStatelessSessionProxyFactoryBean` Convenient factory for remote SLSB proxies.

Uses of DisposableBean in org.springframework.jca.cci.connection

Classes in org.springframework.jca.cci.connection that implement DisposableBean
`class` `SingleConnectionFactory` A CCI ConnectionFactory adapter that returns the same Connection on all `getConnection` calls, and ignores calls to `Connection.close()`.

Uses of DisposableBean in org.springframework.jca.context

Classes in org.springframework.jca.context that implement DisposableBean
`class` `ResourceAdapterApplicationContext` `ApplicationContext` implementation for a JCA ResourceAdapter.

Uses of DisposableBean in org.springframework.jca.endpoint

Classes in org.springframework.jca.endpoint that implement DisposableBean
`class` `GenericMessageEndpointManager` Generic bean that manages JCA 1.5 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle.

Uses of DisposableBean in org.springframework.jca.support

Classes in org.springframework.jca.support that implement DisposableBean
`class` `ResourceAdapterFactoryBean` `FactoryBean` that bootstraps the specified JCA 1.5 `ResourceAdapter`, starting it with a local `BootstrapContext` and exposing it for bean references.

Uses of DisposableBean in org.springframework.jdbc.datasource

Classes in org.springframework.jdbc.datasource that implement DisposableBean
`class` `SingleConnectionDataSource` Implementation of `SmartDataSource` that wraps a single JDBC Connection which is not closed after use.

Uses of DisposableBean in org.springframework.jms.connection

Classes in org.springframework.jms.connection that implement DisposableBean
`class` `CachingConnectionFactory` `SingleConnectionFactory` subclass that adds `Session` caching as well `MessageProducer` caching.
`class` `SingleConnectionFactory102` A subclass of `SingleConnectionFactory` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like SingleConnectionFactory itself.

Uses of DisposableBean in org.springframework.jms.listener

Classes in org.springframework.jms.listener that implement DisposableBean
`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 DisposableBean in org.springframework.jms.listener.endpoint

Classes in org.springframework.jms.listener.endpoint that implement DisposableBean
`class` `JmsMessageEndpointManager` Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, adding JMS-specific support for ActivationSpec configuration.

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

Classes in org.springframework.jms.listener.serversession that implement DisposableBean
`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 DisposableBean in org.springframework.jmx.access

Classes in org.springframework.jmx.access that implement DisposableBean
`class` `MBeanClientInterceptor` `MethodInterceptor` that routes calls to an MBean running on the supplied `MBeanServerConnection`.
`class` `MBeanProxyFactoryBean` Creates a proxy to a managed resource running either locally or remotely.
`class` `NotificationListenerRegistrar` Registrar object that associates a specific `NotificationListener` with one or more MBeans in an `MBeanServer` (typically via a `MBeanServerConnection`).

Uses of DisposableBean in org.springframework.jmx.export

Classes in org.springframework.jmx.export that implement DisposableBean
`class` `MBeanExporter` JMX exporter that allows for exposing any Spring-managed bean to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.

Uses of DisposableBean in org.springframework.jmx.export.annotation

Classes in org.springframework.jmx.export.annotation that implement DisposableBean
`class` `AnnotationMBeanExporter` Convenient subclass of Spring's standard `MBeanExporter`, activating Java 5 annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.

Uses of DisposableBean in org.springframework.jmx.support

Classes in org.springframework.jmx.support that implement DisposableBean
`class` `ConnectorServerFactoryBean` `FactoryBean` that creates a JSR-160 `JMXConnectorServer`, optionally registers it with the `MBeanServer` and then starts it.
`class` `MBeanServerConnectionFactoryBean` `FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.
`class` `MBeanServerFactoryBean` FactoryBean that obtains an `MBeanServer` reference through the standard JMX 1.2 `MBeanServerFactory` API (which is available on JDK 1.5 or as part of a JMX 1.2 provider).

Uses of DisposableBean in org.springframework.orm.hibernate3

Classes in org.springframework.orm.hibernate3 that implement DisposableBean
`class` `AbstractSessionFactoryBean` Abstract `FactoryBean` that creates a Hibernate `SessionFactory` within a Spring application context, providing general infrastructure not related to Hibernate's specific configuration API.
`class` `LocalSessionFactoryBean` `FactoryBean` that creates a Hibernate `SessionFactory`.

Uses of DisposableBean in org.springframework.orm.hibernate3.annotation

Classes in org.springframework.orm.hibernate3.annotation that implement DisposableBean
`class` `AnnotationSessionFactoryBean` Subclass of Spring's standard LocalSessionFactoryBean for Hibernate3, supporting JDK 1.5+ annotation metadata for mappings.

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

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

Uses of DisposableBean in org.springframework.orm.jdo

Classes in org.springframework.orm.jdo that implement DisposableBean
`class` `LocalPersistenceManagerFactoryBean` `FactoryBean` that creates a JDO `PersistenceManagerFactory`.

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

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

Uses of DisposableBean in org.springframework.orm.jpa

Classes in org.springframework.orm.jpa that implement DisposableBean
`class` `AbstractEntityManagerFactoryBean` Abstract `FactoryBean` that creates a local JPA `EntityManagerFactory` instance within a Spring application context.
`class` `LocalContainerEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard container bootstrap contract.
`class` `LocalEntityManagerFactoryBean` `FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard standalone bootstrap contract.

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

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

Uses of DisposableBean in org.springframework.remoting.jaxws

Classes in org.springframework.remoting.jaxws that implement DisposableBean
`class` `AbstractJaxWsServiceExporter` Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation).
`class` `SimpleHttpServerJaxWsServiceExporter` Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them through the HTTP server included in Sun's JDK 1.6.
`class` `SimpleJaxWsServiceExporter` Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.

Uses of DisposableBean in org.springframework.remoting.rmi

Classes in org.springframework.remoting.rmi that implement DisposableBean
`class` `JndiRmiServiceExporter` Service exporter which binds RMI services to JNDI.
`class` `RmiRegistryFactoryBean` FactoryBean that locates a `Registry` and exposes it for bean references.
`class` `RmiServiceExporter` RMI exporter that exposes the specified service as RMI object with the specified name.

Uses of DisposableBean in org.springframework.remoting.support

Classes in org.springframework.remoting.support that implement DisposableBean
`class` `SimpleHttpServerFactoryBean` `FactoryBean` that creates a simple HTTP server, based on the HTTP server that is included in Sun's JRE 1.6.

Uses of DisposableBean in org.springframework.scheduling.backportconcurrent

Classes in org.springframework.scheduling.backportconcurrent that implement DisposableBean
`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 DisposableBean in org.springframework.scheduling.commonj

Classes in org.springframework.scheduling.commonj that implement DisposableBean
`class` `TimerManagerFactoryBean` `FactoryBean` that retrieves a CommonJ `TimerManager` and exposes it for bean references.

Uses of DisposableBean in org.springframework.scheduling.quartz

Classes in org.springframework.scheduling.quartz that implement DisposableBean
`class` `SchedulerFactoryBean` FactoryBean that sets up a Quartz `Scheduler`, manages its lifecycle as part of the Spring application context, and exposes the Scheduler reference for dependency injection.
`class` `SimpleThreadPoolTaskExecutor` Subclass of Quartz's SimpleThreadPool that implements Spring's TaskExecutor interface and listens to Spring lifecycle callbacks.

Uses of DisposableBean in org.springframework.scheduling.timer

Classes in org.springframework.scheduling.timer that implement DisposableBean
`class` `TimerFactoryBean` FactoryBean that sets up a `Timer` and exposes it for bean references.
`class` `TimerTaskExecutor` `TaskExecutor` implementation that uses a single `Timer` for executing all tasks, effectively resulting in serialized asynchronous execution on a single thread.

Uses of DisposableBean in org.springframework.scripting.support

Classes in org.springframework.scripting.support that implement DisposableBean
`class` `ScriptFactoryPostProcessor` `BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.

Uses of DisposableBean in org.springframework.transaction.jta

Classes in org.springframework.transaction.jta that implement DisposableBean
`class` `JotmFactoryBean` FactoryBean that retrieves the JTA UserTransaction/TransactionManager for ObjectWeb's JOTM.

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

Classes in org.springframework.web.context.support that implement DisposableBean
`class` `AbstractRefreshableWebApplicationContext` `AbstractRefreshableApplicationContext` subclass which implements the `ConfigurableWebApplicationContext` interface for web environments.
`class` `GenericWebApplicationContext` Subclass of `GenericApplicationContext`, suitable for web environments.
`class` `StaticWebApplicationContext` Static `WebApplicationContext` implementation for testing.
`class` `XmlWebApplicationContext` `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Uses of DisposableBean in org.springframework.web.filter

Classes in org.springframework.web.filter that implement DisposableBean
`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 DisposableBean in org.springframework.web.multipart.support

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

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

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

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

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

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

Classes in org.springframework.web.servlet.mvc that implement DisposableBean
`class` `ServletWrappingController` Spring Controller implementation that wraps a servlet instance which it manages internally.

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

Classes in org.springframework.web.servlet.view that implement DisposableBean
`class` `ResourceBundleViewResolver` `ViewResolver` implementation that uses bean definitions in a `ResourceBundle`, specified by the bundle basename.
`class` `XmlViewResolver` Implementation of ViewResolver that uses bean definitions in an XML file, specified by resource location.

Uses of DisposableBean in org.springframework.web.servlet.view.tiles2

Classes in org.springframework.web.servlet.view.tiles2 that implement DisposableBean
`class` `TilesConfigurer` Helper class to configure Tiles2 for the Spring Framework.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.