接口 org.springframework.beans.factory.Aware的使用 (Spring Framework 5.2.12.RELEASE API)

使用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 the `org.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 for `java.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's `LoadTimeWeaver` abstraction.
org.springframework.dao.annotation	Annotation support for DAOs.
org.springframework.dao.support	Support classes for DAO implementations, providing miscellaneous utility methods.
org.springframework.ejb.access	This package contains classes that allow easy access to EJBs.
org.springframework.format.datetime	Formatters for `java.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-310 `java.time` package in JDK 8.
org.springframework.format.number	Formatters for `java.lang.Number` properties.
org.springframework.format.number.money	Integration with the JSR-354 `javax.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 remote `MBeanServer`s and for exposing an `MBeanServer` to remote clients.
org.springframework.jndi	The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.
org.springframework.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 of `Message` along with a MessageBuilder and MessageHeaderAccessor for building and working with messages and message headers, as well as various `MessageChannel` 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 the `org.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 the `org.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 the `java.util.concurrent` and `javax.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 the `org.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 the `spring-webflux` module that contains `DispatcherHandler`, 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 the `org.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 the `org.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 the `org.springframework.web.method` package.
org.springframework.web.servlet.mvc.method.annotation	MVC infrastructure for annotation-based handler method processing, building on the `org.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	Convenient `WebSocketHandler` 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 an `AbstractSockJsService` implementation.
org.springframework.web.socket.sockjs.transport.handler	`TransportHandler` implementation classes as well as a concrete `SockJsService`.

org.springframework.aop.aspectj中Aware的使用

实现Aware的org.springframework.aop.aspectj中的类
修饰符和类型	类	说明
`class`	`AspectJExpressionPointcut`	Spring `Pointcut` 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 a `Method` on a specified bean.
`class`	`SimpleBeanFactoryAwareAspectInstanceFactory`	Implementation of `AspectInstanceFactory` that locates the aspect from the `BeanFactory` using a configured bean name.

org.springframework.aop.framework中Aware的使用

实现Aware的org.springframework.aop.framework中的类
修饰符和类型	类	说明
`class`	`AbstractAdvisingBeanPostProcessor`	Base class for `BeanPostProcessor` implementations that apply a Spring AOP `Advisor` to specific beans.
`class`	`AbstractSingletonProxyFactoryBean`	Convenient superclass for `FactoryBean` types that produce singleton-scoped proxy objects.
`class`	`ProxyFactoryBean`	`FactoryBean` implementation that builds an AOP proxy based on beans in Spring `BeanFactory`.
`class`	`ProxyProcessorSupport`	Base class with common functionality for proxy processors, in particular ClassLoader management and the `ProxyProcessorSupport.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 of `AbstractAutoProxyCreator` which implements `BeanFactoryAware`, 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 candidate `Advisor`s in the current `BeanFactory`.
`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 for `TargetSourceCreator` implementations that require creating multiple instances of a prototype bean.
`class`	`LazyInitTargetSourceCreator`	TargetSourceCreator that enforces a LazyInitTargetSource for each bean that is defined as "lazy-init".
`class`	`QuickTargetSourceCreator`	Convenient TargetSourceCreator using bean name prefixes to create one of three well-known TargetSource types: : CommonsPool2TargetSource % ThreadLocalTargetSource !

org.springframework.aop.interceptor中Aware的使用

实现Aware的org.springframework.aop.interceptor中的类
修饰符和类型	类	说明
`class`	`AsyncExecutionAspectSupport`	Base class for asynchronous method execution aspects, such as `org.springframework.scheduling.annotation.AnnotationAsyncExecutionInterceptor` or `org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect`.
`class`	`AsyncExecutionInterceptor`	AOP Alliance `MethodInterceptor` that processes method invocations asynchronously, using a given `AsyncTaskExecutor`.

org.springframework.aop.scope中Aware的使用
实现Aware的org.springframework.aop.scope中的类
修饰符和类型类说明
class ScopedProxyFactoryBean
Convenient proxy factory bean for scoped objects.

实现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 for `TargetSource` implementations that are based on a Spring `BeanFactory`, delegating to Spring-managed bean instances.
`class`	`AbstractPoolingTargetSource`	Abstract base class for pooling `TargetSource` implementations which maintain a pool of target instances, acquiring and releasing a target object from the pool for each method invocation.
`class`	`AbstractPrototypeBasedTargetSource`	Base class for dynamic `TargetSource` 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 a `BeanFactory`.
`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`	Simple `TargetSource` implementation, freshly obtaining the specified target bean from its containing Spring `BeanFactory`.
`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 bean `class 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 owning `BeanFactory`.
`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`	A `BeanFactoryPostProcessor` implementation that allows for convenient registration of custom autowire qualifier types.
`class`	`QualifierAnnotationAutowireCandidateResolver`	`AutowireCandidateResolver` implementation that matches bean definition qualifiers against `qualifier 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 custom `InitializingBean` implementation)

org.springframework.beans.factory.config中Aware的使用

