Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV NEXT | FRAMES NO FRAMES

## 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.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.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.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.serversession | This package contains the ServerSessionMessageListenerContainer implementation, based on the standard JMS ServerSessionPool API.
org.springframework.jmx.access | Provides proxy support for accessing MBean resources through standard Java interfaces.
org.springframework.jmx.export | This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
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.hibernate | Package providing integration of Hibernate 2.1 with Spring concepts.
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.rmi | Remoting classes for conventional RMI and transparent remoting via RMI invokers.
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 1.3+ 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.

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.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 superclass 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` | `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.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.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 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` | `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.serversession

Classes in org.springframework.jms.listener.serversession that implement DisposableBean
`class` | `ServerSessionMessageListenerContainer` Message listener container that builds on the `ServerSessionPool` SPI, creating JMS ServerSession instances through a pluggable `ServerSessionFactory`.
`class` | `ServerSessionMessageListenerContainer102` A subclass of `ServerSessionMessageListenerContainer` for the JMS 1.0.2 specification, not relying on JMS 1.1 methods like ServerSessionMessageListenerContainer itself.

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.

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.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` implementation that creates an `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.hibernate

Classes in org.springframework.orm.hibernate that implement DisposableBean
`class` | `LocalSessionFactoryBean` `FactoryBean` that creates a Hibernate `SessionFactory`.

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.

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.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.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.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| The Spring Framework
PREV NEXT | FRAMES NO FRAMES

Copyright © 2002-2007 The Spring Framework.