接口的使用
org.springframework.beans.factory.BeanFactoryAware
使用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 org.springframework.aop.interceptor Provides miscellaneous interceptor implementations.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 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 Java 6 ServiceLoader facility.org.springframework.beans.factory.support Classes supporting theorg.springframework.beans.factory
package.org.springframework.beans.factory.wiring Mechanism to determine bean wiring metadata from a bean instance.org.springframework.cache.interceptor AOP-based solution for declarative caching demarcation.org.springframework.cache.jcache.interceptor AOP-based solution for declarative caching demarcation using JSR-107 annotations.org.springframework.context.annotation Annotation support for the Application Context, including JSR-250 "common" annotations, component-scanning, and Java-based metadata for creating Spring-managed objects.org.springframework.context.event Support classes for application events, like standard context events.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'sLoadTimeWeaver
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.config Defines the Spring JDBC configuration namespace.org.springframework.jdbc.datasource.lookup Provides a strategy for looking up JDBC DataSources by name.org.springframework.jms.annotation Annotations and support classes for declarative JMS listener endpoints.org.springframework.jms.config Support package for declarative messaging configuration, with Java configuration and XML schema support.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 Java 5 annotations for MBean exposure.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.messaging.core Defines interfaces and implementation classes for messaging templates.org.springframework.messaging.handler.annotation.support Support classes for working with annotated message-handling methods.org.springframework.orm.hibernate5 Package providing integration of Hibernate 5.x with Spring concepts.org.springframework.orm.jpa Package providing integration of JPA (Java Persistence API) with Spring concepts.org.springframework.orm.jpa.support Classes supporting theorg.springframework.orm.jpa
package.org.springframework.orm.jpa.vendor Support classes for adapting to specific JPA vendors.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.annotation Java 5 annotation for asynchronous method execution.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.validation.beanvalidation Support classes for integrating a JSR-303 Bean Validation provider (such as Hibernate Validator) into a Spring ApplicationContext and in particular with Spring's data binding and validation APIs.org.springframework.web.context.request.async Support for asynchronous request processing.org.springframework.web.servlet.mvc.method.annotation MVC infrastructure for annotation-based handler method processing, building on theorg.springframework.web.method.annotation
package.org.springframework.web.socket.client.standard Client-side classes for use with standard Java WebSocket endpoints.org.springframework.web.socket.handler ConvenientWebSocketHandler
implementations and decorators.org.springframework.web.socket.server.standard Server-side classes for use with standard JSR-356 WebSocket endpoints.org.springframework.aop.aspectj中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.aspectj中的类 修饰符和类型 类 说明 class
AspectJExpressionPointcut
SpringPointcut
implementation that uses the AspectJ weaver to evaluate a pointcut expression.class
AspectJExpressionPointcutAdvisor
Spring AOP Advisor that can be used for any AspectJ pointcut expression.org.springframework.aop.aspectj.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.aspectj.annotation中的类 修饰符和类型 类 说明 class
AnnotationAwareAspectJAutoProxyCreator
AspectJAwareAdvisorAutoProxyCreator
subclass that processes all AspectJ annotation aspects in the current application context, as well as Spring Advisors.org.springframework.aop.aspectj.autoproxy中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.aspectj.autoproxy中的类 修饰符和类型 类 说明 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.org.springframework.aop.config中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.config中的类 修饰符和类型 类 说明 class
MethodLocatingFactoryBean
FactoryBean
implementation that locates aMethod
on a specified bean.class
SimpleBeanFactoryAwareAspectInstanceFactory
Implementation ofAspectInstanceFactory
that locates the aspect from theBeanFactory
using a configured bean name.org.springframework.aop.framework中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.framework中的类 修饰符和类型 类 说明 class
ProxyFactoryBean
FactoryBean
implementation that builds an AOP proxy based on beans in SpringBeanFactory
.org.springframework.aop.framework.autoproxy中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.framework.autoproxy中的类 修饰符和类型 类 说明 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
AbstractBeanFactoryAwareAdvisingPostProcessor
Extension ofAbstractAutoProxyCreator
which implementsBeanFactoryAware
, adds exposure of the original target class for each proxied bean (AutoProxyUtils.ORIGINAL_TARGET_CLASS_ATTRIBUTE
), and participates in an externally enforced target-class mode for any given bean (AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE
).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 candidateAdvisor
s in the currentBeanFactory
.class
InfrastructureAdvisorAutoProxyCreator
Auto-proxy creator that considers infrastructure Advisor beans only, ignoring any application-defined Advisors.org.springframework.aop.framework.autoproxy.target中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.framework.autoproxy.target中的类 修饰符和类型 类 说明 class
AbstractBeanFactoryBasedTargetSourceCreator
Convenient superclass forTargetSourceCreator
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: : CommonsPool2TargetSource % ThreadLocalTargetSource !org.springframework.aop.interceptor中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.interceptor中的类 修饰符和类型 类 说明 class
AsyncExecutionAspectSupport
Base class for asynchronous method execution aspects, such asorg.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor
ororg.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect
.class
AsyncExecutionInterceptor
AOP AllianceMethodInterceptor
that processes method invocations asynchronously, using a givenAsyncTaskExecutor
.org.springframework.aop.scope中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.scope中的类 修饰符和类型 类 说明 class
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.org.springframework.aop.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.support中的类 修饰符和类型 类 说明 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.org.springframework.aop.target中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.aop.target中的类 修饰符和类型 类 说明 class
AbstractBeanFactoryBasedTargetSource
Base class forTargetSource
implementations that are based on a SpringBeanFactory
, delegating to Spring-managed bean instances.class
AbstractPoolingTargetSource
Abstract base class for poolingTargetSource
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 dynamicTargetSource
implementations that create new prototype bean instances to support a pooling or new-instance-per-invocation strategy.class
CommonsPool2TargetSource
TargetSource
implementation that holds objects in a configurable Apache Commons2 Pool.class
LazyInitTargetSource
TargetSource
that lazily accesses a singleton bean from aBeanFactory
.class
PrototypeTargetSource
TargetSource
implementation that creates a new instance of the target bean for each request, destroying each instance on release (after each request).class
SimpleBeanTargetSource
SimpleTargetSource
implementation, freshly obtaining the specified target bean from its containing SpringBeanFactory
.class
ThreadLocalTargetSource
Alternative to an object pool.org.springframework.beans.factory.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.beans.factory.annotation中的类 修饰符和类型 类 说明 class
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary config methods.class
QualifierAnnotationAutowireCandidateResolver
AutowireCandidateResolver
implementation that matches bean definition qualifiers againstqualifier annotations
on the field or parameter to be autowired.class
RequiredAnnotationBeanPostProcessor
已过时。as of 5.1, in favor of using constructor injection for required settings (or a customInitializingBean
implementation)org.springframework.beans.factory.config中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.beans.factory.config中的类 修饰符和类型 类 说明 class
AbstractFactoryBean<T>
Simple template superclass forFactoryBean
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
MethodInvokingBean
Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast toMethodInvokingFactoryBean
).class
MethodInvokingFactoryBean
FactoryBean
which returns a value which is the result of a static or instance method invocation.class
ObjectFactoryCreatingFactoryBean
AFactoryBean
implementation that returns a value which is anObjectFactory
that in turn returns a bean sourced from aBeanFactory
.class
PlaceholderConfigurerSupport
Abstract base class for property resource configurers that resolve placeholders in bean definition property values.class
PreferencesPlaceholderConfigurer
已过时。as of 5.2, along withPropertyPlaceholderConfigurer
class
PropertyPathFactoryBean
FactoryBean
that evaluates a property path on a given target object.class
PropertyPlaceholderConfigurer
已过时。as of 5.2; useorg.springframework.context.support.PropertySourcesPlaceholderConfigurer
instead which is more flexible through taking advantage of theEnvironment
andPropertySource
mechanisms.class
ProviderCreatingFactoryBean
AFactoryBean
implementation that returns a value which is a JSR-330Provider
that in turn returns a bean sourced from aBeanFactory
.class
ServiceLocatorFactoryBean
AFactoryBean
implementation that takes an interface which must have one or more methods with the signaturesMyType xxx()
orMyType xxx(MyIdType id)
(typically,MyService getService()
orMyService getService(String id)
) and creates a dynamic proxy which implements that interface, delegating to an underlyingBeanFactory
.class
SetFactoryBean
Simple factory for shared Set instances.org.springframework.beans.factory.serviceloader中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.beans.factory.serviceloader中的类 修饰符和类型 类 说明 class
AbstractServiceLoaderBasedFactoryBean
Abstract base class for FactoryBeans operating on the JDK 1.6ServiceLoader
facility.class
ServiceFactoryBean
FactoryBean
that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6ServiceLoader
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.6ServiceLoader
facility.class
ServiceLoaderFactoryBean
FactoryBean
that exposes the JDK 1.6ServiceLoader
for the configured service class.org.springframework.beans.factory.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.beans.factory.support中的类 修饰符和类型 类 说明 class
GenericTypeAwareAutowireCandidateResolver
BasicAutowireCandidateResolver
that performs a full generic type match with the candidate's type if the dependency is declared as a generic type (e.g.org.springframework.beans.factory.wiring中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.beans.factory.wiring中的类 修饰符和类型 类 说明 class
BeanConfigurerSupport
Convenient base class for bean configurers that can perform Dependency Injection on objects (however they may be created).org.springframework.cache.interceptor中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.cache.interceptor中的类 修饰符和类型 类 说明 class
BeanFactoryCacheOperationSourceAdvisor
Advisor driven by aCacheOperationSource
, used to include a cache advice bean for methods that are cacheable.class
CacheAspectSupport
Base class for caching aspects, such as theCacheInterceptor
or an AspectJ aspect.class
CacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache
).class
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.org.springframework.cache.jcache.interceptor中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.cache.jcache.interceptor中的类 修饰符和类型 类 说明 class
BeanFactoryJCacheOperationSourceAdvisor
Advisor driven by aJCacheOperationSource
, used to include a cache advice bean for methods that are cacheable.class
DefaultJCacheOperationSource
The defaultJCacheOperationSource
implementation delegating default operations to configurable services with sensible defaults when not present.org.springframework.context.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.context.annotation中的类 修饰符和类型 类 说明 class
CommonAnnotationBeanPostProcessor
BeanPostProcessor
implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in thejavax.annotation
package.class
ContextAnnotationAutowireCandidateResolver
Complete implementation of theAutowireCandidateResolver
strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by theLazy
annotation in thecontext.annotation
package.class
MBeanExportConfiguration
@Configuration
class that registers aAnnotationMBeanExporter
bean.org.springframework.context.event中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.context.event中的类 修饰符和类型 类 说明 class
AbstractApplicationEventMulticaster
Abstract implementation of theApplicationEventMulticaster
interface, providing the basic listener registration facility.class
SimpleApplicationEventMulticaster
Simple implementation of theApplicationEventMulticaster
interface.org.springframework.context.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.context.support中的类 修饰符和类型 类 说明 class
DefaultLifecycleProcessor
Default implementation of theLifecycleProcessor
strategy.class
PropertySourcesPlaceholderConfigurer
Specialization ofPlaceholderConfigurerSupport
that resolves ${...} placeholders within bean definition property values and@Value
annotations against the current SpringEnvironment
and its set ofPropertySources
.org.springframework.context.weaving中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.context.weaving中的类 修饰符和类型 类 说明 class
LoadTimeWeaverAwareProcessor
BeanPostProcessor
implementation that passes the context's defaultLoadTimeWeaver
to beans that implement theLoadTimeWeaverAware
interface.org.springframework.dao.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.dao.annotation中的类 修饰符和类型 类 说明 class
PersistenceExceptionTranslationPostProcessor
Bean post-processor that automatically applies persistence exception translation to any bean marked with Spring's @Repository
annotation, adding a correspondingPersistenceExceptionTranslationAdvisor
to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).org.springframework.dao.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.dao.support中的类 修饰符和类型 类 说明 class
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.org.springframework.jdbc.config中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jdbc.config中的类 修饰符和类型 类 说明 class
SortedResourcesFactoryBean
FactoryBean
implementation that takes a list of location Strings and creates a sorted array ofResource
instances.org.springframework.jdbc.datasource.lookup中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jdbc.datasource.lookup中的类 修饰符和类型 类 说明 class
BeanFactoryDataSourceLookup
DataSourceLookup
implementation based on a SpringBeanFactory
.org.springframework.jms.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jms.annotation中的类 修饰符和类型 类 说明 class
JmsListenerAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated withJmsListener
to be invoked by a JMS message listener container created under the cover by aJmsListenerContainerFactory
according to the attributes of the annotation.org.springframework.jms.config中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jms.config中的类 修饰符和类型 类 说明 class
JmsListenerEndpointRegistrar
Helper bean for registeringJmsListenerEndpoint
with aJmsListenerEndpointRegistry
.class
MethodJmsListenerEndpoint
AJmsListenerEndpoint
providing the method to invoke to process an incoming message for this endpoint.org.springframework.jms.support.destination中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jms.support.destination中的类 修饰符和类型 类 说明 class
BeanFactoryDestinationResolver
DestinationResolver
implementation based on a SpringBeanFactory
.org.springframework.jmx.export中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jmx.export中的类 修饰符和类型 类 说明 class
MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean to a JMXMBeanServer
, without the need to define any JMX-specific information in the bean classes.org.springframework.jmx.export.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jmx.export.annotation中的类 修饰符和类型 类 说明 class
AnnotationJmxAttributeSource
Implementation of theJmxAttributeSource
interface that reads annotations and exposes the corresponding attributes.class
AnnotationMBeanExporter
Convenient subclass of Spring's standardMBeanExporter
, activating Java 5 annotation usage for JMX exposure of Spring beans:ManagedResource
,ManagedAttribute
,ManagedOperation
, etc.org.springframework.jndi中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.jndi中的类 修饰符和类型 类 说明 class
JndiObjectFactoryBean
FactoryBean
that looks up a JNDI object.org.springframework.messaging.core中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.messaging.core中的类 修饰符和类型 类 说明 class
BeanFactoryMessageChannelDestinationResolver
An implementation ofDestinationResolver
that interprets a destination name as the bean name of aMessageChannel
and looks up the bean in the configuredBeanFactory
.class
GenericMessagingTemplate
A messaging template that resolves destinations names toMessageChannel
's to send and receive messages from.org.springframework.messaging.handler.annotation.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.messaging.handler.annotation.support中的类 修饰符和类型 类 说明 class
DefaultMessageHandlerMethodFactory
The defaultMessageHandlerMethodFactory
implementation creating anInvocableHandlerMethod
with the necessaryHandlerMethodArgumentResolver
instances to detect and process most of the use cases defined byMessageMapping
.org.springframework.orm.hibernate5中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.orm.hibernate5中的类 修饰符和类型 类 说明 class
HibernateTransactionManager
PlatformTransactionManager
implementation for a single HibernateSessionFactory
.class
LocalSessionFactoryBean
FactoryBean
that creates a HibernateSessionFactory
.org.springframework.orm.jpa中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.orm.jpa中的类 修饰符和类型 类 说明 class
AbstractEntityManagerFactoryBean
AbstractFactoryBean
that creates a local JPAEntityManagerFactory
instance within a Spring application context.class
EntityManagerFactoryAccessor
Base class for any class that needs to access a JPAEntityManagerFactory
, usually in order to obtain a JPAEntityManager
.class
JpaTransactionManager
PlatformTransactionManager
implementation for a single JPAEntityManagerFactory
.class
LocalContainerEntityManagerFactoryBean
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard container bootstrap contract.class
LocalEntityManagerFactoryBean
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard standalone bootstrap contract.org.springframework.orm.jpa.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.orm.jpa.support中的类 修饰符和类型 类 说明 class
OpenEntityManagerInViewInterceptor
Spring web request interceptor that binds a JPA EntityManager to the thread for the entire processing of the request.class
PersistenceAnnotationBeanPostProcessor
BeanPostProcessor that processesPersistenceUnit
andPersistenceContext
annotations, for injection of the corresponding JPA resourcesEntityManagerFactory
andEntityManager
.class
SharedEntityManagerBean
FactoryBean
that exposes a shared JPAEntityManager
reference for a given EntityManagerFactory.org.springframework.orm.jpa.vendor中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.orm.jpa.vendor中的类 修饰符和类型 类 说明 class
HibernateJpaSessionFactoryBean
已过时。as of Spring Framework 4.3.12 against Hibernate 5.2, in favor of a custom solution based onEntityManagerFactory.unwrap(java.lang.Class<T>)
with explicit qualifiers and/or primary markersorg.springframework.remoting.jaxws中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.remoting.jaxws中的类 修饰符和类型 类 说明 class
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebService
annotation).class
SimpleHttpServerJaxWsServiceExporter
已过时。as of Spring Framework 5.1, in favor ofSimpleJaxWsServiceExporter
class
SimpleJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebService
annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.org.springframework.scheduling.annotation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.scheduling.annotation中的类 修饰符和类型 类 说明 class
AnnotationAsyncExecutionInterceptor
Specialization ofAsyncExecutionInterceptor
that delegates method execution to anExecutor
based on theAsync
annotation.class
AsyncAnnotationAdvisor
Advisor that activates asynchronous method execution through theAsync
annotation.class
AsyncAnnotationBeanPostProcessor
Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries theAsync
annotation at class or method-level by adding a correspondingAsyncAnnotationAdvisor
to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).class
ScheduledAnnotationBeanPostProcessor
Bean post-processor that registers methods annotated with @Scheduled
to be invoked by aTaskScheduler
according to the "fixedRate", "fixedDelay", or "cron" expression provided via the annotation.org.springframework.scheduling.quartz中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.scheduling.quartz中的类 修饰符和类型 类 说明 class
MethodInvokingJobDetailFactoryBean
FactoryBean
that exposes aJobDetail
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 givenScheduler
instance.org.springframework.scripting.groovy中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.scripting.groovy中的类 修饰符和类型 类 说明 class
GroovyScriptFactory
ScriptFactory
implementation for a Groovy script.org.springframework.scripting.support中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.scripting.support中的类 修饰符和类型 类 说明 class
ScriptFactoryPostProcessor
BeanPostProcessor
that handlesScriptFactory
definitions, replacing each factory with the actual scripted Java object generated by it.org.springframework.transaction.interceptor中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.transaction.interceptor中的类 修饰符和类型 类 说明 class
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by aTransactionAttributeSource
, used to include a transaction advice bean for methods that are transactional.class
TransactionAspectSupport
Base class for transactional aspects, such as theTransactionInterceptor
or an AspectJ aspect.class
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager
/ReactiveTransactionManager
).class
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.org.springframework.validation.beanvalidation中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.validation.beanvalidation中的类 修饰符和类型 类 说明 class
MethodValidationPostProcessor
A convenientBeanPostProcessor
implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.org.springframework.web.context.request.async中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.web.context.request.async中的类 修饰符和类型 类 说明 class
WebAsyncTask<V>
Holder for aCallable
, a timeout value, and a task executor.org.springframework.web.servlet.mvc.method.annotation中BeanFactoryAware的使用
org.springframework.web.socket.client.standard中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.web.socket.client.standard中的类 修饰符和类型 类 说明 class
AnnotatedEndpointConnectionManager
A WebSocket connection manager that is given a URI, aClientEndpoint
-annotated endpoint, connects to a WebSocket server through theConnectionManagerSupport.start()
andConnectionManagerSupport.stop()
methods.class
EndpointConnectionManager
A WebSocket connection manager that is given a URI, anEndpoint
, connects to a WebSocket server through theConnectionManagerSupport.start()
andConnectionManagerSupport.stop()
methods.org.springframework.web.socket.handler中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.web.socket.handler中的类 修饰符和类型 类 说明 class
BeanCreatingHandlerProvider<T>
Instantiates a target handler through a SpringBeanFactory
and also provides an equivalent destroy method.class
PerConnectionWebSocketHandler
AWebSocketHandler
that initializes and destroys aWebSocketHandler
instance for each WebSocket connection and delegates all other methods to it.org.springframework.web.socket.server.standard中BeanFactoryAware的使用
实现BeanFactoryAware的org.springframework.web.socket.server.standard中的类 修饰符和类型 类 说明 class
ServerEndpointRegistration
An implementation ofServerEndpointConfig
for use in Spring-based applications.