接口的使用
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.concurrentbased 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.timepackage 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 includingClientHttpRequestandClientHttpResponseas 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.corepackage.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.corepackage.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.corepackage.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 remoteMBeanServers and for exposing anMBeanServerto 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.hibernate5package.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.jpapackage.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.concurrentandjavax.enterprise.concurrentpackages, 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.contextpackage, 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.serverpackage.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.functionpackage.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.methodpackage.org.springframework.web.servlet.mvc.method.annotation MVC infrastructure for annotation-based handler method processing, building on theorg.springframework.web.method.annotationpackage.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中的类 修饰符和类型 类 说明 classAbstractSingletonProxyFactoryBeanConvenient superclass forFactoryBeantypes that produce singleton-scoped proxy objects.org.springframework.beans.factory.config中InitializingBean的使用
实现InitializingBean的org.springframework.beans.factory.config中的类 修饰符和类型 类 说明 classAbstractFactoryBean<T>Simple template superclass forFactoryBeanimplementations that creates a singleton or a prototype object, depending on a flag.classFieldRetrievingFactoryBeanFactoryBeanwhich retrieves a static or non-static field value.classListFactoryBeanSimple factory for shared List instances.classMapFactoryBeanSimple factory for shared Map instances.classMethodInvokingBeanSimple method invoker bean: just invoking a target method, not expecting a result to expose to the container (in contrast toMethodInvokingFactoryBean).classMethodInvokingFactoryBeanFactoryBeanwhich returns a value which is the result of a static or instance method invocation.classObjectFactoryCreatingFactoryBeanAFactoryBeanimplementation that returns a value which is anObjectFactorythat in turn returns a bean sourced from aBeanFactory.classPreferencesPlaceholderConfigurer已过时。as of 5.2, along withPropertyPlaceholderConfigurerclassPropertiesFactoryBeanAllows for making a properties file from a classpath location available as Properties instance in a bean factory.classProviderCreatingFactoryBeanAFactoryBeanimplementation that returns a value which is a JSR-330Providerthat in turn returns a bean sourced from aBeanFactory.classServiceLocatorFactoryBeanAFactoryBeanimplementation 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.classSetFactoryBeanSimple factory for shared Set instances.classYamlMapFactoryBeanFactory for aMapthat reads from a YAML source, preserving the YAML-declared value types and their structure.classYamlPropertiesFactoryBeanFactory forPropertiesthat 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中的类 修饰符和类型 类 说明 classAbstractServiceLoaderBasedFactoryBeanAbstract base class for FactoryBeans operating on the JDK 1.6ServiceLoaderfacility.classServiceFactoryBeanFactoryBeanthat exposes the 'primary' service for the configured service class, obtained through the JDK 1.6ServiceLoaderfacility.classServiceListFactoryBeanFactoryBeanthat exposes all services for the configured service class, represented as a List of service objects, obtained through the JDK 1.6ServiceLoaderfacility.classServiceLoaderFactoryBeanFactoryBeanthat exposes the JDK 1.6ServiceLoaderfor the configured service class.org.springframework.beans.factory.wiring中InitializingBean的使用
实现InitializingBean的org.springframework.beans.factory.wiring中的类 修饰符和类型 类 说明 classBeanConfigurerSupportConvenient 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中的类 修饰符和类型 类 说明 classConcurrentMapCacheFactoryBeanFactoryBeanfor easy configuration of aConcurrentMapCachewhen used within a Spring container.org.springframework.cache.ehcache中InitializingBean的使用
实现InitializingBean的org.springframework.cache.ehcache中的类 修饰符和类型 类 说明 classEhCacheCacheManagerCacheManager backed by an EhCacheCacheManager.classEhCacheFactoryBeanFactoryBeanthat creates a named EhCacheCacheinstance (or a decorator that implements theEhcacheinterface), representing a cache region within an EhCacheCacheManager.classEhCacheManagerFactoryBeanFactoryBeanthat exposes an EhCacheCacheManagerinstance (independent or shared), configured from a specified config location.org.springframework.cache.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.cache.interceptor中的类 修饰符和类型 类 说明 classAbstractCacheResolverA baseCacheResolverimplementation that requires the concrete implementation to provide the collection of cache name(s) based on the invocation context.classCacheAspectSupportBase class for caching aspects, such as theCacheInterceptoror an AspectJ aspect.classCacheInterceptorAOP Alliance MethodInterceptor for declarative cache management using the common Spring caching infrastructure (Cache).classCacheProxyFactoryBeanProxy factory bean for simplified declarative caching handling.classNamedCacheResolverACacheResolverthat forces the resolution to a configurable collection of name(s) against a givenCacheManager.classSimpleCacheResolverA simpleCacheResolverthat resolves theCacheinstance(s) based on a configurableCacheManagerand the name of the cache(s) as provided bygetCacheNames().org.springframework.cache.jcache中InitializingBean的使用
实现InitializingBean的org.springframework.cache.jcache中的类 修饰符和类型 类 说明 classJCacheCacheManagerCacheManagerimplementation backed by a JCachejavax.cache.CacheManager.classJCacheManagerFactoryBeanFactoryBeanfor a JCachejavax.cache.CacheManager, obtaining a pre-definedCacheManagerby name through the standard JCachejavax.cache.Cachingclass.org.springframework.cache.jcache.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.cache.jcache.interceptor中的类 修饰符和类型 类 说明 classJCacheAspectSupportBase class for JSR-107 caching aspects, such as theJCacheInterceptoror an AspectJ aspect.classJCacheInterceptorAOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.classSimpleExceptionCacheResolverA simpleCacheResolverthat resolves the exception cache based on a configurableCacheManagerand the name of the cache:CacheResultOperation.getExceptionCacheName().org.springframework.cache.support中InitializingBean的使用
实现InitializingBean的org.springframework.cache.support中的类 修饰符和类型 类 说明 classAbstractCacheManagerAbstract base class implementing the commonCacheManagermethods.classCompositeCacheManagerCompositeCacheManagerimplementation that iterates over a given collection of delegateCacheManagerinstances.classSimpleCacheManagerSimple cache manager working against a given collection of caches.org.springframework.cache.transaction中InitializingBean的使用
实现InitializingBean的org.springframework.cache.transaction中的类 修饰符和类型 类 说明 classAbstractTransactionSupportingCacheManagerBase class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.classTransactionAwareCacheManagerProxyProxy for a targetCacheManager, exposing transaction-awareCacheobjects 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中的类 修饰符和类型 类 说明 classEventPublicationInterceptorInterceptorthat publishes anApplicationEventto allApplicationListenersregistered with anApplicationEventPublisherafter each successful method invocation.org.springframework.context.support中InitializingBean的使用
实现InitializingBean的org.springframework.context.support中的类 修饰符和类型 类 说明 classAbstractRefreshableConfigApplicationContextAbstractRefreshableApplicationContextsubclass that adds common handling of specified config locations.classAbstractXmlApplicationContextConvenient base class forApplicationContextimplementations, drawing configuration from XML documents containing bean definitions understood by anXmlBeanDefinitionReader.classClassPathXmlApplicationContextStandalone 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.classConversionServiceFactoryBeanA factory providing convenient access to a ConversionService configured with converters appropriate for most environments.classFileSystemXmlApplicationContextStandalone 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中的类 修饰符和类型 类 说明 classDaoSupportGeneric base class for DAOs, defining template methods for DAO initialization.classPersistenceExceptionTranslationInterceptorAOP Alliance MethodInterceptor that provides persistence exception translation based on a given PersistenceExceptionTranslator.org.springframework.ejb.access中InitializingBean的使用
实现InitializingBean的org.springframework.ejb.access中的类 修饰符和类型 类 说明 classAbstractRemoteSlsbInvokerInterceptorBase class for interceptors proxying remote Stateless Session Beans.classAbstractSlsbInvokerInterceptorBase class for AOP interceptors invoking local or remote Stateless Session Beans.classLocalSlsbInvokerInterceptorInvoker for a local Stateless Session Bean.classLocalStatelessSessionProxyFactoryBeanConvenientFactoryBeanfor local Stateless Session Bean (SLSB) proxies.classSimpleRemoteSlsbInvokerInterceptorBasic invoker for a remote Stateless Session Bean.classSimpleRemoteStatelessSessionProxyFactoryBeanConvenientFactoryBeanfor remote SLSB proxies.org.springframework.format.datetime.joda中InitializingBean的使用
实现InitializingBean的org.springframework.format.datetime.joda中的类 修饰符和类型 类 说明 classDateTimeFormatterFactoryBeanFactoryBeanthat creates a Joda-TimeDateTimeFormatter.org.springframework.format.datetime.standard中InitializingBean的使用
实现InitializingBean的org.springframework.format.datetime.standard中的类 修饰符和类型 类 说明 classDateTimeFormatterFactoryBeanFactoryBeanthat creates a JSR-310DateTimeFormatter.org.springframework.format.support中InitializingBean的使用
实现InitializingBean的org.springframework.format.support中的类 修饰符和类型 类 说明 classFormattingConversionServiceFactoryBeanA factory providing convenient access to aFormattingConversionServiceconfigured with converters and formatters for common types such as numbers and datetimes.org.springframework.http.client中InitializingBean的使用
实现InitializingBean的org.springframework.http.client中的类 修饰符和类型 类 说明 classHttpComponentsAsyncClientHttpRequestFactory已过时。as of Spring 5.0, with no direct replacementclassNetty4ClientHttpRequestFactory已过时。as of Spring 5.0, in favor ofReactorClientHttpConnectororg.springframework.http.client.reactive中InitializingBean的使用
实现InitializingBean的org.springframework.http.client.reactive中的类 修饰符和类型 类 说明 classJettyResourceFactoryFactory to manage Jetty resources, i.e.classReactorResourceFactoryFactory to manage Reactor Netty resources, i.e.org.springframework.http.client.support中InitializingBean的使用
实现InitializingBean的org.springframework.http.client.support中的类 修饰符和类型 类 说明 classProxyFactoryBeanFactoryBeanthat creates ajava.net.Proxy.org.springframework.http.converter.json中InitializingBean的使用
实现InitializingBean的org.springframework.http.converter.json中的类 修饰符和类型 类 说明 classGsonFactoryBeanAFactoryBeanfor creating a Google Gson 2.xGsoninstance.classJackson2ObjectMapperFactoryBeanAFactoryBeanfor creating a Jackson 2.xObjectMapper(default) orXmlMapper(createXmlMapperproperty 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中的类 修饰符和类型 类 说明 classCciLocalTransactionManagerPlatformTransactionManagerimplementation that manages local transactions for a single CCI ConnectionFactory.classConnectionSpecConnectionFactoryAdapterAn adapter for a target CCIConnectionFactory, applying the given ConnectionSpec to every standardgetConnection()call, that is, implicitly invokinggetConnection(ConnectionSpec)on the target.classDelegatingConnectionFactoryCCIConnectionFactoryimplementation that delegates all calls to a given targetConnectionFactory.classSingleConnectionFactoryA CCI ConnectionFactory adapter that returns the same Connection on allgetConnectioncalls, and ignores calls toConnection.close().classTransactionAwareConnectionFactoryProxyProxy for a target CCIConnectionFactory, adding awareness of Spring-managed transactions.org.springframework.jca.cci.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jca.cci.core.support中的类 修饰符和类型 类 说明 classCciDaoSupportConvenient super class for CCI-based data access objects.org.springframework.jca.cci.object中InitializingBean的使用
实现InitializingBean的org.springframework.jca.cci.object中的类 修饰符和类型 类 说明 classEisOperationBase class for EIS operation objects that work with the CCI API.classMappingCommAreaOperationEIS operation object for access to COMMAREA records.classMappingRecordOperationEIS operation object that expects mapped input and output objects, converting to and from CCI Records.classSimpleRecordOperationEIS 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中的类 修饰符和类型 类 说明 classGenericMessageEndpointManagerGeneric 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中的类 修饰符和类型 类 说明 classLocalConnectionFactoryBeanFactoryBeanthat creates a local JCA connection factory in "non-managed" mode (as defined by the Java Connector Architecture specification).classResourceAdapterFactoryBeanFactoryBeanthat bootstraps the specified JCA 1.7ResourceAdapter, starting it with a localBootstrapContextand exposing it for bean references.org.springframework.jca.work中InitializingBean的使用
实现InitializingBean的org.springframework.jca.work中的类 修饰符和类型 类 说明 classWorkManagerTaskExecutorTaskExecutorimplementation that delegates to a JCA 1.7 WorkManager, implementing theWorkManagerinterface.org.springframework.jdbc.config中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.config中的类 修饰符和类型 类 说明 classSortedResourcesFactoryBeanFactoryBeanimplementation that takes a list of location Strings and creates a sorted array ofResourceinstances.org.springframework.jdbc.core中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.core中的类 修饰符和类型 类 说明 classJdbcTemplateThis 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中的类 修饰符和类型 类 说明 classNamedParameterJdbcDaoSupportExtension of JdbcDaoSupport that exposes a NamedParameterJdbcTemplate as well.org.springframework.jdbc.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.core.support中的类 修饰符和类型 类 说明 classJdbcDaoSupportConvenient super class for JDBC-based data access objects.org.springframework.jdbc.datasource中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource中的类 修饰符和类型 类 说明 classDataSourceTransactionManagerPlatformTransactionManagerimplementation for a single JDBCDataSource.classDelegatingDataSourceJDBCDataSourceimplementation that delegates all calls to a given targetDataSource.classIsolationLevelDataSourceAdapterAn adapter for a targetDataSource, applying the current Spring transaction's isolation level (and potentially specified user credentials) to everygetConnectioncall.classLazyConnectionDataSourceProxyProxy for a target DataSource, fetching actual JDBC Connections lazily, i.e. not until first creation of a Statement.classTransactionAwareDataSourceProxyProxy for a target JDBCDataSource, adding awareness of Spring-managed transactions.classUserCredentialsDataSourceAdapterAn adapter for a target JDBCDataSource, applying the specified user credentials to every standardgetConnection()call, implicitly invokinggetConnection(username, password)on the target.classWebSphereDataSourceAdapterDataSourceimplementation 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中的类 修饰符和类型 类 说明 classEmbeddedDatabaseFactoryBeanA subclass ofEmbeddedDatabaseFactorythat implementsFactoryBeanfor registration as a Spring bean.org.springframework.jdbc.datasource.init中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource.init中的类 修饰符和类型 类 说明 classDataSourceInitializerorg.springframework.jdbc.datasource.lookup中InitializingBean的使用
实现InitializingBean的org.springframework.jdbc.datasource.lookup中的类 修饰符和类型 类 说明 classAbstractRoutingDataSourceAbstractDataSourceimplementation that routesAbstractRoutingDataSource.getConnection()calls to one of various target DataSources based on a lookup key.classIsolationLevelDataSourceRouterDataSource 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中的类 修饰符和类型 类 说明 classBatchSqlUpdateSqlUpdate subclass that performs batch update operations.classGenericSqlQuery<T>classGenericStoredProcedureConcrete implementation making it possible to define the RDBMS stored procedures in an application context without writing a custom Java implementation class.classMappingSqlQuery<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.classMappingSqlQueryWithParameters<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.classRdbmsOperationAn "RDBMS operation" is a multi-threaded, reusable object representing a query, update, or stored procedure call.classSqlCallRdbmsOperation using a JdbcTemplate and representing an SQL-based call such as a stored procedure or a stored function.classSqlFunction<T>SQL "function" wrapper for a query that returns a single row of results.classSqlOperationOperation object representing an SQL-based operation such as a query or update, as opposed to a stored procedure.classSqlQuery<T>Reusable operation object representing an SQL query.classSqlUpdateReusable operation object representing an SQL update.classStoredProcedureSuperclass for object abstractions of RDBMS stored procedures.classUpdatableSqlQuery<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中的类 修饰符和类型 类 说明 classCustomSQLExceptionTranslatorRegistrarRegistry for customSQLExceptionTranslatorinstances for specific databases.classDatabaseStartupValidatorBean that checks if a database has already started up.classJdbcAccessorBase class forJdbcTemplateand 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中的类 修饰符和类型 类 说明 classAbstractColumnMaxValueIncrementerAbstract base class forDataFieldMaxValueIncrementerimplementations that use a column in a custom sequence table.classAbstractDataFieldMaxValueIncrementerBase implementation ofDataFieldMaxValueIncrementerthat delegates to a singleAbstractDataFieldMaxValueIncrementer.getNextKey()template method that returns along.classAbstractIdentityColumnMaxValueIncrementerAbstract base class forDataFieldMaxValueIncrementerimplementations which are based on identity columns in a sequence-like table.classAbstractSequenceMaxValueIncrementerAbstract base class forDataFieldMaxValueIncrementerimplementations that use a database sequence.classDb2LuwMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given sequence on DB2 LUW (for Linux, Unix and Windows).classDb2MainframeMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given sequence on DB2 for the mainframe (z/OS, DB2/390, DB2/400).classDB2MainframeSequenceMaxValueIncrementer已过时。in favor of the differently namedDb2MainframeMaxValueIncrementerclassDB2SequenceMaxValueIncrementer已过时。in favor of the specifically namedDb2LuwMaxValueIncrementerclassDerbyMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given Derby table with the equivalent of an auto-increment column.classH2SequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given H2 sequence.classHanaSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given SAP HANA sequence.classHsqlMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given HSQL table with the equivalent of an auto-increment column.classHsqlSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given HSQL sequence.classMySQLMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given MySQL table with the equivalent of an auto-increment column.classOracleSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given Oracle sequence.classPostgreSQLSequenceMaxValueIncrementer已过时。in favor of the differently namedPostgresSequenceMaxValueIncrementerclassPostgresSequenceMaxValueIncrementerDataFieldMaxValueIncrementerthat retrieves the next value of a given PostgreSQL sequence.classSqlServerMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given SQL Server table with the equivalent of an auto-increment column.classSybaseAnywhereMaxValueIncrementerDataFieldMaxValueIncrementerthat increments the maximum value of a given Sybase table with the equivalent of an auto-increment column.classSybaseMaxValueIncrementerDataFieldMaxValueIncrementerthat 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中的类 修饰符和类型 类 说明 classJmsListenerEndpointRegistrarHelper bean for registeringJmsListenerEndpointwith aJmsListenerEndpointRegistry.org.springframework.jms.connection中InitializingBean的使用
实现InitializingBean的org.springframework.jms.connection中的类 修饰符和类型 类 说明 classCachingConnectionFactoryclassDelegatingConnectionFactoryConnectionFactoryimplementation that delegates all calls to a given targetConnectionFactory, adapting specificcreate(Queue/Topic)Connectioncalls 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).classJmsTransactionManagerPlatformTransactionManagerimplementation for a single JMSConnectionFactory.classSingleConnectionFactoryA JMS ConnectionFactory adapter that returns the same Connection from allSingleConnectionFactory.createConnection()calls, and ignores calls toConnection.close().classUserCredentialsConnectionFactoryAdapterAn 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中的类 修饰符和类型 类 说明 classJmsMessagingTemplateAn implementation ofJmsMessageOperations.classJmsTemplateHelper class that simplifies synchronous JMS access code.org.springframework.jms.core.support中InitializingBean的使用
实现InitializingBean的org.springframework.jms.core.support中的类 修饰符和类型 类 说明 classJmsGatewaySupportConvenient super class for application classes that need JMS access.org.springframework.jms.listener中InitializingBean的使用
实现InitializingBean的org.springframework.jms.listener中的类 修饰符和类型 类 说明 classAbstractJmsListeningContainerCommon base class for all containers which need to implement listening based on a JMS Connection (either shared or freshly obtained for each attempt).classAbstractMessageListenerContainerAbstract base class for Spring message listener container implementations.classAbstractPollingMessageListenerContainerBase class for listener container implementations which are based on polling.classDefaultMessageListenerContainerMessage 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).classSimpleMessageListenerContainerMessage 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中的类 修饰符和类型 类 说明 classJmsMessageEndpointManagerExtension of the generic JCA 1.5GenericMessageEndpointManager, adding JMS-specific support for ActivationSpec configuration.org.springframework.jms.remoting中InitializingBean的使用
实现InitializingBean的org.springframework.jms.remoting中的类 修饰符和类型 类 说明 classJmsInvokerClientInterceptorMethodInterceptorfor accessing a JMS-based remote service.classJmsInvokerProxyFactoryBeanFactoryBean for JMS invoker proxies.classJmsInvokerServiceExporterJMS 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中的类 修饰符和类型 类 说明 classJmsAccessorBase class forJmsTemplateand other JMS-accessing gateway helpers, defining common properties such as the JMSConnectionFactoryto operate on.org.springframework.jms.support.converter中InitializingBean的使用
实现InitializingBean的org.springframework.jms.support.converter中的类 修饰符和类型 类 说明 classMarshallingMessageConverterclassMessagingMessageConverterConvert aMessagefrom the messaging abstraction to and from aMessageusing an underlyingMessageConverterfor the payload and aJmsHeaderMapperto map the JMS headers to and from standard message headers.org.springframework.jms.support.destination中InitializingBean的使用
实现InitializingBean的org.springframework.jms.support.destination中的类 修饰符和类型 类 说明 classJmsDestinationAccessorBase class forJmsTemplateand other JMS-accessing gateway helpers, adding destination-related properties toJmsAccessor'scommon properties.org.springframework.jmx.access中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.access中的类 修饰符和类型 类 说明 classMBeanClientInterceptorMethodInterceptorthat routes calls to an MBean running on the suppliedMBeanServerConnection.classMBeanProxyFactoryBeanCreates a proxy to a managed resource running either locally or remotely.classNotificationListenerRegistrarRegistrar object that associates a specificNotificationListenerwith one or more MBeans in anMBeanServer(typically via aMBeanServerConnection).org.springframework.jmx.export中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export中的类 修饰符和类型 类 说明 classMBeanExporterJMX 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.classNotificationListenerBeanHelper class that aggregates aNotificationListener, aNotificationFilter, and an arbitrary handback object.org.springframework.jmx.export.annotation中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export.annotation中的类 修饰符和类型 类 说明 classAnnotationMBeanExporterConvenient 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中的类 修饰符和类型 类 说明 classInterfaceBasedMBeanInfoAssemblerSubclass ofAbstractReflectiveMBeanInfoAssemblerthat allows for the management interface of a bean to be defined using arbitrary interfaces.classMetadataMBeanInfoAssemblerImplementation of theMBeanInfoAssemblerinterface that reads the management interface information from source level metadata.org.springframework.jmx.export.naming中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.export.naming中的类 修饰符和类型 类 说明 classKeyNamingStrategyObjectNamingStrategyimplementation that buildsObjectNameinstances from the key used in the "beans" map passed toMBeanExporter.classMetadataNamingStrategyAn implementation of theObjectNamingStrategyinterface that reads theObjectNamefrom the source-level metadata.org.springframework.jmx.support中InitializingBean的使用
实现InitializingBean的org.springframework.jmx.support中的类 修饰符和类型 类 说明 classConnectorServerFactoryBeanFactoryBeanthat creates a JSR-160JMXConnectorServer, optionally registers it with theMBeanServer, and then starts it.classMBeanServerConnectionFactoryBeanFactoryBeanthat creates a JMX 1.2MBeanServerConnectionto a remoteMBeanServerexposed via aJMXServerConnector.classMBeanServerFactoryBeanFactoryBeanthat obtains aMBeanServerreference through the standard JMX 1.2MBeanServerFactoryAPI.classWebSphereMBeanServerFactoryBeanFactoryBeanthat obtains a WebSphereMBeanServerreference through WebSphere's proprietaryAdminServiceFactoryAPI, available on WebSphere 5.1 and higher.org.springframework.jndi中InitializingBean的使用
实现InitializingBean的org.springframework.jndi中的类 修饰符和类型 类 说明 classJndiObjectFactoryBeanFactoryBeanthat looks up a JNDI object.classJndiObjectLocatorConvenient superclass for JNDI-based service locators, providing configurable lookup of a specific JNDI resource.classJndiObjectTargetSourceAOPTargetSourcethat provides configurable JNDI lookups forgetTarget()calls.org.springframework.mail.javamail中InitializingBean的使用
实现InitializingBean的org.springframework.mail.javamail中的类 修饰符和类型 类 说明 classConfigurableMimeFileTypeMapSpring-configurableFileTypeMapimplementation that will read MIME type to file extension mappings from a standard JavaMail MIME type mapping file, using a standardMimetypesFileTypeMapunderneath.org.springframework.messaging.core中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.core中的类 修饰符和类型 类 说明 classCachingDestinationResolverProxy<D>DestinationResolverimplementation 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中的类 修饰符和类型 类 说明 classMessageMappingMessageHandlerExtension ofAbstractMethodMessageHandlerfor reactive, non-blocking handling of messages via@MessageMappingmethods.org.springframework.messaging.handler.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.annotation.support中的类 修饰符和类型 类 说明 classDefaultMessageHandlerMethodFactoryThe defaultMessageHandlerMethodFactoryimplementation creating anInvocableHandlerMethodwith the necessaryHandlerMethodArgumentResolverinstances to detect and process most of the use cases defined byMessageMapping.org.springframework.messaging.handler.invocation中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.invocation中的类 修饰符和类型 类 说明 classAbstractMethodMessageHandler<T>Abstract base class for HandlerMethod-based message handling.org.springframework.messaging.handler.invocation.reactive中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.handler.invocation.reactive中的类 修饰符和类型 类 说明 classAbstractMethodMessageHandler<T>Abstract base class for reactive HandlerMethod-based message handling.org.springframework.messaging.rsocket.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.rsocket.annotation.support中的类 修饰符和类型 类 说明 classRSocketMessageHandlerExtension ofMessageMappingMessageHandlerfor handling RSocket requests with@ConnectMappingand@MessageMappingmethods.org.springframework.messaging.simp.annotation.support中InitializingBean的使用
实现InitializingBean的org.springframework.messaging.simp.annotation.support中的类 修饰符和类型 类 说明 classSimpAnnotationMethodMessageHandlerA handler for messages delegating to@MessageMappingand@SubscribeMappingannotated methods.org.springframework.orm.hibernate5中InitializingBean的使用
实现InitializingBean的org.springframework.orm.hibernate5中的类 修饰符和类型 类 说明 classHibernateTemplateHelper class that simplifies Hibernate data access code.classHibernateTransactionManagerPlatformTransactionManagerimplementation for a single HibernateSessionFactory.classLocalSessionFactoryBeanFactoryBeanthat creates a HibernateSessionFactory.org.springframework.orm.hibernate5.support中InitializingBean的使用
实现InitializingBean的org.springframework.orm.hibernate5.support中的类 修饰符和类型 类 说明 classHibernateDaoSupportConvenient super class for Hibernate-based data access objects.classOpenSessionInterceptorSimple AOP AllianceMethodInterceptorimplementation that binds a new HibernateSessionfor each method invocation, if none bound before.classOpenSessionInViewFilterServlet 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中的类 修饰符和类型 类 说明 classAbstractEntityManagerFactoryBeanAbstractFactoryBeanthat creates a local JPAEntityManagerFactoryinstance within a Spring application context.classJpaTransactionManagerPlatformTransactionManagerimplementation for a single JPAEntityManagerFactory.classLocalContainerEntityManagerFactoryBeanFactoryBeanthat creates a JPAEntityManagerFactoryaccording to JPA's standard container bootstrap contract.classLocalEntityManagerFactoryBeanFactoryBeanthat creates a JPAEntityManagerFactoryaccording to JPA's standard standalone bootstrap contract.org.springframework.orm.jpa.persistenceunit中InitializingBean的使用
实现InitializingBean的org.springframework.orm.jpa.persistenceunit中的类 修饰符和类型 类 说明 classDefaultPersistenceUnitManagerDefault implementation of thePersistenceUnitManagerinterface.org.springframework.orm.jpa.support中InitializingBean的使用
实现InitializingBean的org.springframework.orm.jpa.support中的类 修饰符和类型 类 说明 classOpenEntityManagerInViewFilterServlet Filter that binds a JPA EntityManager to the thread for the entire processing of the request.classSharedEntityManagerBeanFactoryBeanthat exposes a shared JPAEntityManagerreference for a given EntityManagerFactory.org.springframework.oxm.jaxb中InitializingBean的使用
实现InitializingBean的org.springframework.oxm.jaxb中的类 修饰符和类型 类 说明 classJaxb2MarshallerImplementation of theGenericMarshallerinterface for JAXB 2.2.org.springframework.oxm.jibx中InitializingBean的使用
实现InitializingBean的org.springframework.oxm.jibx中的类 修饰符和类型 类 说明 classJibxMarshaller已过时。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中的类 修饰符和类型 类 说明 classXStreamMarshallerImplementation of theMarshallerinterface for XStream.org.springframework.remoting.caucho中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.caucho中的类 修饰符和类型 类 说明 classHessianClientInterceptorMethodInterceptorfor accessing a Hessian service.classHessianExporterGeneral stream-based protocol exporter for a Hessian endpoint.classHessianProxyFactoryBeanFactoryBeanfor Hessian proxies.classHessianServiceExporterServlet-API-based HTTP request handler that exports the specified service bean as Hessian service endpoint, accessible via a Hessian proxy.classSimpleHessianServiceExporter已过时。as of Spring Framework 5.1, in favor ofHessianServiceExporterorg.springframework.remoting.httpinvoker中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.httpinvoker中的类 修饰符和类型 类 说明 classHttpInvokerClientInterceptorMethodInterceptorfor accessing an HTTP invoker service.classHttpInvokerProxyFactoryBeanFactoryBeanfor HTTP invoker proxies.classHttpInvokerServiceExporterServlet-API-based HTTP request handler that exports the specified service bean as HTTP invoker service endpoint, accessible via an HTTP invoker proxy.classSimpleHttpInvokerServiceExporter已过时。as of Spring Framework 5.1, in favor ofHttpInvokerServiceExporterorg.springframework.remoting.jaxws中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.jaxws中的类 修饰符和类型 类 说明 classAbstractJaxWsServiceExporterAbstract exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebServiceannotation).classJaxWsPortClientInterceptorMethodInterceptorfor accessing a specific port of a JAX-WS service.classJaxWsPortProxyFactoryBeanFactoryBeanfor a specific port of a JAX-WS service.classLocalJaxWsServiceFactoryBeanFactoryBeanfor locally defined JAX-WS Service references.classSimpleHttpServerJaxWsServiceExporter已过时。as of Spring Framework 5.1, in favor ofSimpleJaxWsServiceExporterclassSimpleJaxWsServiceExporterSimple exporter for JAX-WS services, autodetecting annotated service beans (through the JAX-WSWebServiceannotation) 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中的类 修饰符和类型 类 说明 classJndiRmiClientInterceptorMethodInterceptorfor accessing RMI services from JNDI.classJndiRmiProxyFactoryBeanFactoryBeanfor RMI proxies from JNDI.classJndiRmiServiceExporterService exporter which binds RMI services to JNDI.classRemoteInvocationSerializingExporterAbstract base class for remote service exporters that explicitly deserializeRemoteInvocationobjects and serializeRemoteInvocationResultobjects, for example Spring's HTTP invoker.classRmiClientInterceptorMethodInterceptorfor accessing conventional RMI services or RMI invokers.classRmiProxyFactoryBeanFactoryBeanfor RMI proxies, supporting both conventional RMI services and RMI invokers.classRmiRegistryFactoryBeanFactoryBeanthat locates aRegistryand exposes it for bean references.classRmiServiceExporterRMI exporter that exposes the specified service as RMI object with the specified name.org.springframework.remoting.support中InitializingBean的使用
实现InitializingBean的org.springframework.remoting.support中的类 修饰符和类型 类 说明 classRemoteInvocationBasedAccessorAbstract base class for remote service accessors that are based on serialization ofRemoteInvocationobjects.classSimpleHttpServerFactoryBean已过时。as of Spring Framework 5.1, in favor of embedded Tomcat/Jetty/UndertowclassUrlBasedRemoteAccessorAbstract base class for classes that access remote services via URLs.org.springframework.scheduling.commonj中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.commonj中的类 修饰符和类型 类 说明 classTimerManagerAccessor已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskSchedulerclassTimerManagerFactoryBean已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskSchedulerclassTimerManagerTaskScheduler已过时。as of 5.1, in favor of EE 7'sDefaultManagedTaskSchedulerclassWorkManagerTaskExecutor已过时。as of 5.1, in favor of the EE 7/8 basedDefaultManagedTaskExecutororg.springframework.scheduling.concurrent中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.concurrent中的类 修饰符和类型 类 说明 classDefaultManagedAwareThreadFactoryJNDI-based variant ofCustomizableThreadFactory, performing a default lookup for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Java EE 7 environment, falling back to the localCustomizableThreadFactorysetup if not found.classDefaultManagedTaskExecutorJNDI-based variant ofConcurrentTaskExecutor, performing a default lookup for JSR-236's "java:comp/DefaultManagedExecutorService" in a Java EE 7/8 environment.classDefaultManagedTaskSchedulerJNDI-based variant ofConcurrentTaskScheduler, performing a default lookup for JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Java EE 7 environment.classExecutorConfigurationSupportBase class for setting up aExecutorService(typically aThreadPoolExecutororScheduledThreadPoolExecutor).classForkJoinPoolFactoryBeanA SpringFactoryBeanthat builds and exposes a preconfiguredForkJoinPool.classScheduledExecutorFactoryBeanFactoryBeanthat sets up aScheduledExecutorService(by default: aScheduledThreadPoolExecutor) and exposes it for bean references.classThreadPoolExecutorFactoryBeanJavaBean that allows for configuring aThreadPoolExecutorin bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a bean reference of its nativeExecutorServicetype.classThreadPoolTaskExecutorJavaBean that allows for configuring aThreadPoolExecutorin bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity" properties) and exposing it as a SpringTaskExecutor.classThreadPoolTaskSchedulerImplementation of Spring'sTaskSchedulerinterface, wrapping a nativeScheduledThreadPoolExecutor.org.springframework.scheduling.config中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.config中的类 修饰符和类型 类 说明 classContextLifecycleScheduledTaskRegistrarScheduledTaskRegistrarsubclass which redirects the actual scheduling of tasks to theContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated()callback (as of 4.1.2).classScheduledTaskRegistrarHelper bean for registering tasks with aTaskScheduler, typically using cron expressions.classTaskExecutorFactoryBeanFactoryBeanfor creatingThreadPoolTaskExecutorinstances, primarily used behind the XML task namespace.org.springframework.scheduling.quartz中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.quartz中的类 修饰符和类型 类 说明 classCronTriggerFactoryBeanA SpringFactoryBeanfor creating a QuartzCronTriggerinstance, supporting bean-style usage for trigger configuration.classJobDetailFactoryBeanA SpringFactoryBeanfor creating a QuartzJobDetailinstance, supporting bean-style usage for JobDetail configuration.classMethodInvokingJobDetailFactoryBeanFactoryBeanthat exposes aJobDetailobject which delegates job execution to a specified (static or non-static) method.classSchedulerAccessorBeanSpring bean-style class for accessing a Quartz Scheduler, i.e. for registering jobs, triggers and listeners on a givenSchedulerinstance.classSchedulerFactoryBeanFactoryBeanthat 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.classSimpleThreadPoolTaskExecutorSubclass of Quartz's SimpleThreadPool that implements Spring'sTaskExecutorinterface and listens to Spring lifecycle callbacks.classSimpleTriggerFactoryBeanA SpringFactoryBeanfor creating a QuartzSimpleTriggerinstance, supporting bean-style usage for trigger configuration.org.springframework.scheduling.support中InitializingBean的使用
实现InitializingBean的org.springframework.scheduling.support中的类 修饰符和类型 类 说明 classMethodInvokingRunnableAdapter that implements theRunnableinterface as a configurable method invocation based on Spring's MethodInvoker.org.springframework.transaction.config中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.config中的类 修饰符和类型 类 说明 classJtaTransactionManagerFactoryBeanAFactoryBeanequivalent to the <tx:jta-transaction-manager/> XML element, autodetecting WebLogic and WebSphere servers and exposing the correspondingJtaTransactionManagersubclass.org.springframework.transaction.interceptor中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.interceptor中的类 修饰符和类型 类 说明 classMethodMapTransactionAttributeSourceSimpleTransactionAttributeSourceimplementation that allows attributes to be stored per method in aMap.classTransactionAspectSupportBase class for transactional aspects, such as theTransactionInterceptoror an AspectJ aspect.classTransactionInterceptorAOP Alliance MethodInterceptor for declarative transaction management using the common Spring transaction infrastructure (PlatformTransactionManager/ReactiveTransactionManager).classTransactionProxyFactoryBeanProxy factory bean for simplified declarative transaction handling.org.springframework.transaction.jta中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.jta中的类 修饰符和类型 类 说明 classJtaTransactionManagerPlatformTransactionManagerimplementation for JTA, delegating to a backend JTA provider.classWebLogicJtaTransactionManagerSpecialJtaTransactionManagervariant for BEA WebLogic (9.0 and higher).classWebSphereUowTransactionManagerWebSphere-specific PlatformTransactionManager implementation that delegates to aUOWManagerinstance, obtained from WebSphere's JNDI environment.org.springframework.transaction.support中InitializingBean的使用
实现InitializingBean的org.springframework.transaction.support中的类 修饰符和类型 类 说明 classTransactionTemplateTemplate class that simplifies programmatic transaction demarcation and transaction exception handling.org.springframework.ui.freemarker中InitializingBean的使用
实现InitializingBean的org.springframework.ui.freemarker中的类 修饰符和类型 类 说明 classFreeMarkerConfigurationFactoryBeanFactory bean that creates a FreeMarker Configuration and provides it as bean reference.org.springframework.validation.beanvalidation中InitializingBean的使用
实现InitializingBean的org.springframework.validation.beanvalidation中的类 修饰符和类型 类 说明 classBeanValidationPostProcessorSimpleBeanPostProcessorthat 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).classCustomValidatorBeanConfigurable bean class that exposes a specific JSR-303 Validator through its original interface as well as through the SpringValidatorinterface.classLocalValidatorFactoryBeanThis is the central class forjavax.validation(JSR-303) setup in a Spring application context: It bootstraps ajavax.validation.ValidationFactoryand exposes it through the SpringValidatorinterface as well as through the JSR-303Validatorinterface and theValidatorFactoryinterface itself.classMethodValidationPostProcessorA convenientBeanPostProcessorimplementation that delegates to a JSR-303 provider for performing method-level validation on annotated methods.classOptionalValidatorFactoryBeanLocalValidatorFactoryBeansubclass that simply turnsValidatorcalls into no-ops in case of no Bean Validation provider being available.org.springframework.web.accept中InitializingBean的使用
实现InitializingBean的org.springframework.web.accept中的类 修饰符和类型 类 说明 classContentNegotiationManagerFactoryBeanFactory to create aContentNegotiationManagerand configure it withContentNegotiationStrategyinstances.org.springframework.web.context.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.context.support中的类 修饰符和类型 类 说明 classAbstractRefreshableWebApplicationContextAbstractRefreshableApplicationContextsubclass which implements theConfigurableWebApplicationContextinterface for web environments.classAnnotationConfigWebApplicationContextWebApplicationContextimplementation which accepts component classes as input — in particular@Configuration-annotated classes, but also plain@Componentclasses and JSR-330 compliant classes usingjavax.injectannotations.classGroovyWebApplicationContextWebApplicationContextimplementation which takes its configuration from Groovy bean definition scripts and/or XML files, as understood by aGroovyBeanDefinitionReader.classXmlWebApplicationContextWebApplicationContextimplementation which takes its configuration from XML documents, understood by anXmlBeanDefinitionReader.org.springframework.web.filter中InitializingBean的使用
实现InitializingBean的org.springframework.web.filter中的类 修饰符和类型 类 说明 classAbstractRequestLoggingFilterBase class forFilters that perform logging operations before and after a request is processed.classCharacterEncodingFilterServlet Filter that allows one to specify a character encoding for requests.classCommonsRequestLoggingFilterSimple request logging filter that writes the request URI (and optionally the query string) to the Commons Log.classCorsFilterFilterthat handles CORS preflight requests and intercepts CORS simple and actual requests thanks to aCorsProcessorimplementation (DefaultCorsProcessorby default) in order to add the relevant CORS response headers (likeAccess-Control-Allow-Origin) using the providedCorsConfigurationSource(for example anUrlBasedCorsConfigurationSourceinstance.classDelegatingFilterProxyProxy for a standard Servlet Filter, delegating to a Spring-managed bean that implements the Filter interface.classFormContentFilterFilterthat parses form data for HTTP PUT, PATCH, and DELETE requests and exposes it as Servlet request parameters.classForwardedHeaderFilterExtract 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).classGenericFilterBeanSimple base implementation ofFilterwhich treats its config parameters (init-paramentries within thefiltertag inweb.xml) as bean properties.classHiddenHttpMethodFilterFilterthat converts posted method parameters into HTTP methods, retrievable viaHttpServletRequest.getMethod().classHttpPutFormContentFilter已过时。as of 5.1 in favor ofFormContentFilterwhich is the same but also handles DELETE.classOncePerRequestFilterFilter base class that aims to guarantee a single execution per request dispatch, on any servlet container.classRelativeRedirectFilterOverridesHttpServletResponse.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.classRequestContextFilterServlet Filter that exposes the request to the current thread, through bothLocaleContextHolderandRequestContextHolder.classServletContextRequestLoggingFilterSimple request logging filter that writes the request URI (and optionally the query string) to the ServletContext log.classShallowEtagHeaderFilterFilterthat generates anETagvalue based on the content on the response.org.springframework.web.multipart.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.multipart.support中的类 修饰符和类型 类 说明 classMultipartFilterServlet Filter that resolves multipart requests via aMultipartResolver.org.springframework.web.reactive.function.server.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.function.server.support中的类 修饰符和类型 类 说明 classRouterFunctionMappingHandlerMappingimplementation that supportsRouterFunctions.classServerResponseResultHandlerHandlerResultHandlerimplementation that supportsServerResponses.org.springframework.web.reactive.resource中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.resource中的类 修饰符和类型 类 说明 classResourceWebHandlerHttpRequestHandlerthat 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中的类 修饰符和类型 类 说明 classAbstractHandlerMethodMapping<T>Abstract base class forHandlerMappingimplementations that define a mapping between a request and aHandlerMethod.classRequestMappingInfoHandlerMappingAbstract base class for classes for whichRequestMappingInfodefines 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中的类 修饰符和类型 类 说明 classRequestMappingHandlerAdapterSupports the invocation of@RequestMappinghandler methods.classRequestMappingHandlerMappingAn extension ofRequestMappingInfoHandlerMappingthat createsRequestMappingInfoinstances from class-level and method-level@RequestMappingannotations.org.springframework.web.reactive.result.view中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.view中的类 修饰符和类型 类 说明 classAbstractUrlBasedViewAbstract base class for URL-based views.classRedirectViewView that redirects to an absolute or context relative URL.classUrlBasedViewResolverAViewResolverthat 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中的类 修饰符和类型 类 说明 classFreeMarkerConfigurerConfigures FreeMarker for web usage via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.classFreeMarkerViewAViewimplementation that uses the FreeMarker template engine.classFreeMarkerViewResolverAViewResolverfor resolvingFreeMarkerViewinstances, i.e.org.springframework.web.reactive.result.view.script中InitializingBean的使用
实现InitializingBean的org.springframework.web.reactive.result.view.script中的类 修饰符和类型 类 说明 classScriptTemplateViewAnAbstractUrlBasedViewsubclass designed to run any template library based on a JSR-223 script engine.classScriptTemplateViewResolverConvenience subclass ofUrlBasedViewResolverthat supportsScriptTemplateViewand custom subclasses of it.org.springframework.web.servlet.function.support中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.function.support中的类 修饰符和类型 类 说明 classRouterFunctionMappingHandlerMappingimplementation that supportsRouterFunctions.org.springframework.web.servlet.handler中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.handler中的类 修饰符和类型 类 说明 classAbstractHandlerMethodMapping<T>Abstract base class forHandlerMappingimplementations that define a mapping between a request and aHandlerMethod.classHandlerMappingIntrospectorHelper class to get information from theHandlerMappingthat would serve a specific request.org.springframework.web.servlet.mvc中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.mvc中的类 修饰符和类型 类 说明 classServletWrappingControllerSpring 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中的类 修饰符和类型 类 说明 classRequestMappingInfoHandlerMappingAbstract base class for classes for whichRequestMappingInfodefines 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中的类 修饰符和类型 类 说明 classExceptionHandlerExceptionResolverAnAbstractHandlerMethodExceptionResolverthat resolves exceptions through@ExceptionHandlermethods.classRequestMappingHandlerAdapterclassRequestMappingHandlerMappingCreatesRequestMappingInfoinstances from type and method-level@RequestMappingannotations in@Controllerclasses.org.springframework.web.servlet.resource中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.resource中的类 修饰符和类型 类 说明 classResourceHttpRequestHandlerHttpRequestHandlerthat serves static resources in an optimized way according to the guidelines of Page Speed, YSlow, etc.classResourceUrlEncodingFilterA filter that wraps theHttpServletResponseand overrides itsencodeURLmethod 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中的类 修饰符和类型 类 说明 classAbstractTemplateViewAdapter 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.classAbstractUrlBasedViewAbstract base class for URL-based views.classContentNegotiatingViewResolverImplementation ofViewResolverthat resolves a view based on the request file name orAcceptheader.classInternalResourceViewWrapper for a JSP or other resource within the same web application.classJstlViewSpecialization ofInternalResourceViewfor JSTL pages, i.e.classRedirectViewView that redirects to an absolute, context relative, or current request relative URL.classResourceBundleViewResolverAViewResolverimplementation that uses bean definitions in aResourceBundle, specified by the bundle basename.classViewResolverCompositeAViewResolverthat delegates to others.classXmlViewResolverAViewResolverimplementation 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中的类 修饰符和类型 类 说明 classAbstractPdfStamperViewAbstract 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中的类 修饰符和类型 类 说明 classFreeMarkerConfigurerJavaBean to configure FreeMarker for web usage, via the "configLocation" and/or "freemarkerSettings" and/or "templateLoaderPath" properties.classFreeMarkerViewView using the FreeMarker template engine.org.springframework.web.servlet.view.groovy中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.groovy中的类 修饰符和类型 类 说明 classGroovyMarkupConfigurerAn extension of Groovy'sTemplateConfigurationand an implementation of Spring MVC'sGroovyMarkupConfigfor creating aMarkupTemplateEnginefor use in a web application.classGroovyMarkupViewAnAbstractTemplateViewsubclass based on Groovy XML/XHTML markup templates.org.springframework.web.servlet.view.script中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.script中的类 修饰符和类型 类 说明 classScriptTemplateViewAnAbstractUrlBasedViewsubclass 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中的类 修饰符和类型 类 说明 classTilesConfigurerHelper class to configure Tiles 3.x for the Spring Framework.classTilesViewViewimplementation that renders through the Tiles Request API.org.springframework.web.servlet.view.xslt中InitializingBean的使用
实现InitializingBean的org.springframework.web.servlet.view.xslt中的类 修饰符和类型 类 说明 classXsltViewXSLT-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中的类 修饰符和类型 类 说明 classWebSocketAnnotationMethodMessageHandlerA sub-class ofSimpAnnotationMethodMessageHandlerto provide support forControllerAdvicewith global@MessageExceptionHandlermethods.org.springframework.web.socket.server.standard中InitializingBean的使用
实现InitializingBean的org.springframework.web.socket.server.standard中的类 修饰符和类型 类 说明 classServerEndpointExporterDetects beans of typeServerEndpointConfigand registers with the standard Java WebSocket runtime.classServletServerContainerFactoryBeanAFactoryBeanfor configuringServerContainer.