接口的使用
org.springframework.beans.factory.Aware
使用Aware的程序包 程序包 说明 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 The core package implementing Spring's lightweight Inversion of Control (IoC) container.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.annotation Annotations and supporting classes for declarative cache management.org.springframework.cache.aspectj org.springframework.cache.concurrent Implementation package forjava.util.concurrent
based caches.org.springframework.cache.ehcache Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.org.springframework.cache.interceptor AOP-based solution for declarative caching demarcation.org.springframework.cache.jcache Implementation package for JSR-107 (javax.cache aka "JCache") based caches.org.springframework.cache.jcache.config Support package for declarative JSR-107 caching configuration.org.springframework.cache.jcache.interceptor AOP-based solution for declarative caching demarcation using JSR-107 annotations.org.springframework.context This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.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.ejb.access This package contains classes that allow easy access to EJBs.org.springframework.format.datetime Formatters forjava.util.Date
properties.org.springframework.format.datetime.joda Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.org.springframework.format.datetime.standard Integration with the JSR-310java.time
package in JDK 8.org.springframework.format.number Formatters forjava.lang.Number
properties.org.springframework.format.number.money Integration with the JSR-354javax.money
package.org.springframework.format.support Support classes for the formatting package, providing common implementations as well as adapters.org.springframework.http.converter.json Provides HttpMessageConverter implementations for handling JSON.org.springframework.jca.context Integration package that allows for deploying a Spring application context as a JCA 1.7 compliant RAR file.org.springframework.jca.endpoint This package provides a facility for generic JCA message endpoint management.org.springframework.jca.work Convenience classes for scheduling based on the JCA WorkManager facility, as supported within ResourceAdapters.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.listener This package contains the base message listener container facility.org.springframework.jms.listener.endpoint This package provides JCA-based endpoint management for JMS message listeners.org.springframework.jms.remoting Remoting classes for transparent Java-to-Java remoting via a JMS provider.org.springframework.jms.support.converter Provides a MessageConverter abstraction to convert between Java objects and JMS messages.org.springframework.jms.support.destination Support classes for Spring's JMS framework.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 Java 5 annotations for MBean exposure.org.springframework.jmx.export.assembler Provides a strategy for MBeanInfo assembly.org.springframework.jmx.export.notification Provides supporting infrastructure to allow Spring-created MBeans to send JMX notifications.org.springframework.jmx.support Contains support classes for connecting to local and remoteMBeanServer
s and for exposing anMBeanServer
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.messaging.core Defines interfaces and implementation classes for messaging templates.org.springframework.messaging.handler.annotation.reactive Support classes for working with annotated message-handling methods with non-blocking, reactive contracts.org.springframework.messaging.handler.annotation.support Support classes for working with annotated message-handling methods.org.springframework.messaging.handler.invocation Common infrastructure for invoking message handler methods.org.springframework.messaging.handler.invocation.reactive Common infrastructure for invoking message handler methods with non-blocking, and reactive contracts.org.springframework.messaging.rsocket.annotation.support Support classes for working with annotated RSocket stream handling methods.org.springframework.messaging.simp.annotation.support Support classes for handling messages from simple messaging protocols (like STOMP).org.springframework.messaging.simp.broker Provides a "simple" message broker implementation along with an abstract base class and other supporting types such as a registry for subscriptions.org.springframework.messaging.simp.config Configuration support for WebSocket messaging using higher level messaging protocols.org.springframework.messaging.simp.stomp Generic support for simple messaging protocols (like STOMP).org.springframework.messaging.support Provides implementations ofMessage
along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as variousMessageChannel
implementations and channel interceptor support.org.springframework.orm.hibernate5 Package providing integration of Hibernate 5.x with Spring concepts.org.springframework.orm.hibernate5.support Classes supporting theorg.springframework.orm.hibernate5
package.org.springframework.orm.jpa Package providing integration of JPA (Java Persistence API) with Spring concepts.org.springframework.orm.jpa.persistenceunit Internal support for managing JPA persistence units.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.oxm.jaxb Package providing integration of JAXB with Spring's O/X Mapping support.org.springframework.oxm.xstream Package providing integration of XStream with Spring's O/X Mapping support.org.springframework.remoting.caucho This package provides remoting classes for Caucho's Hessian protocol: a proxy factory for accessing Hessian services, and an exporter for making beans available to Hessian clients.org.springframework.remoting.httpinvoker Remoting classes for transparent Java-to-Java remoting via HTTP invokers.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.annotation Java 5 annotation for asynchronous method execution.org.springframework.scheduling.aspectj org.springframework.scheduling.concurrent Scheduling convenience classes for thejava.util.concurrent
andjavax.enterprise.concurrent
packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.org.springframework.scheduling.config Support package for declarative scheduling configuration, with XML schema being the primary configuration format.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.scripting.bsh Package providing integration of BeanShell (and BeanShell2) into Spring's scripting infrastructure.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.test.context.junit4 Support classes for integrating the Spring TestContext Framework with JUnit 4.12 or higher.org.springframework.test.context.testng Support classes for integrating the Spring TestContext Framework with TestNG.org.springframework.transaction.annotation Spring's support for annotation-based transaction demarcation.org.springframework.transaction.aspectj org.springframework.transaction.interceptor AOP-based solution for declarative transaction demarcation.org.springframework.ui.context.support Classes supporting the org.springframework.ui.context package.org.springframework.ui.freemarker Support classes for setting up FreeMarker within a Spring application context.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.accept This package contains classes used to determine the requested the media types in a request.org.springframework.web.context Contains a variant of the application context interface for web applications, and the ContextLoaderListener that bootstraps a root web application context.org.springframework.web.context.request.async Support for asynchronous request processing.org.springframework.web.context.support Classes supporting theorg.springframework.web.context
package, such as WebApplicationContext implementations and various utility classes.org.springframework.web.filter Provides generic filter base classes allowing for bean-style configuration.org.springframework.web.multipart.commons MultipartResolver implementation for Apache Commons FileUpload.org.springframework.web.multipart.support Support classes for the multipart resolution framework.org.springframework.web.reactive Top-level package for thespring-webflux
module that containsDispatcherHandler
, the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.org.springframework.web.reactive.config Spring WebFlux configuration infrastructure.org.springframework.web.reactive.function.server.support Classes supporting theorg.springframework.web.reactive.function.server
package.org.springframework.web.reactive.handler Provides HandlerMapping implementations including abstract base classes.org.springframework.web.reactive.result.method Infrastructure for handler method processing.org.springframework.web.reactive.result.method.annotation Infrastructure for annotation-based handler method processing.org.springframework.web.reactive.result.view Support for result handling through view resolution.org.springframework.web.reactive.result.view.freemarker Support classes for the integration of FreeMarker as Spring web view technology.org.springframework.web.reactive.result.view.script Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g. using JavaScript via Nashorn on JDK 8.org.springframework.web.servlet Provides servlets that integrate with the application context infrastructure, and the core interfaces and classes for the Spring web MVC framework.org.springframework.web.servlet.config.annotation Annotation-based setup for Spring MVC.org.springframework.web.servlet.function.support Classes supporting theorg.springframework.web.servlet.function
package.org.springframework.web.servlet.handler Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.org.springframework.web.servlet.mvc Standard controller implementations for the Servlet MVC framework that comes with Spring.org.springframework.web.servlet.mvc.annotation Support package for annotation-based Servlet MVC controllers.org.springframework.web.servlet.mvc.method Servlet-based infrastructure for handler method processing, building on theorg.springframework.web.method
package.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.servlet.resource Support classes for serving static resources.org.springframework.web.servlet.support Support classes for Spring's web MVC framework.org.springframework.web.servlet.view Provides standard View and ViewResolver implementations, including abstract base classes for custom implementations.org.springframework.web.servlet.view.document Support classes for document generation, providing View implementations for PDF and Excel.org.springframework.web.servlet.view.feed Support classes for feed generation, providing View implementations for Atom and RSS.org.springframework.web.servlet.view.freemarker Support classes for the integration of FreeMarker as Spring web view technology.org.springframework.web.servlet.view.groovy Support classes for the integration of Groovy Templates as Spring web view technology.org.springframework.web.servlet.view.json Support classes for providing a View implementation based on JSON serialization.org.springframework.web.servlet.view.script Support classes for views based on the JSR-223 script engine abstraction (as included in Java 6+), e.g. using JavaScript via Nashorn on JDK 8.org.springframework.web.servlet.view.tiles3 Support classes for the integration of Tiles 3 (the standalone version of Tiles) as Spring web view technology.org.springframework.web.servlet.view.xml Support classes for providing a View implementation based on XML Marshalling.org.springframework.web.servlet.view.xslt Support classes for XSLT, providing a View implementation for XSLT stylesheets.org.springframework.web.socket.client.standard Client-side classes for use with standard Java WebSocket endpoints.org.springframework.web.socket.config.annotation Support for annotation-based WebSocket setup in configuration classes.org.springframework.web.socket.handler ConvenientWebSocketHandler
implementations and decorators.org.springframework.web.socket.messaging WebSocket integration for Spring's messaging module.org.springframework.web.socket.server.jetty Server-side support for the Jetty 9+ WebSocket API.org.springframework.web.socket.server.standard Server-side classes for use with standard JSR-356 WebSocket endpoints.org.springframework.web.socket.server.support Server-side support classes including container-specific strategies for upgrading a request.org.springframework.web.socket.sockjs.support Support classes for SockJS including anAbstractSockJsService
implementation.org.springframework.web.socket.sockjs.transport.handler TransportHandler
implementation classes as well as a concreteSockJsService
.org.springframework.aop.aspectj中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.aop.framework中的类 修饰符和类型 类 说明 class
AbstractAdvisingBeanPostProcessor
Base class forBeanPostProcessor
implementations that apply a Spring AOPAdvisor
to specific beans.class
AbstractSingletonProxyFactoryBean
Convenient superclass forFactoryBean
types that produce singleton-scoped proxy objects.class
ProxyFactoryBean
FactoryBean
implementation that builds an AOP proxy based on beans in SpringBeanFactory
.class
ProxyProcessorSupport
Base class with common functionality for proxy processors, in particular ClassLoader management and theProxyProcessorSupport.evaluateProxyInterfaces(java.lang.Class<?>, org.springframework.aop.framework.ProxyFactory)
algorithm.org.springframework.aop.framework.autoproxy中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.aop.scope中的类 修饰符和类型 类 说明 class
ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.org.springframework.aop.support中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
org.springframework.beans.factory中Aware的子接口 修饰符和类型 接口 说明 interface
BeanClassLoaderAware
Callback that allows a bean to be aware of the beanclass loader
; that is, the class loader used by the present bean factory to load bean classes.interface
BeanFactoryAware
Interface to be implemented by beans that wish to be aware of their owningBeanFactory
.interface
BeanNameAware
Interface to be implemented by beans that want to be aware of their bean name in a bean factory.org.springframework.beans.factory.annotation中Aware的使用
实现Aware的org.springframework.beans.factory.annotation中的类 修饰符和类型 类 说明 class
AutowiredAnnotationBeanPostProcessor
BeanPostProcessor
implementation that autowires annotated fields, setter methods, and arbitrary config methods.class
CustomAutowireConfigurer
ABeanFactoryPostProcessor
implementation that allows for convenient registration of custom autowire qualifier types.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中Aware的使用
实现Aware的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
CustomScopeConfigurer
SimpleBeanFactoryPostProcessor
implementation that registers customScope(s)
with the containingConfigurableBeanFactory
.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
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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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.annotation中Aware的使用
实现Aware的org.springframework.cache.annotation中的类 修饰符和类型 类 说明 class
AbstractCachingConfiguration
Abstract base@Configuration
class providing common structure for enabling Spring's annotation-driven cache management capability.class
ProxyCachingConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven cache management.org.springframework.cache.aspectj中Aware的使用
实现Aware的org.springframework.cache.aspectj中的类 修饰符和类型 类 说明 class
AspectJCachingConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management.class
AspectJJCacheConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven cache management for standard JSR-107 annotations.org.springframework.cache.concurrent中Aware的使用
实现Aware的org.springframework.cache.concurrent中的类 修饰符和类型 类 说明 class
ConcurrentMapCacheFactoryBean
FactoryBean
for easy configuration of aConcurrentMapCache
when used within a Spring container.class
ConcurrentMapCacheManager
CacheManager
implementation that lazily buildsConcurrentMapCache
instances for eachConcurrentMapCacheManager.getCache(java.lang.String)
request.org.springframework.cache.ehcache中Aware的使用
实现Aware的org.springframework.cache.ehcache中的类 修饰符和类型 类 说明 class
EhCacheFactoryBean
FactoryBean
that creates a named EhCacheCache
instance (or a decorator that implements theEhcache
interface), representing a cache region within an EhCacheCacheManager
.org.springframework.cache.interceptor中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.cache.jcache中的类 修饰符和类型 类 说明 class
JCacheManagerFactoryBean
FactoryBean
for a JCachejavax.cache.CacheManager
, obtaining a pre-definedCacheManager
by name through the standard JCachejavax.cache.Caching
class.org.springframework.cache.jcache.config中Aware的使用
实现Aware的org.springframework.cache.jcache.config中的类 修饰符和类型 类 说明 class
AbstractJCacheConfiguration
Abstract JSR-107 specific@Configuration
class providing common structure for enabling JSR-107 annotation-driven cache management capability.class
ProxyJCacheConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven JSR-107 cache management.org.springframework.cache.jcache.interceptor中Aware的使用
实现Aware的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中Aware的使用
org.springframework.context中Aware的子接口 修饰符和类型 接口 说明 interface
ApplicationContextAware
Interface to be implemented by any object that wishes to be notified of theApplicationContext
that it runs in.interface
ApplicationEventPublisherAware
Interface to be implemented by any object that wishes to be notified of the ApplicationEventPublisher (typically the ApplicationContext) that it runs in.interface
EmbeddedValueResolverAware
Interface to be implemented by any object that wishes to be notified of aStringValueResolver
for the resolution of embedded definition values.interface
EnvironmentAware
Interface to be implemented by any bean that wishes to be notified of theEnvironment
that it runs in.interface
MessageSourceAware
Interface to be implemented by any object that wishes to be notified of the MessageSource (typically the ApplicationContext) that it runs in.interface
ResourceLoaderAware
Interface to be implemented by any object that wishes to be notified of theResourceLoader
(typically the ApplicationContext) that it runs in.org.springframework.context.annotation中Aware的使用
org.springframework.context.annotation中Aware的子接口 修饰符和类型 接口 说明 interface
ImportAware
Interface to be implemented by any @Configuration
class that wishes to be injected with theAnnotationMetadata
of the @Configuration
class that imported it.实现Aware的org.springframework.context.annotation中的类 修饰符和类型 类 说明 class
ClassPathBeanDefinitionScanner
A bean definition scanner that detects bean candidates on the classpath, registering corresponding bean definitions with a given registry (BeanFactory
orApplicationContext
).class
ClassPathScanningCandidateComponentProvider
A component provider that provides candidate components from a base package.class
CommonAnnotationBeanPostProcessor
BeanPostProcessor
implementation that supports common Java annotations out of the box, in particular the JSR-250 annotations in thejavax.annotation
package.class
ConfigurationClassPostProcessor
BeanFactoryPostProcessor
used for bootstrapping processing of@Configuration
classes.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
LoadTimeWeavingConfiguration
@Configuration
class that registers aLoadTimeWeaver
bean.class
MBeanExportConfiguration
@Configuration
class that registers aAnnotationMBeanExporter
bean.org.springframework.context.event中Aware的使用
实现Aware的org.springframework.context.event中的类 修饰符和类型 类 说明 class
AbstractApplicationEventMulticaster
Abstract implementation of theApplicationEventMulticaster
interface, providing the basic listener registration facility.class
EventListenerMethodProcessor
RegistersEventListener
methods as individualApplicationListener
instances.class
EventPublicationInterceptor
Interceptor
that publishes anApplicationEvent
to allApplicationListeners
registered with anApplicationEventPublisher
after each successful method invocation.class
SimpleApplicationEventMulticaster
Simple implementation of theApplicationEventMulticaster
interface.org.springframework.context.support中Aware的使用
实现Aware的org.springframework.context.support中的类 修饰符和类型 类 说明 class
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext
subclass that adds common handling of specified config locations.class
AbstractXmlApplicationContext
Convenient base class forApplicationContext
implementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader
.class
ApplicationObjectSupport
Convenient superclass for application objects that want to be aware of the application context, e.g. for custom lookup of collaborating beans or for context-specific resource access.class
ClassPathXmlApplicationContext
Standalone XML application context, taking the context definition files from the class path, interpreting plain paths as class path resource names that include the package path (e.g.class
DefaultLifecycleProcessor
Default implementation of theLifecycleProcessor
strategy.class
EmbeddedValueResolutionSupport
Convenient base class for components with a need for embedded value resolution (i.e.class
FileSystemXmlApplicationContext
Standalone XML application context, taking the context definition files from the file system or from URLs, interpreting plain paths as relative file system locations (e.g.class
LiveBeansView
Adapter for live beans view exposure, building a snapshot of current beans and their dependencies from either a localApplicationContext
(with a localLiveBeansView
bean definition) or all registered ApplicationContexts (driven by the "spring.liveBeansView.mbeanDomain" environment property).class
PropertySourcesPlaceholderConfigurer
Specialization ofPlaceholderConfigurerSupport
that resolves ${...} placeholders within bean definition property values and@Value
annotations against the current SpringEnvironment
and its set ofPropertySources
.class
ReloadableResourceBundleMessageSource
Spring-specificMessageSource
implementation that accesses resource bundles using specified basenames, participating in the SpringApplicationContext
's resource loading.class
ResourceBundleMessageSource
MessageSource
implementation that accesses resource bundles using specified basenames.org.springframework.context.weaving中Aware的使用
org.springframework.context.weaving中Aware的子接口 修饰符和类型 接口 说明 interface
LoadTimeWeaverAware
Interface to be implemented by any object that wishes to be notified of the application context's defaultLoadTimeWeaver
.实现Aware的org.springframework.context.weaving中的类 修饰符和类型 类 说明 class
AspectJWeavingEnabler
Post-processor that registers AspectJ'sClassPreProcessorAgentAdapter
with the Spring application context's defaultLoadTimeWeaver
.class
DefaultContextLoadTimeWeaver
DefaultLoadTimeWeaver
bean for use in an application context, decorating an automatically detected internalLoadTimeWeaver
.class
LoadTimeWeaverAwareProcessor
BeanPostProcessor
implementation that passes the context's defaultLoadTimeWeaver
to beans that implement theLoadTimeWeaverAware
interface.org.springframework.dao.annotation中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.dao.support中的类 修饰符和类型 类 说明 class
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.org.springframework.ejb.access中Aware的使用
实现Aware的org.springframework.ejb.access中的类 修饰符和类型 类 说明 class
LocalStatelessSessionProxyFactoryBean
ConvenientFactoryBean
for local Stateless Session Bean (SLSB) proxies.class
SimpleRemoteStatelessSessionProxyFactoryBean
ConvenientFactoryBean
for remote SLSB proxies.org.springframework.format.datetime中Aware的使用
实现Aware的org.springframework.format.datetime中的类 修饰符和类型 类 说明 class
DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with theDateTimeFormat
annotation using aDateFormatter
.org.springframework.format.datetime.joda中Aware的使用
实现Aware的org.springframework.format.datetime.joda中的类 修饰符和类型 类 说明 class
JodaDateTimeFormatAnnotationFormatterFactory
Formats fields annotated with theDateTimeFormat
annotation using Joda-Time.org.springframework.format.datetime.standard中Aware的使用
实现Aware的org.springframework.format.datetime.standard中的类 修饰符和类型 类 说明 class
Jsr310DateTimeFormatAnnotationFormatterFactory
Formats fields annotated with theDateTimeFormat
annotation using the JSR-310java.time
package in JDK 8.org.springframework.format.number中Aware的使用
实现Aware的org.springframework.format.number中的类 修饰符和类型 类 说明 class
NumberFormatAnnotationFormatterFactory
Formats fields annotated with theNumberFormat
annotation.org.springframework.format.number.money中Aware的使用
实现Aware的org.springframework.format.number.money中的类 修饰符和类型 类 说明 class
Jsr354NumberFormatAnnotationFormatterFactory
FormatsMonetaryAmount
fields annotated with Spring's commonNumberFormat
annotation.org.springframework.format.support中Aware的使用
实现Aware的org.springframework.format.support中的类 修饰符和类型 类 说明 class
DefaultFormattingConversionService
A specialization ofFormattingConversionService
configured by default with converters and formatters appropriate for most applications.class
FormattingConversionService
AConversionService
implementation designed to be configured as aFormatterRegistry
.class
FormattingConversionServiceFactoryBean
A factory providing convenient access to aFormattingConversionService
configured with converters and formatters for common types such as numbers and datetimes.org.springframework.http.converter.json中Aware的使用
实现Aware的org.springframework.http.converter.json中的类 修饰符和类型 类 说明 class
Jackson2ObjectMapperFactoryBean
AFactoryBean
for creating a Jackson 2.xObjectMapper
(default) orXmlMapper
(createXmlMapper
property set to true) with setters to enable or disable Jackson features from within XML configuration.org.springframework.jca.context中Aware的使用
org.springframework.jca.context中Aware的子接口 修饰符和类型 接口 说明 interface
BootstrapContextAware
Interface to be implemented by any object that wishes to be notified of the BootstrapContext (typically determined by theResourceAdapterApplicationContext
) that it runs in.org.springframework.jca.endpoint中Aware的使用
实现Aware的org.springframework.jca.endpoint中的类 修饰符和类型 类 说明 class
AbstractMessageEndpointFactory
Abstract base implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.class
GenericMessageEndpointFactory
Generic implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for any kind of message listener object (e.g.org.springframework.jca.work中Aware的使用
实现Aware的org.springframework.jca.work中的类 修饰符和类型 类 说明 class
WorkManagerTaskExecutor
TaskExecutor
implementation that delegates to a JCA 1.7 WorkManager, implementing theWorkManager
interface.org.springframework.jdbc.config中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.jdbc.datasource.lookup中的类 修饰符和类型 类 说明 class
BeanFactoryDataSourceLookup
DataSourceLookup
implementation based on a SpringBeanFactory
.org.springframework.jms.annotation中Aware的使用
实现Aware的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中Aware的使用
实现Aware的org.springframework.jms.config中的类 修饰符和类型 类 说明 class
JmsListenerEndpointRegistrar
Helper bean for registeringJmsListenerEndpoint
with aJmsListenerEndpointRegistry
.class
JmsListenerEndpointRegistry
Creates the necessaryMessageListenerContainer
instances for the registered endpoints.class
MethodJmsListenerEndpoint
AJmsListenerEndpoint
providing the method to invoke to process an incoming message for this endpoint.org.springframework.jms.listener中Aware的使用
实现Aware的org.springframework.jms.listener中的类 修饰符和类型 类 说明 class
AbstractJmsListeningContainer
Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).class
AbstractMessageListenerContainer
Abstract base class for Spring message listener container implementations.class
AbstractPollingMessageListenerContainer
Base class for listener container implementations which are based on polling.class
DefaultMessageListenerContainer
Message listener container variant that uses plain JMS client APIs, specifically a loop ofMessageConsumer.receive()
calls that also allow for transactional reception of messages (registering them with XA transactions).class
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API'sMessageConsumer.setMessageListener()
method to create concurrent MessageConsumers for the specified listeners.org.springframework.jms.listener.endpoint中Aware的使用
实现Aware的org.springframework.jms.listener.endpoint中的类 修饰符和类型 类 说明 class
JmsMessageEndpointFactory
JMS-specific implementation of the JCA 1.7MessageEndpointFactory
interface, providing transaction management capabilities for a JMS listener object (e.g. aMessageListener
object).class
JmsMessageEndpointManager
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration.org.springframework.jms.remoting中Aware的使用
实现Aware的org.springframework.jms.remoting中的类 修饰符和类型 类 说明 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.org.springframework.jms.support.converter中Aware的使用
实现Aware的org.springframework.jms.support.converter中的类 修饰符和类型 类 说明 class
MappingJackson2MessageConverter
Message converter that uses Jackson 2.x to convert messages to and from JSON.org.springframework.jms.support.destination中Aware的使用
实现Aware的org.springframework.jms.support.destination中的类 修饰符和类型 类 说明 class
BeanFactoryDestinationResolver
DestinationResolver
implementation based on a SpringBeanFactory
.org.springframework.jmx.access中Aware的使用
实现Aware的org.springframework.jmx.access中的类 修饰符和类型 类 说明 class
MBeanClientInterceptor
MethodInterceptor
that routes calls to an MBean running on the suppliedMBeanServerConnection
.class
MBeanProxyFactoryBean
Creates a proxy to a managed resource running either locally or remotely.org.springframework.jmx.export中Aware的使用
实现Aware的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中Aware的使用
实现Aware的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.jmx.export.assembler中Aware的使用
实现Aware的org.springframework.jmx.export.assembler中的类 修饰符和类型 类 说明 class
InterfaceBasedMBeanInfoAssembler
Subclass ofAbstractReflectiveMBeanInfoAssembler
that allows for the management interface of a bean to be defined using arbitrary interfaces.org.springframework.jmx.export.notification中Aware的使用
org.springframework.jmx.export.notification中Aware的子接口 修饰符和类型 接口 说明 interface
NotificationPublisherAware
Interface to be implemented by any Spring-managed resource that is to be registered with anMBeanServer
and wishes to send JMXjavax.management.Notifications
.org.springframework.jmx.support中Aware的使用
实现Aware的org.springframework.jmx.support中的类 修饰符和类型 类 说明 class
MBeanServerConnectionFactoryBean
FactoryBean
that creates a JMX 1.2MBeanServerConnection
to a remoteMBeanServer
exposed via aJMXServerConnector
.org.springframework.jndi中Aware的使用
实现Aware的org.springframework.jndi中的类 修饰符和类型 类 说明 class
JndiObjectFactoryBean
FactoryBean
that looks up a JNDI object.org.springframework.messaging.core中Aware的使用
实现Aware的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.reactive中Aware的使用
实现Aware的org.springframework.messaging.handler.annotation.reactive中的类 修饰符和类型 类 说明 class
MessageMappingMessageHandler
Extension ofAbstractMethodMessageHandler
for reactive, non-blocking handling of messages via@MessageMapping
methods.org.springframework.messaging.handler.annotation.support中Aware的使用
实现Aware的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.messaging.handler.invocation中Aware的使用
实现Aware的org.springframework.messaging.handler.invocation中的类 修饰符和类型 类 说明 class
AbstractMethodMessageHandler<T>
Abstract base class for HandlerMethod-based message handling.org.springframework.messaging.handler.invocation.reactive中Aware的使用
实现Aware的org.springframework.messaging.handler.invocation.reactive中的类 修饰符和类型 类 说明 class
AbstractMethodMessageHandler<T>
Abstract base class for reactive HandlerMethod-based message handling.org.springframework.messaging.rsocket.annotation.support中Aware的使用
实现Aware的org.springframework.messaging.rsocket.annotation.support中的类 修饰符和类型 类 说明 class
RSocketMessageHandler
Extension ofMessageMappingMessageHandler
for handling RSocket requests with@ConnectMapping
and@MessageMapping
methods.org.springframework.messaging.simp.annotation.support中Aware的使用
实现Aware的org.springframework.messaging.simp.annotation.support中的类 修饰符和类型 类 说明 class
SimpAnnotationMethodMessageHandler
A handler for messages delegating to@MessageMapping
and@SubscribeMapping
annotated methods.org.springframework.messaging.simp.broker中Aware的使用
实现Aware的org.springframework.messaging.simp.broker中的类 修饰符和类型 类 说明 class
AbstractBrokerMessageHandler
Abstract base class for aMessageHandler
that broker messages to registered subscribers.class
SimpleBrokerMessageHandler
A "simple" message broker that recognizes the message types defined inSimpMessageType
, keeps track of subscriptions with the help of aSubscriptionRegistry
and sends messages to subscribers.org.springframework.messaging.simp.config中Aware的使用
实现Aware的org.springframework.messaging.simp.config中的类 修饰符和类型 类 说明 class
AbstractMessageBrokerConfiguration
Provides essential configuration for handling messages with simple messaging protocols such as STOMP.org.springframework.messaging.simp.stomp中Aware的使用
实现Aware的org.springframework.messaging.simp.stomp中的类 修饰符和类型 类 说明 class
StompBrokerRelayMessageHandler
AMessageHandler
that handles messages by forwarding them to a STOMP broker.org.springframework.messaging.support中Aware的使用
实现Aware的org.springframework.messaging.support中的类 修饰符和类型 类 说明 class
AbstractMessageChannel
Abstract base class forMessageChannel
implementations.class
AbstractSubscribableChannel
Abstract base class forSubscribableChannel
implementations.class
ExecutorSubscribableChannel
ASubscribableChannel
that sends messages to each of its subscribers.org.springframework.orm.hibernate5中Aware的使用
实现Aware的org.springframework.orm.hibernate5中的类 修饰符和类型 类 说明 class
HibernateTransactionManager
PlatformTransactionManager
implementation for a single HibernateSessionFactory
.class
LocalSessionFactoryBean
FactoryBean
that creates a HibernateSessionFactory
.org.springframework.orm.hibernate5.support中Aware的使用
实现Aware的org.springframework.orm.hibernate5.support中的类 修饰符和类型 类 说明 class
OpenSessionInViewFilter
Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request.org.springframework.orm.jpa中Aware的使用
实现Aware的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.persistenceunit中Aware的使用
实现Aware的org.springframework.orm.jpa.persistenceunit中的类 修饰符和类型 类 说明 class
DefaultPersistenceUnitManager
Default implementation of thePersistenceUnitManager
interface.org.springframework.orm.jpa.support中Aware的使用
实现Aware的org.springframework.orm.jpa.support中的类 修饰符和类型 类 说明 class
OpenEntityManagerInViewFilter
Servlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.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中Aware的使用
实现Aware的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.oxm.jaxb中Aware的使用
实现Aware的org.springframework.oxm.jaxb中的类 修饰符和类型 类 说明 class
Jaxb2Marshaller
Implementation of theGenericMarshaller
interface for JAXB 2.2.org.springframework.oxm.xstream中Aware的使用
实现Aware的org.springframework.oxm.xstream中的类 修饰符和类型 类 说明 class
XStreamMarshaller
Implementation of theMarshaller
interface for XStream.org.springframework.remoting.caucho中Aware的使用
实现Aware的org.springframework.remoting.caucho中的类 修饰符和类型 类 说明 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
SimpleHessianServiceExporter
已过时。as of Spring Framework 5.1, in favor ofHessianServiceExporter
org.springframework.remoting.httpinvoker中Aware的使用
实现Aware的org.springframework.remoting.httpinvoker中的类 修饰符和类型 类 说明 class
AbstractHttpInvokerRequestExecutor
Abstract base implementation of the HttpInvokerRequestExecutor interface.class
HttpComponentsHttpInvokerRequestExecutor
HttpInvokerRequestExecutor
implementation that uses Apache HttpComponents 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 Java facilities to execute POST requests, without support for HTTP authentication or advanced configuration options.class
SimpleHttpInvokerServiceExporter
已过时。as of Spring Framework 5.1, in favor ofHttpInvokerServiceExporter
org.springframework.remoting.jaxws中Aware的使用
实现Aware的org.springframework.remoting.jaxws中的类 修饰符和类型 类 说明 class
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebService
annotation).class
JaxWsPortClientInterceptor
MethodInterceptor
for accessing a specific port of a JAX-WS service.class
JaxWsPortProxyFactoryBean
FactoryBean
for a specific port of a JAX-WS service.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.remoting.rmi中Aware的使用
实现Aware的org.springframework.remoting.rmi中的类 修饰符和类型 类 说明 class
JndiRmiProxyFactoryBean
FactoryBean
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 deserializeRemoteInvocation
objects and serializeRemoteInvocationResult
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.org.springframework.remoting.support中Aware的使用
实现Aware的org.springframework.remoting.support中的类 修饰符和类型 类 说明 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 ofRemoteInvocation
objects.class
RemoteInvocationBasedExporter
Abstract base class for remote service exporters that are based on deserialization ofRemoteInvocation
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.org.springframework.scheduling.annotation中Aware的使用
实现Aware的org.springframework.scheduling.annotation中的类 修饰符和类型 类 说明 class
AbstractAsyncConfiguration
Abstract baseConfiguration
class providing common structure for enabling Spring's asynchronous method execution capability.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
ProxyAsyncConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable proxy-based asynchronous method execution.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.aspectj中Aware的使用
实现Aware的org.springframework.scheduling.aspectj中的类 修饰符和类型 类 说明 class
AspectJAsyncConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based asynchronous method execution.org.springframework.scheduling.concurrent中Aware的使用
实现Aware的org.springframework.scheduling.concurrent中的类 修饰符和类型 类 说明 class
ExecutorConfigurationSupport
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
ScheduledExecutorFactoryBean
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorService
type.class
ThreadPoolTaskExecutor
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor
.class
ThreadPoolTaskScheduler
Implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
.org.springframework.scheduling.config中Aware的使用
实现Aware的org.springframework.scheduling.config中的类 修饰符和类型 类 说明 class
TaskExecutorFactoryBean
FactoryBean
for creatingThreadPoolTaskExecutor
instances, primarily used behind the XML task namespace.org.springframework.scheduling.quartz中Aware的使用
org.springframework.scheduling.quartz中Aware的子接口 修饰符和类型 接口 说明 interface
SchedulerContextAware
Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).实现Aware的org.springframework.scheduling.quartz中的类 修饰符和类型 类 说明 class
CronTriggerFactoryBean
A SpringFactoryBean
for creating a QuartzCronTrigger
instance, supporting bean-style usage for trigger configuration.class
JobDetailFactoryBean
A SpringFactoryBean
for creating a QuartzJobDetail
instance, supporting bean-style usage for JobDetail configuration.class
MethodInvokingJobDetailFactoryBean
FactoryBean
that exposes aJobDetail
object which delegates job execution to a specified (static or non-static) method.class
SchedulerAccessor
Common base class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on aScheduler
instance.class
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a givenScheduler
instance.class
SchedulerFactoryBean
FactoryBean
that creates and configures a QuartzScheduler
, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.class
SimpleTriggerFactoryBean
A SpringFactoryBean
for creating a QuartzSimpleTrigger
instance, supporting bean-style usage for trigger configuration.class
SpringBeanJobFactory
Subclass ofAdaptableJobFactory
that also supports Spring-style dependency injection on bean properties.org.springframework.scheduling.support中Aware的使用
实现Aware的org.springframework.scheduling.support中的类 修饰符和类型 类 说明 class
MethodInvokingRunnable
Adapter that implements theRunnable
interface as a configurable method invocation based on Spring's MethodInvoker.org.springframework.scripting.bsh中Aware的使用
实现Aware的org.springframework.scripting.bsh中的类 修饰符和类型 类 说明 class
BshScriptEvaluator
BeanShell-based implementation of Spring'sScriptEvaluator
strategy interface.class
BshScriptFactory
ScriptFactory
implementation for a BeanShell script.org.springframework.scripting.groovy中Aware的使用
实现Aware的org.springframework.scripting.groovy中的类 修饰符和类型 类 说明 class
GroovyScriptEvaluator
Groovy-based implementation of Spring'sScriptEvaluator
strategy interface.class
GroovyScriptFactory
ScriptFactory
implementation for a Groovy script.org.springframework.scripting.support中Aware的使用
实现Aware的org.springframework.scripting.support中的类 修饰符和类型 类 说明 class
ScriptFactoryPostProcessor
BeanPostProcessor
that handlesScriptFactory
definitions, replacing each factory with the actual scripted Java object generated by it.class
StandardScriptEvaluator
javax.script
(JSR-223) based implementation of Spring'sScriptEvaluator
strategy interface.class
StandardScriptFactory
ScriptFactory
implementation based on the JSR-223 script engine abstraction (as included in Java 6+).org.springframework.test.context.junit4中Aware的使用
实现Aware的org.springframework.test.context.junit4中的类 修饰符和类型 类 说明 class
AbstractJUnit4SpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicitApplicationContext
testing support in a JUnit 4 environment.class
AbstractTransactionalJUnit4SpringContextTests
Abstract transactional extension ofAbstractJUnit4SpringContextTests
which adds convenience functionality for JDBC access.org.springframework.test.context.testng中Aware的使用
实现Aware的org.springframework.test.context.testng中的类 修饰符和类型 类 说明 class
AbstractTestNGSpringContextTests
Abstract base test class which integrates the Spring TestContext Framework with explicitApplicationContext
testing support in a TestNG environment.class
AbstractTransactionalTestNGSpringContextTests
Abstract transactional extension ofAbstractTestNGSpringContextTests
which adds convenience functionality for JDBC access.org.springframework.transaction.annotation中Aware的使用
实现Aware的org.springframework.transaction.annotation中的类 修饰符和类型 类 说明 class
AbstractTransactionManagementConfiguration
Abstract base@Configuration
class providing common structure for enabling Spring's annotation-driven transaction management capability.class
ProxyTransactionManagementConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven transaction management.org.springframework.transaction.aspectj中Aware的使用
实现Aware的org.springframework.transaction.aspectj中的类 修饰符和类型 类 说明 class
AspectJJtaTransactionManagementConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for the JTA 1.2Transactional
annotation in addition to Spring's ownTransactional
annotation.class
AspectJTransactionManagementConfiguration
@Configuration
class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for Spring's ownTransactional
annotation.org.springframework.transaction.interceptor中Aware的使用
实现Aware的org.springframework.transaction.interceptor中的类 修饰符和类型 类 说明 class
BeanFactoryTransactionAttributeSourceAdvisor
Advisor driven by aTransactionAttributeSource
, used to include a transaction advice bean for methods that are transactional.class
MethodMapTransactionAttributeSource
SimpleTransactionAttributeSource
implementation that allows attributes to be stored per method in aMap
.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.ui.context.support中Aware的使用
实现Aware的org.springframework.ui.context.support中的类 修饰符和类型 类 说明 class
ResourceBundleThemeSource
ThemeSource
implementation that looks up an individualResourceBundle
per theme.org.springframework.ui.freemarker中Aware的使用
实现Aware的org.springframework.ui.freemarker中的类 修饰符和类型 类 说明 class
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker Configuration and provides it as bean reference.org.springframework.validation.beanvalidation中Aware的使用
实现Aware的org.springframework.validation.beanvalidation中的类 修饰符和类型 类 说明 class
LocalValidatorFactoryBean
This is the central class forjavax.validation
(JSR-303) setup in a Spring application context: It bootstraps ajavax.validation.ValidationFactory
and exposes it through the SpringValidator
interface as well as through the JSR-303Validator
interface and theValidatorFactory
interface itself.class
MethodValidationPostProcessor
A convenientBeanPostProcessor
implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.class
OptionalValidatorFactoryBean
LocalValidatorFactoryBean
subclass that simply turnsValidator
calls into no-ops in case of no Bean Validation provider being available.org.springframework.web.accept中Aware的使用
实现Aware的org.springframework.web.accept中的类 修饰符和类型 类 说明 class
ContentNegotiationManagerFactoryBean
Factory to create aContentNegotiationManager
and configure it withContentNegotiationStrategy
instances.org.springframework.web.context中Aware的使用
org.springframework.web.context中Aware的子接口 修饰符和类型 接口 说明 interface
ServletConfigAware
Interface to be implemented by any object that wishes to be notified of theServletConfig
(typically determined by theWebApplicationContext
) that it runs in.interface
ServletContextAware
Interface to be implemented by any object that wishes to be notified of theServletContext
(typically determined by theWebApplicationContext
) that it runs in.org.springframework.web.context.request.async中Aware的使用
实现Aware的org.springframework.web.context.request.async中的类 修饰符和类型 类 说明 class
WebAsyncTask<V>
Holder for aCallable
, a timeout value, and a task executor.org.springframework.web.context.support中Aware的使用
实现Aware的org.springframework.web.context.support中的类 修饰符和类型 类 说明 class
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
subclass which implements theConfigurableWebApplicationContext
interface for web environments.class
AnnotationConfigWebApplicationContext
WebApplicationContext
implementation which accepts component classes as input — in particular@Configuration
-annotated classes, but also plain@Component
classes and JSR-330 compliant classes usingjavax.inject
annotations.class
GroovyWebApplicationContext
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
ServletContextAttributeExporter
Exporter that takes Spring-defined objects and exposes them as ServletContext attributes.class
ServletContextAttributeFactoryBean
FactoryBean
that fetches a specific, existing ServletContext attribute.class
ServletContextLiveBeansView
LiveBeansView
subclass which looks for all ApplicationContexts in the web application, as exposed in ServletContext attributes.class
ServletContextParameterFactoryBean
FactoryBean
that retrieves a specific ServletContext init parameter (that is, a "context-param" defined inweb.xml
).class
WebApplicationObjectSupport
Convenient superclass for application objects running in aWebApplicationContext
.class
XmlWebApplicationContext
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
.org.springframework.web.filter中Aware的使用
实现Aware的org.springframework.web.filter中的类 修饰符和类型 类 说明 class
AbstractRequestLoggingFilter
Base class forFilter
s that perform logging operations before and after a request is processed.class
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.class
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.class
CorsFilter
Filter
that handles CORS preflight requests and intercepts CORS simple and actual requests thanks to aCorsProcessor
implementation (DefaultCorsProcessor
by default) in order to add the relevant CORS response headers (likeAccess-Control-Allow-Origin
) using the providedCorsConfigurationSource
(for example anUrlBasedCorsConfigurationSource
instance.class
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.class
FormContentFilter
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.class
ForwardedHeaderFilter
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods:getServerName()
getServerPort()
getScheme()
isSecure()
sendRedirect(String)
.class
GenericFilterBean
Simple base implementation ofFilter
which treats its config parameters (init-param
entries within thefilter
tag inweb.xml
) as bean properties.class
HiddenHttpMethodFilter
Filter
that converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod()
.class
HttpPutFormContentFilter
已过时。as of 5.1 in favor ofFormContentFilter
which is the same but also handles DELETE.class
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.class
RelativeRedirectFilter
OverridesHttpServletResponse.sendRedirect(String)
and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.class
RequestContextFilter
Servlet Filter that exposes the request to the current thread, through bothLocaleContextHolder
andRequestContextHolder
.class
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.class
ShallowEtagHeaderFilter
Filter
that generates anETag
value based on the content on the response.org.springframework.web.multipart.commons中Aware的使用
实现Aware的org.springframework.web.multipart.commons中的类 修饰符和类型 类 说明 class
CommonsMultipartResolver
Servlet-basedMultipartResolver
implementation for Apache Commons FileUpload 1.2 or above.org.springframework.web.multipart.support中Aware的使用
实现Aware的org.springframework.web.multipart.support中的类 修饰符和类型 类 说明 class
MultipartFilter
Servlet Filter that resolves multipart requests via aMultipartResolver
.org.springframework.web.reactive中Aware的使用
实现Aware的org.springframework.web.reactive中的类 修饰符和类型 类 说明 class
DispatcherHandler
Central dispatcher for HTTP request handlers/controllers.org.springframework.web.reactive.config中Aware的使用
实现Aware的org.springframework.web.reactive.config中的类 修饰符和类型 类 说明 class
DelegatingWebFluxConfiguration
A subclass ofWebFluxConfigurationSupport
that detects and delegates to all beans of typeWebFluxConfigurer
allowing them to customize the configuration provided byWebFluxConfigurationSupport
.class
WebFluxConfigurationSupport
The main class for Spring WebFlux configuration.org.springframework.web.reactive.function.server.support中Aware的使用
实现Aware的org.springframework.web.reactive.function.server.support中的类 修饰符和类型 类 说明 class
RouterFunctionMapping
HandlerMapping
implementation that supportsRouterFunctions
.org.springframework.web.reactive.handler中Aware的使用
实现Aware的org.springframework.web.reactive.handler中的类 修饰符和类型 类 说明 class
AbstractHandlerMapping
Abstract base class forHandlerMapping
implementations.class
AbstractUrlHandlerMapping
Abstract base class for URL-mappedHandlerMapping
implementations.class
SimpleUrlHandlerMapping
Implementation of theHandlerMapping
interface to map from URLs to request handler beans.org.springframework.web.reactive.result.method中Aware的使用
实现Aware的org.springframework.web.reactive.result.method中的类 修饰符和类型 类 说明 class
AbstractHandlerMethodMapping<T>
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
RequestMappingInfoHandlerMapping
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method.org.springframework.web.reactive.result.method.annotation中Aware的使用
实现Aware的org.springframework.web.reactive.result.method.annotation中的类 修饰符和类型 类 说明 class
RequestMappingHandlerAdapter
Supports the invocation of@RequestMapping
handler methods.class
RequestMappingHandlerMapping
An extension ofRequestMappingInfoHandlerMapping
that createsRequestMappingInfo
instances from class-level and method-level@RequestMapping
annotations.org.springframework.web.reactive.result.view中Aware的使用
实现Aware的org.springframework.web.reactive.result.view中的类 修饰符和类型 类 说明 class
AbstractUrlBasedView
Abstract base class for URL-based views.class
AbstractView
Base class forView
implementations.class
RedirectView
View that redirects to an absolute or context relative URL.class
UrlBasedViewResolver
AViewResolver
that allows direct resolution of symbolic view names to URLs without explicit mapping definitions.org.springframework.web.reactive.result.view.freemarker中Aware的使用
实现Aware的org.springframework.web.reactive.result.view.freemarker中的类 修饰符和类型 类 说明 class
FreeMarkerConfigurer
Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
FreeMarkerView
AView
implementation that uses the FreeMarker template engine.class
FreeMarkerViewResolver
AViewResolver
for resolvingFreeMarkerView
instances, i.e.org.springframework.web.reactive.result.view.script中Aware的使用
实现Aware的org.springframework.web.reactive.result.view.script中的类 修饰符和类型 类 说明 class
ScriptTemplateView
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
ScriptTemplateViewResolver
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
and custom subclasses of it.org.springframework.web.servlet中Aware的使用
实现Aware的org.springframework.web.servlet中的类 修饰符和类型 类 说明 class
DispatcherServlet
Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service exporters.class
FrameworkServlet
Base servlet for Spring's web framework.class
HttpServletBean
Simple extension ofHttpServlet
which treats its config parameters (init-param
entries within theservlet
tag inweb.xml
) as bean properties.org.springframework.web.servlet.config.annotation中Aware的使用
实现Aware的org.springframework.web.servlet.config.annotation中的类 修饰符和类型 类 说明 class
DelegatingWebMvcConfiguration
A subclass ofWebMvcConfigurationSupport
that detects and delegates to all beans of typeWebMvcConfigurer
allowing them to customize the configuration provided byWebMvcConfigurationSupport
.class
WebMvcConfigurationSupport
This is the main class providing the configuration behind the MVC Java config.org.springframework.web.servlet.function.support中Aware的使用
实现Aware的org.springframework.web.servlet.function.support中的类 修饰符和类型 类 说明 class
RouterFunctionMapping
HandlerMapping
implementation that supportsRouterFunctions
.org.springframework.web.servlet.handler中Aware的使用
实现Aware的org.springframework.web.servlet.handler中的类 修饰符和类型 类 说明 class
AbstractDetectingUrlHandlerMapping
Abstract implementation of theHandlerMapping
interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.class
AbstractHandlerMapping
Abstract base class forHandlerMapping
implementations.class
AbstractHandlerMethodMapping<T>
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
AbstractUrlHandlerMapping
Abstract base class for URL-mappedHandlerMapping
implementations.class
BeanNameUrlHandlerMapping
Implementation of theHandlerMapping
interface that maps from URLs to beans with names that start with a slash ("/"), similar to how Struts maps URLs to action names.class
HandlerMappingIntrospector
Helper class to get information from theHandlerMapping
that would serve a specific request.class
SimpleServletPostProcessor
BeanPostProcessor
that applies initialization and destruction callbacks to beans that implement theServlet
interface.class
SimpleUrlHandlerMapping
Implementation of theHandlerMapping
interface that maps from URLs to request handler beans.org.springframework.web.servlet.mvc中Aware的使用
实现Aware的org.springframework.web.servlet.mvc中的类 修饰符和类型 类 说明 class
AbstractController
Convenient superclass for controller implementations, using the Template Method design pattern.class
AbstractUrlViewController
Abstract base class forControllers
that return a view name based on the request URL.class
ParameterizableViewController
Trivial controller that always returns a pre-configured view and optionally sets the response status code.class
ServletForwardingController
Spring Controller implementation that forwards to a named servlet, i.e. the "servlet-name" in web.xml rather than a URL path mapping.class
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages internally.class
UrlFilenameViewController
SimpleController
implementation that transforms the virtual path of a URL into a view name and returns that view.class
WebContentInterceptor
Handler interceptor that checks the request and prepares the response.org.springframework.web.servlet.mvc.annotation中Aware的使用
实现Aware的org.springframework.web.servlet.mvc.annotation中的类 修饰符和类型 类 说明 class
ResponseStatusExceptionResolver
AHandlerExceptionResolver
that uses the@ResponseStatus
annotation to map exceptions to HTTP status codes.org.springframework.web.servlet.mvc.method中Aware的使用
实现Aware的org.springframework.web.servlet.mvc.method中的类 修饰符和类型 类 说明 class
AbstractHandlerMethodAdapter
Abstract base class forHandlerAdapter
implementations that support handlers of typeHandlerMethod
.class
RequestMappingInfoHandlerMapping
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method.org.springframework.web.servlet.mvc.method.annotation中Aware的使用
实现Aware的org.springframework.web.servlet.mvc.method.annotation中的类 修饰符和类型 类 说明 class
ExceptionHandlerExceptionResolver
AnAbstractHandlerMethodExceptionResolver
that resolves exceptions through@ExceptionHandler
methods.class
RequestMappingHandlerAdapter
class
RequestMappingHandlerMapping
CreatesRequestMappingInfo
instances from type and method-level@RequestMapping
annotations in@Controller
classes.org.springframework.web.servlet.resource中Aware的使用
实现Aware的org.springframework.web.servlet.resource中的类 修饰符和类型 类 说明 class
DefaultServletHttpRequestHandler
AnHttpRequestHandler
for serving static files using the Servlet container's "default" Servlet.class
ResourceHttpRequestHandler
HttpRequestHandler
that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.class
ResourceUrlEncodingFilter
A filter that wraps theHttpServletResponse
and overrides itsencodeURL
method in order to translate internal resource request URLs into public URL paths for external use.org.springframework.web.servlet.support中Aware的使用
实现Aware的org.springframework.web.servlet.support中的类 修饰符和类型 类 说明 class
WebContentGenerator
Convenient superclass for any kind of web content generator, likeAbstractController
andWebContentInterceptor
.org.springframework.web.servlet.view中Aware的使用
实现Aware的org.springframework.web.servlet.view中的类 修饰符和类型 类 说明 class
AbstractCachingViewResolver
Convenient base class forViewResolver
implementations.class
AbstractTemplateView
Adapter base class for template-based view technologies such as FreeMarker, with the ability to use request and session attributes in their model and the option to expose helper objects for Spring's FreeMarker macro library.class
AbstractTemplateViewResolver
Abstract base class for template view resolvers, in particular for FreeMarker views.class
AbstractUrlBasedView
Abstract base class for URL-based views.class
AbstractView
Abstract base class forView
implementations.class
BeanNameViewResolver
A simple implementation ofViewResolver
that interprets a view name as a bean name in the current application context, i.e. typically in the XML file of the executingDispatcherServlet
.class
ContentNegotiatingViewResolver
Implementation ofViewResolver
that resolves a view based on the request file name orAccept
header.class
InternalResourceView
Wrapper for a JSP or other resource within the same web application.class
InternalResourceViewResolver
Convenient subclass ofUrlBasedViewResolver
that supportsInternalResourceView
(i.e.class
JstlView
Specialization ofInternalResourceView
for JSTL pages, i.e.class
RedirectView
View that redirects to an absolute, context relative, or current request relative URL.class
ResourceBundleViewResolver
AViewResolver
implementation that uses bean definitions in aResourceBundle
, specified by the bundle basename.class
UrlBasedViewResolver
Simple implementation of theViewResolver
interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.class
ViewResolverComposite
AViewResolver
that delegates to others.class
XmlViewResolver
AViewResolver
implementation that uses bean definitions in a dedicated XML file for view definitions, specified by resource location.org.springframework.web.servlet.view.document中Aware的使用
实现Aware的org.springframework.web.servlet.view.document中的类 修饰符和类型 类 说明 class
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing document with an AcroForm.class
AbstractPdfView
Abstract superclass for PDF views.class
AbstractXlsView
Convenient superclass for Excel document views in traditional XLS format.class
AbstractXlsxStreamingView
Convenient superclass for Excel document views in the Office 2007 XLSX format, using POI's streaming variant.class
AbstractXlsxView
Convenient superclass for Excel document views in the Office 2007 XLSX format (as supported by POI-OOXML).org.springframework.web.servlet.view.feed中Aware的使用
实现Aware的org.springframework.web.servlet.view.feed中的类 修饰符和类型 类 说明 class
AbstractAtomFeedView
Abstract superclass for Atom Feed views, using the ROME package.class
AbstractFeedView<T extends com.rometools.rome.feed.WireFeed>
Abstract base class for Atom and RSS Feed views, using the ROME package.class
AbstractRssFeedView
Abstract superclass for RSS Feed views, using the ROME package.org.springframework.web.servlet.view.freemarker中Aware的使用
实现Aware的org.springframework.web.servlet.view.freemarker中的类 修饰符和类型 类 说明 class
FreeMarkerConfigurer
JavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
FreeMarkerView
View using the FreeMarker template engine.class
FreeMarkerViewResolver
Convenience subclass ofUrlBasedViewResolver
that supportsFreeMarkerView
(i.e.org.springframework.web.servlet.view.groovy中Aware的使用
实现Aware的org.springframework.web.servlet.view.groovy中的类 修饰符和类型 类 说明 class
GroovyMarkupConfigurer
An extension of Groovy'sTemplateConfiguration
and an implementation of Spring MVC'sGroovyMarkupConfig
for creating aMarkupTemplateEngine
for use in a web application.class
GroovyMarkupView
AnAbstractTemplateView
subclass based on Groovy XML/XHTML markup templates.class
GroovyMarkupViewResolver
Convenience subclass of @link AbstractTemplateViewResolver} that supportsGroovyMarkupView
(i.e.org.springframework.web.servlet.view.json中Aware的使用
实现Aware的org.springframework.web.servlet.view.json中的类 修饰符和类型 类 说明 class
AbstractJackson2View
Abstract base class for Jackson based and content type independentAbstractView
implementations.class
MappingJackson2JsonView
Spring MVCView
that renders JSON content by serializing the model for the current request using Jackson 2'sObjectMapper
.org.springframework.web.servlet.view.script中Aware的使用
实现Aware的org.springframework.web.servlet.view.script中的类 修饰符和类型 类 说明 class
ScriptTemplateView
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
ScriptTemplateViewResolver
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
and custom subclasses of it.org.springframework.web.servlet.view.tiles3中Aware的使用
实现Aware的org.springframework.web.servlet.view.tiles3中的类 修饰符和类型 类 说明 class
TilesConfigurer
Helper class to configure Tiles 3.x for the Spring Framework.class
TilesView
View
implementation that renders through the Tiles Request API.class
TilesViewResolver
Convenience subclass ofUrlBasedViewResolver
that supportsTilesView
(i.e.org.springframework.web.servlet.view.xml中Aware的使用
实现Aware的org.springframework.web.servlet.view.xml中的类 修饰符和类型 类 说明 class
MappingJackson2XmlView
Spring MVCView
that renders XML content by serializing the model for the current request using Jackson 2'sXmlMapper
.class
MarshallingView
Spring-MVCView
that allows for response context to be rendered as the result of marshalling by aMarshaller
.org.springframework.web.servlet.view.xslt中Aware的使用
实现Aware的org.springframework.web.servlet.view.xslt中的类 修饰符和类型 类 说明 class
XsltView
XSLT-driven View that allows for response context to be rendered as the result of an XSLT transformation.class
XsltViewResolver
ViewResolver
implementation that resolves instances ofXsltView
by translating the supplied view name into the URL of the XSLT stylesheet.org.springframework.web.socket.client.standard中Aware的使用
实现Aware的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.config.annotation中Aware的使用
实现Aware的org.springframework.web.socket.config.annotation中的类 修饰符和类型 类 说明 class
DelegatingWebSocketMessageBrokerConfiguration
AWebSocketMessageBrokerConfigurationSupport
extension that detects beans of typeWebSocketMessageBrokerConfigurer
and delegates to all of them allowing callback style customization of the configuration provided inWebSocketMessageBrokerConfigurationSupport
.class
WebSocketMessageBrokerConfigurationSupport
ExtendsAbstractMessageBrokerConfiguration
and adds configuration for receiving and responding to STOMP messages from WebSocket clients.org.springframework.web.socket.handler中Aware的使用
实现Aware的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.messaging中Aware的使用
实现Aware的org.springframework.web.socket.messaging中的类 修饰符和类型 类 说明 class
StompSubProtocolHandler
ASubProtocolHandler
for STOMP that supports versions 1.0, 1.1, and 1.2 of the STOMP specification.class
WebSocketAnnotationMethodMessageHandler
A sub-class ofSimpAnnotationMethodMessageHandler
to provide support forControllerAdvice
with global@MessageExceptionHandler
methods.org.springframework.web.socket.server.jetty中Aware的使用
实现Aware的org.springframework.web.socket.server.jetty中的类 修饰符和类型 类 说明 class
JettyRequestUpgradeStrategy
ARequestUpgradeStrategy
for use with Jetty 9.4.org.springframework.web.socket.server.standard中Aware的使用
实现Aware的org.springframework.web.socket.server.standard中的类 修饰符和类型 类 说明 class
ServerEndpointExporter
Detects beans of typeServerEndpointConfig
and registers with the standard Java WebSocket runtime.class
ServerEndpointRegistration
An implementation ofServerEndpointConfig
for use in Spring-based applications.class
ServletServerContainerFactoryBean
AFactoryBean
for configuringServerContainer
.org.springframework.web.socket.server.support中Aware的使用
实现Aware的org.springframework.web.socket.server.support中的类 修饰符和类型 类 说明 class
DefaultHandshakeHandler
A defaultHandshakeHandler
implementation, extendingAbstractHandshakeHandler
with Servlet-specific initialization support.class
WebSocketHandlerMapping
An extension ofSimpleUrlHandlerMapping
that is also aSmartLifecycle
container and propagates start and stop calls to any handlers that implementLifecycle
.class
WebSocketHttpRequestHandler
AHttpRequestHandler
for processing WebSocket handshake requests.org.springframework.web.socket.sockjs.support中Aware的使用
实现Aware的org.springframework.web.socket.sockjs.support中的类 修饰符和类型 类 说明 class
SockJsHttpRequestHandler
AnHttpRequestHandler
that allows mapping aSockJsService
to requests in a Servlet container.org.springframework.web.socket.sockjs.transport.handler中Aware的使用
实现Aware的org.springframework.web.socket.sockjs.transport.handler中的类 修饰符和类型 类 说明 class
DefaultSockJsService
A default implementation ofSockJsService
with all defaultTransportHandler
implementations pre-registered.class
WebSocketTransportHandler
WebSocket-basedTransportHandler
.