实现Aware的org.springframework.beans.factory.config中的类
修饰符和类型	类	说明
`class`	`AbstractFactoryBean<T>`	Simple template superclass for `FactoryBean` implementations that creates a singleton or a prototype object, depending on a flag.
`class`	`CustomScopeConfigurer`	Simple `BeanFactoryPostProcessor` implementation that registers custom `Scope(s)` with the containing `ConfigurableBeanFactory`.
`class`	`FieldRetrievingFactoryBean`	`FactoryBean` which retrieves a static or non-static field value.
`class`	`ListFactoryBean`	Simple factory for shared List instances.
`class`	`MapFactoryBean`	Simple factory for shared Map instances.
`class`	`MethodInvokingBean`	Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast to `MethodInvokingFactoryBean`).
`class`	`MethodInvokingFactoryBean`	`FactoryBean` which returns a value which is the result of a static or instance method invocation.
`class`	`ObjectFactoryCreatingFactoryBean`	A `FactoryBean` implementation that returns a value which is an `ObjectFactory` that in turn returns a bean sourced from a `BeanFactory`.
`class`	`PlaceholderConfigurerSupport`	Abstract base class for property resource configurers that resolve placeholders in bean definition property values.
`class`	`PreferencesPlaceholderConfigurer`	已过时。 as of 5.2, along with `PropertyPlaceholderConfigurer`
`class`	`PropertyPathFactoryBean`	`FactoryBean` that evaluates a property path on a given target object.
`class`	`PropertyPlaceholderConfigurer`	已过时。 as of 5.2; use `org.springframework.context.support.PropertySourcesPlaceholderConfigurer` instead which is more flexible through taking advantage of the `Environment` and `PropertySource` mechanisms.
`class`	`ProviderCreatingFactoryBean`	A `FactoryBean` implementation that returns a value which is a JSR-330 `Provider` that in turn returns a bean sourced from a `BeanFactory`.
`class`	`ServiceLocatorFactoryBean`	A `FactoryBean` implementation that takes an interface which must have one or more methods with the signatures `MyType xxx()` or `MyType xxx(MyIdType id)` (typically, `MyService getService()` or `MyService getService(String id)`) and creates a dynamic proxy which implements that interface, delegating to an underlying `BeanFactory`.
`class`	`SetFactoryBean`	Simple factory for shared Set instances.

org.springframework.beans.factory.serviceloader中Aware的使用

实现Aware的org.springframework.beans.factory.serviceloader中的类
修饰符和类型	类	说明
`class`	`AbstractServiceLoaderBasedFactoryBean`	Abstract base class for FactoryBeans operating on the JDK 1.6 `ServiceLoader` facility.
`class`	`ServiceFactoryBean`	`FactoryBean` that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6 `ServiceLoader` facility.
`class`	`ServiceListFactoryBean`	`FactoryBean` that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6 `ServiceLoader` facility.
`class`	`ServiceLoaderFactoryBean`	`FactoryBean` that exposes the JDK 1.6 `ServiceLoader` for the configured service class.

org.springframework.beans.factory.support中Aware的使用

实现Aware的org.springframework.beans.factory.support中的类
修饰符和类型	类	说明
`class`	`GenericTypeAwareAutowireCandidateResolver`	Basic `AutowireCandidateResolver` 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 a `ConcurrentMapCache` when used within a Spring container.
`class`	`ConcurrentMapCacheManager`	`CacheManager` implementation that lazily builds `ConcurrentMapCache` instances for each `ConcurrentMapCacheManager.getCache(java.lang.String)` request.

org.springframework.cache.ehcache中Aware的使用

实现Aware的org.springframework.cache.ehcache中的类
修饰符和类型	类	说明
`class`	`EhCacheFactoryBean`	`FactoryBean` that creates a named EhCache `Cache` instance (or a decorator that implements the `Ehcache` interface), representing a cache region within an EhCache `CacheManager`.

org.springframework.cache.interceptor中Aware的使用

实现Aware的org.springframework.cache.interceptor中的类
修饰符和类型	类	说明
`class`	`BeanFactoryCacheOperationSourceAdvisor`	Advisor driven by a `CacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
`class`	`CacheAspectSupport`	Base class for caching aspects, such as the `CacheInterceptor` 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 JCache `javax.cache.CacheManager`, obtaining a pre-defined `CacheManager` by name through the standard JCache `javax.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 a `JCacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
`class`	`DefaultJCacheOperationSource`	The default `JCacheOperationSource` 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 the `ApplicationContext` 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 a `StringValueResolver` for the resolution of embedded definition values.
`interface`	`EnvironmentAware`	Interface to be implemented by any bean that wishes to be notified of the `Environment` 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 the `ResourceLoader` (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 the `AnnotationMetadata` 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` or `ApplicationContext`).
`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 the `javax.annotation` package.
`class`	`ConfigurationClassPostProcessor`	`BeanFactoryPostProcessor` used for bootstrapping processing of `@Configuration` classes.
`class`	`ContextAnnotationAutowireCandidateResolver`	Complete implementation of the `AutowireCandidateResolver` strategy interface, providing support for qualifier annotations as well as for lazy resolution driven by the `Lazy` annotation in the `context.annotation` package.
`class`	`LoadTimeWeavingConfiguration`	`@Configuration` class that registers a `LoadTimeWeaver` bean.
`class`	`MBeanExportConfiguration`	`@Configuration` class that registers a `AnnotationMBeanExporter` bean.

org.springframework.context.event中Aware的使用

实现Aware的org.springframework.context.event中的类
修饰符和类型	类	说明
`class`	`AbstractApplicationEventMulticaster`	Abstract implementation of the `ApplicationEventMulticaster` interface, providing the basic listener registration facility.
`class`	`EventListenerMethodProcessor`	Registers `EventListener` methods as individual `ApplicationListener` instances.
`class`	`EventPublicationInterceptor`	`Interceptor` that publishes an `ApplicationEvent` to all `ApplicationListeners` registered with an `ApplicationEventPublisher` after each successful method invocation.
`class`	`SimpleApplicationEventMulticaster`	Simple implementation of the `ApplicationEventMulticaster` 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 for `ApplicationContext` implementations, drawing configuration from XML documents containing bean definitions understood by an `XmlBeanDefinitionReader`.
`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 the `LifecycleProcessor` 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 local `ApplicationContext` (with a local `LiveBeansView` bean definition) or all registered ApplicationContexts (driven by the "spring.liveBeansView.mbeanDomain" environment property).
`class`	`PropertySourcesPlaceholderConfigurer`	Specialization of `PlaceholderConfigurerSupport` that resolves ${...} placeholders within bean definition property values and `@Value` annotations against the current Spring `Environment` and its set of `PropertySources`.
`class`	`ReloadableResourceBundleMessageSource`	Spring-specific `MessageSource` implementation that accesses resource bundles using specified basenames, participating in the Spring `ApplicationContext`'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 default `LoadTimeWeaver`.

