|
|||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES | ||||||||
owner.(abstract)=true
Default is "false".
AbstractTransactionalJUnit4SpringContextTests)AbstractAnnotationAwareTransactionalTests.AbstractAnnotationAwareTransactionalTests(String).
name and retrieves the configured (or
default) ProfileValueSource.
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.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.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)
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.
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.
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
configuration 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.
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.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.
|
|||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES | ||||||||