|
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.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.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.concurrent | Scheduling convenience classes for the JDK 1.5+ Executor mechanism
in the java.util.concurrent package, allowing to set
up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as bean in
a Spring context. |
org.springframework.scheduling.quartz | Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context. |
org.springframework.scheduling.timer | Scheduling convenience classes for the JDK 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 superclass for pooling TargetSources that maintains 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 that are supposed to support multiple refreshs, creating a new internal bean factory instance every time. |
class |
AbstractXmlApplicationContext
Convenient abstract superclass 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. |
class |
FileSystemXmlApplicationContext
Standalone XML application context, taking the context definition files from the file system or from URLs. |
class |
GenericApplicationContext
Generic ApplicationContext implementation that holds a single internal DefaultListableBeanFactory instance and does not assume a specific bean definition format. |
class |
StaticApplicationContext
ApplicationContext that allows concrete registration of beans and messages in code, rather than 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.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 |
AbstractMessageListenerContainer
Abstract base class for message listener containers. |
class |
DefaultMessageListenerContainer
Message listener container 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
Effects the exporting of 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 local Hibernate SessionFactory instance. |
Uses of DisposableBean in org.springframework.orm.hibernate3 |
---|
Classes in org.springframework.orm.hibernate3 that implement DisposableBean | |
---|---|
class |
AbstractSessionFactoryBean
Abstract FactoryBean that exposes 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 local JDO EntityManagerFactory instance. |
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 base class for a FactoryBean that creates a local JPA EntityManagerFactory instance with a Spring application context. |
class |
LocalContainerEntityManagerFactoryBean
Powerful FactoryBean that creates a fully Spring-configured EntityManagerFactory according to the container contract for JPA bootstrapping As with LocalEntityManagerFactoryBean, configuration settings are usually read in from a META-INF/persistence.xml config file, residing in the class path,
according to the general JPA configuration contract. |
class |
LocalEntityManagerFactoryBean
FactoryBean that creates a local JPA EntityManagerFactory instance 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 an RMI 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.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.concurrent |
---|
Classes in org.springframework.scheduling.concurrent that implement DisposableBean | |
---|---|
class |
ScheduledExecutorFactoryBean
FactoryBean that sets up a JDK 1.5 ScheduledExecutorService
(by default: ScheduledThreadPoolExecutor as implementation)
and exposes it for bean references. |
class |
ThreadPoolTaskExecutor
JavaBean that allows for configuring a JDK 1.5 ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties), exposing it as a Spring TaskExecutor . |
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 and exposes it for bean references. |
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 that 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 that takes configuration from an XML document, 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 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 javax.servlet.Filter that treats
its config parameters 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 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 that implements the ConfigurablePortletApplicationContext interface for portlet environments. |
class |
StaticPortletApplicationContext
Static ApplicationContext for Portlet environments. |
class |
XmlPortletApplicationContext
PortletApplicationContext implementation that takes configuration from an XML document, 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 |