The Spring Framework

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

Packages that use BeanClassLoaderAware
org.springframework.aop.aspectj.annotation: Classes enabling AspectJ 5 @Annotated classes to be used in Spring AOP.
org.springframework.aop.aspectj.autoproxy: Base classes enabling auto-proxying based on AspectJ.
org.springframework.aop.framework: Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.
org.springframework.aop.framework.autoproxy: Bean post-processors for use in ApplicationContexts to simplify AOP usage by automatically creating AOP proxies without the need to use a ProxyFactoryBean.
org.springframework.beans.factory.annotation: Support package for annotation-driven bean configuration.
org.springframework.beans.factory.config: SPI interfaces and configuration-related convenience classes for bean factories.
org.springframework.beans.factory.serviceloader: Support package for the JDK 1.6 ServiceLoader facility.
org.springframework.context.support: Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
org.springframework.context.weaving: Load-time weaving support for a Spring application context, building on Spring's `LoadTimeWeaver` abstraction.
org.springframework.dao.annotation: Annotation support for DAOs.
org.springframework.ejb.access: This package contains classes that allow easy access to EJBs.
org.springframework.jms.remoting: Remoting classes for transparent Java-to-Java remoting via a JMS provider.
org.springframework.jmx.access: Provides support for accessing remote MBean resources.
org.springframework.jmx.export: This package provides declarative creation and registration of Spring-managed beans as JMX MBeans.
org.springframework.jmx.export.annotation: JDK 1.5+ annotations for MBean exposure.
org.springframework.jmx.export.assembler: Provides a strategy for MBeanInfo assembly.
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.jndi: The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
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.jdo: Package providing integration of JDO (Java Date Objects) with Spring concepts.
org.springframework.orm.jpa: Package providing integration of JPA (Java Persistence API) with Spring concepts.
org.springframework.remoting.caucho: This package provides remoting classes for Caucho's Hessian and Burlap protocols: a proxy factory for accessing Hessian/Burlap services, and an exporter for making beans available to Hessian/Burlap clients.
org.springframework.remoting.httpinvoker: Remoting classes for transparent Java-to-Java remoting via HTTP invokers.
org.springframework.remoting.jaxrpc: Remoting classes for Web Services via JAX-RPC.
org.springframework.remoting.jaxrpc.support: Support for specific JAX-RPC providers.
org.springframework.remoting.jaxws: Remoting classes for Web Services via JAX-WS (the successor of JAX-RPC), as included in Java 6 and Java EE 5.
org.springframework.remoting.rmi: Remoting classes for conventional RMI and transparent remoting via RMI invokers.
org.springframework.remoting.support: Generic support classes for remoting implementations.
org.springframework.scheduling.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.support: Generic support classes for scheduling.
org.springframework.scheduling.timer: Scheduling convenience classes for the JDK Timer, allowing to set up Timers and ScheduledTimerTasks as beans in a Spring context.
org.springframework.scripting.bsh: Package providing integration of BeanShell into Spring's scripting infrastructure.
org.springframework.scripting.groovy: Package providing integration of Groovy into Spring's scripting infrastructure.
org.springframework.scripting.jruby: Package providing integration of JRuby into Spring's scripting infrastructure.
org.springframework.scripting.support: Support classes for Spring's scripting package.
org.springframework.transaction.interceptor: AOP-based solution for declarative transaction demarcation.

Uses of BeanClassLoaderAware in org.springframework.aop.aspectj.annotation

Classes in org.springframework.aop.aspectj.annotation that implement BeanClassLoaderAware
`class` `AnnotationAwareAspectJAutoProxyCreator` `AspectJAwareAdvisorAutoProxyCreator` subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.

Uses of BeanClassLoaderAware in org.springframework.aop.aspectj.autoproxy

Classes in org.springframework.aop.aspectj.autoproxy that implement BeanClassLoaderAware
`class` `AspectJAwareAdvisorAutoProxyCreator` `AbstractAdvisorAutoProxyCreator` subclass that exposes AspectJ's invocation context and understands AspectJ's rules for advice precedence when multiple pieces of advice come from the same aspect.

Uses of BeanClassLoaderAware in org.springframework.aop.framework