实现Aware的org.springframework.context.weaving中的类
修饰符和类型	类	说明
`class`	`AspectJWeavingEnabler`	Post-processor that registers AspectJ's `ClassPreProcessorAgentAdapter` with the Spring application context's default `LoadTimeWeaver`.
`class`	`DefaultContextLoadTimeWeaver`	Default `LoadTimeWeaver` bean for use in an application context, decorating an automatically detected internal `LoadTimeWeaver`.
`class`	`LoadTimeWeaverAwareProcessor`	`BeanPostProcessor` implementation that passes the context's default `LoadTimeWeaver` to beans that implement the `LoadTimeWeaverAware` 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 corresponding `PersistenceExceptionTranslationAdvisor` 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`	Convenient `FactoryBean` for local Stateless Session Bean (SLSB) proxies.
`class`	`SimpleRemoteStatelessSessionProxyFactoryBean`	Convenient `FactoryBean` for remote SLSB proxies.

org.springframework.format.datetime中Aware的使用

实现Aware的org.springframework.format.datetime中的类
修饰符和类型	类	说明
`class`	`DateTimeFormatAnnotationFormatterFactory`	Formats fields annotated with the `DateTimeFormat` annotation using a `DateFormatter`.

org.springframework.format.datetime.joda中Aware的使用

实现Aware的org.springframework.format.datetime.joda中的类
修饰符和类型	类	说明
`class`	`JodaDateTimeFormatAnnotationFormatterFactory`	Formats fields annotated with the `DateTimeFormat` annotation using Joda-Time.

org.springframework.format.datetime.standard中Aware的使用

实现Aware的org.springframework.format.datetime.standard中的类
修饰符和类型	类	说明
`class`	`Jsr310DateTimeFormatAnnotationFormatterFactory`	Formats fields annotated with the `DateTimeFormat` annotation using the JSR-310 `java.time` package in JDK 8.

org.springframework.format.number中Aware的使用
实现Aware的org.springframework.format.number中的类
修饰符和类型类说明
class NumberFormatAnnotationFormatterFactory
Formats fields annotated with the NumberFormat annotation.

实现Aware的org.springframework.format.number中的类
修饰符和类型	类	说明
`class`	`NumberFormatAnnotationFormatterFactory`	Formats fields annotated with the `NumberFormat` annotation.

org.springframework.format.number.money中Aware的使用

实现Aware的org.springframework.format.number.money中的类
修饰符和类型	类	说明
`class`	`Jsr354NumberFormatAnnotationFormatterFactory`	Formats `MonetaryAmount` fields annotated with Spring's common `NumberFormat` annotation.

org.springframework.format.support中Aware的使用

实现Aware的org.springframework.format.support中的类
修饰符和类型	类	说明
`class`	`DefaultFormattingConversionService`	A specialization of `FormattingConversionService` configured by default with converters and formatters appropriate for most applications.
`class`	`FormattingConversionService`	A `ConversionService` implementation designed to be configured as a `FormatterRegistry`.
`class`	`FormattingConversionServiceFactoryBean`	A factory providing convenient access to a `FormattingConversionService` 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`	A `FactoryBean` for creating a Jackson 2.x `ObjectMapper` (default) or `XmlMapper` (`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 the `ResourceAdapterApplicationContext`) that it runs in.

org.springframework.jca.endpoint中Aware的使用

实现Aware的org.springframework.jca.endpoint中的类
修饰符和类型	类	说明
`class`	`AbstractMessageEndpointFactory`	Abstract base implementation of the JCA 1.7 `MessageEndpointFactory` interface, providing transaction management capabilities as well as ClassLoader exposure for endpoint invocations.
`class`	`GenericMessageEndpointFactory`	Generic implementation of the JCA 1.7 `MessageEndpointFactory` 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 the `WorkManager` 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 of `Resource` instances.

org.springframework.jdbc.datasource.lookup中Aware的使用
实现Aware的org.springframework.jdbc.datasource.lookup中的类
修饰符和类型类说明
class BeanFactoryDataSourceLookup
DataSourceLookup implementation based on a Spring BeanFactory.

实现Aware的org.springframework.jdbc.datasource.lookup中的类
修饰符和类型	类	说明
`class`	`BeanFactoryDataSourceLookup`	`DataSourceLookup` implementation based on a Spring `BeanFactory`.

org.springframework.jms.annotation中Aware的使用

实现Aware的org.springframework.jms.annotation中的类
修饰符和类型	类	说明
`class`	`JmsListenerAnnotationBeanPostProcessor`	Bean post-processor that registers methods annotated with `JmsListener` to be invoked by a JMS message listener container created under the cover by a `JmsListenerContainerFactory` according to the attributes of the annotation.

org.springframework.jms.config中Aware的使用

实现Aware的org.springframework.jms.config中的类
修饰符和类型	类	说明
`class`	`JmsListenerEndpointRegistrar`	Helper bean for registering `JmsListenerEndpoint` with a `JmsListenerEndpointRegistry`.
`class`	`JmsListenerEndpointRegistry`	Creates the necessary `MessageListenerContainer` instances for the registered endpoints.
`class`	`MethodJmsListenerEndpoint`	A `JmsListenerEndpoint` 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 of `MessageConsumer.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's `MessageConsumer.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.7 `MessageEndpointFactory` interface, providing transaction management capabilities for a JMS listener object (e.g. a `MessageListener` object).
`class`	`JmsMessageEndpointManager`	Extension of the generic JCA 1.5 `GenericMessageEndpointManager`, 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 Spring BeanFactory.

