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