Classes in org.springframework.aop.framework that implement BeanClassLoaderAware
`class` `AbstractSingletonProxyFactoryBean` Convenient proxy factory bean superclass for proxy factory beans that create only singletons.
`class` `ProxyFactoryBean` `FactoryBean` implementation that builds an AOP proxy based on beans in Spring `BeanFactory`.

Uses of BeanClassLoaderAware in org.springframework.aop.framework.autoproxy

Classes in org.springframework.aop.framework.autoproxy that implement BeanClassLoaderAware
`class` `AbstractAdvisorAutoProxyCreator` Generic auto proxy creator that builds AOP proxies for specific beans based on detected Advisors for each bean.
`class` `AbstractAutoProxyCreator` `BeanPostProcessor` implementation that wraps each eligible bean with an AOP proxy, delegating to specified interceptors before invoking the bean itself.
`class` `BeanNameAutoProxyCreator` Auto proxy creator that identifies beans to proxy via a list of names.
`class` `DefaultAdvisorAutoProxyCreator` BeanPostProcessor implementation that creates AOP proxies based on all candidate Advisors in the current BeanFactory.
`class` `InfrastructureAdvisorAutoProxyCreator` Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.

Uses of BeanClassLoaderAware in org.springframework.beans.factory.annotation

Classes in org.springframework.beans.factory.annotation that implement BeanClassLoaderAware
`class` `CustomAutowireConfigurer` A `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom autowire qualifier types.

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

Classes in org.springframework.beans.factory.config that implement BeanClassLoaderAware
`class` `AbstractFactoryBean` Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
`class` `CustomEditorConfigurer` `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom `property editors`.
`class` `CustomScopeConfigurer` Simple `BeanFactoryPostProcessor` implementation that registers custom `Scope(s)` with the containing `ConfigurableBeanFactory`.
`class` `FieldRetrievingFactoryBean` FactoryBean which retrieves a static or non-static field value.
`class` `ListFactoryBean` Simple factory for shared List instances.
`class` `MapFactoryBean` Simple factory for shared Map instances.
`class` `MethodInvokingFactoryBean` FactoryBean which returns a value which is the result of a static or instance method invocation.
`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 BeanClassLoaderAware in org.springframework.beans.factory.serviceloader

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

Uses of BeanClassLoaderAware in org.springframework.context.support

Classes in org.springframework.context.support that implement BeanClassLoaderAware
`class` `ResourceBundleMessageSource` `MessageSource` implementation that accesses resource bundles using specified basenames.

Uses of BeanClassLoaderAware in org.springframework.context.weaving

Classes in org.springframework.context.weaving that implement BeanClassLoaderAware
`class` `AspectJWeavingEnabler` Post-processor that registers AspectJ's `ClassPreProcessorAgentAdapter` with the Spring application context's default `LoadTimeWeaver`.
`class` `DefaultContextLoadTimeWeaver` Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.

Uses of BeanClassLoaderAware in org.springframework.dao.annotation

Classes in org.springframework.dao.annotation that implement BeanClassLoaderAware
`class` `PersistenceExceptionTranslationPostProcessor` Bean post-processor that automatically applies persistence exception translation to any bean that carries the `Repository` annotation, adding a corresponding `PersistenceExceptionTranslationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

Uses of BeanClassLoaderAware in org.springframework.ejb.access

Classes in org.springframework.ejb.access that implement BeanClassLoaderAware
`class` `LocalStatelessSessionProxyFactoryBean` Convenient factory for local Stateless Session Bean (SLSB) proxies.
`class` `SimpleRemoteStatelessSessionProxyFactoryBean` Convenient factory for remote SLSB proxies.

Uses of BeanClassLoaderAware in org.springframework.jms.remoting

Classes in org.springframework.jms.remoting that implement BeanClassLoaderAware
`class` `JmsInvokerProxyFactoryBean` FactoryBean for JMS invoker proxies.
`class` `JmsInvokerServiceExporter` JMS message listener that exports the specified service bean as a JMS service endpoint, accessible via a JMS invoker proxy.

Uses of BeanClassLoaderAware in org.springframework.jmx.access

