|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
| Packages that use BeanFactoryAware | |
|---|---|
| org.springframework.aop.aspectj | AspectJ integration package. |
| 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.config | Support package for declarative AOP configuration, with XML schema being the primary configuration format. |
| 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.aop.framework.autoproxy.target | Generic support classes for target source creation. |
| org.springframework.aop.scope | Support for AOP-based scoping of target objects, with configurable backend. |
| org.springframework.aop.support | Convenience classes for using Spring's AOP API. |
| org.springframework.aop.target | This package contains implementations of the org.springframework.aop.TargetSource interface. |
| 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.beans.factory.wiring | Mechanism to determine bean wiring metadata from a bean instance. |
| org.springframework.context.annotation | Annotation support for context configuration, including classpath scanning for autowire candidates. |
| 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.dao.support | Support classes for DAO implementations, providing miscellaneous utility methods. |
| org.springframework.jdbc.datasource.lookup | Provides a strategy for looking up JDBC DataSources by name. |
| org.springframework.jms.support.destination | Support classes for Spring's JMS framework. |
| 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.orm.hibernate3 | Package providing integration of Hibernate3 with Spring concepts. |
| org.springframework.orm.hibernate3.support | Classes supporting the org.springframework.orm.hibernate3 package. |
| org.springframework.orm.jpa.support | Classes supporting the org.springframework.orm.jpa package. |
| 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.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.scripting.groovy | Package providing integration of Groovy 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. |
| org.springframework.web.context.support | Classes supporting the org.springframework.web.context package,
such as WebApplicationContext implementations and various utility classes. |
| Uses of BeanFactoryAware in org.springframework.aop.aspectj |
|---|
| Classes in org.springframework.aop.aspectj that implement BeanFactoryAware | |
|---|---|
class |
AspectJExpressionPointcut
Spring Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression. |
| Uses of BeanFactoryAware in org.springframework.aop.aspectj.annotation |
|---|
| Classes in org.springframework.aop.aspectj.annotation that implement BeanFactoryAware | |
|---|---|
class |
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors. |
| Uses of BeanFactoryAware in org.springframework.aop.aspectj.autoproxy |
|---|
| Classes in org.springframework.aop.aspectj.autoproxy that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.aop.config |
|---|
| Classes in org.springframework.aop.config that implement BeanFactoryAware | |
|---|---|
class |
MethodLocatingFactoryBean
FactoryBean implementation that locates a Method on a specified bean. |
class |
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation of AspectInstanceFactory that locates the aspect from the
BeanFactory using a configured bean name. |
| Uses of BeanFactoryAware in org.springframework.aop.framework |
|---|
| Classes in org.springframework.aop.framework that implement BeanFactoryAware | |
|---|---|
class |
ProxyFactoryBean
FactoryBean implementation that builds an
AOP proxy based on beans in Spring BeanFactory. |
| Uses of BeanFactoryAware in org.springframework.aop.framework.autoproxy |
|---|
| Classes in org.springframework.aop.framework.autoproxy that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.aop.framework.autoproxy.target |
|---|
| Classes in org.springframework.aop.framework.autoproxy.target that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.aop.scope |
|---|
| Classes in org.springframework.aop.scope that implement BeanFactoryAware | |
|---|---|
class |
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects. |
| Uses of BeanFactoryAware in org.springframework.aop.support |
|---|
| Classes in org.springframework.aop.support that implement BeanFactoryAware | |
|---|---|
class |
AbstractBeanFactoryPointcutAdvisor
Abstract BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in a BeanFactory. |
class |
DefaultBeanFactoryPointcutAdvisor
Concrete BeanFactory-based PointcutAdvisor that allows for any Advice to be configured as reference to an Advice bean in the BeanFactory, as well as the Pointcut to be configured through a bean property. |
| Uses of BeanFactoryAware in org.springframework.aop.target |
|---|
| Classes in org.springframework.aop.target that implement BeanFactoryAware | |
|---|---|
class |
AbstractBeanFactoryBasedTargetSource
Base class for TargetSource implementations
that are based on a Spring BeanFactory,
delegating to Spring-managed bean instances. |
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 |
AbstractPrototypeBasedTargetSource
Base class for dynamic TargetSources that can create new prototype bean instances to support a pooling or new-instance-per-invocation strategy. |
class |
CommonsPoolTargetSource
TargetSource implementation that holds objects in a configurable Jakarta Commons Pool. |
class |
LazyInitTargetSource
TargetSource that lazily accesses a
singleton bean from a BeanFactory. |
class |
PrototypeTargetSource
TargetSource that creates a new instance of the target bean for each request, destroying each instance on release (after each request). |
class |
SimpleBeanTargetSource
Simple TargetSource implementation,
freshly obtaining the specified target bean from its containing
Spring BeanFactory. |
class |
ThreadLocalTargetSource
Alternative to an object pool. |
| Uses of BeanFactoryAware in org.springframework.beans.factory.annotation |
|---|
| Classes in org.springframework.beans.factory.annotation that implement BeanFactoryAware | |
|---|---|
class |
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods. |
| Uses of BeanFactoryAware in org.springframework.beans.factory.config |
|---|
| Classes in org.springframework.beans.factory.config that implement BeanFactoryAware | |
|---|---|
class |
AbstractFactoryBean
Simple template superclass for FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag. |
class |
BeanReferenceFactoryBean
FactoryBean that exposes an arbitrary target bean under a different name. |
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 |
PreferencesPlaceholderConfigurer
Subclass of PropertyPlaceholderConfigurer that supports JDK 1.4's Preferences API ( java.util.prefs). |
class |
PropertyPathFactoryBean
FactoryBean that evaluates a property path on a given target object. |
class |
PropertyPlaceholderConfigurer
A property resource configurer that resolves placeholders in bean property values of context definitions. |
class |
ServiceLocatorFactoryBean
A FactoryBean implementation that
takes an interface which must have one or more methods with
the signatures MyType xxx() or MyType xxx(MyIdType id)
(typically, MyService getService() or MyService getService(String id))
and creates a dynamic proxy which implements that interface, delegating to an
underlying BeanFactory. |
class |
SetFactoryBean
Simple factory for shared Set instances. |
| Uses of BeanFactoryAware in org.springframework.beans.factory.serviceloader |
|---|
| Classes in org.springframework.beans.factory.serviceloader that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.beans.factory.wiring |
|---|
| Classes in org.springframework.beans.factory.wiring that implement BeanFactoryAware | |
|---|---|
class |
BeanConfigurerSupport
Convenient base class for configurers that can perform Dependency Injection on objects (however they may be created). |
| Uses of BeanFactoryAware in org.springframework.context.annotation |
|---|
| Classes in org.springframework.context.annotation that implement BeanFactoryAware | |
|---|---|
class |
CommonAnnotationBeanPostProcessor
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation package. |
| Uses of BeanFactoryAware in org.springframework.context.weaving |
|---|
| Classes in org.springframework.context.weaving that implement BeanFactoryAware | |
|---|---|
class |
LoadTimeWeaverAwareProcessor
BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface. |
| Uses of BeanFactoryAware in org.springframework.dao.annotation |
|---|
| Classes in org.springframework.dao.annotation that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.dao.support |
|---|
| Classes in org.springframework.dao.support that implement BeanFactoryAware | |
|---|---|
class |
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator. |
| Uses of BeanFactoryAware in org.springframework.jdbc.datasource.lookup |
|---|
| Classes in org.springframework.jdbc.datasource.lookup that implement BeanFactoryAware | |
|---|---|
class |
BeanFactoryDataSourceLookup
DataSourceLookup implementation based on a Spring BeanFactory. |
| Uses of BeanFactoryAware in org.springframework.jms.support.destination |
|---|
| Classes in org.springframework.jms.support.destination that implement BeanFactoryAware | |
|---|---|
class |
BeanFactoryDestinationResolver
DestinationResolver implementation based on a Spring BeanFactory. |
| Uses of BeanFactoryAware in org.springframework.jmx.export |
|---|
| Classes in org.springframework.jmx.export that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.jmx.export.annotation |
|---|
| Classes in org.springframework.jmx.export.annotation that implement BeanFactoryAware | |
|---|---|
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 BeanFactoryAware in org.springframework.orm.hibernate3 |
|---|
| Classes in org.springframework.orm.hibernate3 that implement BeanFactoryAware | |
|---|---|
class |
HibernateAccessor
Base class for HibernateTemplate and HibernateInterceptor,
defining common properties such as SessionFactory and flushing behavior. |
class |
HibernateInterceptor
This interceptor binds a new Hibernate Session to the thread before a method call, closing and removing it afterwards in case of any method outcome. |
class |
HibernateTemplate
Helper class that simplifies Hibernate data access code. |
class |
HibernateTransactionManager
PlatformTransactionManager
implementation for a single Hibernate SessionFactory. |
| Uses of BeanFactoryAware in org.springframework.orm.hibernate3.support |
|---|
| Classes in org.springframework.orm.hibernate3.support that implement BeanFactoryAware | |
|---|---|
class |
OpenSessionInViewInterceptor
Spring web request interceptor that binds a Hibernate Session to the
thread for the entire processing of the request. |
| Uses of BeanFactoryAware in org.springframework.orm.jpa.support |
|---|
| Classes in org.springframework.orm.jpa.support that implement BeanFactoryAware | |
|---|---|
class |
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processes PersistenceUnit
and PersistenceContext annotations, for injection of
the corresponding JPA resources EntityManagerFactory
and EntityManager. |
| Uses of BeanFactoryAware in org.springframework.remoting.jaxws |
|---|
| Classes in org.springframework.remoting.jaxws that implement BeanFactoryAware | |
|---|---|
class |
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebService annotation). |
class |
SimpleHttpServerJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebService annotation) and exporting
them through the HTTP server included in Sun's JDK 1.6. |
class |
SimpleJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS WebService annotation) and exporting
them with a configured base address (by default "http://localhost:8080/")
using the JAX-WS provider's built-in publication support. |
| Uses of BeanFactoryAware in org.springframework.scheduling.quartz |
|---|
| Classes in org.springframework.scheduling.quartz that implement BeanFactoryAware | |
|---|---|
class |
MethodInvokingJobDetailFactoryBean
FactoryBean that exposes a
JobDetail object which delegates job execution to a
specified (static or non-static) method. |
class |
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a given Scheduler instance. |
| Uses of BeanFactoryAware in org.springframework.scripting.groovy |
|---|
| Classes in org.springframework.scripting.groovy that implement BeanFactoryAware | |
|---|---|
class |
GroovyScriptFactory
ScriptFactory implementation
for a Groovy script. |
| Uses of BeanFactoryAware in org.springframework.scripting.support |
|---|
| Classes in org.springframework.scripting.support that implement BeanFactoryAware | |
|---|---|
class |
ScriptFactoryPostProcessor
BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it. |
| Uses of BeanFactoryAware in org.springframework.transaction.interceptor |
|---|
| Classes in org.springframework.transaction.interceptor that implement BeanFactoryAware | |
|---|---|
class |
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by a TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional. |
class |
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling. |
| Uses of BeanFactoryAware in org.springframework.web.context.support |
|---|
| Classes in org.springframework.web.context.support that implement BeanFactoryAware | |
|---|---|
class |
ServletContextPropertyPlaceholderConfigurer
Subclass of PropertyPlaceholderConfigurer that resolves placeholders as ServletContext init parameters (that is, web.xml context-param
entries). |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||