|
spring-core | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
ClassMetadata object
to subclasses, for class testing purposes.Environment implementations.Environment instance, calling back to
AbstractEnvironment.customizePropertySources(MutablePropertySources) during construction to
allow subclasses to contribute or manipulate PropertySource instances as
appropriate.
UrlResource or ClassPathResource.Resource implementations,
pre-implementing typical behavior.DefaultConversionService.addDefaultConverters(ConverterRegistry)
ClassLoader.getResource
(also suitable for use with Class.getResource by prepending a
slash ('/') to the return value).
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.
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).AnnotationTypeFilter for the given annotation type.
StringBuilder.
TaskExecutor implementations,
offering an overloaded AsyncTaskExecutor.execute(Runnable, long) variant with a start
timeout parameter as well support for Callable.AttributeAccessors, providing
a base implementation of all methods.Strings in attribute name format (lowercase, hyphens separating words)
into property name format (camel-cased).
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.bridge Methods to the
Method being bridged.Resource implementation for a given byte array.MetadataReaderFactory interface,
caching MetadataReader per Spring Resource handle
(i.e.String, changing the first letter to
upper case as per Character.toUpperCase(char).
Enum.valueOf(Class, String).
Resource implementation for class path resources.ResourceLoader implementation that interprets plain resource paths
as relative to a given java.lang.Class.CODE_ORDER.
CommandLinePropertySource instances: "commandLineArgs"
PropertySource implementations backed by command line
arguments.CommandLinePropertySource having the default name "commandLineArgs" and backed by the given source object.
CommandLinePropertySource having the given name and backed by
the given source object.
java.io.Writer adapter for a Commons Logging Log.PropertySource implementation that iterates over a set of
PropertySource instances.CompositePropertySource.
Executor interface
for any Spring TaskExecutor.ConcurrentMap
is available on Java 5+ anywayConversionService
types.Environment types.PropertyResolver types.Constants class is asked for
an invalid constant name.true if any element in 'candidates' is
contained in 'source'; otherwise returns false.
PropertySource contains a property with the given name.
PropertySource contains a property with the given name.
null.
PropertySource contains the given name.
ConversionService
configurations.PropertyEditor for any given
ConversionService and specific target type.ConversionService
and the given target type.
src file/directory
to the dest file/directory.
ContentHandler that transforms callback calls to DOM Nodes.
ContentHandler that writes to the given StAX XMLStreamWriter.
ContentHandler that writes events to the given StAX XMLEventWriter.
ControlFlow instance.
Result for the given XMLStreamWriter.
Result for the given XMLEventWriter.
Source for the given XMLStreamReader.
Source for the given XMLEventReader.
DefaultConversionService.DefaultConversionService()
XMLStreamReader that reads from a XMLEventReader.
XMLStreamWriter that writes to a XMLEventWriter.
Result for the given XMLStreamWriter.
Result for the given XMLEventWriter.
Source for the given XMLStreamReader.
Source for the given XMLEventReader.
XMLReader that reads from the given StAX XMLStreamReader.
XMLReader that reads from the given StAX XMLEventReader.
PropertySource objects to be searched by this
Environment during calls to AbstractEnvironment.getProperty(String) and related
methods.
OverridingClassLoader
and org.springframework.instrument.classloading.ShadowingClassLoader,
providing common handling of excluded packages and classes.indenting is enabled.
LABEL_ORDER,
then CODE_ORDER.
GenericConversionService configured by default with
converters appropriate for most environments.DefaultConversionService with the set of
default converters.
PropertiesPersister interface.ResourceLoader interface.toString() styler.toString styling conventions.File - for directories,
recursively delete any nested directories or files as well.
Resource implementation that holds a resource description
but does not point to an actually readable resource.Converter that delegates to a Deserializer
to convert data in a byte array to an object.Deserializer.
InputStream.
Transformer.
AbstractEnvironment.setActiveProfiles(java.lang.String...) or if the current set of active profiles
is empty, check for the presence of the "spring.profiles.active"
property and assign its value to the set of active profiles.
AbstractEnvironment.setDefaultProfiles(String...) or if the current set of default profiles
consists only of reserved default
profiles, then check for the presence of the
"spring.profiles.default" property and assign its value (if any)
to the set of default profiles.
path against the given pattern.
Collection or an Array, creates a element TypeDescriptor from the provided collection or array element.
Transformer.
Transformer.
Resource
with a specific encoding to be used for reading from the resource.PropertySource implementation capable of interrogating its
underlying source object to enumerate all possible property name/value
pairs.Environment object.PropertySource object is equal to the given object if:
they are the same instance
the name properties for both objects are equal
task.
task synchronously, through direct
invocation of it's run() method.
task.
TaskExecutor)
and exposes a full java.util.concurrent.ExecutorService for it.true.
true.
Resource implementation for java.io.File handles.ResourceLoader implementation that resolves plain paths as
file system resources rather than as class path resources
(the latter is DefaultResourceLoader's default strategy).Annotation of annotationType from the supplied Method,
traversing its super methods if no annotation can be found on the given method itself.
Annotation of annotationType from the supplied Class,
traversing its interfaces and superclasses if no annotation can be found on the given class itself.
Class in the inheritance hierarchy of the specified clazz
(including the specified clazz itself) which declares an annotation for the
specified annotationType, or null if not found.
bridge Method.
field on the supplied Class with the
supplied name.
field on the supplied Class with the
supplied name and/or type.
candidates' that is contained in
'source'.
Method on the supplied class with the supplied name
and no parameters.
Method on the supplied class with the supplied name
and parameter types.
ClassUtils.forName(String, ClassLoader)
Class.forName() that also returns Class instances
for primitives (e.g."int") and array class names (e.g.
AnnotationAttributes instance based on the given map; if the map
is already an AnnotationAttributes instance, it is casted and returned
immediately without creating any new instance; otherwise create a new instance by
wrapping the map with the AnnotationAttributes.AnnotationAttributes(Map) constructor.
ConversionService implementation suitable for use in most environments.null if not found.
Annotation of annotationType from the supplied
Method, Constructor or Field.
Annotation of annotationType from the supplied Method.
AnnotationAttributes
map structure.
Annotations from the supplied Method.
name.
null).
null).
"value" attribute
of a single-element Annotation, given an annotation instance.
"value" attribute
of a single-element Annotation, given the annotation type.
annotation type.
obj is
not null; otherwise returns an empty String.
TypeDescriptor.getElementTypeDescriptor().
null if the underlying class is a top-level class.
null if none specified.
field object on the
specified target object.
java.io.File,
i.e.
java.io.File,
i.e.
java.io.File,
i.e.
java.io.File,
i.e.
java.io.File,
i.e.
null,
assuming that this resource type does not have a filename.
InputStream.
InputStream.
System.getProperty("java.version").
LabeledEnum by its identifying code.
LabeledEnum by its identifying code.
TypeDescriptor.getMapKeyTypeDescriptor().
Map and its key type is parameterized, returns the map's key type.
Map, creates a mapKey TypeDescriptor from the provided map key.
TypeDescriptor.getMapValueTypeDescriptor().
Map and its value type is parameterized, returns the map's value type.
Map, creates a mapValue TypeDescriptor from the provided map value.
IllegalStateException).
null).
PropertySource
TypeDescriptor.getType() that accounts for a primitive type by returning its object wrapper type.
OutputStream for the underlying resource,
allowing to (over-)write its content.
null if they cannot be determined.
null if they cannot be determined.
Comparator suitable for sorting patterns in order of explicitness.
Comparator suitable for sorting patterns
in order of explicitness for that path.
null if not found.
null
if the key cannot be resolved.
defaultValue if the key cannot be resolved.
null
if the key cannot be resolved.
defaultValue if the key cannot be resolved.
null if not found.
null.
null if not found.
Class
of type T or null if the key cannot be resolved.
null).
PropertySources for this Environment in mutable form,
allowing for manipulation of the set of PropertySource objects that should
be searched when resolving properties against this Environment object.
Class.
java.io.Reader for the specified resource,
using the specified encoding (if any).
null).
null).
PropertySource.
null if there is no super class defined.
System.getenv() if allowed by the current
SecurityManager, otherwise return a map implementation that will attempt
to access individual keys using calls to System.getenv(String).
System.getProperties() if allowed by the current
SecurityManager, otherwise return a map implementation that will attempt
to access individual keys using calls to System.getProperty(String).
null) for the default group.
TypeVariable names to concrete
Class for the specified Class.
AbstractResource.getURL().
java.net.URL.
"value" attribute of a
single-element Annotation, given an annotation instance.
Object based on its concrete type.
null if it cannot be determined.
null).
XMLEventReader for the given StAX Source.
XMLEventWriter for the given StAX Result.
XMLStreamReader for the given StAX Source.
XMLStreamWriter for the given StAX Result.
true if the attribute identified by name exists.
name property of this PropertySource
object.
Boolean.hashCode().
Double.hashCode().
Float.hashCode().
Long.hashCode().
null and not the empty String.
null and not the empty String.
null nor of length 0.
null nor of length 0.
null and must contain at least one non-whitespace character.
null and must contain at least one non-whitespace character.
Resource implementation for a given InputStream.InputStream.StaticLabeledEnumResolver singleton instance.
Method against the supplied target
object with no arguments.
Method against the supplied target
object with the supplied arguments.
Method against the supplied target object with no arguments.
Method against the supplied target object with the
supplied arguments.
annotationType is
declared locally on the supplied clazz.
annotationType is present
on the supplied clazz and is inherited
i.e., not declared locally for the class).
superType.isAssignableFrom(subType) is true.
superType.isAssignableFrom(subType) is true.
Collection type?
true if the supplied Collection is null
or empty.
true if the supplied Map is null
or empty.
doFindPathMatchingJarResources method can handle.
Map type?
null .
null .
Object.
false.
true.
path represent a pattern that can be matched
by an implementation of this interface?
ClassUtils.isPresent(String, ClassLoader)
Class identified by the supplied name is present
and can be loaded.
true.
Result is a StAX Result.
Source is a StAX Source.
IllegalArgumentException
if the test result is false.
IllegalArgumentException
if the test result is false.
CommandLinePropertySource implementation backed by a JOpt OptionSet.JOptCommandLinePropertySource having the default name
and backed by the given OptionSet.
JOptCommandLinePropertySource having the given name
and backed by the given OptionSet.
LABEL_ORDER.
LinkedHashMap variant that stores String keys in a case-insensitive
manner, for example for key-based access in a results table.LinkedHashMap
with the given initial capacity and stores lower-case keys according
to the default Locale.
LinkedHashMap
with the given initial capacity and stores lower-case keys according
to the given Locale.
MultiValueMap that wraps a LinkedHashMap,
storing multiple values in a LinkedList.LinkedHashMap.
LinkedHashMap
with the given initial capacity.
ClassLoader.defineClass(byte[], int, int) call.
ParameterNameDiscoverer that uses the LocalVariableTable
information in the method attributes to discover parameter names.PropertySource that reads keys and values from a Map object.path against the given pattern,
according to this PathMatcher's matching strategy.
sourceType to targetType
currently under consideration be selected?
path against the corresponding part of the given
pattern, according to this PathMatcher's matching strategy.
ClassReader.MetadataReader instances.Map interface that stores multiple values.PropertySources interface.MutablePropertySources object.
MutablePropertySources from the given propertySources
object, preserving the original order of contained PropertySource objects.
PropertySource implementation intended for collection comparison purposes only.
InheritableThreadLocal subclass that exposes a specified name
as NamedInheritableThreadLocal.toString() result (allowing for introspection).ThreadLocal subclass that exposes a specified name
as NamedThreadLocal.toString() result (allowing for introspection).TypeDescriptor by setting its type to the class of the provided value.
Exceptions with a root cause.NestedCheckedException with the specified detail message.
NestedCheckedException with the specified detail message
and nested exception.
IOException that properly handles a root cause,
exposing the root cause just like NestedChecked/RuntimeException does.NestedIOException with the specified detail message.
NestedIOException with the specified detail message
and nested exception.
Exceptions with a root cause.NestedRuntimeException with the specified detail message.
NestedRuntimeException with the specified detail message
and nested exception.
null and must have at least one element.
null and must have at least one element.
null and must have at least one element.
null and must have at least one element.
null
and must have at least one entry.
null
and must have at least one entry.
null .
null .
null based on the
provided flag, decorating the given Comparator.
true
if both are null or false if only one is
null.
Object.hashCode().
Comparator implementation for Ordered objects,
sorting by order value ascending (resp.java.util.Comparator implementations,
such as an invertible comparator and a compound comparator.ClassLoader that does not always delegate to the
parent loader, as normal class loaders do.localeString value into a Locale.
decode / valueOf methods.
String-based path matching.ResourcePatternResolver implementation that is able to resolve a
specified resource location path into one or more matching Resources.-1 if not found.
Ordered interface, expressing a 'priority'
ordering: Order values expressed by PriorityOrdered objects always
apply before order values of 'plain' Ordered values.java.util.Properties,
performing standard handling of input streams.java.util.Properties,
allowing for pluggable parsing strategies.PropertySource implementation that extracts properties from a
Properties object.java.beans.PropertyDescriptor.PropertyPlaceholderHelper that uses the supplied prefix and suffix.
PropertyPlaceholderHelper that uses the supplied prefix and suffix.
PropertySource with the given name and source object.
PropertySource with the given name and with a new Object
instance as the underlying source.
PropertySource to be used as a placeholder in cases where an actual
property source cannot be eagerly initialized at application context
creation time.PropertySource objects.PropertyResolver implementation that resolves property values against
an underlying set of PropertySources.Pattern.null if not found.
name and return its value.
${name} with the corresponding property
from the supplied Properties.
${name} with the value returned from the supplied
PropertyPlaceholderHelper.PlaceholderResolver.
environment if necessary.
PropertyResolver.getProperty(java.lang.String).
PropertyResolver.getProperty(java.lang.String).
Resource arrays, to
automatically convert String location patterns
(e.g.PathMatchingResourcePatternResolver and StandardEnvironment.
ResourceArrayPropertyEditor.ResourceArrayPropertyEditor(ResourcePatternResolver, PropertyResolver)
ResourcePatternResolver
and PropertyResolver (typically an Environment).
ResourceArrayPropertyEditor.ResourceArrayPropertyEditor(ResourcePatternResolver, PropertyResolver, boolean)
ResourcePatternResolver
and PropertyResolver (typically an Environment).
Editor for Resource
descriptors, to automatically convert String locations
e.g.ResourceEditor class
using a DefaultResourceLoader and StandardEnvironment.
ResourceEditor.ResourceEditor(ResourceLoader, PropertyResolver)
ResourceEditor class
using the given ResourceLoader and PropertyResolver.
ResourceEditor.ResourceEditor(ResourceLoader, PropertyResolver, boolean)
ResourceEditor class
using the given ResourceLoader.
PropertiesPropertySource that loads a Properties
object from a given Resource or resource location such as
"classpath:/com/myco/foo.properties" or "file:/path/to/file.properties".classpath:).
classpath:.
exception, which is presumably the
target exception of an InvocationTargetException.
exception, which is presumably the
target exception of an InvocationTargetException.
Serializer or
Deserializer failed.SerializationException with the specified detail message.
SerializationException with the specified detail message
and nested exception.
Converter that delegates to a Serializer
to convert an object to a byte array.Serializer
Environment.
name to the supplied value.
null
for using the thread context class loader at the time of actual resource access.
ConfigurableConversionService to be used when performing type
conversions on properties.
ConfigurableEnvironment.setActiveProfiles(java.lang.String...).
ConfigurableEnvironment.setActiveProfiles(java.lang.String...).
field object on the
specified target object to the specified value.
ConfigurablePropertyResolver.validateRequiredProperties().
null if no such
special character should be processed as a value separator.
null if no such
special character should be processed as a value separator.
AliasRegistry interface.TaskExecutor implementation that fires up a new Thread for each task,
executing it asynchronously.CommandLinePropertySource implementation backed by a simple String array.SimpleCommandLinePropertySource having the default name
and backed by the given String[] of command line arguments.
SimpleCommandLinePropertySource having the given name
and backed by the given String[] of command line arguments.
MetadataReaderFactory interface,
creating a new ASM ClassReader for every request.javax.xml.namespace.NamespaceContext implementation.org.xml.sax.ErrorHandler implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.PropertySource objects contained.
AnnotationMetadata implementation that uses standard reflection
to introspect a given Class.StandardAnnotationMetadata wrapper for the given Class.
StandardAnnotationMetadata wrapper for the given Class,
providing the option to return any nested annotations or annotation arrays in the
form of AnnotationAttributes instead of actual Annotation instances.
ClassMetadata implementation that uses standard reflection
to introspect a given Class.Environment implementation suitable for use in 'standard' (i.e.MethodMetadata implementation that uses standard reflection
to introspect a given Method.IllegalStateException
if the test result is false.
IllegalStateException
if the test result is false.
String utility methods.toString()'ed object after it's fields are styled.
toString()'ed object before its fields are styled.
TaskExecutor implementation that executes each task synchronously
in the calling thread.MapPropertySource designed for use with
system environment variables.SystemEnvironmentPropertySource with the given name and
delegating to the given MapPropertySource.
Runnable.java.util.concurrent.Executor and
exposes a Spring TaskExecutor for it.TaskExecutor rejects to accept
a given task for execution.TaskRejectedException
with the specified detail message and no root cause.
TaskRejectedException
with the specified detail message and the given root cause.
AsyncTaskExecutor rejects to accept
a given task for execution because of the specified timeout.TaskTimeoutException
with the specified detail message and no root cause.
TaskTimeoutException
with the specified detail message and the given root cause.
Map<K, List<V>> to an MultiValueMap<K,V>.
MultiValueMap.
getTaskInfo() and use the task info directly.
toString() methods
with pluggable styling conventions.toString() methods.Transformers, and the
javax.xml.transform package in general.String.trim() on each of them.
MethodParameter.
Field.
Property.
MetadataReader.String, changing the first letter to
lower case as per Character.toLowerCase(char).
Resource implementation for java.net.URL locators."useCaches" flag on the
given connection, preferring false but leaving the
flag at true for JNLP based resources.
java.lang.Object.
ConfigurablePropertyResolver.setRequiredProperties(java.lang.String...) is present and resolves to a
non-null value.
Resource implementation.
|
spring-core | ||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||