Classes in org.springframework.jmx.access that implement BeanClassLoaderAware
`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 BeanClassLoaderAware in org.springframework.jmx.export

Classes in org.springframework.jmx.export that implement BeanClassLoaderAware
`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 BeanClassLoaderAware in org.springframework.jmx.export.annotation

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

Uses of BeanClassLoaderAware in org.springframework.jmx.export.assembler

Classes in org.springframework.jmx.export.assembler that implement BeanClassLoaderAware
`class` `InterfaceBasedMBeanInfoAssembler` Subclass of `AbstractReflectiveMBeanInfoAssembler` that allows for the management interface of a bean to be defined using arbitrary interfaces.

Uses of BeanClassLoaderAware in org.springframework.jmx.support

Classes in org.springframework.jmx.support that implement BeanClassLoaderAware
`class` `MBeanServerConnectionFactoryBean` `FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.

Uses of BeanClassLoaderAware in org.springframework.jndi

Classes in org.springframework.jndi that implement BeanClassLoaderAware
`class` `JndiObjectFactoryBean` `FactoryBean` that looks up a JNDI object.

Uses of BeanClassLoaderAware in org.springframework.orm.hibernate3

Classes in org.springframework.orm.hibernate3 that implement BeanClassLoaderAware
`class` `LocalSessionFactoryBean` `FactoryBean` that creates a Hibernate `SessionFactory`.

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

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

Uses of BeanClassLoaderAware in org.springframework.orm.jdo

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

Uses of BeanClassLoaderAware in org.springframework.orm.jpa

Classes in org.springframework.orm.jpa that implement BeanClassLoaderAware
`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 BeanClassLoaderAware in org.springframework.remoting.caucho

Classes in org.springframework.remoting.caucho that implement BeanClassLoaderAware
`class` `BurlapClientInterceptor` `MethodInterceptor` for accessing a Burlap service.
`class` `BurlapExporter` General stream-based protocol exporter for a Burlap endpoint.
`class` `BurlapProxyFactoryBean` FactoryBean for Burlap proxies.
`class` `BurlapServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy.
`class` `HessianClientInterceptor` `MethodInterceptor` for accessing a Hessian service.
`class` `HessianExporter` General stream-based protocol exporter for a Hessian endpoint.
`class` `HessianProxyFactoryBean` FactoryBean for Hessian proxies.
`class` `HessianServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.
`class` `SimpleBurlapServiceExporter` HTTP request handler that exports the specified service bean as Burlap service endpoint, accessible via a Burlap proxy.
`class` `SimpleHessianServiceExporter` HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.

Uses of BeanClassLoaderAware in org.springframework.remoting.httpinvoker

Classes in org.springframework.remoting.httpinvoker that implement BeanClassLoaderAware
`class` `AbstractHttpInvokerRequestExecutor` Abstract base implementation of the HttpInvokerRequestExecutor interface.
`class` `CommonsHttpInvokerRequestExecutor` `HttpInvokerRequestExecutor` implementation that uses Jakarta Commons HttpClient to execute POST requests.
`class` `HttpInvokerClientInterceptor` `MethodInterceptor` for accessing an HTTP invoker service.
`class` `HttpInvokerProxyFactoryBean` FactoryBean for HTTP invoker proxies.
`class` `HttpInvokerServiceExporter` Servlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.
`class` `SimpleHttpInvokerRequestExecutor` HttpInvokerRequestExecutor implementation that uses standard J2SE facilities to execute POST requests, without support for HTTP authentication or advanced configuration options.
`class` `SimpleHttpInvokerServiceExporter` HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.

Uses of BeanClassLoaderAware in org.springframework.remoting.jaxrpc

Classes in org.springframework.remoting.jaxrpc that implement BeanClassLoaderAware
`class` `JaxRpcPortProxyFactoryBean` `FactoryBean` for a specific port of a JAX-RPC service.

Uses of BeanClassLoaderAware in org.springframework.remoting.jaxrpc.support

Classes in org.springframework.remoting.jaxrpc.support that implement BeanClassLoaderAware
`class` `AxisBeanMappingServicePostProcessor` Axis-specific `JaxRpcServicePostProcessor` that registers bean mappings for domain objects that follow the JavaBean pattern.

