|
|||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES | ||||||||
owner.(abstract)=true
Default is "false".
AbstractJUnit38SpringContextTests)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)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.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.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 strategy.HandlerMapping implementations
that derive URL paths according to conventions for specific controller types.DataFieldMaxValueIncrementer that delegates
to a single AbstractDataFieldMaxValueIncrementer.getNextKey() template method that returns a long.DataSource
implementations, taking care of the padding.AbstractJUnit38SpringContextTests)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.Errors interface.FactoryBean implementations that
creates a singleton or a prototype object, depending on a flag.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.AbstractContextLoader which loads a
GenericApplicationContext from the locations provided to
AbstractGenericContextLoader.loadContext(String...).HandlerExceptionResolver implementations.HandlerExceptionResolver implementations.HandlerMapping
implementations.HandlerMapping
implementations.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.TestCase which integrates the Spring TestContext
Framework and explicit ApplicationContext testing support in a
JUnit 3.8 environment.TestContextManager 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.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 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.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'.AbstractJUnit38SpringContextTests)AbstractJUnit38SpringContextTests)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.AbstractJUnit38SpringContextTests)transactional extension of
AbstractJUnit38SpringContextTests which adds convenience
functionality for JDBC access.name.
transactional extension of
AbstractJUnit4SpringContextTests which adds convenience functionality
for JDBC access.AbstractJUnit38SpringContextTests)transactional extension of
AbstractTestNGSpringContextTests which adds convenience functionality
for JDBC access.TransactionStatus interface.HandlerMapping
implementations.MethodNameResolver implementations.Controllers that return a view name
based on the request URL.View
implementations.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.
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.
Errors instance to this
Errors instance.
ModelMap.addAllAttributes(Collection)
ModelMap.addAllAttributes(Map)
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.
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)
ObjectError or FieldError to the errors list.
javax.activation.DataSource.
java.io.File.
org.springframework.core.io.Resource.
org.springframework.core.InputStreamResource, and
specifying the content type explicitly.
AbstractApplicationContext.addApplicationListener(org.springframework.context.ApplicationListener)
ModelMap.addAttribute(String, Object)
ModelMap.addAttribute(Object)
addPropertyValue that takes
a property name and a property value.
ClassLoader.getResource
(also suitable for use with Class.getResource by prepending a
slash ('/') to the return value).
ClassFileTransformer to be applied by this
LoadTimeWeaver.
ClassFileTransformer to be applied by this
ClassLoader.
addTransformer method.
ParseState entry representing an advice element.AdviceEntry class.
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).
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.BeanDefinition
interface that exposes AnnotationMetadata
about its bean class - without requiring the class to be loaded yet.GenericBeanDefinition
class, adding support for annotation metadata exposed through the
AnnotatedBeanDefinition interface.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.@Configuration-annotated
classes, but also plain @Components
and JSR-330 compliant classes using javax.inject annotations.AnnotationConfigApplicationContext.register(java.lang.Class...) calls and then manually refreshed.
BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration.WebApplicationContext implementation
which accepts annotated classes as input - in particular
@Configuration-annotated
classes, but also plain @Components
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.
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.
application/x-www-form-urlencoded.
application/json.
application/octet-stream.
application/xhtml+xml.
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.
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).
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.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.Pointcut implementation
that uses the AspectJ weaver to evaluate a pointcut expression.AbstractAspectJAdvice
to the PointcutAdvisor interface.AspectJProxyFactory.
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.
Async
annotation.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).MethodInterceptor that processes method invocations
asynchronously, using a given AsyncTaskExecutor.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.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 | ||||||||