org.springframework.jmx.access中Aware的使用

实现Aware的org.springframework.jmx.access中的类
修饰符和类型	类	说明
`class`	`MBeanClientInterceptor`	`MethodInterceptor` that routes calls to an MBean running on the supplied `MBeanServerConnection`.
`class`	`MBeanProxyFactoryBean`	Creates a proxy to a managed resource running either locally or remotely.

org.springframework.jmx.export中Aware的使用

实现Aware的org.springframework.jmx.export中的类
修饰符和类型	类	说明
`class`	`MBeanExporter`	JMX exporter that allows for exposing any Spring-managed bean to a JMX `MBeanServer`, without the need to define any JMX-specific information in the bean classes.

org.springframework.jmx.export.annotation中Aware的使用

实现Aware的org.springframework.jmx.export.annotation中的类
修饰符和类型	类	说明
`class`	`AnnotationJmxAttributeSource`	Implementation of the `JmxAttributeSource` interface that reads annotations and exposes the corresponding attributes.
`class`	`AnnotationMBeanExporter`	Convenient subclass of Spring's standard `MBeanExporter`, 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 of `AbstractReflectiveMBeanInfoAssembler` 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 an `MBeanServer` and wishes to send JMX `javax.management.Notifications`.

org.springframework.jmx.support中Aware的使用

实现Aware的org.springframework.jmx.support中的类
修饰符和类型	类	说明
`class`	`MBeanServerConnectionFactoryBean`	`FactoryBean` that creates a JMX 1.2 `MBeanServerConnection` to a remote `MBeanServer` exposed via a `JMXServerConnector`.

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 of `DestinationResolver` that interprets a destination name as the bean name of a `MessageChannel` and looks up the bean in the configured `BeanFactory`.
`class`	`GenericMessagingTemplate`	A messaging template that resolves destinations names to `MessageChannel`'s to send and receive messages from.

org.springframework.messaging.handler.annotation.reactive中Aware的使用