Uses of BeanClassLoaderAware in org.springframework.remoting.jaxws

Classes in org.springframework.remoting.jaxws that implement BeanClassLoaderAware
`class` `JaxWsPortProxyFactoryBean` `FactoryBean` for a specific port of a JAX-WS service.

Uses of BeanClassLoaderAware in org.springframework.remoting.rmi

Classes in org.springframework.remoting.rmi that implement BeanClassLoaderAware
`class` `JndiRmiProxyFactoryBean` Factory bean for RMI proxies from JNDI.
`class` `JndiRmiServiceExporter` Service exporter which binds RMI services to JNDI.
`class` `RemoteInvocationSerializingExporter` Abstract base class for remote service exporters that explicitly deserialize `RemoteInvocation` objects and serialize `RemoteInvocationResult` objects, for example Spring's HTTP invoker.
`class` `RmiBasedExporter` Convenient superclass for RMI-based remote exporters.
`class` `RmiClientInterceptor` `MethodInterceptor` for accessing conventional RMI services or RMI invokers.
`class` `RmiProxyFactoryBean` FactoryBean for RMI proxies, supporting both conventional RMI services and RMI invokers.
`class` `RmiServiceExporter` RMI exporter that exposes the specified service as RMI object with the specified name.

Uses of BeanClassLoaderAware in org.springframework.remoting.support

Classes in org.springframework.remoting.support that implement BeanClassLoaderAware
`class` `RemoteAccessor` Abstract base class for classes that access a remote service.
`class` `RemoteExporter` Abstract base class for classes that export a remote service.
`class` `RemoteInvocationBasedAccessor` Abstract base class for remote service accessors that are based on serialization of `RemoteInvocation` objects.
`class` `RemoteInvocationBasedExporter` Abstract base class for remote service exporters that are based on deserialization of `RemoteInvocation` objects.
`class` `RemotingSupport` Generic support base class for remote accessor and exporters, providing common bean ClassLoader handling.
`class` `UrlBasedRemoteAccessor` Abstract base class for classes that access remote services via URLs.

Uses of BeanClassLoaderAware in org.springframework.scheduling.quartz

Classes in org.springframework.scheduling.quartz that implement BeanClassLoaderAware
`class` `MethodInvokingJobDetailFactoryBean` `FactoryBean` that exposes a `JobDetail` object which delegates job execution to a specified (static or non-static) method.

Uses of BeanClassLoaderAware in org.springframework.scheduling.support

Classes in org.springframework.scheduling.support that implement BeanClassLoaderAware
`class` `MethodInvokingRunnable` Adapter that implements the `Runnable` interface as a configurable method invocation based on Spring's MethodInvoker.

Uses of BeanClassLoaderAware in org.springframework.scheduling.timer

Classes in org.springframework.scheduling.timer that implement BeanClassLoaderAware
`class` `MethodInvokingTimerTaskFactoryBean` FactoryBean that exposes a TimerTask object that delegates job execution to a specified (static or non-static) method.

Uses of BeanClassLoaderAware in org.springframework.scripting.bsh

Classes in org.springframework.scripting.bsh that implement BeanClassLoaderAware
`class` `BshScriptFactory` `ScriptFactory` implementation for a BeanShell script.

Uses of BeanClassLoaderAware in org.springframework.scripting.groovy

Classes in org.springframework.scripting.groovy that implement BeanClassLoaderAware
`class` `GroovyScriptFactory` `ScriptFactory` implementation for a Groovy script.

Uses of BeanClassLoaderAware in org.springframework.scripting.jruby

Classes in org.springframework.scripting.jruby that implement BeanClassLoaderAware
`class` `JRubyScriptFactory` `ScriptFactory` implementation for a JRuby script.

Uses of BeanClassLoaderAware in org.springframework.scripting.support

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

Uses of BeanClassLoaderAware in org.springframework.transaction.interceptor

Classes in org.springframework.transaction.interceptor that implement BeanClassLoaderAware
`class` `MethodMapTransactionAttributeSource` Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.
`class` `TransactionProxyFactoryBean` Proxy factory bean for simplified declarative transaction handling.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.