|
Spring Framework | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
owner.(abstract)=true
Default is "false".
AbstractTransactionalJUnit4SpringContextTests)AbstractAnnotationAwareTransactionalTests.AbstractAnnotationAwareTransactionalTests(String).
name and retrieves the configured (or
default) ProfileValueSource.
WebApplicationInitializer implementations that register a DispatcherServlet
configured with annotated classes, e.g.ApplicationContext
interface.ApplicationEventMulticaster interface,
providing the basic listener registration facility.Advice classes
wrapping an AspectJ aspect or an AspectJ-annotated advice method.AbstractJUnit38SpringContextTests)Configuration class providing common structure for enabling
Spring's asynchronous method execution capability.BeanPostProcessor implementation
that wraps each eligible bean with an AOP proxy, delegating to specified interceptors
before invoking the bean itself.RootBeanDefinition class.BeanDefinition classes,
factoring out common properties of RootBeanDefinition and
ChildBeanDefinition.AbstractBeanDefinition.AbstractBeanDefinition(BeanDefinition)
BeanDefinitionParser implementation providing
a number of convenience methods and a
template method
that subclasses must override to provide the actual parsing logic.BeanDefinitionReader interface.BeanFactory
implementations, providing the full capabilities of the
ConfigurableBeanFactory SPI.TargetSource implementations
that are based on a Spring BeanFactory,
delegating to Spring-managed bean instances.TargetSourceCreator
implementations that require creating multiple instances of a prototype bean.BindingResult interface and
its super-interface Errors.CacheManager
methods.@Configuration class providing common structure for enabling
Spring's annotation-driven cache management capability.ViewResolver
implementations.input'
element with a 'type' of 'checkbox' or 'radio'.ClassMetadata object
to subclasses, for class testing purposes.ClientHttpRequest that makes sure that headers and body are not written multiple times.ClientHttpRequestFactory implementations that decorate another request factory.AbstractClientHttpRequestFactoryWrapper wrapping the given request factory.
ClientHttpResponse.DataFieldMaxValueIncrementer implementations that use
a column in a custom sequence table.ComponentDefinition that provides a basic implementation of
AbstractComponentDefinition.getDescription() which delegates to ComponentDefinition.getName().ContextLoader SPI.WebApplicationInitializer implementations that
register a ContextLoaderListener in the servlet context.HandlerMapping implementations
that derive URL paths according to conventions for specific controller types.@CookieValue.DataFieldMaxValueIncrementer that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long.DataSource
implementations, taking care of the padding.AbstractJUnit4SpringContextTests)HandlerMapping
interface, detecting URL mappings for handler beans through introspection of all
defined beans in the application context.WebApplicationInitializer implementations that register a DispatcherServlet in
the servlet context.DataSource implementations
that operate on a JDBC Driver.FactoryBean that
creates a local JPA EntityManagerFactory
instance within a Spring application context.Environment implementations.Environment instance, calling back to
AbstractEnvironment.customizePropertySources(MutablePropertySources) during construction to
allow subclasses to contribute or manipulate PropertySource instances as
appropriate.
Errors interface.FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag.CacheOperation that caches
attributes for methods and implements a fallback policy: 1.SQLExceptionTranslator implementations that allow for
fallback to some other SQLExceptionTranslator.TransactionAttributeSource that caches
attributes for methods and implements a fallback policy: 1.UrlResource or ClassPathResource.FlashMapManager implementations.AbstractContextLoader that loads a
GenericApplicationContext.HandlerExceptionResolver implementations.HandlerExceptionResolver implementations.HandlerMapping
implementations.HandlerMapping
implementations.HandlerAdapter implementations that support
handlers of type HandlerMethod.HandlerExceptionResolver
implementations that support handling exceptions from handlers of type HandlerMethod.HandlerMapping implementations that define a
mapping between a request and a HandlerMethod.AbstractHtmlElementTag.HttpMessageConverter implementations.AbstractHttpMessageConverter with no supported media types.
AbstractHttpMessageConverter with one supported media type.
AbstractHttpMessageConverter with multiple supported media type.
BeanDefinitionDecorators
wishing to add an interceptor
to the resulting bean.InterruptibleBatchPreparedStatementSetter
interface, combining the check for available values and setting of those
into a single callback method AbstractInterruptibleBatchPreparedStatementSetter.setValuesIfAvailable(java.sql.PreparedStatement, int).AbstractJasperReportsView to provide basic rendering logic
for views that use a fixed format, e.g.HttpMessageConverters that
use JAXB2.WebService annotation).DataSource.
JdbcTemplate.
AbstractJUnit38SpringContextTests)JpaVendorAdapter implementation that defines common properties,
to be translated into vendor-specific JPA properties by concrete subclasses.AbstractJUnit4SpringContextTestsTestContextManager for the current test; and
retrieves the configured (or default) ProfileValueSource.
name; initializes the internal
TestContextManager for the current test; and retrieves the
configured (or default) ProfileValueSource.
ApplicationContext testing support in a
JUnit 4.5+ environment.TargetSource implementation that will
lazily create a user-managed object.null).
LocaleResolver implementations.HandlerMapping
implementations that rely on a map which caches handler objects per lookup key.Marshaller and Unmarshaller interface.MBeanInfoAssembler interface
that encapsulates the creation of a ModelMBeanInfo instance
but delegates the creation of metadata to subclasses.HttpMessageConverters.AbstractMessageConverterMethodArgumentResolver with the ability to handle method return
values by writing to the response with HttpMessageConverters.MessageEndpointFactory interface,
providing transaction management capabilities as well as ClassLoader
exposure for endpoint invocations.HierarchicalMessageSource interface,
implementing common handling of message variants, making it easy
to implement a specific strategy for a concrete MessageSource.AbstractJUnit38SpringContextTests)
or ModelAndViewAssert with JUnit 4 and TestNG.input' elements with a 'type'
of 'checkbox' or 'radio'.AbstractNumberFormatter.getNumberFormat(java.util.Locale) template method.JtaTransactionManager.PointcutAdvisor
implementations.TargetSource
implementations which maintain a pool of target instances, acquiring and
releasing a target object from the pool for each method invocation.PropertyAccessor interface.BindingResult implementations that work with
Spring's PropertyAccessor mechanism.TargetSource implementations
that create new prototype bean instances to support a pooling or
new-instance-per-invocation strategy.AbstractMBeanInfoAssembler superclass to
add a basic algorithm for building metadata based on the
reflective metadata of the MBean class.ApplicationContext
implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh(),
creating a new internal bean factory instance every time.AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations.AbstractRefreshableApplicationContext
subclass which implements the ConfigurablePortletApplicationContext
interface for portlet environments.TargetSource implementation that
wraps a refreshable target object.AbstractRefreshableApplicationContext
subclass which implements the
ConfigurableWebApplicationContext
interface for web environments.Scope implementation that reads from a particular scope
in the current thread-bound RequestAttributes object.RequestCondition types providing implementations of
AbstractRequestCondition.equals(Object), AbstractRequestCondition.hashCode(), and AbstractRequestCondition.toString().Filters that perform logging operations before and after a request is processed.Resource implementations,
pre-implementing typical behavior.DataSource implementation that routes AbstractRoutingDataSource.getConnection()
calls to one of various target DataSources based on a lookup key.DataFieldMaxValueIncrementer implementations that use
a database sequence.ServiceLoader facility.FactoryBean that creates
a Hibernate SessionFactory within a Spring application
context, providing general infrastructure not related to Hibernate's
specific configuration API.Class being configured.BeanDefinitionParser implementations that
need to parse and define just a single BeanDefinition.input' element with a 'type'
of 'checkbox' or 'radio'.AbstractJUnit4SpringContextTests)FactoryBean types that produce singleton-scoped
proxy objects.AbstractJUnit4SpringContextTests)PreparerFactory
interface, obtaining the current Spring WebApplicationContext and delegating to
AbstractSpringPreparerFactory.getPreparer(String, org.springframework.web.context.WebApplicationContext).SqlParameterSource implementations.PreparedStatement.setObject method.TestExecutionListener interface which
provides empty method stubs.ApplicationContext testing support in a TestNG
environment.TestContextManager for the current test.
ThemeResolver implementations.MethodInterceptor implementation for tracing.AbstractTransactionalJUnit4SpringContextTests)AbstractTransactionalJUnit4SpringContextTestsname.
transactional extension of
AbstractJUnit4SpringContextTests which adds convenience functionality
for JDBC access.AbstractTransactionalJUnit4SpringContextTests)transactional extension of
AbstractTestNGSpringContextTests which adds convenience functionality
for JDBC access.@Configuration class providing common structure for enabling
Spring's annotation-driven transaction management capability.TransactionStatus interface.HandlerMapping
implementations.MethodNameResolver implementations.Controllers that return a view name
based on the request URL.View
implementations.WebArgumentResolver to the
HandlerMethodArgumentResolver contract.ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader.HttpMessageConverters
that convert from/to XML.supportedMediaTypes
to text/xml and application/xml, and application/*-xml.
XsltView and its
more flexible XsltView.locateSource(java.util.Map) mechanismaccesskey' attribute.
ActiveProfiles is a class-level annotation that is used to declare
which active bean definition profiles should be used when loading
an ApplicationContext
for test classes.Runnable
objects as well as standard Quartz Job instances.AdvisedSupport.addAdvisors(org.springframework.aop.Advisor...)
Collection into this
Map, using attribute name generation for each element.
Map into this Map.
Collection into this
Map, using attribute name generation for each element.
Map into this Map.
Collection into this
Map, using attribute name generation for each element.
Map into this Map.
Errors instance to this
Errors instance.
ModelMap.addAllAttributes(Collection)
ModelMap.addAllAttributes(Map)
HandlerMethodArgumentResolvers to use in addition to
the ones registered by default.
javax.activation.DataSource.
java.io.File.
org.springframework.core.io.InputStreamResource.
org.springframework.core.io.InputStreamResource.
Map using a
generated name.
Map using a
generated name.
Map using a
generated name.
BeanDefinitionBuilder.addConstructorArgValue(java.lang.Object)
CronTask.
DataSource to the map of DataSources
maintained by this object.
RowMapper for the specified parameter or column.
AbstractJdbcCall.addDeclaredRowMapper(String, org.springframework.jdbc.core.RowMapper)
DefaultConversionService.addDefaultConverters(ConverterRegistry)
HandlerExceptionResolvers.
ObjectError or FieldError to the errors list.
IntervalTask.
IntervalTask.
generated name.
Converters and Formatters.
Converters and Formatters in addition to the ones
registered by default.
Converters and Formatters in addition to the ones
registered by default.
HandlerMethodReturnValueHandler.
HandlerMethodReturnValueHandlers.
javax.activation.DataSource.
java.io.File.
org.springframework.core.io.Resource.
org.springframework.core.InputStreamResource, and
specifying the content type explicitly.
HandlerInterceptor.
AbstractApplicationContext.addApplicationListener(org.springframework.context.ApplicationListener)
ModelMap.addAttribute(String, Object)
ModelMap.addAttribute(Object)
addPropertyValue that takes
a property name and a property value.
HandlerMethodArgumentResolver.
HandlerMethodArgumentResolvers.
ClassLoader.getResource
(also suitable for use with Class.getResource by prepending a
slash ('/') to the return value).
HandlerMethodReturnValueHandlers in addition to the
ones registered by default.
SimpleMappingExceptionResolver.setStatusCodes(Properties) for use with
Java-based configuration.
ClassFileTransformer to be applied by this
LoadTimeWeaver.
ClassFileTransformer to be applied by this
ClassLoader.
addTransformer method.
Trigger.
TriggerTask.
WebRequestInterceptor.
ParseState entry representing an advice element.AdviceEntry class.
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations).ProxyCreatorSupport objects
Allows for receiving callbacks on activation and change of advice.AdvisorAdapter beans in the BeanFactory with
an AdvisorAdapterRegistry (by default the GlobalAdvisorAdapterRegistry).ComponentDefinition
that bridges the gap between the advisor bean definition configured
by the <aop:advisor> tag and the component definition
infrastructure.ParseState entry representing an advisor.AdvisorEntry class.
HandlerInterceptorAdapter.afterCompletion(javax.portlet.PortletRequest, javax.portlet.PortletResponse, java.lang.Object, java.lang.Exception).
AfterReturningAdvice and ThrowsAdvice.Session from the thread and close it (in
single session mode), or process deferred close for all sessions that have
been opened during the current request (in deferred close mode).
Session from the thread and close it).
afterCompletion callback: invoked after commit/rollback.
afterDelivery implementation resets the thread context
ClassLoader and completes the transaction, if any.
HandlerInterceptorAdapter.afterCompletion(javax.portlet.PortletRequest, javax.portlet.PortletResponse, java.lang.Object, java.lang.Exception).
BeanFactory has been set.
AbstractApplicationContext.refresh() if not refreshed in the concrete context's
constructor already.
AbstractJmsListeningContainer.validateConfiguration() and AbstractJmsListeningContainer.initialize().
MBeanServerConnection if the "connectOnStartup"
is turned on (which it is by default).
proxyInterface has been specified and then
generates the proxy for the target MBean.
ApplicationContext.
Properties configured in the mappings and
mappingLocations into the final Properties instance
used for ObjectName resolution.
JMXConnector for the given settings
and exposes the associated MBeanServerConnection.
MBeanServer instance.
initialize() after the container applied all property values.
initialize() after the container applied all property values.
"methodMap", if any.
initFilterBean() method that might
contain custom initialization of a subclass.
HandlerInterceptorAdapter.afterCompletion(javax.portlet.PortletRequest, javax.portlet.PortletResponse, java.lang.Object, java.lang.Exception).
HandlerInterceptorAdapter.afterCompletion(javax.portlet.PortletRequest, javax.portlet.PortletResponse, java.lang.Object, java.lang.Exception).
AfterReturningAdvice.test context is
annotated with @DirtiesContext, the
application context of the test context will
be marked as dirty ,
and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to
true.
test
context is annotated with @DirtiesContext,
or if the test class is annotated with @DirtiesContext and the class
mode is set to AFTER_EACH_TEST_METHOD, the application
context of the test context will be
marked as dirty and the
REINJECT_DEPENDENCIES_ATTRIBUTE in the test context will be set to
true.
test method, for example for tearing down test fixtures,
ending a transaction, etc.
test method in the supplied
test context, for example by tearing down test
fixtures.
test context, this method will end the transaction
and run @AfterTransaction methods.
public void
method should be executed after a transaction is ended for test
methods configured to run within a transaction via the
@Transactional annotation.MediaType.ALL.
BeanDefinition
interface that exposes AnnotationMetadata
about its bean class - without requiring the class to be loaded yet.AnnotatedBeanDefinitionReader for the given registry.
AnnotatedBeanDefinitionReader for the given registry and using
the given Environment.
GenericBeanDefinition
class, adding support for annotation metadata exposed through the
AnnotatedBeanDefinition interface.AsyncExecutionInterceptor that delegates method execution to
an Executor based on the Async annotation.AnnotationAsyncExecutionInterceptor with the given executor.
LinkedHashMap subclass representing annotation attribute key/value pairs
as read by Spring's reflection- or ASM-based AnnotationMetadata implementations.AnnotationAttributes instance.
AnnotationAttributes instance with the given initial
capacity to optimize performance.
AnnotationAttributes instance, wrapping the provided map
and all its key/value pairs.
AspectJAwareAdvisorAutoProxyCreator subclass that processes all AspectJ
annotation aspects in the current application context, as well as Spring Advisors.Comparator implementation that checks
Ordered as well as the
Order annotation, with an order value provided by an
Ordered instance overriding a statically defined
annotation value (if any).BeanNameGenerator
implementation for bean classes annotated with the
@Component annotation
or with another annotation that is itself annotated with
@Component as a
meta-annotation.BeanWiringInfoResolver that
uses the Configurable annotation to identify which classes need autowiring.CacheOperationSource interface for working with caching metadata in annotation format.Cacheable and CacheEvict annotations.
AnnotationCacheOperationSource, supporting public methods
that carry the Cacheable and CacheEvict annotations.
@Configuration-annotated classes, but also plain
@Component types and JSR-330 compliant
classes using javax.inject annotations.AnnotationConfigApplicationContext.register(java.lang.Class...) calls and then manually refreshed.
AbstractGenericContextLoader that loads
bean definitions from annotated classes.BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration.WebApplicationContext
implementation which accepts annotated classes as input - in particular
@Configuration-annotated
classes, but also plain @Component
classes and JSR-330 compliant classes using javax.inject annotations.Annotation.JmxAttributeSource interface that
reads JDK 1.5+ annotations and exposes the corresponding attributes.class or
method.MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Spring beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc.HandlerAdapter
interface that maps handler methods based on portlet modes, action/render phases
and request parameters expressed through the RequestMapping annotation.HandlerAdapter interface
that maps handler methods based on HTTP paths, HTTP methods and request parameters
expressed through the RequestMapping annotation.HandlerExceptionResolver interface that handles
exceptions through the ExceptionHandler annotation.HandlerExceptionResolver interface that handles
exceptions through the ExceptionHandler annotation.ScopeMetadataResolver implementation that by default checks for
the presence of Spring's Scope annotation on the bean class.AnnotationScopeMetadataResolver class.
AnnotationScopeMetadataResolver class.
TransactionAttributeSource
interface for working with transaction metadata in JDK 1.5+ annotation format.Transactional annotation
or the EJB3 TransactionAttribute annotation.
Transactional annotation
or the EJB3 TransactionAttribute annotation.
AnnotationTypeFilter for the given annotation type.
NamespaceHandler for the aop namespace.aop' namespace tags.AdvisedSupport configuration objects.ObjectName with the key being
the static value identity and the value being the identity hash code of the
managed resource being exposed on the supplied ObjectName.
StringBuilder.
application/atom+xml.
MediaType.APPLICATION_ATOM_XML.
application/x-www-form-urlencoded.
MediaType.APPLICATION_FORM_URLENCODED.
application/json.
MediaType.APPLICATION_JSON.
application/octet-stream.
MediaType.APPLICATION_OCTET_STREAM.
application/xhtml+xml.
MediaType.APPLICATION_XHTML_XML.
application/xml.
MediaType.APPLICATION_XML.
ApplicationContext that was injected into this test instance
via AbstractJUnit38SpringContextTests.setApplicationContext(ApplicationContext).
ApplicationContext that was injected into this test instance
via AbstractJUnit4SpringContextTests.setApplicationContext(ApplicationContext).
ApplicationContext that was injected into this test instance
via AbstractTestNGSpringContextTests.setApplicationContext(ApplicationContext).
ApplicationContext that it runs in.ApplicationContext.ApplicationContextException
with the specified detail message and no root cause.
ApplicationContextException
with the specified detail message and the given root cause.
ConfigurableApplicationContext
prior to being refreshed.ApplicationListener objects, and publish events to them.SESSION_TRANSACTED onto an
ActivationSpec property named "useRAManagedTransaction", if available
(following ActiveMQ's naming conventions).
BeanPostProcessors to the given existing bean
instance, invoking their postProcessAfterInitialization methods.
BeanPostProcessors to the given existing bean
instance, invoking their postProcessBeforeInitialization methods.
postProcessBeforeInstantiation methods.
currencyTimeLimit field to the specified
"defaultCurrencyTimeLimit", if any (by default none).
ApplicationContextInitializer instances specified by the
"contextInitializerClasses" servlet init-param.
postProcessMergedBeanDefinition methods.
MethodInvoker that tries to convert the given
arguments for the actual target method via a TypeConverter.ComponentDefinition
that holds an aspect definition, including its nested pointcuts.ParseState entry representing an aspect.ParameterNameDiscoverer implementation that tries to deduce parameter names
for an advice method from the pointcut expression, returning, and throwing clauses.@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based asynchronous method execution.AbstractAdvisorAutoProxyCreator
subclass that exposes AspectJ's invocation context and understands AspectJ's rules
for advice precedence when multiple pieces of advice come from the same aspect.@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven cache management.Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression.AbstractAspectJAdvice
to the PointcutAdvisor interface.AspectJProxyFactory.
@Configuration class that registers the Spring infrastructure beans necessary
to enable AspectJ-based annotation-driven transaction management.IMessageHandler interface that
routes AspectJ weaving messages through the same logging system as the
regular Spring messages.ClassPreProcessorAgentAdapter
with the Spring application context's default
LoadTimeWeaver.modelName
exists and checks it type, based on the expectedType.
modelName
exists and checks it type, based on the expectedType.
Tag has any ancestor tag
of the supplied type, throwing an IllegalStateException
if not.
expectedValue to the value from the model
bound under the given modelName.
expectedValue to the value from the model
bound under the given modelName.
expectedModel to see if all elements in the
model appear and are equal.
expectedModel to see if all elements in the
model appear and are equal.
@Test(expected=...) supportAssertThrows class.
AssertThrows class.
expectedName.
expectedName.
AnnotationConfigUtils.ASYNC_ANNOTATION_PROCESSOR_BEAN_NAME
AnnotationConfigUtils.ASYNC_EXECUTION_ASPECT_BEAN_NAME
Configuration class.
Async
annotation.AsyncAnnotationAdvisor for bean-style configuration.
AsyncAnnotationAdvisor for the given task executor.
Async annotation at class or
method-level by adding a corresponding AsyncAnnotationAdvisor to the
exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces).AbstractAsyncConfiguration should be used based
on the value of EnableAsync.mode() on the importing @Configuration class.Configuration classes annotated with @EnableAsync that wish to customize the
Executor instance used when processing async method invocations.AnnotationAsyncExecutionInterceptor
or org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect.AsyncExecutionAspectSupport, using the provided default
executor unless individual async methods indicate via qualifier that a more
specific executor should be used.
MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor.AsyncExecutionInterceptor.
HanderInterceptor with lifecycle methods specific to async
request processing.Callable and DeferredResult.Future handle that can be used for method signatures
which are declared with a Future return type for asynchronous execution.TaskExecutor implementations,
offering an overloaded AsyncTaskExecutor.execute(Runnable, long) variant with a start
timeout parameter as well support for Callable.NativeWebRequest with methods for async request processing.WebRequestInterceptor with lifecycle methods specific to async
request processing.HttpMessageConverter that can read and write Atom feeds.AttributeAccessors, providing
a base implementation of all methods.Strings in attribute name format (lowercase, hyphens separating words)
into property name format (camel-cased).
MBeanInfoAssembler should be able
to autodetect beans.
MBeanInfoAssembler to add autodetection logic.FreeMarkerConfig object via the ApplicationContext.
for' attribute value for this tag.
id' attribute value for this tag.
id' attribute.
List wrapper class that allows for elements to be
automatically populated as they are requested.AutoPopulatingList that is backed by a standard
ArrayList and adds new instances of the supplied element Class
to the backing List on demand.
AutoPopulatingList that is backed by the supplied List
and adds new instances of the supplied element Class to the backing
List on demand.
AutoPopulatingList that is backed by a standard
ArrayList and creates new elements on demand using the supplied AutoPopulatingList.ElementFactory.
AutoPopulatingList that is backed by the supplied List
and creates new elements on demand using the supplied AutoPopulatingList.ElementFactory.
List.BeanDefinitionRegistry
as appropriate based on an @Enable* annotation having mode and
proxyTargetClass attributes set to the correct values.value attribute also matches
the specified value.
value attribute also matches
the specified value.
BeanFactory
interface to be implemented by bean factories that are capable of
autowiring, provided that they want to expose this functionality for
existing bean instances.BeanPostProcessor implementation
that autowires annotated fields, setter methods and arbitrary config methods.Autowired annotation.
converting from a String.
JdbcTemplate class.BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS
class loader; that is, the class loader used by the
present bean factory to load bean classes.BeanDefinitions
using the builder pattern.DefaultBeanDefinitionDocumentReader
to handle custom, nested (directly under a <bean>) tags.BeanDefinition property defaults.DefaultBeanDefinitionDocumentReader to handle custom,
top-level (directly under <beans/>) tags.XmlReaderContext and Environment.
BeanDefinitionParserDelegate.BeanDefinitionParserDelegate(XmlReaderContext, Environment)
BeanFactoryPostProcessor SPI, allowing for
the registration of further bean definitions before regular
BeanFactoryPostProcessor detection kicks in.BeanDefinition objects, in particular
the property values and constructor argument values contained in them,
resolving bean metadata values.ParseState entry representing a bean definition.BeanEntry class.
BeanExpressionContext.BeanFactory.@Qualifier annotation.AspectInstanceFactory implementation
backed by a Spring BeanFactory.BeanFactory.CacheOperationSource, used to include a
cache advice bean for methods that are cacheable.DataSourceLookup implementation based on a Spring BeanFactory.BeanFactoryDataSourceLookup class.
BeanFactoryDataSourceLookup class.
DestinationResolver implementation based on a Spring BeanFactory.BeanFactoryDestinationResolver class.
BeanFactoryDestinationResolver class.
BeanFactory,
or a BeanFactory subclass such as an
ApplicationContext.BeanFactory obtained through
a BeanFactoryLocator.BeanFactory.TransactionAttributeSource, used to include
a transaction advice bean for methods that are transactional.ListableBeanFactory interface.AttributeAccessorSupport,
holding attributes as BeanMetadataAttribute objects in order
to keep track of the definition source.BeanNameUrlHandlerMapping ordered at 2 to map URL
paths to controller bean names.
HandlerMapping
interface that map from URLs to beans with names that start with a slash ("/"),
similar to how Struts maps URLs to action names.Errors and BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects.BeanPropertyBindingResult class.
BeanPropertyBindingResult class.
RowMapper implementation that converts a row into a new instance
of the specified mapped target class.SqlParameterSource implementation that obtains parameter values
from bean properties of a given JavaBean object.@myBeanName still expressions.BeanPostProcessor 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).BeanWrapper implementation that should be sufficient
for all typical use cases.MethodBeforeAdvice.beforeCompletion callback: just invoked before commit.
beforeDelivery implementation starts a transaction,
if necessary, and exposes the endpoint ClassLoader as current
thread context ClassLoader.
DependencyInjectionTestExecutionListener.REINJECT_DEPENDENCIES_ATTRIBUTE in the supplied
test context has a value of Boolean.TRUE,
this method will have the same effect as
prepareTestInstance();
otherwise, this method will have no effect.
test method, for example for setting up test fixtures,
starting a transaction, etc.
test method in the supplied
test context, for example by setting up test
fixtures.
test context is
configured to run within a transaction, this method will run
@BeforeTransaction methods and start a new
transaction.
public void
method should be executed before a transaction is started for test
methods configured to run within a transaction via the
@Transactional annotation.Transaction.begin
method.
Transaction.begin
method.
HttpServletRequest attribute that contains the
best matching pattern within the handler mapping.
ExtendedModelMap that
automatically removes a BindingResult
object if the corresponding target attribute gets replaced.DataBinder's missing field errors,
and for translating a PropertyAccessException to a
FieldError.WebDataBinder.bindMultipart(java.util.Map>, org.springframework.beans.MutablePropertyValues) which binds
all multipart files, even if more than one sent for the same name
null).
null).
null).
ResourceAdapterApplicationContext) that it runs in.bridge Methods to the
Method being bridged.ScriptFactory implementation
for a BeanShell script.HttpMessageConverter that can read and write BufferedImages.ClientHttpRequestFactory that buffers all outgoing and incoming streams in memory.UriComponents instance from the various components contained in this builder.
UriComponents instance from the various components contained in this builder.
UriComponents instance and replaces URI template variables
with the values from a map.
UriComponents instance and replaces URI template variables
with the values from an array.
AbstractAtomFeedView.buildFeedEntries(Map, HttpServletRequest, HttpServletResponse)
to get a list of feed entries.
AbstractRssFeedView.buildFeedItems(Map, HttpServletRequest, HttpServletResponse)
to get a list of feed items.
field
to the supplied field list.
String for the given SQLException.
HandlerMapping.PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE, as well as
the HandlerMapping.URI_TEMPLATE_VARIABLES_ATTRIBUTE before executing the handler.
SessionFactory.
MethodInterceptor for accessing a Burlap service.FactoryBean for Burlap proxies.HttpMessageConverter that can read and write byte arrays.ByteArrayHttpMessageConverter.
PropertyEditor for converting
MultipartFiles to byte arrays.Resource implementation for a given byte array.NativeJdbcExtractor interface for the
C3P0 connection pool.Configuration class.
Connection for each
listener thread.
Connection, a JMS
Session, and a JMS MessageConsumer for each listener thread.
Connection and a JMS
Session for each listener thread.
CacheInterceptor
or an AspectJ aspect.PropertyDescriptor
information for a Java class.Cache).Caches.NamespaceHandler allowing for the configuration of declarative
cache management using either XML or using annotations.CacheOperation.CacheInterceptor.Cache.put(Object, Object) operation.AbstractCachingConfiguration should be used
based on the value of EnableCaching.mode() on the importing @Configuration
class.Configuration classes annotated with @EnableCaching that wish or need to
specify explicitly the CacheManager and KeyGenerator beans to be used
for annotation-driven cache management.SingleConnectionFactory subclass that adds Session
caching as well MessageProducer caching.MetadataReaderFactory interface,
caching MetadataReader per Spring Resource handle
(i.e.CallableStatementCreator
objects with different parameters based on a SQL statement and a single
set of parameter declarations.PlatformTransactionManager
interface, exposing a method for executing a given callback within a transaction.CallMetaDataProvider implementation based on the type of databse being used.active flag
after an exception got thrown.
ViewResolver can
handle the supplied view name.
ResourceDatabasePopulator if one of its SQL scripts could
not be read during population.Environment, thus always returns true.
true if the given media type includes any of the
supported media types.
String, changing the first letter to
upper case as per Character.toUpperCase(char).
Enum.valueOf(Class, String).
CastorMarshaller whenever it encounters a mapping problem.CastorMappingException with the specified detail message
and nested exception.
Marshaller interface for Castor.<oxm:castor-marshaller/> element.PlatformTransactionManager implementation
that manages local transactions for a single CCI ConnectionFactory.PersistenceExceptionTranslator that supports chaining,
allowing the addition of PersistenceExceptionTranslator instances in order.Character, to populate a property
of type Character or char from a String value.java.nio.charset.Charset, translating charset
String representations into Charset objects and back.- CharsetEditor() -
Constructor for class org.springframework.beans.propertyeditors.CharsetEditor
-
- check(PortletRequest, PortletResponse) -
Method in class org.springframework.web.portlet.handler.PortletContentGenerator
- Check and prepare the given request and response according to the settings
of this generator.
- checkActive() -
Method in class org.springframework.mock.web.MockHttpServletRequest
- Check whether this request is still active (that is, not completed yet),
throwing an IllegalStateException if not active anymore.
- checkActive() -
Method in class org.springframework.mock.web.portlet.MockPortletRequest
- Check whether this request is still active (that is, not completed yet),
throwing an IllegalStateException if not active anymore.
- checkAllowedFields(MutablePropertyValues) -
Method in class org.springframework.validation.DataBinder
- Check the given property values against the allowed fields,
removing values for fields that are not allowed.
- checkAndPrepare(PortletRequest, MimeResponse) -
Method in class org.springframework.web.portlet.handler.PortletContentGenerator
- Check and prepare the given request and response according to the settings
of this generator.
- checkAndPrepare(PortletRequest, MimeResponse, int) -
Method in class org.springframework.web.portlet.handler.PortletContentGenerator
- Check and prepare the given request and response according to the settings
of this generator.
- checkAndPrepare(HttpServletRequest, HttpServletResponse, boolean) -
Method in class org.springframework.web.servlet.support.WebContentGenerator
- Check and prepare the given request and response according to the settings
of this generator.
- checkAndPrepare(HttpServletRequest, HttpServletResponse, int, boolean) -
Method in class org.springframework.web.servlet.support.WebContentGenerator
- Check and prepare the given request and response according to the settings
of this generator.
- CheckboxesTag - Class in org.springframework.web.servlet.tags.form
- Databinding-aware JSP tag for rendering multiple HTML '
input'
elements with a 'type' of 'checkbox'. - CheckboxesTag() -
Constructor for class org.springframework.web.servlet.tags.form.CheckboxesTag
-
- CheckboxTag - Class in org.springframework.web.servlet.tags.form
- Databinding-aware JSP tag for rendering an HTML '
input'
element with a 'type' of 'checkbox'. - CheckboxTag() -
Constructor for class org.springframework.web.servlet.tags.form.CheckboxTag
-
- checkCandidate(String, BeanDefinition) -
Method in class org.springframework.context.annotation.ClassPathBeanDefinitionScanner
- Check the given candidate's bean name, determining whether the corresponding
bean definition needs to be registered or conflicts with an existing definition.
- checkCommand(Object) -
Method in class org.springframework.web.portlet.mvc.BaseCommandController
- Deprecated. Check if the given command object is a valid for this controller,
i.e.
- checkCommand(Object) -
Method in class org.springframework.web.servlet.mvc.BaseCommandController
- Deprecated. Check if the given command object is a valid for this controller,
i.e.
- checkCompiled() -
Method in class org.springframework.jdbc.core.simple.AbstractJdbcCall
- Check whether this operation has been compiled already;
lazily compile it if not already compiled.
- checkCompiled() -
Method in class org.springframework.jdbc.core.simple.AbstractJdbcInsert
- Check whether this operation has been compiled already;
lazily compile it if not already compiled.
- checkCompiled() -
Method in class org.springframework.jdbc.object.RdbmsOperation
- Check whether this operation has been compiled already;
lazily compile it if not already compiled.
- checkConfigMembers(RootBeanDefinition) -
Method in class org.springframework.beans.factory.annotation.InjectionMetadata
-
- checkDaoConfig() -
Method in class org.springframework.dao.support.DaoSupport
- Abstract subclasses must override this to check their configuration.
- checkDaoConfig() -
Method in class org.springframework.jca.cci.core.support.CciDaoSupport
-
- checkDaoConfig() -
Method in class org.springframework.jdbc.core.support.JdbcDaoSupport
-
- checkDaoConfig() -
Method in class org.springframework.orm.hibernate3.support.HibernateDaoSupport
-
- checkDaoConfig() -
Method in class org.springframework.orm.ibatis.support.SqlMapClientDaoSupport
-
- checkDaoConfig() -
Method in class org.springframework.orm.jdo.support.JdoDaoSupport
- Deprecated.
- checkDaoConfig() -
Method in class org.springframework.orm.jpa.support.JpaDaoSupport
- Deprecated.
- checkDefaultConnectionProperties(Connection) -
Method in class org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy
- Check the default connection properties (auto-commit, transaction isolation),
keeping them to be able to expose them correctly without fetching an actual
JDBC Connection from the target DataSource.
- checkDependencies(String, AbstractBeanDefinition, PropertyDescriptor[], PropertyValues) -
Method in class org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory
- Perform a dependency check that all properties exposed have been set,
if desired.
- checkExceptionExpectations(Exception) -
Method in class org.springframework.test.AssertThrows
- Deprecated. Does the donkey work of checking (verifying) that the
Exception that was thrown in the body of a test is
an instance of the AssertThrows.getExpectedException() class (or an
instance of a subclass).
- checkFieldDefaults(MutablePropertyValues) -
Method in class org.springframework.web.bind.WebDataBinder
- Check the given property values for field defaults,
i.e.
- checkFieldMarkers(MutablePropertyValues) -
Method in class org.springframework.web.bind.WebDataBinder
- Check the given property values for field markers,
i.e.
- checkForAliasCircle(String, String) -
Method in class org.springframework.core.SimpleAliasRegistry
- Check whether the given name points back to given alias as an alias
in the other direction, catching a circular reference upfront and
throwing a corresponding IllegalStateException.
- checkIfConfigurationModificationIsAllowed() -
Method in class org.springframework.jdbc.core.simple.AbstractJdbcInsert
- Method to check whether we are allowd to make any configuration changes at this time.
- checkManagedBean(Object) -
Method in class org.springframework.jmx.export.assembler.AbstractMBeanInfoAssembler
- Check the given bean instance, throwing an IllegalArgumentException
if it is not eligible for exposure with this assembler.
- checkManagedBean(Object) -
Method in class org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler
- Throws an IllegalArgumentException if it encounters a JDK dynamic proxy.
- checkMergedBeanDefinition(RootBeanDefinition, String, Object[]) -
Method in class org.springframework.beans.factory.support.AbstractBeanFactory
- Check the given merged bean definition,
potentially throwing validation exceptions.
- checkMessageListener(Object) -
Method in class org.springframework.jms.listener.AbstractMessageListenerContainer
- Check the given message listener, throwing an exception
if it does not correspond to a supported listener type.
- checkMultipart(ActionRequest) -
Method in class org.springframework.web.portlet.DispatcherPortlet
- Convert the request into a multipart request, and make multipart resolver available.
- checkMultipart(HttpServletRequest) -
Method in class org.springframework.web.servlet.DispatcherServlet
- Convert the request into a multipart request, and make multipart resolver available.
- checkNameUniqueness(String, List<String>, Element) -
Method in class org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
- Validate that the specified bean name and aliases have not been used already
within the current level of beans element nesting.
- checkNotModified(long) -
Method in class org.springframework.web.context.request.FacesWebRequest
-
- checkNotModified(String) -
Method in class org.springframework.web.context.request.FacesWebRequest
-
- checkNotModified(long) -
Method in class org.springframework.web.context.request.ServletWebRequest
-
- checkNotModified(String) -
Method in class org.springframework.web.context.request.ServletWebRequest
-
- checkNotModified(long) -
Method in interface org.springframework.web.context.request.WebRequest
- Check whether the request qualifies as not modified given the
supplied last-modified timestamp (as determined by the application).
- checkNotModified(String) -
Method in interface org.springframework.web.context.request.WebRequest
- Check whether the request qualifies as not modified given the
supplied
ETag (entity tag), as determined by the application.
- checkNotModified(long) -
Method in class org.springframework.web.portlet.context.PortletWebRequest
- Last-modified handling not supported for portlet requests:
As a consequence, this method always returns
false.
- checkNotModified(String) -
Method in class org.springframework.web.portlet.context.PortletWebRequest
- Last-modified handling not supported for portlet requests:
As a consequence, this method always returns
false.
- checkPropertySkipping(PropertyValues) -
Method in class org.springframework.beans.factory.annotation.InjectionMetadata.InjectedElement
- Checks whether this injector's property needs to be skipped due to
an explicit property value having been specified.
- checkQualifier(BeanDefinitionHolder, Annotation, TypeConverter) -
Method in class org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver
- Match the given qualifier annotation against the candidate bean definition.
- checkQualifiers(BeanDefinitionHolder, Annotation[]) -
Method in class org.springframework.beans.factory.annotation.QualifierAnnotationAutowireCandidateResolver
- Match the given qualifier annotations against the candidate bean definition.
- checkRequiredFields(MutablePropertyValues) -
Method in class org.springframework.validation.DataBinder
- Check the given property values against the required fields,
generating missing field errors where appropriate.
- checkResource(Locale) -
Method in class org.springframework.web.servlet.view.AbstractUrlBasedView
- Check whether the underlying resource that the configured URL points to
actually exists.
- checkResource(Locale) -
Method in class org.springframework.web.servlet.view.freemarker.FreeMarkerView
- Check that the FreeMarker template used for this view exists and is valid.
- checkResource(Locale) -
Method in class org.springframework.web.servlet.view.tiles2.TilesView
-
- checkResource(Locale) -
Method in class org.springframework.web.servlet.view.velocity.VelocityLayoutView
- Overrides
VelocityView.checkTemplate() to additionally check
that both the layout template and the screen content template can be loaded.
- checkResource(Locale) -
Method in class org.springframework.web.servlet.view.velocity.VelocityView
- Check that the Velocity template used for this view exists and is valid.
- checkResourceType(Class) -
Method in class org.springframework.beans.factory.annotation.InjectionMetadata.InjectedElement
-
- checkRowsAffected(int) -
Method in class org.springframework.jdbc.object.SqlUpdate
- Check the given number of affected rows against the
specified maximum number or required number.
- checkService() -
Method in class org.springframework.remoting.support.RemoteExporter
- Check whether the service reference has been set.
- checkServiceInterface() -
Method in class org.springframework.remoting.support.RemoteExporter
- Check whether a service reference has been set,
and whether it matches the specified service.
- checkUserTransactionAndTransactionManager() -
Method in class org.springframework.transaction.jta.JtaTransactionManager
- Check the UserTransaction as well as the TransactionManager handle,
assuming standard JTA requirements.
- checkWriteOperationAllowed(Session) -
Method in class org.springframework.orm.hibernate3.HibernateTemplate
- Check whether write operations are allowed on the given Session.
- childBeanDefinition(String) -
Static method in class org.springframework.beans.factory.support.BeanDefinitionBuilder
- Create a new
BeanDefinitionBuilder used to construct a ChildBeanDefinition.
- ChildBeanDefinition - Class in org.springframework.beans.factory.support
- Bean definition for beans which inherit settings from their parent.
- ChildBeanDefinition(String) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition for the given parent, to be
configured through its bean properties and configuration methods.
- ChildBeanDefinition(String, MutablePropertyValues) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition for the given parent.
- ChildBeanDefinition(String, ConstructorArgumentValues, MutablePropertyValues) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition for the given parent.
- ChildBeanDefinition(String, Class, ConstructorArgumentValues, MutablePropertyValues) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition for the given parent,
providing constructor arguments and property values.
- ChildBeanDefinition(String, String, ConstructorArgumentValues, MutablePropertyValues) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition for the given parent,
providing constructor arguments and property values.
- ChildBeanDefinition(ChildBeanDefinition) -
Constructor for class org.springframework.beans.factory.support.ChildBeanDefinition
- Create a new ChildBeanDefinition as deep copy of the given
bean definition.
- children -
Variable in class org.springframework.expression.spel.ast.SpelNodeImpl
-
- CLASS_ATTRIBUTE -
Static variable in class org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
-
- CLASS_ATTRIBUTE -
Static variable in class org.springframework.web.servlet.tags.form.AbstractHtmlElementTag
-
- CLASS_FILE_SUFFIX -
Static variable in class org.springframework.util.ClassUtils
- The ".class" file suffix
- CLASS_KEY -
Static variable in class org.springframework.beans.factory.support.PropertiesBeanDefinitionReader
- Special key to distinguish
owner.(class)=com.myapp.MyClass-
- ClassArrayEditor - Class in org.springframework.beans.propertyeditors
- Property editor for an array of
Classes, to enable
the direct population of a Class[] property without having to
use a String class name property as bridge. - ClassArrayEditor() -
Constructor for class org.springframework.beans.propertyeditors.