实现Aware的org.springframework.messaging.handler.annotation.reactive中的类
修饰符和类型	类	说明
`class`	`MessageMappingMessageHandler`	Extension of `AbstractMethodMessageHandler` 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 default `MessageHandlerMethodFactory` implementation creating an `InvocableHandlerMethod` with the necessary `HandlerMethodArgumentResolver` instances to detect and process most of the use cases defined by `MessageMapping`.

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 of `MessageMappingMessageHandler` 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 a `MessageHandler` that broker messages to registered subscribers.
`class`	`SimpleBrokerMessageHandler`	A "simple" message broker that recognizes the message types defined in `SimpMessageType`, keeps track of subscriptions with the help of a `SubscriptionRegistry` 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`	A `MessageHandler` 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 for `MessageChannel` implementations.
`class`	`AbstractSubscribableChannel`	Abstract base class for `SubscribableChannel` implementations.
`class`	`ExecutorSubscribableChannel`	A `SubscribableChannel` 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 Hibernate `SessionFactory`.
`class`	`LocalSessionFactoryBean`	`FactoryBean` that creates a Hibernate `SessionFactory`.

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`	Abstract `FactoryBean` that creates a local JPA `EntityManagerFactory` instance within a Spring application context.
`class`	`EntityManagerFactoryAccessor`	Base class for any class that needs to access a JPA `EntityManagerFactory`, usually in order to obtain a JPA `EntityManager`.
`class`	`JpaTransactionManager`	`PlatformTransactionManager` implementation for a single JPA `EntityManagerFactory`.
`class`	`LocalContainerEntityManagerFactoryBean`	`FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard container bootstrap contract.
`class`	`LocalEntityManagerFactoryBean`	`FactoryBean` that creates a JPA `EntityManagerFactory` according to JPA's standard standalone bootstrap contract.

org.springframework.orm.jpa.persistenceunit中Aware的使用
实现Aware的org.springframework.orm.jpa.persistenceunit中的类
修饰符和类型类说明
class DefaultPersistenceUnitManager
Default implementation of the PersistenceUnitManager 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 processes `PersistenceUnit` and `PersistenceContext` annotations, for injection of the corresponding JPA resources `EntityManagerFactory` and `EntityManager`.
`class`	`SharedEntityManagerBean`	`FactoryBean` that exposes a shared JPA `EntityManager` 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 on `EntityManagerFactory.unwrap(java.lang.Class<T>)` with explicit qualifiers and/or primary markers

org.springframework.oxm.jaxb中Aware的使用
实现Aware的org.springframework.oxm.jaxb中的类
修饰符和类型类说明
class Jaxb2Marshaller
Implementation of the GenericMarshaller interface for JAXB 2.2.
org.springframework.oxm.xstream中Aware的使用
实现Aware的org.springframework.oxm.xstream中的类
修饰符和类型类说明
class XStreamMarshaller
Implementation of the Marshaller 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 of `HessianServiceExporter`

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 of `HttpInvokerServiceExporter`

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-WS `WebService` 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 of `SimpleJaxWsServiceExporter`
`class`	`SimpleJaxWsServiceExporter`	Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WS `WebService` annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.

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 deserialize `RemoteInvocation` objects and serialize `RemoteInvocationResult` objects, for example Spring's HTTP invoker.
`class`	`RmiBasedExporter`	Convenient superclass for RMI-based remote exporters.
`class`	`RmiClientInterceptor`	`MethodInterceptor` for accessing conventional RMI services or RMI invokers.
`class`	`RmiProxyFactoryBean`	`FactoryBean` for RMI proxies, supporting both conventional RMI services and RMI invokers.
`class`	`RmiServiceExporter`	RMI exporter that exposes the specified service as RMI object with the specified name.

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 of `RemoteInvocation` objects.
`class`	`RemoteInvocationBasedExporter`	Abstract base class for remote service exporters that are based on deserialization of `RemoteInvocation` objects.
`class`	`RemotingSupport`	Generic support base class for remote accessor and exporters, providing common bean ClassLoader handling.
`class`	`UrlBasedRemoteAccessor`	Abstract base class for classes that access remote services via URLs.

org.springframework.scheduling.annotation中Aware的使用

实现Aware的org.springframework.scheduling.annotation中的类
修饰符和类型	类	说明
`class`	`AbstractAsyncConfiguration`	Abstract base `Configuration` class providing common structure for enabling Spring's asynchronous method execution capability.
`class`	`AnnotationAsyncExecutionInterceptor`	Specialization of `AsyncExecutionInterceptor` that delegates method execution to an `Executor` based on the `Async` annotation.
`class`	`AsyncAnnotationAdvisor`	Advisor that activates asynchronous method execution through the `Async` annotation.
`class`	`AsyncAnnotationBeanPostProcessor`	Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the `Async` annotation at class or method-level by adding a corresponding `AsyncAnnotationAdvisor` 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 a `TaskScheduler` 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 a `ExecutorService` (typically a `ThreadPoolExecutor` or `ScheduledThreadPoolExecutor`).
`class`	`ScheduledExecutorFactoryBean`	`FactoryBean` that sets up a `ScheduledExecutorService` (by default: a `ScheduledThreadPoolExecutor`) and exposes it for bean references.
`class`	`ThreadPoolExecutorFactoryBean`	JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its native `ExecutorService` type.
`class`	`ThreadPoolTaskExecutor`	JavaBean that allows for configuring a `ThreadPoolExecutor` in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a Spring `TaskExecutor`.
`class`	`ThreadPoolTaskScheduler`	Implementation of Spring's `TaskScheduler` interface, wrapping a native `ScheduledThreadPoolExecutor`.

org.springframework.scheduling.config中Aware的使用

实现Aware的org.springframework.scheduling.config中的类
修饰符和类型	类	说明
`class`	`TaskExecutorFactoryBean`	`FactoryBean` for creating `ThreadPoolTaskExecutor` 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 Spring `FactoryBean` for creating a Quartz `CronTrigger` instance, supporting bean-style usage for trigger configuration.
`class`	`JobDetailFactoryBean`	A Spring `FactoryBean` for creating a Quartz `JobDetail` instance, supporting bean-style usage for JobDetail configuration.
`class`	`MethodInvokingJobDetailFactoryBean`	`FactoryBean` that exposes a `JobDetail` 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 a `Scheduler` instance.
`class`	`SchedulerAccessorBean`	Spring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a given `Scheduler` instance.
`class`	`SchedulerFactoryBean`	`FactoryBean` that creates and configures a Quartz `Scheduler`, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.
`class`	`SimpleTriggerFactoryBean`	A Spring `FactoryBean` for creating a Quartz `SimpleTrigger` instance, supporting bean-style usage for trigger configuration.
`class`	`SpringBeanJobFactory`	Subclass of `AdaptableJobFactory` 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 the `Runnable` 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's `ScriptEvaluator` 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's `ScriptEvaluator` strategy interface.
`class`	`GroovyScriptFactory`	`ScriptFactory` implementation for a Groovy script.

org.springframework.scripting.support中Aware的使用

实现Aware的org.springframework.scripting.support中的类
修饰符和类型	类	说明
`class`	`ScriptFactoryPostProcessor`	`BeanPostProcessor` that handles `ScriptFactory` definitions, replacing each factory with the actual scripted Java object generated by it.
`class`	`StandardScriptEvaluator`	`javax.script` (JSR-223) based implementation of Spring's `ScriptEvaluator` 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 explicit `ApplicationContext` testing support in a JUnit 4 environment.
`class`	`AbstractTransactionalJUnit4SpringContextTests`	Abstract transactional extension of `AbstractJUnit4SpringContextTests` 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 explicit `ApplicationContext` testing support in a TestNG environment.
`class`	`AbstractTransactionalTestNGSpringContextTests`	Abstract transactional extension of `AbstractTestNGSpringContextTests` 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.2 `Transactional` annotation in addition to Spring's own `Transactional` annotation.
`class`	`AspectJTransactionManagementConfiguration`	`@Configuration` class that registers the Spring infrastructure beans necessary to enable AspectJ-based annotation-driven transaction management for Spring's own `Transactional` annotation.

org.springframework.transaction.interceptor中Aware的使用

实现Aware的org.springframework.transaction.interceptor中的类
修饰符和类型	类	说明
`class`	`BeanFactoryTransactionAttributeSourceAdvisor`	Advisor driven by a `TransactionAttributeSource`, used to include a transaction advice bean for methods that are transactional.
`class`	`MethodMapTransactionAttributeSource`	Simple `TransactionAttributeSource` implementation that allows attributes to be stored per method in a `Map`.
`class`	`TransactionAspectSupport`	Base class for transactional aspects, such as the `TransactionInterceptor` 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 individual `ResourceBundle` 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 for `javax.validation` (JSR-303) setup in a Spring application context: It bootstraps a `javax.validation.ValidationFactory` and exposes it through the Spring `Validator` interface as well as through the JSR-303 `Validator` interface and the `ValidatorFactory` interface itself.
`class`	`MethodValidationPostProcessor`	A convenient `BeanPostProcessor` implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.
`class`	`OptionalValidatorFactoryBean`	`LocalValidatorFactoryBean` subclass that simply turns `Validator` 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 a `ContentNegotiationManager` and configure it with `ContentNegotiationStrategy` 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 the `ServletConfig` (typically determined by the `WebApplicationContext`) that it runs in.
`interface`	`ServletContextAware`	Interface to be implemented by any object that wishes to be notified of the `ServletContext` (typically determined by the `WebApplicationContext`) that it runs in.

org.springframework.web.context.request.async中Aware的使用
实现Aware的org.springframework.web.context.request.async中的类
修饰符和类型类说明
class WebAsyncTask<V>
Holder for a Callable, 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 the `ConfigurableWebApplicationContext` 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 using `javax.inject` annotations.
`class`	`GroovyWebApplicationContext`	`WebApplicationContext` implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by a `GroovyBeanDefinitionReader`.
`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 in `web.xml`).
`class`	`WebApplicationObjectSupport`	Convenient superclass for application objects running in a `WebApplicationContext`.
`class`	`XmlWebApplicationContext`	`WebApplicationContext` implementation which takes its configuration from XML documents, understood by an `XmlBeanDefinitionReader`.

