接口的使用
org.springframework.beans.factory.InitializingBean
使用InitializingBean的程序包 程序包 说明 org.springframework.aop.framework Package containing Spring's basic AOP infrastructure, compliant with the AOP Alliance interfaces.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.wiring Mechanism to determine bean wiring metadata from a bean instance.org.springframework.cache.concurrent Implementation package forjava.util.concurrent
based caches.org.springframework.cache.ehcache Support classes for the open source cache EhCache 2.x, allowing to set up an EhCache CacheManager and Caches as beans in a Spring context.org.springframework.cache.interceptor AOP-based solution for declarative caching demarcation.org.springframework.cache.jcache Implementation package for JSR-107 (javax.cache aka "JCache") based caches.org.springframework.cache.jcache.interceptor AOP-based solution for declarative caching demarcation using JSR-107 annotations.org.springframework.cache.support Support classes for the org.springframework.cache package.org.springframework.cache.transaction Transaction-aware decorators for the org.springframework.cache package.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.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.joda Integration with Joda-Time for formatting Joda date and time types as well as standard JDK Date types.org.springframework.format.datetime.standard Integration with the JSR-310java.time
package in JDK 8.org.springframework.format.support Support classes for the formatting package, providing common implementations as well as adapters.org.springframework.http.client Contains an abstraction over client-side HTTP.org.springframework.http.client.reactive Abstractions for reactive HTTP client support includingClientHttpRequest
andClientHttpResponse
as well as aClientHttpConnector
.org.springframework.http.client.support This package provides generic HTTP support classes, to be used by higher-level classes like RestTemplate.org.springframework.http.converter.json Provides HttpMessageConverter implementations for handling JSON.org.springframework.jca.cci.connection Provides a utility class for easy ConnectionFactory access, a PlatformTransactionManager for local CCI transactions, and various simple ConnectionFactory proxies/adapters.org.springframework.jca.cci.core.support Classes supporting theorg.springframework.jca.cci.core
package.org.springframework.jca.cci.object The classes in this package represent EIS operations as threadsafe, reusable objects.org.springframework.jca.endpoint This package provides a facility for generic JCA message endpoint management.org.springframework.jca.support Provides generic support classes for JCA usage within Spring, mainly for local setup of a JCA ResourceAdapter and/or ConnectionFactory.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.core Provides the core JDBC framework, based on JdbcTemplate and its associated callback interfaces and helper objects.org.springframework.jdbc.core.namedparam JdbcTemplate variant with named parameter support.org.springframework.jdbc.core.support Classes supporting theorg.springframework.jdbc.core
package.org.springframework.jdbc.datasource Provides a utility class for easy DataSource access, a PlatformTransactionManager for a single DataSource, and various simple DataSource implementations.org.springframework.jdbc.datasource.embedded Provides extensible support for creating embedded database instances.org.springframework.jdbc.datasource.init Provides extensible support for initializing databases through scripts.org.springframework.jdbc.datasource.lookup Provides a strategy for looking up JDBC DataSources by name.org.springframework.jdbc.object The classes in this package represent RDBMS queries, updates, and stored procedures as threadsafe, reusable objects.org.springframework.jdbc.support Support classes for the JDBC framework, used by the classes in the jdbc.core and jdbc.object packages.org.springframework.jdbc.support.incrementer Provides a support framework for incrementing database table values via sequences, with implementations for various databases.org.springframework.jms.config Support package for declarative messaging configuration, with Java configuration and XML schema support.org.springframework.jms.connection Provides a PlatformTransactionManager implementation for a single JMS ConnectionFactory, and a SingleConnectionFactory adapter.org.springframework.jms.core Core package of the JMS support.org.springframework.jms.core.support Classes supporting theorg.springframework.jms.core
package.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 This package provides generic JMS support classes, to be used by higher-level classes like JmsTemplate.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.naming Provides a strategy for ObjectName creation.org.springframework.jmx.support Contains support classes for connecting to local and remoteMBeanServer
s and for exposing anMBeanServer
to remote clients.org.springframework.jndi The classes in this package make JNDI easier to use, facilitating the accessing of configuration stored in JNDI, and provide useful superclasses for JNDI access classes.org.springframework.mail.javamail JavaMail support for Spring's mail infrastructure.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.orm.hibernate5 Package providing integration of Hibernate 5.x with Spring concepts.org.springframework.orm.hibernate5.support Classes supporting theorg.springframework.orm.hibernate5
package.org.springframework.orm.jpa Package providing integration of JPA (Java Persistence API) with Spring concepts.org.springframework.orm.jpa.persistenceunit Internal support for managing JPA persistence units.org.springframework.orm.jpa.support Classes supporting theorg.springframework.orm.jpa
package.org.springframework.oxm.jaxb Package providing integration of JAXB with Spring's O/X Mapping support.org.springframework.oxm.jibx Package providing integration of JiBX 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.commonj Convenience classes for scheduling based on the CommonJ WorkManager/TimerManager facility, as supported by IBM WebSphere 6.0+ and BEA WebLogic 9.0+.org.springframework.scheduling.concurrent Scheduling convenience classes for thejava.util.concurrent
andjavax.enterprise.concurrent
packages, allowing to set up a ThreadPoolExecutor or ScheduledThreadPoolExecutor as a bean in a Spring context.org.springframework.scheduling.config Support package for declarative scheduling configuration, with XML schema being the primary configuration format.org.springframework.scheduling.quartz Support classes for the open source scheduler Quartz, allowing to set up Quartz Schedulers, JobDetails and Triggers as beans in a Spring context.org.springframework.scheduling.support Generic support classes for scheduling.org.springframework.transaction.config Support package for declarative transaction configuration, with XML schema being the primary configuration format.org.springframework.transaction.interceptor AOP-based solution for declarative transaction demarcation.org.springframework.transaction.jta Transaction SPI implementation for JTA.org.springframework.transaction.support Support classes for the org.springframework.transaction 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.support Classes supporting theorg.springframework.web.context
package, such as WebApplicationContext implementations and various utility classes.org.springframework.web.filter Provides generic filter base classes allowing for bean-style configuration.org.springframework.web.multipart.support Support classes for the multipart resolution framework.org.springframework.web.reactive.function.server.support Classes supporting theorg.springframework.web.reactive.function.server
package.org.springframework.web.reactive.resource Support classes for serving static resources.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.function.support Classes supporting theorg.springframework.web.servlet.function
package.org.springframework.web.servlet.handler Provides standard HandlerMapping implementations, including abstract base classes for custom implementations.org.springframework.web.servlet.mvc Standard controller implementations for the Servlet MVC framework that comes with Spring.org.springframework.web.servlet.mvc.method Servlet-based infrastructure for handler method processing, building on theorg.springframework.web.method
package.org.springframework.web.servlet.mvc.method.annotation MVC infrastructure for annotation-based handler method processing, building on theorg.springframework.web.method.annotation
package.org.springframework.web.servlet.resource Support classes for serving static resources.org.springframework.web.servlet.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.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.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.xslt Support classes for XSLT, providing a View implementation for XSLT stylesheets.org.springframework.web.socket.messaging WebSocket integration for Spring's messaging module.org.springframework.web.socket.server.standard Server-side classes for use with standard JSR-356 WebSocket endpoints.org.springframework.aop.framework中InitializingBean的使用
实现InitializingBean的org.springframework.aop.framework中的类 修饰符和类型 类 说明 class
AbstractSingletonProxyFactoryBean
Convenient superclass forFactoryBean
types that produce singleton-scoped proxy objects.org.springframework.beans.factory.config中InitializingBean的使用
实现InitializingBean的org.springframework.beans.factory.config中的类 修饰符和类型 类 说明 class
AbstractFactoryBean<T>
Simple template superclass forFactoryBean
implementations that creates a singleton or a prototype object, depending on a flag.class
FieldRetrievingFactoryBean
FactoryBean
which retrieves a static or non-static field value.class
ListFactoryBean
Simple factory for shared List instances.class
MapFactoryBean
Simple factory for shared Map instances.class
MethodInvokingBean
Simple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast toMethodInvokingFactoryBean
).class
MethodInvokingFactoryBean
FactoryBean
which returns a value which is the result of a static or instance method invocation.class
ObjectFactoryCreatingFactoryBean
AFactoryBean
implementation that returns a value which is anObjectFactory
that in turn returns a bean sourced from aBeanFactory
.class
PreferencesPlaceholderConfigurer
已过时。as of 5.2, along withPropertyPlaceholderConfigurer
class
PropertiesFactoryBean
Allows for making a properties file from a classpath location available as Properties instance in a bean factory.class
ProviderCreatingFactoryBean
AFactoryBean
implementation that returns a value which is a JSR-330Provider
that in turn returns a bean sourced from aBeanFactory
.class
ServiceLocatorFactoryBean
AFactoryBean
implementation that takes an interface which must have one or more methods with the signaturesMyType xxx()
orMyType xxx(MyIdType id)
(typically,MyService getService()
orMyService getService(String id)
) and creates a dynamic proxy which implements that interface, delegating to an underlyingBeanFactory
.class
SetFactoryBean
Simple factory for shared Set instances.class
YamlMapFactoryBean
Factory for aMap
that reads from a YAML source, preserving the YAML-declared value types and their structure.class
YamlPropertiesFactoryBean
Factory forProperties
that reads from a YAML source, exposing a flat structure of String property values.org.springframework.beans.factory.serviceloader中InitializingBean的使用
实现InitializingBean的org.springframework.beans.factory.serviceloader中的类 修饰符和类型 类 说明 class
AbstractServiceLoaderBasedFactoryBean
Abstract base class for FactoryBeans operating on the JDK 1.6ServiceLoader
facility.class
ServiceFactoryBean
FactoryBean
that exposes the 'primary' service for the configured service class, obtained through the JDK 1.6ServiceLoader
facility.class
ServiceListFactoryBean
FactoryBean
that exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6ServiceLoader
facility.class
ServiceLoaderFactoryBean
FactoryBean
that exposes the JDK 1.6ServiceLoader
for the configured service class.org.springframework.beans.factory.wiring中InitializingBean的使用
实现InitializingBean的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.concurrent中InitializingBean的使用
实现InitializingBean的org.springframework.cache.concurrent中的类 修饰符和类型 类 说明 class
ConcurrentMapCacheFactoryBean
FactoryBean
for easy configuration of aConcurrentMapCache
when used within a Spring container.org.springframework.cache.ehcache中InitializingBean的使用
实现InitializingBean的org.springframework.cache.ehcache中的类 修饰符和类型 类 说明 class
EhCacheCacheManager
CacheManager backed by an EhCacheCacheManager
.class
EhCacheFactoryBean
FactoryBean
that creates a named EhCacheCache
instance (or a decorator that implements theEhcache
interface), representing a cache region within an EhCacheCacheManager
.class
EhCacheManagerFactoryBean
FactoryBean
that exposes an EhCacheCacheManager
instance (independent or shared), configured from a specified config location.org.springframework.cache.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.cache.interceptor中的类 修饰符和类型 类 说明 class
AbstractCacheResolver
A baseCacheResolver
implementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.class
CacheAspectSupport
Base class for caching aspects, such as theCacheInterceptor
or an AspectJ aspect.class
CacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache
).class
CacheProxyFactoryBean
Proxy factory bean for simplified declarative caching handling.class
NamedCacheResolver
ACacheResolver
that forces the resolution to a configurable collection of name(s) against a givenCacheManager
.class
SimpleCacheResolver
A simpleCacheResolver
that resolves theCache
instance(s) based on a configurableCacheManager
and the name of the cache(s) as provided bygetCacheNames()
.org.springframework.cache.jcache中InitializingBean的使用
实现InitializingBean的org.springframework.cache.jcache中的类 修饰符和类型 类 说明 class
JCacheCacheManager
CacheManager
implementation backed by a JCachejavax.cache.CacheManager
.class
JCacheManagerFactoryBean
FactoryBean
for a JCachejavax.cache.CacheManager
, obtaining a pre-definedCacheManager
by name through the standard JCachejavax.cache.Caching
class.org.springframework.cache.jcache.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.cache.jcache.interceptor中的类 修饰符和类型 类 说明 class
JCacheAspectSupport
Base class for JSR-107 caching aspects, such as theJCacheInterceptor
or an AspectJ aspect.class
JCacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.class
SimpleExceptionCacheResolver
A simpleCacheResolver
that resolves the exception cache based on a configurableCacheManager
and the name of the cache:CacheResultOperation.getExceptionCacheName()
.org.springframework.cache.support中InitializingBean的使用
实现InitializingBean的org.springframework.cache.support中的类 修饰符和类型 类 说明 class
AbstractCacheManager
Abstract base class implementing the commonCacheManager
methods.class
CompositeCacheManager
CompositeCacheManager
implementation that iterates over a given collection of delegateCacheManager
instances.class
SimpleCacheManager
Simple cache manager working against a given collection of caches.org.springframework.cache.transaction中InitializingBean的使用
实现InitializingBean的org.springframework.cache.transaction中的类 修饰符和类型 类 说明 class
AbstractTransactionSupportingCacheManager
Base class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.class
TransactionAwareCacheManagerProxy
Proxy for a targetCacheManager
, exposing transaction-awareCache
objects which synchronize theirCache.put(java.lang.Object, java.lang.Object)
operations with Spring-managed transactions (through Spring'sTransactionSynchronizationManager
, performing the actual cache put operation only in the after-commit phase of a successful transaction.org.springframework.context.event中InitializingBean的使用
实现InitializingBean的org.springframework.context.event中的类 修饰符和类型 类 说明 class
EventPublicationInterceptor
Interceptor
that publishes anApplicationEvent
to allApplicationListeners
registered with anApplicationEventPublisher
after each successful method invocation.org.springframework.context.support中InitializingBean的使用
实现InitializingBean的org.springframework.context.support中的类 修饰符和类型 类 说明 class
AbstractRefreshableConfigApplicationContext
AbstractRefreshableApplicationContext
subclass that adds common handling of specified config locations.class
AbstractXmlApplicationContext
Convenient base class forApplicationContext
implementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader
.class
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
ConversionServiceFactoryBean
A factory providing convenient access to a ConversionService configured with converters appropriate for most environments.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.org.springframework.dao.support中InitializingBean的使用
实现InitializingBean的org.springframework.dao.support中的类 修饰符和类型 类 说明 class
DaoSupport
Generic base class for DAOs, defining template methods for DAO initialization.class
PersistenceExceptionTranslationInterceptor
AOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.org.springframework.ejb.access中InitializingBean的使用
实现InitializingBean的org.springframework.ejb.access中的类 修饰符和类型 类 说明 class
AbstractRemoteSlsbInvokerInterceptor
Base class for interceptors proxying remote Stateless Session Beans.class
AbstractSlsbInvokerInterceptor
Base class for AOP interceptors invoking local or remote Stateless Session Beans.class
LocalSlsbInvokerInterceptor
Invoker for a local Stateless Session Bean.class
LocalStatelessSessionProxyFactoryBean
ConvenientFactoryBean
for local Stateless Session Bean (SLSB) proxies.class
SimpleRemoteSlsbInvokerInterceptor
Basic invoker for a remote Stateless Session Bean.class
SimpleRemoteStatelessSessionProxyFactoryBean
ConvenientFactoryBean
for remote SLSB proxies.org.springframework.format.datetime.joda中InitializingBean的使用
实现InitializingBean的org.springframework.format.datetime.joda中的类 修饰符和类型 类 说明 class
DateTimeFormatterFactoryBean
FactoryBean
that creates a Joda-TimeDateTimeFormatter
.org.springframework.format.datetime.standard中InitializingBean的使用
实现InitializingBean的org.springframework.format.datetime.standard中的类 修饰符和类型 类 说明 class
DateTimeFormatterFactoryBean
FactoryBean
that creates a JSR-310DateTimeFormatter
.org.springframework.format.support中InitializingBean的使用
实现InitializingBean的org.springframework.format.support中的类 修饰符和类型 类 说明 class
FormattingConversionServiceFactoryBean
A factory providing convenient access to aFormattingConversionService
configured with converters and formatters for common types such as numbers and datetimes.org.springframework.http.client中InitializingBean的使用
实现InitializingBean的org.springframework.http.client中的类 修饰符和类型 类 说明 class
HttpComponentsAsyncClientHttpRequestFactory
已过时。as of Spring 5.0, with no direct replacementclass
Netty4ClientHttpRequestFactory
已过时。as of Spring 5.0, in favor ofReactorClientHttpConnector
org.springframework.http.client.reactive中InitializingBean的使用
实现InitializingBean的org.springframework.http.client.reactive中的类 修饰符和类型 类 说明 class
JettyResourceFactory
Factory to manage Jetty resources, i.e.class
ReactorResourceFactory
Factory to manage Reactor Netty resources, i.e.org.springframework.http.client.support中InitializingBean的使用
实现InitializingBean的org.springframework.http.client.support中的类 修饰符和类型 类 说明 class
ProxyFactoryBean
FactoryBean
that creates ajava.net.Proxy
.org.springframework.http.converter.json中InitializingBean的使用
实现InitializingBean的org.springframework.http.converter.json中的类 修饰符和类型 类 说明 class
GsonFactoryBean
AFactoryBean
for creating a Google Gson 2.xGson
instance.class
Jackson2ObjectMapperFactoryBean
AFactoryBean
for creating a Jackson 2.xObjectMapper
(default) orXmlMapper
(createXmlMapper
property set to true) with setters to enable or disable Jackson features from within XML configuration.org.springframework.jca.cci.connection中InitializingBean的使用
实现InitializingBean的org.springframework.jca.cci.connection中的类 修饰符和类型 类 说明 class
CciLocalTransactionManager
PlatformTransactionManager
implementation that manages local transactions for a single CCI ConnectionFactory.class
ConnectionSpecConnectionFactoryAdapter
An adapter for a target CCIConnectionFactory
, applying the given ConnectionSpec to every standardgetConnection()
call, that is, implicitly invokinggetConnection(ConnectionSpec)
on the target.class
DelegatingConnectionFactory
CCIConnectionFactory
implementation that delegates all calls to a given targetConnectionFactory
.class
SingleConnectionFactory
A CCI ConnectionFactory adapter that returns the same Connection on allgetConnection
calls, and ignores calls toConnection.close()
.class
TransactionAwareConnectionFactoryProxy
Proxy for a target CCIConnectionFactory
, adding awareness of Spring-managed transactions.org.springframework.jca.cci.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jca.cci.core.support中的类 修饰符和类型 类 说明 class
CciDaoSupport
Convenient super class for CCI-based data access objects.org.springframework.jca.cci.object中InitializingBean的使用
实现InitializingBean的org.springframework.jca.cci.object中的类 修饰符和类型 类 说明 class
EisOperation
Base class for EIS operation objects that work with the CCI API.class
MappingCommAreaOperation
EIS operation object for access to COMMAREA records.class
MappingRecordOperation
EIS operation object that expects mapped input and output objects, converting to and from CCI Records.class
SimpleRecordOperation
EIS operation object that accepts a passed-in CCI input Record and returns a corresponding CCI output Record.org.springframework.jca.endpoint中InitializingBean的使用
实现InitializingBean的org.springframework.jca.endpoint中的类 修饰符和类型 类 说明 class
GenericMessageEndpointManager
Generic bean that manages JCA 1.7 message endpoints within a Spring application context, activating and deactivating the endpoint as part of the application context's lifecycle.org.springframework.jca.support中InitializingBean的使用
实现InitializingBean的org.springframework.jca.support中的类 修饰符和类型 类 说明 class
LocalConnectionFactoryBean
FactoryBean
that creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).class
ResourceAdapterFactoryBean
FactoryBean
that bootstraps the specified JCA 1.7ResourceAdapter
, starting it with a localBootstrapContext
and exposing it for bean references.org.springframework.jca.work中InitializingBean的使用
实现InitializingBean的org.springframework.jca.work中的类 修饰符和类型 类 说明 class
WorkManagerTaskExecutor
TaskExecutor
implementation that delegates to a JCA 1.7 WorkManager, implementing theWorkManager
interface.org.springframework.jdbc.config中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.config中的类 修饰符和类型 类 说明 class
SortedResourcesFactoryBean
FactoryBean
implementation that takes a list of location Strings and creates a sorted array ofResource
instances.org.springframework.jdbc.core中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.core中的类 修饰符和类型 类 说明 class
JdbcTemplate
This is the central class in the JDBC core package. It simplifies the use of JDBC and helps to avoid common errors.org.springframework.jdbc.core.namedparam中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.core.namedparam中的类 修饰符和类型 类 说明 class
NamedParameterJdbcDaoSupport
Extension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.org.springframework.jdbc.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.core.support中的类 修饰符和类型 类 说明 class
JdbcDaoSupport
Convenient super class for JDBC-based data access objects.org.springframework.jdbc.datasource中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource中的类 修饰符和类型 类 说明 class
DataSourceTransactionManager
PlatformTransactionManager
implementation for a single JDBCDataSource
.class
DelegatingDataSource
JDBCDataSource
implementation that delegates all calls to a given targetDataSource
.class
IsolationLevelDataSourceAdapter
An adapter for a targetDataSource
, applying the current Spring transaction's isolation level (and potentially specified user credentials) to everygetConnection
call.class
LazyConnectionDataSourceProxy
Proxy for a target DataSource, fetching actual JDBC Connections lazily, i.e. not until first creation of a Statement.class
TransactionAwareDataSourceProxy
Proxy for a target JDBCDataSource
, adding awareness of Spring-managed transactions.class
UserCredentialsDataSourceAdapter
An adapter for a target JDBCDataSource
, applying the specified user credentials to every standardgetConnection()
call, implicitly invokinggetConnection(username, password)
on the target.class
WebSphereDataSourceAdapter
DataSource
implementation that delegates all calls to a WebSphere targetDataSource
, typically obtained from JNDI, applying a current isolation level and/or current user credentials to every Connection obtained from it.org.springframework.jdbc.datasource.embedded中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource.embedded中的类 修饰符和类型 类 说明 class
EmbeddedDatabaseFactoryBean
A subclass ofEmbeddedDatabaseFactory
that implementsFactoryBean
for registration as a Spring bean.org.springframework.jdbc.datasource.init中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource.init中的类 修饰符和类型 类 说明 class
DataSourceInitializer
org.springframework.jdbc.datasource.lookup中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource.lookup中的类 修饰符和类型 类 说明 class
AbstractRoutingDataSource
AbstractDataSource
implementation that routesAbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.class
IsolationLevelDataSourceRouter
DataSource that routes to one of various target DataSources based on the current transaction isolation level.org.springframework.jdbc.object中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.object中的类 修饰符和类型 类 说明 class
BatchSqlUpdate
SqlUpdate subclass that performs batch update operations.class
GenericSqlQuery<T>
class
GenericStoredProcedure
Concrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.class
MappingSqlQuery<T>
Reusable query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to convert each row of the JDBC ResultSet into an object.class
MappingSqlQueryWithParameters<T>
Reusable RDBMS query in which concrete subclasses must implement the abstract mapRow(ResultSet, int) method to map each row of the JDBC ResultSet into an object.class
RdbmsOperation
An "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call.class
SqlCall
RdbmsOperation using a JdbcTemplate and representing an SQL-based call such as a stored procedure or a stored function.class
SqlFunction<T>
SQL "function" wrapper for a query that returns a single row of results.class
SqlOperation
Operation object representing an SQL-based operation such as a query or update, as opposed to a stored procedure.class
SqlQuery<T>
Reusable operation object representing an SQL query.class
SqlUpdate
Reusable operation object representing an SQL update.class
StoredProcedure
Superclass for object abstractions of RDBMS stored procedures.class
UpdatableSqlQuery<T>
Reusable RDBMS query in which concrete subclasses must implement the abstract updateRow(ResultSet, int, context) method to update each row of the JDBC ResultSet and optionally map contents into an object.org.springframework.jdbc.support中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.support中的类 修饰符和类型 类 说明 class
CustomSQLExceptionTranslatorRegistrar
Registry for customSQLExceptionTranslator
instances for specific databases.class
DatabaseStartupValidator
Bean that checks if a database has already started up.class
JdbcAccessor
Base class forJdbcTemplate
and other JDBC-accessing DAO helpers, defining common properties such as DataSource and exception translator.org.springframework.jdbc.support.incrementer中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.support.incrementer中的类 修饰符和类型 类 说明 class
AbstractColumnMaxValueIncrementer
Abstract base class forDataFieldMaxValueIncrementer
implementations that use a column in a custom sequence table.class
AbstractDataFieldMaxValueIncrementer
Base implementation ofDataFieldMaxValueIncrementer
that delegates to a singleAbstractDataFieldMaxValueIncrementer.getNextKey()
template method that returns along
.class
AbstractIdentityColumnMaxValueIncrementer
Abstract base class forDataFieldMaxValueIncrementer
implementations which are based on identity columns in a sequence-like table.class
AbstractSequenceMaxValueIncrementer
Abstract base class forDataFieldMaxValueIncrementer
implementations that use a database sequence.class
Db2LuwMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence on DB2 LUW (for Linux, Unix and Windows).class
Db2MainframeMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).class
DB2MainframeSequenceMaxValueIncrementer
已过时。in favor of the differently namedDb2MainframeMaxValueIncrementer
class
DB2SequenceMaxValueIncrementer
已过时。in favor of the specifically namedDb2LuwMaxValueIncrementer
class
DerbyMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given Derby table with the equivalent of an auto-increment column.class
H2SequenceMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given H2 sequence.class
HanaSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given SAP HANA sequence.class
HsqlMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.class
HsqlSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given HSQL sequence.class
MySQLMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.class
OracleSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given Oracle sequence.class
PostgreSQLSequenceMaxValueIncrementer
已过时。in favor of the differently namedPostgresSequenceMaxValueIncrementer
class
PostgresSequenceMaxValueIncrementer
DataFieldMaxValueIncrementer
that retrieves the next value of a given PostgreSQL sequence.class
SqlServerMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.class
SybaseAnywhereMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.class
SybaseMaxValueIncrementer
DataFieldMaxValueIncrementer
that increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.org.springframework.jms.config中InitializingBean的使用
实现InitializingBean的org.springframework.jms.config中的类 修饰符和类型 类 说明 class
JmsListenerEndpointRegistrar
Helper bean for registeringJmsListenerEndpoint
with aJmsListenerEndpointRegistry
.org.springframework.jms.connection中InitializingBean的使用
实现InitializingBean的org.springframework.jms.connection中的类 修饰符和类型 类 说明 class
CachingConnectionFactory
class
DelegatingConnectionFactory
ConnectionFactory
implementation that delegates all calls to a given targetConnectionFactory
, adapting specificcreate(Queue/Topic)Connection
calls to the target ConnectionFactory if necessary (e.g. when running JMS 1.0.2 API based code against a generic JMS 1.1 ConnectionFactory, such as ActiveMQ's PooledConnectionFactory).class
JmsTransactionManager
PlatformTransactionManager
implementation for a single JMSConnectionFactory
.class
SingleConnectionFactory
A JMS ConnectionFactory adapter that returns the same Connection from allSingleConnectionFactory.createConnection()
calls, and ignores calls toConnection.close()
.class
UserCredentialsConnectionFactoryAdapter
An adapter for a target JMSConnectionFactory
, applying the given user credentials to every standardcreateConnection()
call, that is, implicitly invokingcreateConnection(username, password)
on the target.org.springframework.jms.core中InitializingBean的使用
实现InitializingBean的org.springframework.jms.core中的类 修饰符和类型 类 说明 class
JmsMessagingTemplate
An implementation ofJmsMessageOperations
.class
JmsTemplate
Helper class that simplifies synchronous JMS access code.org.springframework.jms.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jms.core.support中的类 修饰符和类型 类 说明 class
JmsGatewaySupport
Convenient super class for application classes that need JMS access.org.springframework.jms.listener中InitializingBean的使用
实现InitializingBean的org.springframework.jms.listener中的类 修饰符和类型 类 说明 class
AbstractJmsListeningContainer
Common base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).class
AbstractMessageListenerContainer
Abstract base class for Spring message listener container implementations.class
AbstractPollingMessageListenerContainer
Base class for listener container implementations which are based on polling.class
DefaultMessageListenerContainer
Message listener container variant that uses plain JMS client APIs, specifically a loop ofMessageConsumer.receive()
calls that also allow for transactional reception of messages (registering them with XA transactions).class
SimpleMessageListenerContainer
Message listener container that uses the plain JMS client API'sMessageConsumer.setMessageListener()
method to create concurrent MessageConsumers for the specified listeners.org.springframework.jms.listener.endpoint中InitializingBean的使用
实现InitializingBean的org.springframework.jms.listener.endpoint中的类 修饰符和类型 类 说明 class
JmsMessageEndpointManager
Extension of the generic JCA 1.5GenericMessageEndpointManager
, adding JMS-specific support for ActivationSpec configuration.org.springframework.jms.remoting中InitializingBean的使用
实现InitializingBean的org.springframework.jms.remoting中的类 修饰符和类型 类 说明 class
JmsInvokerClientInterceptor
MethodInterceptor
for accessing a JMS-based remote service.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中InitializingBean的使用
实现InitializingBean的org.springframework.jms.support中的类 修饰符和类型 类 说明 class
JmsAccessor
Base class forJmsTemplate
and other JMS-accessing gateway helpers, defining common properties such as the JMSConnectionFactory
to operate on.org.springframework.jms.support.converter中InitializingBean的使用
实现InitializingBean的org.springframework.jms.support.converter中的类 修饰符和类型 类 说明 class
MarshallingMessageConverter
class
MessagingMessageConverter
Convert aMessage
from the messaging abstraction to and from aMessage
using an underlyingMessageConverter
for the payload and aJmsHeaderMapper
to map the JMS headers to and from standard message headers.org.springframework.jms.support.destination中InitializingBean的使用
实现InitializingBean的org.springframework.jms.support.destination中的类 修饰符和类型 类 说明 class
JmsDestinationAccessor
Base class forJmsTemplate
and other JMS-accessing gateway helpers, adding destination-related properties toJmsAccessor's
common properties.org.springframework.jmx.access中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.access中的类 修饰符和类型 类 说明 class
MBeanClientInterceptor
MethodInterceptor
that routes calls to an MBean running on the suppliedMBeanServerConnection
.class
MBeanProxyFactoryBean
Creates a proxy to a managed resource running either locally or remotely.class
NotificationListenerRegistrar
Registrar object that associates a specificNotificationListener
with one or more MBeans in anMBeanServer
(typically via aMBeanServerConnection
).org.springframework.jmx.export中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export中的类 修饰符和类型 类 说明 class
MBeanExporter
JMX exporter that allows for exposing any Spring-managed bean to a JMXMBeanServer
, without the need to define any JMX-specific information in the bean classes.class
NotificationListenerBean
Helper class that aggregates aNotificationListener
, aNotificationFilter
, and an arbitrary handback object.org.springframework.jmx.export.annotation中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export.annotation中的类 修饰符和类型 类 说明 class
AnnotationMBeanExporter
Convenient subclass of Spring's standardMBeanExporter
, activating Java 5 annotation usage for JMX exposure of Spring beans:ManagedResource
,ManagedAttribute
,ManagedOperation
, etc.org.springframework.jmx.export.assembler中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export.assembler中的类 修饰符和类型 类 说明 class
InterfaceBasedMBeanInfoAssembler
Subclass ofAbstractReflectiveMBeanInfoAssembler
that allows for the management interface of a bean to be defined using arbitrary interfaces.class
MetadataMBeanInfoAssembler
Implementation of theMBeanInfoAssembler
interface that reads the management interface information from source level metadata.org.springframework.jmx.export.naming中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export.naming中的类 修饰符和类型 类 说明 class
KeyNamingStrategy
ObjectNamingStrategy
implementation that buildsObjectName
instances from the key used in the "beans" map passed toMBeanExporter
.class
MetadataNamingStrategy
An implementation of theObjectNamingStrategy
interface that reads theObjectName
from the source-level metadata.org.springframework.jmx.support中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.support中的类 修饰符和类型 类 说明 class
ConnectorServerFactoryBean
FactoryBean
that creates a JSR-160JMXConnectorServer
, optionally registers it with theMBeanServer
, and then starts it.class
MBeanServerConnectionFactoryBean
FactoryBean
that creates a JMX 1.2MBeanServerConnection
to a remoteMBeanServer
exposed via aJMXServerConnector
.class
MBeanServerFactoryBean
FactoryBean
that obtains aMBeanServer
reference through the standard JMX 1.2MBeanServerFactory
API.class
WebSphereMBeanServerFactoryBean
FactoryBean
that obtains a WebSphereMBeanServer
reference through WebSphere's proprietaryAdminServiceFactory
API, available on WebSphere 5.1 and higher.org.springframework.jndi中InitializingBean的使用
实现InitializingBean的org.springframework.jndi中的类 修饰符和类型 类 说明 class
JndiObjectFactoryBean
FactoryBean
that looks up a JNDI object.class
JndiObjectLocator
Convenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.class
JndiObjectTargetSource
AOPTargetSource
that provides configurable JNDI lookups forgetTarget()
calls.org.springframework.mail.javamail中InitializingBean的使用
实现InitializingBean的org.springframework.mail.javamail中的类 修饰符和类型 类 说明 class
ConfigurableMimeFileTypeMap
Spring-configurableFileTypeMap
implementation that will read MIME type to file extension mappings from a standard JavaMail MIME type mapping file, using a standardMimetypesFileTypeMap
underneath.org.springframework.messaging.core中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.core中的类 修饰符和类型 类 说明 class
CachingDestinationResolverProxy<D>
DestinationResolver
implementation that proxies a target DestinationResolver, caching itsCachingDestinationResolverProxy.resolveDestination(java.lang.String)
results.org.springframework.messaging.handler.annotation.reactive中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.annotation.reactive中的类 修饰符和类型 类 说明 class
MessageMappingMessageHandler
Extension ofAbstractMethodMessageHandler
for reactive, non-blocking handling of messages via@MessageMapping
methods.org.springframework.messaging.handler.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.annotation.support中的类 修饰符和类型 类 说明 class
DefaultMessageHandlerMethodFactory
The defaultMessageHandlerMethodFactory
implementation creating anInvocableHandlerMethod
with the necessaryHandlerMethodArgumentResolver
instances to detect and process most of the use cases defined byMessageMapping
.org.springframework.messaging.handler.invocation中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.invocation中的类 修饰符和类型 类 说明 class
AbstractMethodMessageHandler<T>
Abstract base class for HandlerMethod-based message handling.org.springframework.messaging.handler.invocation.reactive中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.invocation.reactive中的类 修饰符和类型 类 说明 class
AbstractMethodMessageHandler<T>
Abstract base class for reactive HandlerMethod-based message handling.org.springframework.messaging.rsocket.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.rsocket.annotation.support中的类 修饰符和类型 类 说明 class
RSocketMessageHandler
Extension ofMessageMappingMessageHandler
for handling RSocket requests with@ConnectMapping
and@MessageMapping
methods.org.springframework.messaging.simp.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.simp.annotation.support中的类 修饰符和类型 类 说明 class
SimpAnnotationMethodMessageHandler
A handler for messages delegating to@MessageMapping
and@SubscribeMapping
annotated methods.org.springframework.orm.hibernate5中InitializingBean的使用
实现InitializingBean的org.springframework.orm.hibernate5中的类 修饰符和类型 类 说明 class
HibernateTemplate
Helper class that simplifies Hibernate data access code.class
HibernateTransactionManager
PlatformTransactionManager
implementation for a single HibernateSessionFactory
.class
LocalSessionFactoryBean
FactoryBean
that creates a HibernateSessionFactory
.org.springframework.orm.hibernate5.support中InitializingBean的使用
实现InitializingBean的org.springframework.orm.hibernate5.support中的类 修饰符和类型 类 说明 class
HibernateDaoSupport
Convenient super class for Hibernate-based data access objects.class
OpenSessionInterceptor
Simple AOP AllianceMethodInterceptor
implementation that binds a new HibernateSession
for each method invocation, if none bound before.class
OpenSessionInViewFilter
Servlet Filter that binds a Hibernate Session to the thread for the entire processing of the request.org.springframework.orm.jpa中InitializingBean的使用
实现InitializingBean的org.springframework.orm.jpa中的类 修饰符和类型 类 说明 class
AbstractEntityManagerFactoryBean
AbstractFactoryBean
that creates a local JPAEntityManagerFactory
instance within a Spring application context.class
JpaTransactionManager
PlatformTransactionManager
implementation for a single JPAEntityManagerFactory
.class
LocalContainerEntityManagerFactoryBean
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard container bootstrap contract.class
LocalEntityManagerFactoryBean
FactoryBean
that creates a JPAEntityManagerFactory
according to JPA's standard standalone bootstrap contract.org.springframework.orm.jpa.persistenceunit中InitializingBean的使用
实现InitializingBean的org.springframework.orm.jpa.persistenceunit中的类 修饰符和类型 类 说明 class
DefaultPersistenceUnitManager
Default implementation of thePersistenceUnitManager
interface.org.springframework.orm.jpa.support中InitializingBean的使用
实现InitializingBean的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
SharedEntityManagerBean
FactoryBean
that exposes a shared JPAEntityManager
reference for a given EntityManagerFactory.org.springframework.oxm.jaxb中InitializingBean的使用
实现InitializingBean的org.springframework.oxm.jaxb中的类 修饰符和类型 类 说明 class
Jaxb2Marshaller
Implementation of theGenericMarshaller
interface for JAXB 2.2.org.springframework.oxm.jibx中InitializingBean的使用
实现InitializingBean的org.springframework.oxm.jibx中的类 修饰符和类型 类 说明 class
JibxMarshaller
已过时。as of Spring Framework 5.1.5, due to the lack of activity on the JiBX projectorg.springframework.oxm.xstream中InitializingBean的使用
实现InitializingBean的org.springframework.oxm.xstream中的类 修饰符和类型 类 说明 class
XStreamMarshaller
Implementation of theMarshaller
interface for XStream.org.springframework.remoting.caucho中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.caucho中的类 修饰符和类型 类 说明 class
HessianClientInterceptor
MethodInterceptor
for accessing a Hessian service.class
HessianExporter
General stream-based protocol exporter for a Hessian endpoint.class
HessianProxyFactoryBean
FactoryBean
for Hessian proxies.class
HessianServiceExporter
Servlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.class
SimpleHessianServiceExporter
已过时。as of Spring Framework 5.1, in favor ofHessianServiceExporter
org.springframework.remoting.httpinvoker中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.httpinvoker中的类 修饰符和类型 类 说明 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
SimpleHttpInvokerServiceExporter
已过时。as of Spring Framework 5.1, in favor ofHttpInvokerServiceExporter
org.springframework.remoting.jaxws中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.jaxws中的类 修饰符和类型 类 说明 class
AbstractJaxWsServiceExporter
Abstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebService
annotation).class
JaxWsPortClientInterceptor
MethodInterceptor
for accessing a specific port of a JAX-WS service.class
JaxWsPortProxyFactoryBean
FactoryBean
for a specific port of a JAX-WS service.class
LocalJaxWsServiceFactoryBean
FactoryBean
for locally defined JAX-WS Service references.class
SimpleHttpServerJaxWsServiceExporter
已过时。as of Spring Framework 5.1, in favor ofSimpleJaxWsServiceExporter
class
SimpleJaxWsServiceExporter
Simple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebService
annotation) and exporting them with a configured base address (by default "http://localhost:8080/") using the JAX-WS provider's built-in publication support.org.springframework.remoting.rmi中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.rmi中的类 修饰符和类型 类 说明 class
JndiRmiClientInterceptor
MethodInterceptor
for accessing RMI services from JNDI.class
JndiRmiProxyFactoryBean
FactoryBean
for RMI proxies from JNDI.class
JndiRmiServiceExporter
Service exporter which binds RMI services to JNDI.class
RemoteInvocationSerializingExporter
Abstract base class for remote service exporters that explicitly deserializeRemoteInvocation
objects and serializeRemoteInvocationResult
objects, for example Spring's HTTP invoker.class
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
RmiRegistryFactoryBean
FactoryBean
that locates aRegistry
and exposes it for bean references.class
RmiServiceExporter
RMI exporter that exposes the specified service as RMI object with the specified name.org.springframework.remoting.support中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.support中的类 修饰符和类型 类 说明 class
RemoteInvocationBasedAccessor
Abstract base class for remote service accessors that are based on serialization ofRemoteInvocation
objects.class
SimpleHttpServerFactoryBean
已过时。as of Spring Framework 5.1, in favor of embedded Tomcat/Jetty/Undertowclass
UrlBasedRemoteAccessor
Abstract base class for classes that access remote services via URLs.org.springframework.scheduling.commonj中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.commonj中的类 修饰符和类型 类 说明 class
TimerManagerAccessor
已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskScheduler
class
TimerManagerFactoryBean
已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskScheduler
class
TimerManagerTaskScheduler
已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskScheduler
class
WorkManagerTaskExecutor
已过时。as of 5.1, in favor of the EE 7/8 basedDefaultManagedTaskExecutor
org.springframework.scheduling.concurrent中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.concurrent中的类 修饰符和类型 类 说明 class
DefaultManagedAwareThreadFactory
JNDI-based variant ofCustomizableThreadFactory
, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment, falling back to the localCustomizableThreadFactory
setup if not found.class
DefaultManagedTaskExecutor
JNDI-based variant ofConcurrentTaskExecutor
, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7/8 environment.class
DefaultManagedTaskScheduler
JNDI-based variant ofConcurrentTaskScheduler
, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment.class
ExecutorConfigurationSupport
Base class for setting up aExecutorService
(typically aThreadPoolExecutor
orScheduledThreadPoolExecutor
).class
ForkJoinPoolFactoryBean
A SpringFactoryBean
that builds and exposes a preconfiguredForkJoinPool
.class
ScheduledExecutorFactoryBean
FactoryBean
that sets up aScheduledExecutorService
(by default: aScheduledThreadPoolExecutor
) and exposes it for bean references.class
ThreadPoolExecutorFactoryBean
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorService
type.class
ThreadPoolTaskExecutor
JavaBean that allows for configuring aThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor
.class
ThreadPoolTaskScheduler
Implementation of Spring'sTaskScheduler
interface, wrapping a nativeScheduledThreadPoolExecutor
.org.springframework.scheduling.config中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.config中的类 修饰符和类型 类 说明 class
ContextLifecycleScheduledTaskRegistrar
ScheduledTaskRegistrar
subclass which redirects the actual scheduling of tasks to theContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated()
callback (as of 4.1.2).class
ScheduledTaskRegistrar
Helper bean for registering tasks with aTaskScheduler
, typically using cron expressions.class
TaskExecutorFactoryBean
FactoryBean
for creatingThreadPoolTaskExecutor
instances, primarily used behind the XML task namespace.org.springframework.scheduling.quartz中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.quartz中的类 修饰符和类型 类 说明 class
CronTriggerFactoryBean
A SpringFactoryBean
for creating a QuartzCronTrigger
instance, supporting bean-style usage for trigger configuration.class
JobDetailFactoryBean
A SpringFactoryBean
for creating a QuartzJobDetail
instance, supporting bean-style usage for JobDetail configuration.class
MethodInvokingJobDetailFactoryBean
FactoryBean
that exposes aJobDetail
object which delegates job execution to a specified (static or non-static) method.class
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a givenScheduler
instance.class
SchedulerFactoryBean
FactoryBean
that creates and configures a QuartzScheduler
, manages its lifecycle as part of the Spring application context, and exposes the Scheduler as bean reference for dependency injection.class
SimpleThreadPoolTaskExecutor
Subclass of Quartz's SimpleThreadPool that implements Spring'sTaskExecutor
interface and listens to Spring lifecycle callbacks.class
SimpleTriggerFactoryBean
A SpringFactoryBean
for creating a QuartzSimpleTrigger
instance, supporting bean-style usage for trigger configuration.org.springframework.scheduling.support中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.support中的类 修饰符和类型 类 说明 class
MethodInvokingRunnable
Adapter that implements theRunnable
interface as a configurable method invocation based on Spring's MethodInvoker.org.springframework.transaction.config中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.config中的类 修饰符和类型 类 说明 class
JtaTransactionManagerFactoryBean
AFactoryBean
equivalent to the <tx:jta-transaction-manager/> XML element, autodetecting WebLogic and WebSphere servers and exposing the correspondingJtaTransactionManager
subclass.org.springframework.transaction.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.interceptor中的类 修饰符和类型 类 说明 class
MethodMapTransactionAttributeSource
SimpleTransactionAttributeSource
implementation that allows attributes to be stored per method in aMap
.class
TransactionAspectSupport
Base class for transactional aspects, such as theTransactionInterceptor
or an AspectJ aspect.class
TransactionInterceptor
AOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager
/ReactiveTransactionManager
).class
TransactionProxyFactoryBean
Proxy factory bean for simplified declarative transaction handling.org.springframework.transaction.jta中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.jta中的类 修饰符和类型 类 说明 class
JtaTransactionManager
PlatformTransactionManager
implementation for JTA, delegating to a backend JTA provider.class
WebLogicJtaTransactionManager
SpecialJtaTransactionManager
variant for BEA WebLogic (9.0 and higher).class
WebSphereUowTransactionManager
WebSphere-specific PlatformTransactionManager implementation that delegates to aUOWManager
instance, obtained from WebSphere's JNDI environment.org.springframework.transaction.support中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.support中的类 修饰符和类型 类 说明 class
TransactionTemplate
Template class that simplifies programmatic transaction demarcation and transaction exception handling.org.springframework.ui.freemarker中InitializingBean的使用
实现InitializingBean的org.springframework.ui.freemarker中的类 修饰符和类型 类 说明 class
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker Configuration and provides it as bean reference.org.springframework.validation.beanvalidation中InitializingBean的使用
实现InitializingBean的org.springframework.validation.beanvalidation中的类 修饰符和类型 类 说明 class
BeanValidationPostProcessor
SimpleBeanPostProcessor
that checks JSR-303 constraint annotations in Spring-managed beans, throwing an initialization exception in case of constraint violations right before calling the bean's init method (if any).class
CustomValidatorBean
Configurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the SpringValidator
interface.class
LocalValidatorFactoryBean
This is the central class forjavax.validation
(JSR-303) setup in a Spring application context: It bootstraps ajavax.validation.ValidationFactory
and exposes it through the SpringValidator
interface as well as through the JSR-303Validator
interface and theValidatorFactory
interface itself.class
MethodValidationPostProcessor
A convenientBeanPostProcessor
implementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.class
OptionalValidatorFactoryBean
LocalValidatorFactoryBean
subclass that simply turnsValidator
calls into no-ops in case of no Bean Validation provider being available.org.springframework.web.accept中InitializingBean的使用
实现InitializingBean的org.springframework.web.accept中的类 修饰符和类型 类 说明 class
ContentNegotiationManagerFactoryBean
Factory to create aContentNegotiationManager
and configure it withContentNegotiationStrategy
instances.org.springframework.web.context.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.context.support中的类 修饰符和类型 类 说明 class
AbstractRefreshableWebApplicationContext
AbstractRefreshableApplicationContext
subclass which implements theConfigurableWebApplicationContext
interface for web environments.class
AnnotationConfigWebApplicationContext
WebApplicationContext
implementation which accepts component classes as input — in particular@Configuration
-annotated classes, but also plain@Component
classes and JSR-330 compliant classes usingjavax.inject
annotations.class
GroovyWebApplicationContext
WebApplicationContext
implementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader
.class
XmlWebApplicationContext
WebApplicationContext
implementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader
.org.springframework.web.filter中InitializingBean的使用
实现InitializingBean的org.springframework.web.filter中的类 修饰符和类型 类 说明 class
AbstractRequestLoggingFilter
Base class forFilter
s that perform logging operations before and after a request is processed.class
CharacterEncodingFilter
Servlet Filter that allows one to specify a character encoding for requests.class
CommonsRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.class
CorsFilter
Filter
that handles CORS preflight requests and intercepts CORS simple and actual requests thanks to aCorsProcessor
implementation (DefaultCorsProcessor
by default) in order to add the relevant CORS response headers (likeAccess-Control-Allow-Origin
) using the providedCorsConfigurationSource
(for example anUrlBasedCorsConfigurationSource
instance.class
DelegatingFilterProxy
Proxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.class
FormContentFilter
Filter
that parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.class
ForwardedHeaderFilter
Extract values from "Forwarded" and "X-Forwarded-*" headers, wrap the request and response, and make they reflect the client-originated protocol and address in the following methods:getServerName()
getServerPort()
getScheme()
isSecure()
sendRedirect(String)
.class
GenericFilterBean
Simple base implementation ofFilter
which treats its config parameters (init-param
entries within thefilter
tag inweb.xml
) as bean properties.class
HiddenHttpMethodFilter
Filter
that converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod()
.class
HttpPutFormContentFilter
已过时。as of 5.1 in favor ofFormContentFilter
which is the same but also handles DELETE.class
OncePerRequestFilter
Filter base class that aims to guarantee a single execution per request dispatch, on any servlet container.class
RelativeRedirectFilter
OverridesHttpServletResponse.sendRedirect(String)
and handles it by setting the HTTP status and "Location" headers, which keeps the Servlet container from re-writing relative redirect URLs into absolute ones.class
RequestContextFilter
Servlet Filter that exposes the request to the current thread, through bothLocaleContextHolder
andRequestContextHolder
.class
ServletContextRequestLoggingFilter
Simple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.class
ShallowEtagHeaderFilter
Filter
that generates anETag
value based on the content on the response.org.springframework.web.multipart.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.multipart.support中的类 修饰符和类型 类 说明 class
MultipartFilter
Servlet Filter that resolves multipart requests via aMultipartResolver
.org.springframework.web.reactive.function.server.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.function.server.support中的类 修饰符和类型 类 说明 class
RouterFunctionMapping
HandlerMapping
implementation that supportsRouterFunctions
.class
ServerResponseResultHandler
HandlerResultHandler
implementation that supportsServerResponses
.org.springframework.web.reactive.resource中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.resource中的类 修饰符和类型 类 说明 class
ResourceWebHandler
HttpRequestHandler
that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.org.springframework.web.reactive.result.method中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.method中的类 修饰符和类型 类 说明 class
AbstractHandlerMethodMapping<T>
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
RequestMappingInfoHandlerMapping
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method.org.springframework.web.reactive.result.method.annotation中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.method.annotation中的类 修饰符和类型 类 说明 class
RequestMappingHandlerAdapter
Supports the invocation of@RequestMapping
handler methods.class
RequestMappingHandlerMapping
An extension ofRequestMappingInfoHandlerMapping
that createsRequestMappingInfo
instances from class-level and method-level@RequestMapping
annotations.org.springframework.web.reactive.result.view中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.view中的类 修饰符和类型 类 说明 class
AbstractUrlBasedView
Abstract base class for URL-based views.class
RedirectView
View that redirects to an absolute or context relative URL.class
UrlBasedViewResolver
AViewResolver
that allows direct resolution of symbolic view names to URLs without explicit mapping definitions.org.springframework.web.reactive.result.view.freemarker中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.view.freemarker中的类 修饰符和类型 类 说明 class
FreeMarkerConfigurer
Configures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.class
FreeMarkerView
AView
implementation that uses the FreeMarker template engine.class
FreeMarkerViewResolver
AViewResolver
for resolvingFreeMarkerView
instances, i.e.org.springframework.web.reactive.result.view.script中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.view.script中的类 修饰符和类型 类 说明 class
ScriptTemplateView
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.class
ScriptTemplateViewResolver
Convenience subclass ofUrlBasedViewResolver
that supportsScriptTemplateView
and custom subclasses of it.org.springframework.web.servlet.function.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.function.support中的类 修饰符和类型 类 说明 class
RouterFunctionMapping
HandlerMapping
implementation that supportsRouterFunctions
.org.springframework.web.servlet.handler中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.handler中的类 修饰符和类型 类 说明 class
AbstractHandlerMethodMapping<T>
Abstract base class forHandlerMapping
implementations that define a mapping between a request and aHandlerMethod
.class
HandlerMappingIntrospector
Helper class to get information from theHandlerMapping
that would serve a specific request.org.springframework.web.servlet.mvc中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.mvc中的类 修饰符和类型 类 说明 class
ServletWrappingController
Spring Controller implementation that wraps a servlet instance which it manages internally.org.springframework.web.servlet.mvc.method中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.mvc.method中的类 修饰符和类型 类 说明 class
RequestMappingInfoHandlerMapping
Abstract base class for classes for whichRequestMappingInfo
defines the mapping between a request and a handler method.org.springframework.web.servlet.mvc.method.annotation中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.mvc.method.annotation中的类 修饰符和类型 类 说明 class
ExceptionHandlerExceptionResolver
AnAbstractHandlerMethodExceptionResolver
that resolves exceptions through@ExceptionHandler
methods.class
RequestMappingHandlerAdapter
class
RequestMappingHandlerMapping
CreatesRequestMappingInfo
instances from type and method-level@RequestMapping
annotations in@Controller
classes.org.springframework.web.servlet.resource中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.resource中的类 修饰符和类型 类 说明 class
ResourceHttpRequestHandler
HttpRequestHandler
that serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.class
ResourceUrlEncodingFilter
A filter that wraps theHttpServletResponse
and overrides itsencodeURL
method in order to translate internal resource request URLs into public URL paths for external use.org.springframework.web.servlet.view中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view中的类 修饰符和类型 类 说明 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
AbstractUrlBasedView
Abstract base class for URL-based views.class
ContentNegotiatingViewResolver
Implementation ofViewResolver
that resolves a view based on the request file name orAccept
header.class
InternalResourceView
Wrapper for a JSP or other resource within the same web application.class
JstlView
Specialization ofInternalResourceView
for JSTL pages, i.e.class
RedirectView
View that redirects to an absolute, context relative, or current request relative URL.class
ResourceBundleViewResolver
AViewResolver
implementation that uses bean definitions in aResourceBundle
, specified by the bundle basename.class
ViewResolverComposite
AViewResolver
that delegates to others.class
XmlViewResolver
AViewResolver
implementation that uses bean definitions in a dedicated XML file for view definitions, specified by resource location.org.springframework.web.servlet.view.document中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.document中的类 修饰符和类型 类 说明 class
AbstractPdfStamperView
Abstract superclass for PDF views that operate on an existing document with an AcroForm.org.springframework.web.servlet.view.freemarker中InitializingBean的使用
实现InitializingBean的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.org.springframework.web.servlet.view.groovy中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.groovy中的类 修饰符和类型 类 说明 class
GroovyMarkupConfigurer
An extension of Groovy'sTemplateConfiguration
and an implementation of Spring MVC'sGroovyMarkupConfig
for creating aMarkupTemplateEngine
for use in a web application.class
GroovyMarkupView
AnAbstractTemplateView
subclass based on Groovy XML/XHTML markup templates.org.springframework.web.servlet.view.script中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.script中的类 修饰符和类型 类 说明 class
ScriptTemplateView
AnAbstractUrlBasedView
subclass designed to run any template library based on a JSR-223 script engine.org.springframework.web.servlet.view.tiles3中InitializingBean的使用
实现InitializingBean的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.org.springframework.web.servlet.view.xslt中InitializingBean的使用
实现InitializingBean的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.org.springframework.web.socket.messaging中InitializingBean的使用
实现InitializingBean的org.springframework.web.socket.messaging中的类 修饰符和类型 类 说明 class
WebSocketAnnotationMethodMessageHandler
A sub-class ofSimpAnnotationMethodMessageHandler
to provide support forControllerAdvice
with global@MessageExceptionHandler
methods.org.springframework.web.socket.server.standard中InitializingBean的使用
实现InitializingBean的org.springframework.web.socket.server.standard中的类 修饰符和类型 类 说明 class
ServerEndpointExporter
Detects beans of typeServerEndpointConfig
and registers with the standard Java WebSocket runtime.class
ServletServerContainerFactoryBean
AFactoryBean
for configuringServerContainer
.