|
The Spring Framework | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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 that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by 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 that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by 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 that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by 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 JMS ServerSessionPool SPI, creating JMS ServerSessions through a pluggable ServerSessionFactory. |
class |
ServerSessionMessageListenerContainer102
A subclass of ServerSessionMessageListenerContainer that uses the JMS 1.0.2 specification, rather than the JMS 1.1 methods used by ServerSessionMessageListenerContainer itself. |
Uses of DisposableBean in org.springframework.jmx.access |
---|
Classes in org.springframework.jmx.access that implement DisposableBean | |
---|---|
class |
MBeanClientInterceptor
MethodInterceptor implementation 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. |
|
The Spring Framework | |||||||||
PREV NEXT | FRAMES NO FRAMES |