org.springframework.web.filter中Aware的使用

实现Aware的org.springframework.web.filter中的类
修饰符和类型	类	说明
`class`	`AbstractRequestLoggingFilter`	Base class for `Filter`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 a `CorsProcessor` implementation (`DefaultCorsProcessor` by default) in order to add the relevant CORS response headers (like `Access-Control-Allow-Origin`) using the provided `CorsConfigurationSource` (for example an `UrlBasedCorsConfigurationSource` 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 of `Filter` which treats its config parameters (`init-param` entries within the `filter` tag in `web.xml`) as bean properties.
`class`	`HiddenHttpMethodFilter`	`Filter` that converts posted method parameters into HTTP methods, retrievable via `HttpServletRequest.getMethod()`.
`class`	`HttpPutFormContentFilter`	已过时。 as of 5.1 in favor of `FormContentFilter` 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`	Overrides `HttpServletResponse.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 both `LocaleContextHolder` and `RequestContextHolder`.
`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 an `ETag` value based on the content on the response.

org.springframework.web.multipart.commons中Aware的使用

实现Aware的org.springframework.web.multipart.commons中的类
修饰符和类型	类	说明
`class`	`CommonsMultipartResolver`	Servlet-based `MultipartResolver` 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 a MultipartResolver.
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 of `WebFluxConfigurationSupport` that detects and delegates to all beans of type `WebFluxConfigurer` allowing them to customize the configuration provided by `WebFluxConfigurationSupport`.
`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 supports RouterFunctions.

org.springframework.web.reactive.handler中Aware的使用

实现Aware的org.springframework.web.reactive.handler中的类
修饰符和类型	类	说明
`class`	`AbstractHandlerMapping`	Abstract base class for `HandlerMapping` implementations.
`class`	`AbstractUrlHandlerMapping`	Abstract base class for URL-mapped `HandlerMapping` implementations.
`class`	`SimpleUrlHandlerMapping`	Implementation of the `HandlerMapping` 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 for `HandlerMapping` implementations that define a mapping between a request and a `HandlerMethod`.
`class`	`RequestMappingInfoHandlerMapping`	Abstract base class for classes for which `RequestMappingInfo` 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 of `RequestMappingInfoHandlerMapping` that creates `RequestMappingInfo` 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 for `View` implementations.
`class`	`RedirectView`	View that redirects to an absolute or context relative URL.
`class`	`UrlBasedViewResolver`	A `ViewResolver` 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`	A `View` implementation that uses the FreeMarker template engine.
`class`	`FreeMarkerViewResolver`	A `ViewResolver` for resolving `FreeMarkerView` instances, i.e.

org.springframework.web.reactive.result.view.script中Aware的使用

实现Aware的org.springframework.web.reactive.result.view.script中的类
修饰符和类型	类	说明
`class`	`ScriptTemplateView`	An `AbstractUrlBasedView` subclass designed to run any template library based on a JSR-223 script engine.
`class`	`ScriptTemplateViewResolver`	Convenience subclass of `UrlBasedViewResolver` that supports `ScriptTemplateView` 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 of `HttpServlet` which treats its config parameters (`init-param` entries within the `servlet` tag in `web.xml`) as bean properties.

org.springframework.web.servlet.config.annotation中Aware的使用

实现Aware的org.springframework.web.servlet.config.annotation中的类
修饰符和类型	类	说明
`class`	`DelegatingWebMvcConfiguration`	A subclass of `WebMvcConfigurationSupport` that detects and delegates to all beans of type `WebMvcConfigurer` allowing them to customize the configuration provided by `WebMvcConfigurationSupport`.
`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 supports RouterFunctions.

org.springframework.web.servlet.handler中Aware的使用

实现Aware的org.springframework.web.servlet.handler中的类
修饰符和类型	类	说明
`class`	`AbstractDetectingUrlHandlerMapping`	Abstract implementation of the `HandlerMapping` interface, detecting URL mappings for handler beans through introspection of all defined beans in the application context.
`class`	`AbstractHandlerMapping`	Abstract base class for `HandlerMapping` implementations.
`class`	`AbstractHandlerMethodMapping<T>`	Abstract base class for `HandlerMapping` implementations that define a mapping between a request and a `HandlerMethod`.
`class`	`AbstractUrlHandlerMapping`	Abstract base class for URL-mapped `HandlerMapping` implementations.
`class`	`BeanNameUrlHandlerMapping`	Implementation of the `HandlerMapping` 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 the `HandlerMapping` that would serve a specific request.
`class`	`SimpleServletPostProcessor`	`BeanPostProcessor` that applies initialization and destruction callbacks to beans that implement the `Servlet` interface.
`class`	`SimpleUrlHandlerMapping`	Implementation of the `HandlerMapping` 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 for `Controllers` 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`	Simple `Controller` 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`	A `HandlerExceptionResolver` 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 for `HandlerAdapter` implementations that support handlers of type `HandlerMethod`.
`class`	`RequestMappingInfoHandlerMapping`	Abstract base class for classes for which `RequestMappingInfo` 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`	An `AbstractHandlerMethodExceptionResolver` that resolves exceptions through `@ExceptionHandler` methods.
`class`	`RequestMappingHandlerAdapter`	Extension of `AbstractHandlerMethodAdapter` that supports `@RequestMapping` annotated `HandlerMethods`.
`class`	`RequestMappingHandlerMapping`	Creates `RequestMappingInfo` 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`	An `HttpRequestHandler` 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 the `HttpServletResponse` and overrides its `encodeURL` 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, like `AbstractController` and `WebContentInterceptor`.

org.springframework.web.servlet.view中Aware的使用

实现Aware的org.springframework.web.servlet.view中的类
修饰符和类型	类	说明
`class`	`AbstractCachingViewResolver`	Convenient base class for `ViewResolver` 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 for `View` implementations.
`class`	`BeanNameViewResolver`	A simple implementation of `ViewResolver` that interprets a view name as a bean name in the current application context, i.e. typically in the XML file of the executing `DispatcherServlet`.
`class`	`ContentNegotiatingViewResolver`	Implementation of `ViewResolver` that resolves a view based on the request file name or `Accept` header.
`class`	`InternalResourceView`	Wrapper for a JSP or other resource within the same web application.
`class`	`InternalResourceViewResolver`	Convenient subclass of `UrlBasedViewResolver` that supports `InternalResourceView` (i.e.
`class`	`JstlView`	Specialization of `InternalResourceView` for JSTL pages, i.e.
`class`	`RedirectView`	View that redirects to an absolute, context relative, or current request relative URL.
`class`	`ResourceBundleViewResolver`	A `ViewResolver` implementation that uses bean definitions in a `ResourceBundle`, specified by the bundle basename.
`class`	`UrlBasedViewResolver`	Simple implementation of the `ViewResolver` interface, allowing for direct resolution of symbolic view names to URLs, without explicit mapping definitions.
`class`	`ViewResolverComposite`	A `ViewResolver` that delegates to others.
`class`	`XmlViewResolver`	A `ViewResolver` 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 of `UrlBasedViewResolver` that supports `FreeMarkerView` (i.e.

org.springframework.web.servlet.view.groovy中Aware的使用

实现Aware的org.springframework.web.servlet.view.groovy中的类
修饰符和类型	类	说明
`class`	`GroovyMarkupConfigurer`	An extension of Groovy's `TemplateConfiguration` and an implementation of Spring MVC's `GroovyMarkupConfig` for creating a `MarkupTemplateEngine` for use in a web application.
`class`	`GroovyMarkupView`	An `AbstractTemplateView` subclass based on Groovy XML/XHTML markup templates.
`class`	`GroovyMarkupViewResolver`	Convenience subclass of @link AbstractTemplateViewResolver} that supports `GroovyMarkupView` (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 independent `AbstractView` implementations.
`class`	`MappingJackson2JsonView`	Spring MVC `View` that renders JSON content by serializing the model for the current request using Jackson 2's `ObjectMapper`.

org.springframework.web.servlet.view.script中Aware的使用

实现Aware的org.springframework.web.servlet.view.script中的类
修饰符和类型	类	说明
`class`	`ScriptTemplateView`	An `AbstractUrlBasedView` subclass designed to run any template library based on a JSR-223 script engine.
`class`	`ScriptTemplateViewResolver`	Convenience subclass of `UrlBasedViewResolver` that supports `ScriptTemplateView` 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 of `UrlBasedViewResolver` that supports `TilesView` (i.e.

org.springframework.web.servlet.view.xml中Aware的使用

实现Aware的org.springframework.web.servlet.view.xml中的类
修饰符和类型	类	说明
`class`	`MappingJackson2XmlView`	Spring MVC `View` that renders XML content by serializing the model for the current request using Jackson 2's `XmlMapper`.
`class`	`MarshallingView`	Spring-MVC `View` that allows for response context to be rendered as the result of marshalling by a `Marshaller`.

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 of `XsltView` 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, a `ClientEndpoint`-annotated endpoint, connects to a WebSocket server through the `ConnectionManagerSupport.start()` and `ConnectionManagerSupport.stop()` methods.
`class`	`EndpointConnectionManager`	A WebSocket connection manager that is given a URI, an `Endpoint`, connects to a WebSocket server through the `ConnectionManagerSupport.start()` and `ConnectionManagerSupport.stop()` methods.

org.springframework.web.socket.config.annotation中Aware的使用

实现Aware的org.springframework.web.socket.config.annotation中的类
修饰符和类型	类	说明
`class`	`DelegatingWebSocketMessageBrokerConfiguration`	A `WebSocketMessageBrokerConfigurationSupport` extension that detects beans of type `WebSocketMessageBrokerConfigurer` and delegates to all of them allowing callback style customization of the configuration provided in `WebSocketMessageBrokerConfigurationSupport`.
`class`	`WebSocketMessageBrokerConfigurationSupport`	Extends `AbstractMessageBrokerConfiguration` 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 Spring `BeanFactory` and also provides an equivalent destroy method.
`class`	`PerConnectionWebSocketHandler`	A `WebSocketHandler` that initializes and destroys a `WebSocketHandler` 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`	A `SubProtocolHandler` for STOMP that supports versions 1.0, 1.1, and 1.2 of the STOMP specification.
`class`	`WebSocketAnnotationMethodMessageHandler`	A sub-class of `SimpAnnotationMethodMessageHandler` to provide support for `ControllerAdvice` with global `@MessageExceptionHandler` methods.

org.springframework.web.socket.server.jetty中Aware的使用
实现Aware的org.springframework.web.socket.server.jetty中的类
修饰符和类型类说明
class JettyRequestUpgradeStrategy
A RequestUpgradeStrategy 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 type `ServerEndpointConfig` and registers with the standard Java WebSocket runtime.
`class`	`ServerEndpointRegistration`	An implementation of `ServerEndpointConfig` for use in Spring-based applications.
`class`	`ServletServerContainerFactoryBean`	A `FactoryBean` for configuring `ServerContainer`.

org.springframework.web.socket.server.support中Aware的使用

实现Aware的org.springframework.web.socket.server.support中的类
修饰符和类型	类	说明
`class`	`DefaultHandshakeHandler`	A default `HandshakeHandler` implementation, extending `AbstractHandshakeHandler` with Servlet-specific initialization support.
`class`	`WebSocketHandlerMapping`	An extension of `SimpleUrlHandlerMapping` that is also a `SmartLifecycle` container and propagates start and stop calls to any handlers that implement `Lifecycle`.
`class`	`WebSocketHttpRequestHandler`	A `HttpRequestHandler` for processing WebSocket handshake requests.

org.springframework.web.socket.sockjs.support中Aware的使用

实现Aware的org.springframework.web.socket.sockjs.support中的类
修饰符和类型	类	说明
`class`	`SockJsHttpRequestHandler`	An `HttpRequestHandler` that allows mapping a `SockJsService` 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 of `SockJsService` with all default `TransportHandler` implementations pre-registered.
`class`	`WebSocketTransportHandler`	WebSocket-based `TransportHandler`.

接口的使用org.springframework.beans.factory.Aware

org.springframework.aop.aspectj中Aware的使用

org.springframework.aop.aspectj.annotation中Aware的使用

org.springframework.aop.aspectj.autoproxy中Aware的使用

org.springframework.aop.config中Aware的使用

org.springframework.aop.framework中Aware的使用

org.springframework.aop.framework.autoproxy中Aware的使用

org.springframework.aop.framework.autoproxy.target中Aware的使用

org.springframework.aop.interceptor中Aware的使用

org.springframework.aop.scope中Aware的使用

org.springframework.aop.support中Aware的使用

org.springframework.aop.target中Aware的使用

org.springframework.beans.factory中Aware的使用

org.springframework.beans.factory.annotation中Aware的使用

org.springframework.beans.factory.config中Aware的使用

org.springframework.beans.factory.serviceloader中Aware的使用

org.springframework.beans.factory.support中Aware的使用

org.springframework.beans.factory.wiring中Aware的使用

org.springframework.cache.annotation中Aware的使用

org.springframework.cache.aspectj中Aware的使用

org.springframework.cache.concurrent中Aware的使用

org.springframework.cache.ehcache中Aware的使用

org.springframework.cache.interceptor中Aware的使用

org.springframework.cache.jcache中Aware的使用

org.springframework.cache.jcache.config中Aware的使用

org.springframework.cache.jcache.interceptor中Aware的使用

org.springframework.context中Aware的使用

org.springframework.context.annotation中Aware的使用

org.springframework.context.event中Aware的使用

org.springframework.context.support中Aware的使用

org.springframework.context.weaving中Aware的使用

org.springframework.dao.annotation中Aware的使用

org.springframework.dao.support中Aware的使用

org.springframework.ejb.access中Aware的使用

org.springframework.format.datetime中Aware的使用

org.springframework.format.datetime.joda中Aware的使用

org.springframework.format.datetime.standard中Aware的使用

org.springframework.format.number中Aware的使用

org.springframework.format.number.money中Aware的使用

org.springframework.format.support中Aware的使用

org.springframework.http.converter.json中Aware的使用

org.springframework.jca.context中Aware的使用

org.springframework.jca.endpoint中Aware的使用

org.springframework.jca.work中Aware的使用

org.springframework.jdbc.config中Aware的使用

org.springframework.jdbc.datasource.lookup中Aware的使用

org.springframework.jms.annotation中Aware的使用

org.springframework.jms.config中Aware的使用

org.springframework.jms.listener中Aware的使用

org.springframework.jms.listener.endpoint中Aware的使用

org.springframework.jms.remoting中Aware的使用

org.springframework.jms.support.converter中Aware的使用

org.springframework.jms.support.destination中Aware的使用

org.springframework.jmx.access中Aware的使用

org.springframework.jmx.export中Aware的使用

org.springframework.jmx.export.annotation中Aware的使用

org.springframework.jmx.export.assembler中Aware的使用

org.springframework.jmx.export.notification中Aware的使用

org.springframework.jmx.support中Aware的使用

org.springframework.jndi中Aware的使用

org.springframework.messaging.core中Aware的使用

org.springframework.messaging.handler.annotation.reactive中Aware的使用

org.springframework.messaging.handler.annotation.support中Aware的使用

org.springframework.messaging.handler.invocation中Aware的使用

org.springframework.messaging.handler.invocation.reactive中Aware的使用

org.springframework.messaging.rsocket.annotation.support中Aware的使用

org.springframework.messaging.simp.annotation.support中Aware的使用

org.springframework.messaging.simp.broker中Aware的使用

org.springframework.messaging.simp.config中Aware的使用

org.springframework.messaging.simp.stomp中Aware的使用

org.springframework.messaging.support中Aware的使用

org.springframework.orm.hibernate5中Aware的使用

org.springframework.orm.hibernate5.support中Aware的使用

org.springframework.orm.jpa中Aware的使用

org.springframework.orm.jpa.persistenceunit中Aware的使用

org.springframework.orm.jpa.support中Aware的使用

org.springframework.orm.jpa.vendor中Aware的使用

org.springframework.oxm.jaxb中Aware的使用

org.springframework.oxm.xstream中Aware的使用

org.springframework.remoting.caucho中Aware的使用

接口的使用
org.springframework.beans.factory.Aware