DisposableBean

org.springframework.beans.factory.DisposableBean

Known Indirect Subclasses

AbstractApplicationContext, AbstractBeanFactoryBasedTargetSourceCreator, AbstractEntityManagerFactoryBean, AbstractFactoryBean<T>, AbstractJaxWsServiceExporter, AbstractJmsListeningContainer, AbstractMessageListenerContainer, AbstractPollingMessageListenerContainer, AbstractPoolingTargetSource, AbstractRefreshableApplicationContext, AbstractRefreshableConfigApplicationContext, AbstractRefreshablePortletApplicationContext, AbstractRefreshableWebApplicationContext, AbstractRequestLoggingFilter, AbstractServiceLoaderBasedFactoryBean, and 102 others.

AbstractApplicationContext	Abstract implementation of the `ApplicationContext` interface.
AbstractBeanFactoryBasedTargetSourceCreator	Convenient superclass for `TargetSourceCreator` implementations that require creating multiple instances of a prototype bean.
AbstractEntityManagerFactoryBean	Abstract `FactoryBean` that creates a local JPA javax.persistence.EntityManagerFactory instance within a Spring application context.
AbstractFactoryBean<T>	Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
AbstractJaxWsServiceExporter	Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation).
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.
AbstractPollingMessageListenerContainer	Base class for listener container implementations which are based on polling.
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.
AbstractRefreshableApplicationContext	Base class for `ApplicationContext` implementations which are supposed to support multiple calls to `refresh()`, creating a new internal bean factory instance every time.
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.
AbstractServiceLoaderBasedFactoryBean	Abstract base class for FactoryBeans operating on the JDK 1.6 java.util.ServiceLoader facility.
AbstractSessionFactoryBean	Abstract `FactoryBean` that creates a Hibernate org.hibernate.SessionFactory within a Spring application context, providing general infrastructure not related to Hibernate's specific configuration API.
AbstractXmlApplicationContext	Convenient base class for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
AnnotationConfigApplicationContext	Standalone application context, accepting annotated classes as input - in particular `@Configuration`-annotated classes, but also plain `@Components` and JSR-330 compliant classes using `javax.inject` annotations.
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.
AnnotationMBeanExporter	Convenient subclass of Spring's standard `MBeanExporter`, activating Java 5 annotation usage for JMX exposure of Spring beans: `ManagedResource`, `ManagedAttribute`, `ManagedOperation`, etc.
AnnotationSessionFactoryBean	Subclass of Spring's standard LocalSessionFactoryBean for Hibernate, supporting JDK 1.5+ annotation metadata for mappings.
BeanConfigurerSupport	Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created).
CachingConnectionFactory	`SingleConnectionFactory` subclass that adds javax.jms.Session caching as well javax.jms.MessageProducer caching.
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.
CommonsClientHttpRequestFactory	`ClientHttpRequestFactory` implementation that uses Jakarta Commons HttpClient to create requests.
CommonsPoolTargetSource	TargetSource implementation that holds objects in a configurable Jakarta Commons Pool.
CommonsRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.
ConnectorServerFactoryBean	`FactoryBean` that creates a JSR-160 JMXConnectorServer, optionally registers it with the MBeanServer and then starts it.
DefaultContextLoadTimeWeaver	Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.
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.
EhCacheManagerFactoryBean	`FactoryBean` that exposes an EHCache net.sf.ehcache.CacheManager instance (independent or shared), configured from a specified config location.
EmbeddedDatabaseFactoryBean	A subclass of `EmbeddedDatabaseFactory` that implements `FactoryBean` for registration as a Spring bean.
ExecutorConfigurationSupport	Base class for classes that are setting up a `java.util.concurrent.ExecutorService` (typically a java.util.concurrent.ThreadPoolExecutor).
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.
GenericApplicationContext	Generic ApplicationContext implementation that holds a single internal `DefaultListableBeanFactory` instance and does not assume a specific bean definition format.
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.
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.
GenericWebApplicationContext	Subclass of `GenericApplicationContext`, suitable for web environments.
GenericXmlApplicationContext	Convenient application context with built-in XML support.
HiddenHttpMethodFilter	javax.servlet.Filter that converts posted method parameters into HTTP methods, retrievable via `getMethod()`.
JmsMessageEndpointManager	Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, adding JMS-specific support for ActivationSpec configuration.
JndiRmiServiceExporter	Service exporter which binds RMI services to JNDI.
LazyInitTargetSourceCreator	TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init".
ListFactoryBean	Simple factory for shared List instances.
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.
LocalPersistenceManagerFactoryBean	`FactoryBean` that creates a JDO javax.jdo.PersistenceManagerFactory.
LocalSessionFactoryBean	`FactoryBean` that creates a Hibernate org.hibernate.SessionFactory.
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.
MBeanClientInterceptor	org.aopalliance.intercept.MethodInterceptor that routes calls to an MBean running on the supplied `MBeanServerConnection`.
MBeanExporter	JMX exporter that allows for exposing any Spring-managed bean to a JMX javax.management.MBeanServer, without the need to define any JMX-specific information in the bean classes.
MBeanProxyFactoryBean	Creates a proxy to a managed resource running either locally or remotely.
MBeanServerConnectionFactoryBean	`FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.
MBeanServerFactoryBean	`FactoryBean` that obtains an javax.management.MBeanServer reference through the standard JMX 1.2 javax.management.MBeanServerFactory API (which is available on JDK 1.5 or as part of a JMX 1.2 provider).
MapFactoryBean	Simple factory for shared Map instances.
MultipartFilter	Servlet 2.3 Filter that resolves multipart requests via a MultipartResolver.
NotificationListenerRegistrar	Registrar object that associates a specific javax.management.NotificationListener with one or more MBeans in an javax.management.MBeanServer (typically via a javax.management.MBeanServerConnection).
ObjectFactoryCreatingFactoryBean	A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
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.
PortletContextScope	`Scope` wrapper for a PortletContext, i.e.
PortletWrappingController	`Controller` implementation that wraps a portlet instance which it manages internally.
ProviderCreatingFactoryBean	A `FactoryBean` implementation that returns a value which is a JSR-330 javax.inject.Provider that in turn returns a bean sourced from a `BeanFactory`.
QuickTargetSourceCreator	Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPoolTargetSource % ThreadLocalTargetSource ! PrototypeTargetSource
RequestContextFilter	Servlet 2.3 Filter that exposes the request to the current thread, through both `LocaleContextHolder` and `RequestContextHolder`.
ResourceAdapterApplicationContext	`ApplicationContext` implementation for a JCA ResourceAdapter.
ResourceAdapterFactoryBean	`FactoryBean` that bootstraps the specified JCA 1.5 javax.resource.spi.ResourceAdapter, starting it with a local javax.resource.spi.BootstrapContext and exposing it for bean references.
ResourceBundleViewResolver	`ViewResolver` implementation that uses bean definitions in a ResourceBundle, specified by the bundle basename.
RmiRegistryFactoryBean	`FactoryBean` that locates a java.rmi.registry.Registry and exposes it for bean references.
RmiServiceExporter	RMI exporter that exposes the specified service as RMI object with the specified name.
ScheduledAnnotationBeanPostProcessor	Bean post-processor that registers methods annotated with `@Scheduled` to be invoked by a `TaskScheduler` according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.
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.
ScheduledTaskRegistrar	Helper bean for registering tasks with a `TaskScheduler`, typically using cron expressions.
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.
ScriptFactoryPostProcessor	`BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.
ServiceFactoryBean	`FactoryBean` that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 java.util.ServiceLoader facility.
ServiceListFactoryBean	`FactoryBean` that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 java.util.ServiceLoader facility.
ServiceLoaderFactoryBean	`FactoryBean` that exposes the JDK 1.6 java.util.ServiceLoader for the configured service class.
ServletContextRequestLoggingFilter	Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.
ServletContextScope	`Scope` wrapper for a ServletContext, i.e.
ServletWrappingController	Spring Controller implementation that wraps a servlet instance which it manages internally.
SetFactoryBean	Simple factory for shared Set instances.
ShallowEtagHeaderFilter	javax.servlet.Filter that generates an `ETag` value based on the content on the response.
SimpleHttpServerFactoryBean	`FactoryBean` that creates a simple HTTP server, based on the HTTP server that is included in Sun's JRE 1.6.
SimpleHttpServerJaxWsServiceExporter	Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.WebService annotation) and exporting them through the HTTP server included in Sun's JDK 1.6.
SimpleJaxWsServiceExporter	Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS javax.jws.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.
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`
SimpleRemoteSlsbInvokerInterceptor	Basic invoker for a remote Stateless Session Bean.
SimpleRemoteStatelessSessionProxyFactoryBean	Convenient `FactoryBean` for remote SLSB proxies.
SimpleThreadPoolTaskExecutor	Subclass of Quartz's SimpleThreadPool that implements Spring's `TaskExecutor` interface and listens to Spring lifecycle callbacks.
SingleConnectionDataSource	Implementation of `SmartDataSource` that wraps a single JDBC Connection which is not closed after use.
SingleConnectionFactory	A JMS ConnectionFactory adapter that returns the same Connection from all `createConnection()` calls, and ignores calls to javax.jms.Connection#close().
SingleConnectionFactory102	This class is deprecated. as of Spring 3.0, in favor of the JMS 1.1 based `SingleConnectionFactory`
SortedResourcesFactoryBean	`FactoryBean` implementation that takes a list of location Strings and creates a sorted array of `Resource` instances.
StaticApplicationContext	`ApplicationContext` implementation which supports programmatic registration of beans and messages, rather than reading bean definitions from external configuration sources.
StaticPortletApplicationContext	Static Portlet-based `ApplicationContext` implementation for testing.
StaticWebApplicationContext	Static `WebApplicationContext` implementation for testing.
TaskExecutorFactoryBean	FactoryBean for creating ThreadPoolTaskExecutor instances, choosing between the standard concurrent and the backport-concurrent variant.
ThreadLocalTargetSource	Alternative to an object pool.
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.
TilesConfigurer	Helper class to configure Tiles 2.x for the Spring Framework.
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`
TimerManagerAccessor	Base class for classes that are accessing a CommonJ commonj.timers.TimerManager Defines common configuration settings and common lifecycle handling.
TimerManagerFactoryBean	`FactoryBean` that retrieves a CommonJ commonj.timers.TimerManager and exposes it for bean references.
TimerManagerTaskScheduler	Implementation of Spring's `TaskScheduler` interface, wrapping a CommonJ commonj.timers.TimerManager.
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`
XmlPortletApplicationContext	Portlet-based `WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.
XmlViewResolver	Implementation of ViewResolver that uses bean definitions in an XML file, specified by resource location.
XmlWebApplicationContext	`WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

Class Overview

Interface to be implemented by beans that want to release resources on destruction. A BeanFactory is supposed to invoke the destroy method if it disposes a cached singleton. An application context is supposed to dispose all of its singletons on close.

An alternative to implementing DisposableBean is specifying a custom destroy-method, for example in an XML bean definition. For a list of all bean lifecycle methods, see the BeanFactory javadocs.

Summary

Public Methods
abstract void	destroy() Invoked by a BeanFactory on destruction of a singleton.

Public Methods

public abstract void destroy ()

Also: SpringBeans

Invoked by a BeanFactory on destruction of a singleton.

Throws

Exception	in case of shutdown errors. Exceptions will get logged but not rethrown to allow other beans to release their resources too.

Interfaces

Classes