A B C D E F G H I J K L M N O P Q R S T U V W X

## A

AALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
AASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
AbstractClassTestingTypeFilter - org.springframework.core.type.filter中的类
  Type filter that exposes a `ClassMetadata` object to subclasses, for class testing purposes.
AbstractClassTestingTypeFilter() - 类 的构造器org.springframework.core.type.filter.AbstractClassTestingTypeFilter
AbstractDataBufferDecoder<T> - org.springframework.core.codec中的类
  Abstract base class for `Decoder` implementations that can decode a `DataBuffer` directly to the target element type.
AbstractDataBufferDecoder(MimeType...) - 类 的构造器org.springframework.core.codec.AbstractDataBufferDecoder
AbstractDecoder<T> - org.springframework.core.codec中的类
  Abstract base class for `Decoder` implementations.
AbstractDecoder(MimeType...) - 类 的构造器org.springframework.core.codec.AbstractDecoder
AbstractEncoder<T> - org.springframework.core.codec中的类
  Abstract base class for `Decoder` implementations.
AbstractEncoder(MimeType...) - 类 的构造器org.springframework.core.codec.AbstractEncoder
AbstractEnvironment - org.springframework.core.env中的类
  Abstract base class for `Environment` implementations.
AbstractEnvironment() - 类 的构造器org.springframework.core.env.AbstractEnvironment
  Create a new `Environment` instance, calling back to `AbstractEnvironment.customizePropertySources(MutablePropertySources)` during construction to allow subclasses to contribute or manipulate `PropertySource` instances as appropriate.
AbstractFileResolvingResource - org.springframework.core.io中的类
  Abstract base class for resources which resolve URLs into File references, such as `UrlResource` or `ClassPathResource`.
AbstractFileResolvingResource() - 类 的构造器org.springframework.core.io.AbstractFileResolvingResource
AbstractPropertyResolver - org.springframework.core.env中的类
  Abstract base class for resolving properties against any underlying source.
AbstractPropertyResolver() - 类 的构造器org.springframework.core.env.AbstractPropertyResolver
AbstractResource - org.springframework.core.io中的类
  Convenience base class for `Resource` implementations, pre-implementing typical behavior.
AbstractResource() - 类 的构造器org.springframework.core.io.AbstractResource
AbstractSingleValueEncoder<T> - org.springframework.core.codec中的类
  Abstract base class for `Encoder` classes that can only deal with a single value.
AbstractSingleValueEncoder(MimeType...) - 类 的构造器org.springframework.core.codec.AbstractSingleValueEncoder
AbstractTypeHierarchyTraversingFilter - org.springframework.core.type.filter中的类
  Type filter that is aware of traversing over hierarchy.
AbstractTypeHierarchyTraversingFilter(boolean, boolean) - 类 的构造器org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
ACC_ABSTRACT - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_ANNOTATION - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_BRIDGE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_DEPRECATED - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_ENUM - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_FINAL - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_INTERFACE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_MANDATED - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_MODULE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_NATIVE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_OPEN - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_PRIVATE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_PROTECTED - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_PUBLIC - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_STATIC - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_STATIC_PHASE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_STRICT - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_SUPER - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_SYNCHRONIZED - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_SYNTHETIC - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_TRANSIENT - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_TRANSITIVE - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_VARARGS - 接口 中的静态变量org.springframework.asm.Opcodes
ACC_VOLATILE - 接口 中的静态变量org.springframework.asm.Opcodes
accept(ClassVisitor, int) - 类 中的方法org.springframework.asm.ClassReader
  Makes the given visitor visit the Java class of this `ClassReader` .
accept(ClassVisitor, Attribute[], int) - 类 中的方法org.springframework.asm.ClassReader
  Makes the given visitor visit the Java class of this `ClassReader`.
acceptsProfiles(String...) - 类 中的方法org.springframework.core.env.AbstractEnvironment
acceptsProfiles(String...) - 接口 中的方法org.springframework.core.env.Environment
  Return whether one or more of the given profiles is active or, in the case of no explicit active profiles, whether one or more of the given profiles is included in the set of default profiles.
access - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
accessibleConstructor(Class<T>, Class<?>...) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Obtain an accessible constructor for the given class and parameters.
ACONST_NULL - 接口 中的静态变量org.springframework.asm.Opcodes
ACTIVE_PROFILES_PROPERTY_NAME - 类 中的静态变量org.springframework.core.env.AbstractEnvironment
  Name of property to set to specify active profiles: "spring.profiles.active".
adapt(S) - 类 中的方法org.springframework.util.concurrent.FutureAdapter
  Adapts the given adaptee's result into T.
adaptAnnotation(A) - 类 中的方法org.springframework.core.annotation.SynthesizingMethodParameter
adaptAnnotation(A) - 类 中的方法org.springframework.core.MethodParameter
  A template method to post-process a given annotation instance before returning it to the caller.
adaptAnnotationArray(Annotation[]) - 类 中的方法org.springframework.core.annotation.SynthesizingMethodParameter
adaptAnnotationArray(Annotation[]) - 类 中的方法org.springframework.core.MethodParameter
  A template method to post-process a given annotation array before returning it to the caller.
add(int, E) - 类 中的方法org.springframework.util.AutoPopulatingList
add(E) - 类 中的方法org.springframework.util.AutoPopulatingList
add(Iterator<E>) - 类 中的方法org.springframework.util.CompositeIterator
  Add given iterator to this composite.
add(K, V) - 类 中的方法org.springframework.util.LinkedMultiValueMap
add(K, V) - 接口 中的方法org.springframework.util.MultiValueMap
  Add the given single value to the current list of values for the given key.
addActiveProfile(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
addActiveProfile(String) - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Add a profile to the current set of active profiles.
addAfter(String, PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Add the given property source object with precedence immediately lower than the named relative property source.
addAll(Collection<? extends E>) - 类 中的方法org.springframework.util.AutoPopulatingList
addAll(int, Collection<? extends E>) - 类 中的方法org.springframework.util.AutoPopulatingList
addAll(K, List<? extends V>) - 类 中的方法org.springframework.util.LinkedMultiValueMap
addAll(MultiValueMap<K, V>) - 类 中的方法org.springframework.util.LinkedMultiValueMap
addAll(K, List<? extends V>) - 接口 中的方法org.springframework.util.MultiValueMap
  Add all the values of the given list to the current list of values for the given key.
addAll(MultiValueMap<K, V>) - 接口 中的方法org.springframework.util.MultiValueMap
  Add all the values of the given `MultiValueMap` to the current values.
addAllClassLoaderJarRoots(ClassLoader, Set<Resource>) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Search all `URLClassLoader` URLs for jar file references and add them to the given set of resources in the form of pointers to the root of the jar file content.
addBefore(String, PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Add the given property source object with precedence immediately higher than the named relative property source.
addCallback(ListenableFutureCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
addCallback(SuccessCallback<? super T>, FailureCallback) - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
addCallback(ListenableFutureCallback<? super T>) - 接口 中的方法org.springframework.util.concurrent.ListenableFuture
  Register the given `ListenableFutureCallback`.
addCallback(SuccessCallback<? super T>, FailureCallback) - 接口 中的方法org.springframework.util.concurrent.ListenableFuture
  Java 8 lambda-friendly alternative with success and failure callbacks.
addCallback(ListenableFutureCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.ListenableFutureAdapter
addCallback(SuccessCallback<? super T>, FailureCallback) - 类 中的方法org.springframework.util.concurrent.ListenableFutureAdapter
addCallback(ListenableFutureCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.ListenableFutureCallbackRegistry
  Add the given callback to this registry.
addCallback(ListenableFutureCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.ListenableFutureTask
addCallback(SuccessCallback<? super T>, FailureCallback) - 类 中的方法org.springframework.util.concurrent.ListenableFutureTask
addCallback(ListenableFutureCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
addCallback(SuccessCallback<? super T>, FailureCallback) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
addClassPathManifestEntries(Set<Resource>) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Determine jar file references from the "java.class.path." manifest property and add them to the given set of resources in the form of pointers to the root of the jar file content.
addCollectionConverters(ConverterRegistry) - 类 中的静态方法org.springframework.core.convert.support.DefaultConversionService
  Add common collection converters.
addComparator(Comparator<? extends T>) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Add a Comparator to the end of the chain.
addComparator(Comparator<? extends T>, boolean) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Add a Comparator to the end of the chain using the provided sort order.
addConverter(Converter<?, ?>) - 接口 中的方法org.springframework.core.convert.converter.ConverterRegistry
  Add a plain converter to this registry.
addConverter(Class<S>, Class<T>, Converter<? super S, ? extends T>) - 接口 中的方法org.springframework.core.convert.converter.ConverterRegistry
  Add a plain converter to this registry.
addConverter(GenericConverter) - 接口 中的方法org.springframework.core.convert.converter.ConverterRegistry
  Add a generic converter to this registry.
addConverter(Converter<?, ?>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
addConverter(Class<S>, Class<T>, Converter<? super S, ? extends T>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
addConverter(GenericConverter) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
addConverterFactory(ConverterFactory<?, ?>) - 接口 中的方法org.springframework.core.convert.converter.ConverterRegistry
  Add a ranged converter factory to this registry.
addConverterFactory(ConverterFactory<?, ?>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
addDefaultConverters(ConverterRegistry) - 类 中的静态方法org.springframework.core.convert.support.DefaultConversionService
  Add converters appropriate for most environments.
addDiscoverer(ParameterNameDiscoverer) - 类 中的方法org.springframework.core.PrioritizedParameterNameDiscoverer
  Add a further `ParameterNameDiscoverer` delegate to the list of discoverers that this `PrioritizedParameterNameDiscoverer` checks.
addFailureCallback(FailureCallback) - 类 中的方法org.springframework.util.concurrent.ListenableFutureCallbackRegistry
  Add the given failure callback to this registry.
addFirst(PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Add the given property source object with highest precedence.
addFirstPropertySource(PropertySource<?>) - 类 中的方法org.springframework.core.env.CompositePropertySource
  Add the given `PropertySource` to the start of the chain.
addLast(PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Add the given property source object with lowest precedence.
addObjectToArray(A[], O) - 类 中的静态方法org.springframework.util.ObjectUtils
  Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
addPropertySource(PropertySource<?>) - 类 中的方法org.springframework.core.env.CompositePropertySource
  Add the given `PropertySource` to the end of the chain.
addProtocolResolver(ProtocolResolver) - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Register the given resolver with this resource loader, allowing for additional protocols to be handled.
addResourcePathToPackagePath(Class<?>, String) - 类 中的静态方法org.springframework.util.ClassUtils
  Return a path suitable for use with `ClassLoader.getResource` (also suitable for use with `Class.getResource` by prepending a slash ('/') to the return value).
addStringToArray(String[], String) - 类 中的静态方法org.springframework.util.StringUtils
  Append the given `String` to the given `String` array, returning a new array consisting of the input array contents plus the given `String`.
addSuccessCallback(SuccessCallback<? super T>) - 类 中的方法org.springframework.util.concurrent.ListenableFutureCallbackRegistry
  Add the given success callback to this registry.
afterAccess() - 类 中的方法org.springframework.util.ConcurrencyThrottleSupport
  To be invoked after the main execution logic of concrete subclasses.
AliasFor - org.springframework.core.annotation中的注释类型
  `@AliasFor` is an annotation that is used to declare aliases for annotation attributes.
AliasRegistry - org.springframework.core中的接口
  Common interface for managing aliases.
ALL - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type that includes all media ranges (i.e. "*/*").
ALL_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.ALL`.
allMimeTypes() - 类 中的静态方法org.springframework.core.codec.CharSequenceEncoder
  Create a `CharSequenceEncoder` that supports all MIME types.
allMimeTypes(boolean) - 类 中的静态方法org.springframework.core.codec.StringDecoder
  已过时。
  as of Spring 5.0.4, in favor of `StringDecoder.allMimeTypes()` or `StringDecoder.allMimeTypes(List, boolean)`
allMimeTypes() - 类 中的静态方法org.springframework.core.codec.StringDecoder
  Create a `StringDecoder` that supports all MIME types.
allMimeTypes(List<String>, boolean) - 类 中的静态方法org.springframework.core.codec.StringDecoder
  Create a `StringDecoder` that supports all MIME types.
allocateBuffer() - 接口 中的方法org.springframework.core.io.buffer.DataBufferFactory
  Allocate a data buffer of a default initial capacity.
allocateBuffer(int) - 接口 中的方法org.springframework.core.io.buffer.DataBufferFactory
  Allocate a data buffer of the given initial capacity.
allocateBuffer() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
allocateBuffer(int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
allocateBuffer() - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
allocateBuffer(int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
allowAliasOverriding() - 类 中的方法org.springframework.core.SimpleAliasRegistry
  Return whether alias overriding is allowed.
ALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
AlternativeJdkIdGenerator - org.springframework.util中的类
  An `IdGenerator` that uses `SecureRandom` for the initial seed and `Random` thereafter, instead of calling `UUID.randomUUID()` every time as `JdkIdGenerator` does.
AlternativeJdkIdGenerator() - 类 的构造器org.springframework.util.AlternativeJdkIdGenerator
ANEWARRAY - 接口 中的静态变量org.springframework.asm.Opcodes
AnnotatedElementUtils - org.springframework.core.annotation中的类
  General utility methods for finding annotations, meta-annotations, and repeatable annotations on `AnnotatedElements`.
AnnotatedElementUtils() - 类 的构造器org.springframework.core.annotation.AnnotatedElementUtils
AnnotatedTypeMetadata - org.springframework.core.type中的接口
  Defines access to the annotations of a specific type (`class` or `method`), in a form that does not necessarily require the class-loading.
AnnotationAttributes - org.springframework.core.annotation中的类
  `LinkedHashMap` subclass representing annotation attribute key-value pairs as read by `AnnotationUtils`, `AnnotatedElementUtils`, and Spring's reflection- and ASM-based `AnnotationMetadata` implementations.
AnnotationAttributes() - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new, empty `AnnotationAttributes` instance.
AnnotationAttributes(int) - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new, empty `AnnotationAttributes` instance with the given initial capacity to optimize performance.
AnnotationAttributes(Map<String, Object>) - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new `AnnotationAttributes` instance, wrapping the provided map and all its key-value pairs.
AnnotationAttributes(AnnotationAttributes) - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new `AnnotationAttributes` instance, wrapping the provided map and all its key-value pairs.
AnnotationAttributes(Class<? extends Annotation>) - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new, empty `AnnotationAttributes` instance for the specified `annotationType`.
AnnotationAttributes(String, ClassLoader) - 类 的构造器org.springframework.core.annotation.AnnotationAttributes
  Create a new, empty `AnnotationAttributes` instance for the specified `annotationType`.
AnnotationAwareOrderComparator - org.springframework.core.annotation中的类
  `AnnotationAwareOrderComparator` is an extension of `OrderComparator` that supports Spring's `Ordered` interface as well as the `@Order` and `@Priority` annotations, with an order value provided by an `Ordered` instance overriding a statically defined annotation value (if any).
AnnotationAwareOrderComparator() - 类 的构造器org.springframework.core.annotation.AnnotationAwareOrderComparator
AnnotationConfigurationException - org.springframework.core.annotation中的异常错误
  Thrown by `AnnotationUtils` and synthesized annotations if an annotation is improperly configured.
AnnotationConfigurationException(String) - 异常错误 的构造器org.springframework.core.annotation.AnnotationConfigurationException
  Construct a new `AnnotationConfigurationException` with the supplied message.
AnnotationConfigurationException(String, Throwable) - 异常错误 的构造器org.springframework.core.annotation.AnnotationConfigurationException
  Construct a new `AnnotationConfigurationException` with the supplied message and cause.
AnnotationMetadata - org.springframework.core.type中的接口
  Interface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet.
AnnotationMetadataReadingVisitor - org.springframework.core.type.classreading中的类
  ASM class visitor which looks for the class name and implemented types as well as for the annotations defined on the class, exposing them through the `AnnotationMetadata` interface.
AnnotationMetadataReadingVisitor(ClassLoader) - 类 的构造器org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
annotationSet - 类 中的变量org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
annotationType() - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the type of annotation represented by this `AnnotationAttributes`.
AnnotationTypeFilter - org.springframework.core.type.filter中的类
  A simple filter which matches classes with a given annotation, checking inherited annotations as well.
AnnotationTypeFilter(Class<? extends Annotation>) - 类 的构造器org.springframework.core.type.filter.AnnotationTypeFilter
  Create a new AnnotationTypeFilter for the given annotation type.
AnnotationTypeFilter(Class<? extends Annotation>, boolean) - 类 的构造器org.springframework.core.type.filter.AnnotationTypeFilter
  Create a new AnnotationTypeFilter for the given annotation type.
AnnotationTypeFilter(Class<? extends Annotation>, boolean, boolean) - 类 的构造器org.springframework.core.type.filter.AnnotationTypeFilter
  Create a new `AnnotationTypeFilter` for the given annotation type.
AnnotationUtils - org.springframework.core.annotation中的类
  General utility methods for working with annotations, handling meta-annotations, bridge methods (which the compiler generates for generic declarations) as well as super methods (for optional annotation inheritance).
AnnotationUtils() - 类 的构造器org.springframework.core.annotation.AnnotationUtils
AnnotationVisitor - org.springframework.asm中的类
  A visitor to visit a Java annotation.
AnnotationVisitor(int) - 类 的构造器org.springframework.asm.AnnotationVisitor
  Constructs a new `AnnotationVisitor`.
AnnotationVisitor(int, AnnotationVisitor) - 类 的构造器org.springframework.asm.AnnotationVisitor
  Constructs a new `AnnotationVisitor`.
AntPathMatcher - org.springframework.util中的类
  `PathMatcher` implementation for Ant-style path patterns.
AntPathMatcher() - 类 的构造器org.springframework.util.AntPathMatcher
  Create a new instance with the `AntPathMatcher.DEFAULT_PATH_SEPARATOR`.
AntPathMatcher(String) - 类 的构造器org.springframework.util.AntPathMatcher
  A convenient, alternative constructor to use with a custom path separator.
AntPathMatcher.AntPathStringMatcher - org.springframework.util中的类
  Tests whether or not a string matches against a pattern via a `Pattern`.
AntPathMatcher.AntPatternComparator - org.springframework.util中的类
  The default `Comparator` implementation returned by `AntPathMatcher.getPatternComparator(String)`.
AntPathStringMatcher(String) - 类 的构造器org.springframework.util.AntPathMatcher.AntPathStringMatcher
AntPathStringMatcher(String, boolean) - 类 的构造器org.springframework.util.AntPathMatcher.AntPathStringMatcher
AntPatternComparator(String) - 类 的构造器org.springframework.util.AntPathMatcher.AntPatternComparator
api - 类 中的变量org.springframework.asm.AnnotationVisitor
  The ASM API version implemented by this visitor.
api - 类 中的变量org.springframework.asm.ClassVisitor
  The ASM API version implemented by this visitor.
api - 类 中的变量org.springframework.asm.FieldVisitor
  The ASM API version implemented by this visitor.
api - 类 中的变量org.springframework.asm.MethodVisitor
  The ASM API version implemented by this visitor.
api - 类 中的变量org.springframework.asm.ModuleVisitor
  The ASM API version implemented by this visitor.
append(String, byte) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a byte field value.
append(String, short) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a short field value.
append(String, int) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a integer field value.
append(String, long) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a long field value.
append(String, float) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a float field value.
append(String, double) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a double field value.
append(String, boolean) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a boolean field value.
append(String, Object) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append a field value.
append(Object) - 类 中的方法org.springframework.core.style.ToStringCreator
  Append the provided value.
appendMd5DigestAsHex(byte[], StringBuilder) - 类 中的静态方法org.springframework.util.DigestUtils
  Append a hexadecimal string representation of the MD5 digest of the given bytes to the given `StringBuilder`.
appendMd5DigestAsHex(InputStream, StringBuilder) - 类 中的静态方法org.springframework.util.DigestUtils
  Append a hexadecimal string representation of the MD5 digest of the given inputStream to the given `StringBuilder`.
appendTo(StringBuilder) - 类 中的方法org.springframework.util.MimeType
APPLICATION_JSON - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `application/json`.
APPLICATION_JSON_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.APPLICATION_JSON`.
APPLICATION_OCTET_STREAM - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `application/octet-stream`.
APPLICATION_OCTET_STREAM_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.APPLICATION_OCTET_STREAM`.
APPLICATION_XML - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `application/xml`.
APPLICATION_XML_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.APPLICATION_XML`.
applyRelativePath(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Apply the given relative path to the given Java resource path, assuming standard Java folder separation (i.e. "/" separators).
ARETURN - 接口 中的静态变量org.springframework.asm.Opcodes
ARRAY - 类 中的静态变量org.springframework.asm.Type
  The sort of array reference types.
array(TypeDescriptor) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor as an array of the specified type.
ARRAY_ELEMENT - 类 中的静态变量org.springframework.asm.TypePath
  A type path step that steps into the element type of an array type.
ARRAY_SUFFIX - 类 中的静态变量org.springframework.util.ClassUtils
  Suffix for array class names: "[]"
ARRAYLENGTH - 接口 中的静态变量org.springframework.asm.Opcodes
arrayToCommaDelimitedString(Object[]) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a `String` array into a comma delimited `String` (i.e., CSV).
arrayToDelimitedString(Object[], String) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a `String` array into a delimited `String` (e.g.
arrayToList(Object) - 类 中的静态方法org.springframework.util.CollectionUtils
  Convert the supplied array into a List.
as(Class<?>) - 类 中的方法org.springframework.core.ResolvableType
  Return this type as a `ResolvableType` of the specified class.
asByteBuffer() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Expose this buffer's bytes as a `ByteBuffer`.
asByteBuffer(int, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Expose a subsequence of this buffer's bytes as a `ByteBuffer`.
asByteBuffer() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
asByteBuffer(int, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
asByteBuffer() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
asByteBuffer(int, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
asCollection() - 类 中的方法org.springframework.core.ResolvableType
  Convenience method to return this type as a resolvable `Collection` type.
asInputStream() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Expose this buffer's data as an `InputStream`.
asInputStream(boolean) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Expose this buffer's data as an `InputStream`.
asInputStream() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
asInputStream(boolean) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
asInputStream() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
asInputStream(boolean) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
ASM4 - 接口 中的静态变量org.springframework.asm.Opcodes
ASM5 - 接口 中的静态变量org.springframework.asm.Opcodes
ASM6 - 接口 中的静态变量org.springframework.asm.Opcodes
ASM_VERSION - 类 中的静态变量org.springframework.asm.SpringAsmInfo
  The ASM compatibility version for Spring's ASM visitor implementations: currently `Opcodes.ASM6`.
asMap() - 类 中的方法org.springframework.core.ResolvableType
  Convenience method to return this type as a resolvable `Map` type.
asNumber(String) - 类 中的方法org.springframework.core.Constants
  Return a constant value cast to a Number.
asObject(String) - 类 中的方法org.springframework.core.Constants
  Parse the given String (upper or lower case accepted) and return the appropriate value if it's the name of a constant field in the class that we're analysing.
asOutputStream() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Expose this buffer's data as an `OutputStream`.
asOutputStream() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
asOutputStream() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
AspectJTypeFilter - org.springframework.core.type.filter中的类
  Type filter that uses AspectJ type pattern for matching.
AspectJTypeFilter(String, ClassLoader) - 类 的构造器org.springframework.core.type.filter.AspectJTypeFilter
Assert - org.springframework.util中的类
  Assertion utility class that assists in validating arguments.
Assert() - 类 的构造器org.springframework.util.Assert
assertLegalRelativeAddition(String, PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Ensure that the given property source is not being added relative to itself.
AssignableTypeFilter - org.springframework.core.type.filter中的类
  A simple filter which matches classes that are assignable to a given type.
AssignableTypeFilter(Class<?>) - 类 的构造器org.springframework.core.type.filter.AssignableTypeFilter
  Create a new AssignableTypeFilter for the given type.
asString(String) - 类 中的方法org.springframework.core.Constants
  Return a constant value as a String.
ASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
AsyncListenableTaskExecutor - org.springframework.core.task中的接口
  Extension of the `AsyncTaskExecutor` interface, adding the capability to submit tasks for `ListenableFuture`s.
AsyncTaskExecutor - org.springframework.core.task中的接口
  Extended interface for asynchronous `TaskExecutor` implementations, offering an overloaded `AsyncTaskExecutor.execute(Runnable, long)` variant with a start timeout parameter as well support for `Callable`.
ATHROW - 接口 中的静态变量org.springframework.asm.Opcodes
Attribute - org.springframework.asm中的类
  A non standard class, field, method or code attribute.
Attribute(String) - 类 的构造器org.springframework.asm.Attribute
  Constructs a new empty attribute.
AttributeAccessor - org.springframework.core中的接口
  Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
AttributeAccessorSupport - org.springframework.core中的类
  Support class for `AttributeAccessors`, providing a base implementation of all methods.
AttributeAccessorSupport() - 类 的构造器org.springframework.core.AttributeAccessorSupport
attributeNames() - 接口 中的方法org.springframework.core.AttributeAccessor
  Return the names of all attributes.
attributeNames() - 类 中的方法org.springframework.core.AttributeAccessorSupport
attributeNameToPropertyName(String) - 类 中的静态方法org.springframework.core.Conventions
  Convert `String`s in attribute name format (e.g. lowercase, hyphens separating words) into property name format (camel-case).
attributesMap - 类 中的变量org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
  Declared as a `LinkedMultiValueMap` instead of a `MultiValueMap` to ensure that the hierarchical ordering of the entries is preserved.
attributesMap - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
AutoPopulatingList<E> - org.springframework.util中的类
  Simple `List` wrapper class that allows for elements to be automatically populated as they are requested.
AutoPopulatingList(Class<? extends E>) - 类 的构造器org.springframework.util.AutoPopulatingList
  Creates a new `AutoPopulatingList` that is backed by a standard `ArrayList` and adds new instances of the supplied `element Class` to the backing `List` on demand.
AutoPopulatingList(List<E>, Class<? extends E>) - 类 的构造器org.springframework.util.AutoPopulatingList
  Creates a new `AutoPopulatingList` that is backed by the supplied `List` and adds new instances of the supplied `element Class` to the backing `List` on demand.
AutoPopulatingList(AutoPopulatingList.ElementFactory<E>) - 类 的构造器org.springframework.util.AutoPopulatingList
  Creates a new `AutoPopulatingList` that is backed by a standard `ArrayList` and creates new elements on demand using the supplied `AutoPopulatingList.ElementFactory`.
AutoPopulatingList(List<E>, AutoPopulatingList.ElementFactory<E>) - 类 的构造器org.springframework.util.AutoPopulatingList
  Creates a new `AutoPopulatingList` that is backed by the supplied `List` and creates new elements on demand using the supplied `AutoPopulatingList.ElementFactory`.
AutoPopulatingList.ElementFactory<E> - org.springframework.util中的接口
  Factory interface for creating elements for an index-based access data structure such as a `List`.
AutoPopulatingList.ElementInstantiationException - org.springframework.util中的异常错误
  Exception to be thrown from ElementFactory.
av - 类 中的变量org.springframework.asm.AnnotationVisitor
  The annotation visitor to which this visitor must delegate method calls.
awaitTermination(long, TimeUnit) - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter

## B

b - 类 中的变量org.springframework.asm.ClassReader
  The class to be parsed.
BackOff - org.springframework.util.backoff中的接口
  Provide a `BackOffExecution` that indicates the rate at which an operation should be retried.
BackOffExecution - org.springframework.util.backoff中的接口
  Represent a particular back-off execution.
BALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
Base64Utils - org.springframework.util中的类
  A simple utility class for Base64 encoding and decoding.
Base64Utils() - 类 的构造器org.springframework.util.Base64Utils
BASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
beforeAccess() - 类 中的方法org.springframework.util.ConcurrencyThrottleSupport
  To be invoked before the main execution logic of concrete subclasses.
bindDefaultNamespaceUri(String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Bind the given namespace as default namespace.
bindNamespaceUri(String, String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Bind the given prefix to the given namespace.
BIPUSH - 接口 中的静态变量org.springframework.asm.Opcodes
BOOLEAN - 类 中的静态变量org.springframework.asm.Type
  The sort of the `boolean` type.
BOOLEAN_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `boolean` type.
BooleanComparator - org.springframework.util.comparator中的类
  A `Comparator` for `Boolean` objects that can sort either `true` or `false` first.
BooleanComparator(boolean) - 类 的构造器org.springframework.util.comparator.BooleanComparator
  Create a BooleanComparator that sorts boolean values based on the provided flag.
BOUNDARY_STRING_HINT - 类 中的静态变量org.springframework.core.codec.ResourceRegionEncoder
BridgeMethodResolver - org.springframework.core中的类
  Helper for resolving synthetic `bridge Methods` to the `Method` being bridged.
BridgeMethodResolver() - 类 的构造器org.springframework.core.BridgeMethodResolver
BUFFER_SIZE - 类 中的静态变量org.springframework.util.FileCopyUtils
BUFFER_SIZE - 类 中的静态变量org.springframework.util.StreamUtils
buildMessage(String, Throwable) - 类 中的静态方法org.springframework.core.NestedExceptionUtils
  Build a message for the given base message and root cause.
BYTE - 类 中的静态变量org.springframework.asm.Type
  The sort of the `byte` type.
BYTE_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `byte` type.
ByteArrayDecoder - org.springframework.core.codec中的类
  Decoder for `byte` arrays.
ByteArrayDecoder() - 类 的构造器org.springframework.core.codec.ByteArrayDecoder
ByteArrayEncoder - org.springframework.core.codec中的类
  Encoder for `byte` arrays.
ByteArrayEncoder() - 类 的构造器org.springframework.core.codec.ByteArrayEncoder
ByteArrayResource - org.springframework.core.io中的类
  `Resource` implementation for a given byte array.
ByteArrayResource(byte[]) - 类 的构造器org.springframework.core.io.ByteArrayResource
  Create a new `ByteArrayResource`.
ByteArrayResource(byte[], String) - 类 的构造器org.springframework.core.io.ByteArrayResource
  Create a new `ByteArrayResource` with a description.
ByteBufferDecoder - org.springframework.core.codec中的类
  Decoder for `ByteBuffer`s.
ByteBufferDecoder() - 类 的构造器org.springframework.core.codec.ByteBufferDecoder
ByteBufferEncoder - org.springframework.core.codec中的类
  Encoder for `ByteBuffer`s.
ByteBufferEncoder() - 类 的构造器org.springframework.core.codec.ByteBufferEncoder
ByteVector - org.springframework.asm中的类
  A dynamically extensible vector of bytes.
ByteVector() - 类 的构造器org.springframework.asm.ByteVector
  Constructs a new `ByteVector` with a default initial size.
ByteVector(int) - 类 的构造器org.springframework.asm.ByteVector
  Constructs a new `ByteVector` with the given initial size.

## C

CachingMetadataReaderFactory - org.springframework.core.type.classreading中的类
  Caching implementation of the `MetadataReaderFactory` interface, caching a `MetadataReader` instance per Spring `Resource` handle (i.e. per ".class" file).
CachingMetadataReaderFactory() - 类 的构造器org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Create a new CachingMetadataReaderFactory for the default class loader, using a local resource cache.
CachingMetadataReaderFactory(ClassLoader) - 类 的构造器org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Create a new CachingMetadataReaderFactory for the given `ClassLoader`, using a local resource cache.
CachingMetadataReaderFactory(ResourceLoader) - 类 的构造器org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Create a new CachingMetadataReaderFactory for the given `ResourceLoader`, using a shared resource cache if supported or a local resource cache otherwise.
calculateShift(int, int) - 类 中的静态方法org.springframework.util.ConcurrentReferenceHashMap
  Calculate a shift value that can be used to create a power-of-two value between the specified maximum and minimum values.
CALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
canBypassConvert(TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
  Return whether conversion between the source type and the target type can be bypassed.
cancel(boolean) - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
cancel(boolean) - 类 中的方法org.springframework.util.concurrent.FutureAdapter
cancel(boolean) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
canConvert(Class<?>, Class<?>) - 接口 中的方法org.springframework.core.convert.ConversionService
  Return `true` if objects of `sourceType` can be converted to the `targetType`.
canConvert(TypeDescriptor, TypeDescriptor) - 接口 中的方法org.springframework.core.convert.ConversionService
  Return `true` if objects of `sourceType` can be converted to the `targetType`.
canConvert(Class<?>, Class<?>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
canConvert(TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.AbstractDecoder
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ByteArrayDecoder
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ByteBufferDecoder
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.DataBufferDecoder
canDecode(ResolvableType, MimeType) - 接口 中的方法org.springframework.core.codec.Decoder
  Whether the decoder supports the given target element type and the MIME type of the source stream.
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ResourceDecoder
canDecode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.StringDecoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.AbstractEncoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ByteArrayEncoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ByteBufferEncoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.CharSequenceEncoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.DataBufferEncoder
canEncode(ResolvableType, MimeType) - 接口 中的方法org.springframework.core.codec.Encoder
  Whether the encoder supports the given source element type and the MIME type for the output stream.
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ResourceEncoder
canEncode(ResolvableType, MimeType) - 类 中的方法org.springframework.core.codec.ResourceRegionEncoder
canonicalName(String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
  解析bean 的别名
capacity() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the number of bytes that this buffer can contain.
capacity(int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Set the number of bytes that this buffer can contain.
capacity() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
capacity(int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
capacity() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
capacity(int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
capacity() - 类 中的方法org.springframework.util.ResizableByteArrayOutputStream
  Return the current size of this stream's internal buffer.
capitalize(String) - 类 中的静态方法org.springframework.util.StringUtils
  Capitalize a `String`, changing the first letter to upper case as per `Character.toUpperCase(char)`.
caseInsensitiveValueOf(E[], String) - 类 中的静态方法org.springframework.util.ObjectUtils
  Case insensitive alternative to `Enum.valueOf(Class, String)`.
CAST - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type declared in an explicit or implicit cast instruction.
CASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
CGLIB_CLASS_SEPARATOR - 类 中的静态变量org.springframework.util.ClassUtils
  The CGLIB class separator: "$$"
CHAR - 类 中的静态变量org.springframework.asm.Type
  The sort of the `char` type.
CHAR_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `char` type.
CharSequenceEncoder - org.springframework.core.codec中的类
  Encode from a `CharSequence` stream to a bytes stream.
CHECKCAST - 接口 中的静态变量org.springframework.asm.Opcodes
checkForAliasCircle(String, String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
  Check whether the given name points back to the given alias as an alias in the other direction already, catching a circular reference upfront and throwing a corresponding IllegalStateException.
checkParameters(String, String) - 类 中的方法org.springframework.util.MimeType
CLASS_EXTENDS - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the super class of a class or one of the interfaces it implements.
CLASS_FILE_SUFFIX - 类 中的静态变量org.springframework.util.ClassUtils
  The ".class" file suffix
CLASS_TYPE_PARAMETER - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic class.
CLASS_TYPE_PARAMETER_BOUND - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a bound of a type parameter of a generic class.
classLoader - 类 中的变量org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
classLoader - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
ClassMetadata - org.springframework.core.type中的接口
  Interface that defines abstract metadata of a specific class, in a form that does not require that class to be loaded yet.
classNamesToString(Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Build a String that consists of the names of the classes/interfaces in the given array.
classNamesToString(Collection<Class<?>>) - 类 中的静态方法org.springframework.util.ClassUtils
  Build a String that consists of the names of the classes/interfaces in the given collection.
classPackageAsResourcePath(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Given an input class object, return a string which consists of the class's package name as a pathname, i.e., all dots ('.') are replaced by slashes ('/').
CLASSPATH_ALL_URL_PREFIX - 接口 中的静态变量org.springframework.core.io.support.ResourcePatternResolver
  Pseudo URL prefix for all matching resources from the class path: "classpath*:" This differs from ResourceLoader's classpath URL prefix in that it retrieves all matching resources for a given name (e.g.
CLASSPATH_URL_PREFIX - 接口 中的静态变量org.springframework.core.io.ResourceLoader
  Pseudo URL prefix for loading from the class path: "classpath:"
CLASSPATH_URL_PREFIX - 类 中的静态变量org.springframework.util.ResourceUtils
  Pseudo URL prefix for loading from the class path: "classpath:"
ClassPathContextResource(String, ClassLoader) - 类 的构造器org.springframework.core.io.DefaultResourceLoader.ClassPathContextResource
ClassPathResource - org.springframework.core.io中的类
  `Resource` implementation for class path resources.
ClassPathResource(String) - 类 的构造器org.springframework.core.io.ClassPathResource
  Create a new `ClassPathResource` for `ClassLoader` usage.
ClassPathResource(String, ClassLoader) - 类 的构造器org.springframework.core.io.ClassPathResource
  Create a new `ClassPathResource` for `ClassLoader` usage.
ClassPathResource(String, Class<?>) - 类 的构造器org.springframework.core.io.ClassPathResource
  Create a new `ClassPathResource` for `Class` usage.
ClassPathResource(String, ClassLoader, Class<?>) - 类 的构造器org.springframework.core.io.ClassPathResource
  已过时。
  as of 4.3.13, in favor of selective use of `ClassPathResource.ClassPathResource(String, ClassLoader)` vs `ClassPathResource.ClassPathResource(String, Class)`
ClassReader - org.springframework.asm中的类
  A Java class parser to make a `ClassVisitor` visit an existing class.
ClassReader(byte[]) - 类 的构造器org.springframework.asm.ClassReader
  Constructs a new `ClassReader` object.
ClassReader(byte[], int, int) - 类 的构造器org.springframework.asm.ClassReader
  Constructs a new `ClassReader` object.
ClassReader(InputStream) - 类 的构造器org.springframework.asm.ClassReader
  Constructs a new `ClassReader` object.
ClassReader(String) - 类 的构造器org.springframework.asm.ClassReader
  Constructs a new `ClassReader` object.
ClassRelativeResourceLoader - org.springframework.core.io中的类
  `ResourceLoader` implementation that interprets plain resource paths as relative to a given `java.lang.Class`.
ClassRelativeResourceLoader(Class<?>) - 类 的构造器org.springframework.core.io.ClassRelativeResourceLoader
  Create a new ClassRelativeResourceLoader for the given class.
ClassUtils - org.springframework.util中的类
  Miscellaneous `java.lang.Class` utility methods.
ClassUtils() - 类 的构造器org.springframework.util.ClassUtils
ClassVisitor - org.springframework.asm中的类
  A visitor to visit a Java class.
ClassVisitor(int) - 类 的构造器org.springframework.asm.ClassVisitor
  Constructs a new `ClassVisitor`.
ClassVisitor(int, ClassVisitor) - 类 的构造器org.springframework.asm.ClassVisitor
  Constructs a new `ClassVisitor`.
ClassWriter - org.springframework.asm中的类
  A `ClassVisitor` that generates classes in bytecode form.
ClassWriter(int) - 类 的构造器org.springframework.asm.ClassWriter
  Constructs a new `ClassWriter` object.
ClassWriter(ClassReader, int) - 类 的构造器org.springframework.asm.ClassWriter
  Constructs a new `ClassWriter` object and enables optimizations for "mostly add" bytecode transformations.
cleanPath(String) - 类 中的静态方法org.springframework.util.StringUtils
  Normalize the path by suppressing sequences like "path/.." and inner simple dots.
clear() - 类 中的方法org.springframework.util.AutoPopulatingList
clear() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
clear() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
  Clear all items from this segment.
clear() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
clear() - 类 中的方法org.springframework.util.LinkedMultiValueMap
clear() - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Remove all declared prefixes.
clearCache() - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Clear the internal annotation metadata cache.
clearCache() - 类 中的静态方法org.springframework.core.ResolvableType
  Clear the internal `ResolvableType`/`SerializableTypeWrapper` cache.
clearCache() - 类 中的方法org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Clear the local MetadataReader cache, if any, removing all cached class metadata.
clearCache() - 类 中的静态方法org.springframework.util.ReflectionUtils
  Clear the internal method/field cache.
clearResourceCaches() - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Clear all resource caches in this resource loader.
clone() - 类 中的方法org.springframework.core.annotation.SynthesizingMethodParameter
clone() - 类 中的方法org.springframework.core.MethodParameter
clone() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
clone() - 类 中的方法org.springframework.util.LinkedMultiValueMap
  Create a regular copy of this Map.
close() - 类 中的方法org.springframework.util.CommonsLogWriter
close() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
CodecException - org.springframework.core.codec中的异常错误
  General error that indicates a problem while encoding and decoding to and from an Object stream.
CodecException(String) - 异常错误 的构造器org.springframework.core.codec.CodecException
  Create a new CodecException.
CodecException(String, Throwable) - 异常错误 的构造器org.springframework.core.codec.CodecException
  Create a new CodecException.
collection(Class<?>, TypeDescriptor) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `Collection` type.
CollectionFactory - org.springframework.core中的类
  Factory for collections that is aware of common Java and Spring collection types.
CollectionFactory() - 类 的构造器org.springframework.core.CollectionFactory
collectionToCommaDelimitedString(Collection<?>) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a `Collection` into a delimited `String` (e.g., CSV).
collectionToDelimitedString(Collection<?>, String, String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a `Collection` to a delimited `String` (e.g.
collectionToDelimitedString(Collection<?>, String) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a `Collection` into a delimited `String` (e.g.
CollectionUtils - org.springframework.util中的类
  Miscellaneous collection utility methods.
CollectionUtils() - 类 的构造器org.springframework.util.CollectionUtils
combine(String, String) - 类 中的方法org.springframework.util.AntPathMatcher
  Combine two patterns into a new pattern.
combine(String, String) - 接口 中的方法org.springframework.util.PathMatcher
  Combines two patterns into a new pattern that is returned.
commaDelimitedListToSet(String) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a comma delimited list (e.g., a row from a CSV file) into a set.
commaDelimitedListToStringArray(String) - 类 中的静态方法org.springframework.util.StringUtils
  Convert a comma delimited list (e.g., a row from a CSV file) into an array of strings.
COMMAND_LINE_PROPERTY_SOURCE_NAME - 类 中的静态变量org.springframework.core.env.CommandLinePropertySource
  The default name given to `CommandLinePropertySource` instances: "commandLineArgs"
CommandLinePropertySource<T> - org.springframework.core.env中的类
  Abstract base class for `PropertySource` implementations backed by command line arguments.
CommandLinePropertySource(T) - 类 的构造器org.springframework.core.env.CommandLinePropertySource
  Create a new `CommandLinePropertySource` having the default name "commandLineArgs" and backed by the given source object.
CommandLinePropertySource(String, T) - 类 的构造器org.springframework.core.env.CommandLinePropertySource
  Create a new `CommandLinePropertySource` having the given name and backed by the given source object.
CommonsLogWriter - org.springframework.util中的类
  `java.io.Writer` adapter for a Commons Logging `Log`.
CommonsLogWriter(Log) - 类 的构造器org.springframework.util.CommonsLogWriter
  Create a new CommonsLogWriter for the given Commons Logging logger.
comparable() - 类 中的静态方法org.springframework.util.comparator.Comparators
  Return a `Comparable` adapter.
ComparableComparator<T extends Comparable<T>> - org.springframework.util.comparator中的类
  Comparator that adapts Comparables to the Comparator interface.
ComparableComparator() - 类 的构造器org.springframework.util.comparator.ComparableComparator
Comparators - org.springframework.util.comparator中的类
  Convenient entry point with generically typed factory methods for common Spring `Comparator` variants.
Comparators() - 类 的构造器org.springframework.util.comparator.Comparators
compare(S, S) - 类 中的方法org.springframework.core.convert.converter.ConvertingComparator
compare(Class<? extends Throwable>, Class<? extends Throwable>) - 类 中的方法org.springframework.core.ExceptionDepthComparator
compare(Object, Object) - 类 中的方法org.springframework.core.OrderComparator
compare(String, String) - 类 中的方法org.springframework.util.AntPathMatcher.AntPatternComparator
  Compare two patterns to determine which should match first, i.e. which is the most specific regarding the current path.
compare(Boolean, Boolean) - 类 中的方法org.springframework.util.comparator.BooleanComparator
compare(T, T) - 类 中的方法org.springframework.util.comparator.ComparableComparator
compare(T, T) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
compare(T, T) - 类 中的方法org.springframework.util.comparator.InstanceComparator
compare(T, T) - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
compare(T, T) - 类 中的方法org.springframework.util.comparator.NullSafeComparator
compare(T, T) - 类 中的方法org.springframework.util.MimeType.SpecificityComparator
compareParameters(T, T) - 类 中的方法org.springframework.util.MimeType.SpecificityComparator
compareTo(MethodClassKey) - 类 中的方法org.springframework.core.MethodClassKey
compareTo(MimeType) - 类 中的方法org.springframework.util.MimeType
  Compares this MIME Type to another alphabetically.
completable() - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
completable() - 接口 中的方法org.springframework.util.concurrent.ListenableFuture
  Expose this `ListenableFuture` as a JDK `CompletableFuture`.
completable() - 类 中的方法org.springframework.util.concurrent.ListenableFutureTask
completable() - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
CompletableToListenableFutureAdapter<T> - org.springframework.util.concurrent中的类
  Adapts a `CompletableFuture` or `CompletionStage` into a Spring `ListenableFuture`.
CompletableToListenableFutureAdapter(CompletionStage<T>) - 类 的构造器org.springframework.util.concurrent.CompletableToListenableFutureAdapter
  Create a new adapter for the given `CompletionStage`.
CompletableToListenableFutureAdapter(CompletableFuture<T>) - 类 的构造器org.springframework.util.concurrent.CompletableToListenableFutureAdapter
  Create a new adapter for the given `CompletableFuture`.
CompositeIterator<E> - org.springframework.util中的类
  Composite iterator that combines multiple other iterators, as registered via `CompositeIterator.add(Iterator)`.
CompositeIterator() - 类 的构造器org.springframework.util.CompositeIterator
CompositePropertySource - org.springframework.core.env中的类
  Composite `PropertySource` implementation that iterates over a set of `PropertySource` instances.
CompositePropertySource(String) - 类 的构造器org.springframework.core.env.CompositePropertySource
  Create a new `CompositePropertySource`.
CompoundComparator<T> - org.springframework.util.comparator中的类
  已过时。
  as of Spring Framework 5.0, in favor of the standard JDK 8 `Comparator.thenComparing(Comparator)`
CompoundComparator() - 类 的构造器org.springframework.util.comparator.CompoundComparator
  已过时。
  Construct a CompoundComparator with initially no Comparators.
CompoundComparator(Comparator...) - 类 的构造器org.springframework.util.comparator.CompoundComparator
  已过时。
  Construct a CompoundComparator from the Comparators in the provided array.
COMPUTE_FRAMES - 类 中的静态变量org.springframework.asm.ClassWriter
  Flag to automatically compute the stack map frames of methods from scratch.
COMPUTE_MAXS - 类 中的静态变量org.springframework.asm.ClassWriter
  Flag to automatically compute the maximum stack size and the maximum number of local variables of methods.
concatenateStringArrays(String[], String[]) - 类 中的静态方法org.springframework.util.StringUtils
  Concatenate the given `String` arrays into one, with overlapping array elements included twice.
ConcurrencyThrottleSupport - org.springframework.util中的类
  Support class for throttling concurrent access to a specific resource.
ConcurrencyThrottleSupport() - 类 的构造器org.springframework.util.ConcurrencyThrottleSupport
ConcurrentExecutorAdapter - org.springframework.core.task.support中的类
  Adapter that exposes the `Executor` interface for any Spring `TaskExecutor`.
ConcurrentExecutorAdapter(TaskExecutor) - 类 的构造器org.springframework.core.task.support.ConcurrentExecutorAdapter
  Create a new ConcurrentExecutorAdapter for the given Spring TaskExecutor.
ConcurrentReferenceHashMap<K,V> - org.springframework.util中的类
  A `ConcurrentHashMap` that uses `soft` or weak references for both `keys` and `values`.
ConcurrentReferenceHashMap() - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int, float) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int, int) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int, ConcurrentReferenceHashMap.ReferenceType) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int, float, int) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap(int, float, int, ConcurrentReferenceHashMap.ReferenceType) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap
  Create a new `ConcurrentReferenceHashMap` instance.
ConcurrentReferenceHashMap.Entry<K,V> - org.springframework.util中的类
  A single map entry.
ConcurrentReferenceHashMap.Reference<K,V> - org.springframework.util中的接口
  A reference to an `ConcurrentReferenceHashMap.Entry` contained in the map.
ConcurrentReferenceHashMap.ReferenceManager - org.springframework.util中的类
  Strategy class used to manage `ConcurrentReferenceHashMap.Reference`s.
ConcurrentReferenceHashMap.ReferenceType - org.springframework.util中的枚举
  Various reference types supported by this map.
ConcurrentReferenceHashMap.Restructure - org.springframework.util中的枚举
  The types of restructuring that can be performed.
ConcurrentReferenceHashMap.Segment - org.springframework.util中的类
  A single segment used to divide the map to allow better concurrent performance.
ConditionalConverter - org.springframework.core.convert.converter中的接口
  Allows a `Converter`, `GenericConverter` or `ConverterFactory` to conditionally execute based on attributes of the `source` and `target` `TypeDescriptor`.
ConditionalGenericConverter - org.springframework.core.convert.converter中的接口
  A `GenericConverter` that may conditionally execute based on attributes of the `source` and `target` `TypeDescriptor`.
ConfigurableConversionService - org.springframework.core.convert.support中的接口
  Configuration interface to be implemented by most if not all `ConversionService` types.
ConfigurableEnvironment - org.springframework.core.env中的接口
  Configuration interface to be implemented by most if not all `Environment` types.
ConfigurableObjectInputStream - org.springframework.core中的类
  Special ObjectInputStream subclass that resolves class names against a specific ClassLoader.
ConfigurableObjectInputStream(InputStream, ClassLoader) - 类 的构造器org.springframework.core.ConfigurableObjectInputStream
  Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
ConfigurableObjectInputStream(InputStream, ClassLoader, boolean) - 类 的构造器org.springframework.core.ConfigurableObjectInputStream
  Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
ConfigurablePropertyResolver - org.springframework.core.env中的接口
  Configuration interface to be implemented by most if not all `PropertyResolver` types.
ConstantException(String, String, String) - 异常错误 的构造器org.springframework.core.Constants.ConstantException
  Thrown when an invalid constant name is requested.
ConstantException(String, String, Object) - 异常错误 的构造器org.springframework.core.Constants.ConstantException
  Thrown when an invalid constant value is looked up.
Constants - org.springframework.core中的类
  This class can be used to parse other classes containing constant definitions in public static final members.
Constants(Class<?>) - 类 的构造器org.springframework.core.Constants
  Create a new Constants converter class wrapping the given class.
Constants.ConstantException - org.springframework.core中的异常错误
  Exception thrown when the `Constants` class is asked for an invalid constant name.
CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic constructor in a constructor call.
CONSTRUCTOR_REFERENCE - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the receiver type of a constructor reference.
CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic constructor in a constructor reference.
contains(String) - 类 中的方法org.springframework.core.env.MutablePropertySources
contains(String) - 接口 中的方法org.springframework.core.env.PropertySources
  Return whether a property source with the given name is contained.
contains(Class<?>) - 异常错误 中的方法org.springframework.core.NestedCheckedException
  Check whether this exception contains an exception of the given type: either it is of the given class itself or it contains a nested cause of the given type.
contains(Class<?>) - 异常错误 中的方法org.springframework.core.NestedRuntimeException
  Check whether this exception contains an exception of the given type: either it is of the given class itself or it contains a nested cause of the given type.
contains(Object) - 类 中的方法org.springframework.util.AutoPopulatingList
contains(Iterator<?>, Object) - 类 中的静态方法org.springframework.util.CollectionUtils
  Check whether the given Iterator contains the given element.
contains(Enumeration<?>, Object) - 类 中的静态方法org.springframework.util.CollectionUtils
  Check whether the given Enumeration contains the given element.
containsAll(Collection<?>) - 类 中的方法org.springframework.util.AutoPopulatingList
containsAny(Collection<?>, Collection<?>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Return `true` if any element in '`candidates`' is contained in '`source`'; otherwise returns `false`.
containsConstant(Enum<?>[], String) - 类 中的静态方法org.springframework.util.ObjectUtils
  Check whether the given array of enum constants contains a constant with the given name, ignoring case when determining a match.
containsConstant(Enum<?>[], String, boolean) - 类 中的静态方法org.springframework.util.ObjectUtils
  Check whether the given array of enum constants contains a constant with the given name.
containsElement(Object[], Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Check whether the given array contains the given element.
containsInstance(Collection<?>, Object) - 类 中的静态方法org.springframework.util.CollectionUtils
  Check whether the given Collection contains the given element instance.
containsKey(Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
containsKey(Object) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
containsKey(Object) - 类 中的方法org.springframework.util.LinkedMultiValueMap
containsOption(String) - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  Return whether the set of option arguments parsed from the command line contains an option with the given name.
containsOption(String) - 类 中的方法org.springframework.core.env.JOptCommandLinePropertySource
containsOption(String) - 类 中的方法org.springframework.core.env.SimpleCommandLinePropertySource
containsProperty(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
containsProperty(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
containsProperty(String) - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  This implementation first checks to see if the name specified is the special "non-option arguments" property, and if so delegates to the abstract `CommandLinePropertySource.getNonOptionArgs()` method checking to see whether it returns an empty collection.
containsProperty(String) - 类 中的方法org.springframework.core.env.CompositePropertySource
containsProperty(String) - 类 中的方法org.springframework.core.env.EnumerablePropertySource
  Return whether this `PropertySource` contains a property with the given name.
containsProperty(String) - 类 中的方法org.springframework.core.env.MapPropertySource
containsProperty(String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return whether the given property key is available for resolution, i.e. if the value for the given key is not `null`.
containsProperty(String) - 类 中的方法org.springframework.core.env.PropertySource
  Return whether this `PropertySource` contains the given name.
containsProperty(String) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
containsProperty(String) - 类 中的方法org.springframework.core.env.SystemEnvironmentPropertySource
  Return `true` if a property with the given name or any underscore/uppercase variant thereof exists in this property source.
containsValue(Object) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
containsValue(Object) - 类 中的方法org.springframework.util.LinkedMultiValueMap
containsWhitespace(CharSequence) - 类 中的静态方法org.springframework.util.StringUtils
  Check whether the given `CharSequence` contains any whitespace characters.
containsWhitespace(String) - 类 中的静态方法org.springframework.util.StringUtils
  Check whether the given `String` contains any whitespace characters.
contentLength() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
contentLength() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation reads the entire InputStream to calculate the content length.
contentLength() - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation returns the length of the underlying byte array.
contentLength() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns the underlying File's length.
contentLength() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns the underlying file's length.
contentLength() - 接口 中的方法org.springframework.core.io.Resource
  Determine the content length for this resource.
contentLength() - 类 中的方法org.springframework.core.io.VfsResource
ContextResource - org.springframework.core.io中的接口
  Extended interface for a resource that is loaded from an enclosing 'context', e.g. from a `ServletContext` but also from plain classpath paths or relative file system paths (specified without an explicit prefix, hence applying relative to the local `ResourceLoader`'s context).
Conventions - org.springframework.core中的类
  Provides methods to support various naming and other conventions used throughout the framework.
Conventions() - 类 的构造器org.springframework.core.Conventions
ConversionException - org.springframework.core.convert中的异常错误
  Base class for exceptions thrown by the conversion system.
ConversionException(String) - 异常错误 的构造器org.springframework.core.convert.ConversionException
  Construct a new conversion exception.
ConversionException(String, Throwable) - 异常错误 的构造器org.springframework.core.convert.ConversionException
  Construct a new conversion exception.
ConversionFailedException - org.springframework.core.convert中的异常错误
  Exception to be thrown when an actual type conversion attempt fails.
ConversionFailedException(TypeDescriptor, TypeDescriptor, Object, Throwable) - 异常错误 的构造器org.springframework.core.convert.ConversionFailedException
  Create a new conversion exception.
ConversionService - org.springframework.core.convert中的接口
  A service interface for type conversion.
ConversionServiceFactory - org.springframework.core.convert.support中的类
  A factory for common `ConversionService` configurations.
ConversionServiceFactory() - 类 的构造器org.springframework.core.convert.support.ConversionServiceFactory
convert(Object, Class<T>) - 接口 中的方法org.springframework.core.convert.ConversionService
  Convert the given `source` to the specified `targetType`.
convert(Object, TypeDescriptor, TypeDescriptor) - 接口 中的方法org.springframework.core.convert.ConversionService
  Convert the given `source` to the specified `targetType`.
convert(S) - 接口 中的方法org.springframework.core.convert.converter.Converter
  Convert the source object of type `S` to target type `T`.
convert(Object, TypeDescriptor, TypeDescriptor) - 接口 中的方法org.springframework.core.convert.converter.GenericConverter
  Convert the source object to the targetType described by the `TypeDescriptor`.
convert(Object, Class<T>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
convert(Object, TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
convert(Object, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
  Convenience operation for converting a source object to the specified targetType, where the target type is a descriptor that provides additional conversion context.
convert(byte[]) - 类 中的方法org.springframework.core.serializer.support.DeserializingConverter
convert(Object) - 类 中的方法org.springframework.core.serializer.support.SerializingConverter
  Serializes the source object and returns the byte array result.
convertClassLoaderURL(URL) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Convert the given URL as returned from the ClassLoader into a `Resource`.
convertClassNameToResourcePath(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Convert a "."
Converter<S,T> - org.springframework.core.convert.converter中的接口
  A converter converts a source object of type `S` to a target of type `T`.
ConverterFactory<S,R> - org.springframework.core.convert.converter中的接口
  A factory for "ranged" converters that can convert objects from S to subtypes of R.
ConverterNotFoundException - org.springframework.core.convert中的异常错误
  Exception to be thrown when a suitable converter could not be found in a given conversion service.
ConverterNotFoundException(TypeDescriptor, TypeDescriptor) - 异常错误 的构造器org.springframework.core.convert.ConverterNotFoundException
  Create a new conversion executor not found exception.
ConverterRegistry - org.springframework.core.convert.converter中的接口
  For registering converters with a type conversion system.
ConvertiblePair(Class<?>, Class<?>) - 类 的构造器org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
  Create a new source-to-target pair.
ConvertingComparator<S,T> - org.springframework.core.convert.converter中的类
  A `Comparator` that converts values before they are compared.
ConvertingComparator(Converter<S, T>) - 类 的构造器org.springframework.core.convert.converter.ConvertingComparator
  Create a new `ConvertingComparator` instance.
ConvertingComparator(Comparator<T>, Converter<S, T>) - 类 的构造器org.springframework.core.convert.converter.ConvertingComparator
  Create a new `ConvertingComparator` instance.
ConvertingComparator(Comparator<T>, ConversionService, Class<? extends T>) - 类 的构造器org.springframework.core.convert.converter.ConvertingComparator
  Create a new `ConvertingComparator` instance.
ConvertingPropertyEditorAdapter - org.springframework.core.convert.support中的类
  Adapter that exposes a `PropertyEditor` for any given `ConversionService` and specific target type.
ConvertingPropertyEditorAdapter(ConversionService, TypeDescriptor) - 类 的构造器org.springframework.core.convert.support.ConvertingPropertyEditorAdapter
  Create a new ConvertingPropertyEditorAdapter for a given `ConversionService` and the given target type.
convertKey(String) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
  Convert the given key to a case-insensitive key.
convertNullSource(TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
  Template method to convert a `null` source.
convertNumberToTargetClass(Number, Class<T>) - 类 中的静态方法org.springframework.util.NumberUtils
  Convert the given number into an instance of the given target class.
convertResourcePathToClassName(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Convert a "/"-based resource path to a "."
convertValueIfNecessary(Object, Class<T>) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Convert the given value to the specified target type, if necessary.
copy(File, File) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given input File to the given output File.
copy(byte[], File) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given byte array to the given output File.
copy(InputStream, OutputStream) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given InputStream to the given OutputStream.
copy(byte[], OutputStream) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given byte array to the given OutputStream.
copy(Reader, Writer) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given Reader to the given Writer.
copy(String, Writer) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given String to the given output Writer.
copy(byte[], OutputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy the contents of the given byte array to the given OutputStream.
copy(String, Charset, OutputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy the contents of the given String to the given output OutputStream.
copy(InputStream, OutputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy the contents of the given InputStream to the given OutputStream.
COPYABLE_FIELDS - 类 中的静态变量org.springframework.util.ReflectionUtils
  Pre-built FieldFilter that matches all non-static, non-final fields.
copyAttributesFrom(AttributeAccessor) - 类 中的方法org.springframework.core.AttributeAccessorSupport
  Copy the attributes from the supplied AttributeAccessor to this accessor.
copyRange(InputStream, OutputStream, long, long) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy a range of content of the given InputStream to the given OutputStream.
copyRecursively(File, File) - 类 中的静态方法org.springframework.util.FileSystemUtils
  Recursively copy the contents of the `src` file/directory to the `dest` file/directory.
copyRecursively(Path, Path) - 类 中的静态方法org.springframework.util.FileSystemUtils
  Recursively copy the contents of the `src` file/directory to the `dest` file/directory.
copyToByteArray(File) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given input File into a new byte array.
copyToByteArray(InputStream) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given InputStream into a new byte array.
copyToByteArray(InputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy the contents of the given InputStream into a new byte array.
copyToString(Reader) - 类 中的静态方法org.springframework.util.FileCopyUtils
  Copy the contents of the given Reader into a String.
copyToString(InputStream, Charset) - 类 中的静态方法org.springframework.util.StreamUtils
  Copy the contents of the given InputStream into a String.
countOccurrencesOf(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Count the occurrences of the substring `sub` in string `str`.
createApproximateCollection(Object, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most approximate collection for the given collection.
createApproximateMap(Object, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most approximate map for the given map.
createCollection(Class<?>, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most appropriate collection for the given collection type.
createCollection(Class<?>, Class<?>, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most appropriate collection for the given collection type.
createCompositeInterface(Class<?>[], ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
createContentHandler(Node) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Returns a SAX `ContentHandler` that transforms callback calls to DOM `Node`s.
createContentHandler(XMLStreamWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a SAX `ContentHandler` that writes to the given StAX `XMLStreamWriter`.
createContentHandler(XMLEventWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a SAX `ContentHandler` that writes events to the given StAX `XMLEventWriter`.
createCustomStaxResult(XMLStreamWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a custom, non-JAXP 1.4 StAX `Result` for the given `XMLStreamWriter`.
createCustomStaxResult(XMLEventWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a custom, non-JAXP 1.4 StAX `Result` for the given `XMLEventWriter`.
createCustomStaxSource(XMLStreamReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a custom, non-JAXP 1.4 StAX `Source` for the given `XMLStreamReader`.
createCustomStaxSource(XMLEventReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a custom, non-JAXP 1.4 StAX `Source` for the given `XMLEventReader`.
createDefensiveInputFactory() - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create an `XMLInputFactory` with Spring's defensive setup, i.e. no support for the resolution of DTDs and external entities.
createElement(int) - 接口 中的方法org.springframework.util.AutoPopulatingList.ElementFactory
  Create the element for the supplied index.
createEventStreamReader(XMLEventReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return a `XMLStreamReader` that reads from a `XMLEventReader`.
createEventStreamWriter(XMLEventWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return a `XMLStreamWriter` that writes to a `XMLEventWriter`.
createEventStreamWriter(XMLEventWriter, XMLEventFactory) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return a `XMLStreamWriter` that writes to a `XMLEventWriter`.
createMap(Class<?>, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most appropriate map for the given map type.
createMap(Class<?>, Class<?>, int) - 类 中的静态方法org.springframework.core.CollectionFactory
  Create the most appropriate map for the given map type.
createPropertySource(String, EncodedResource) - 类 中的方法org.springframework.core.io.support.DefaultPropertySourceFactory
createPropertySource(String, EncodedResource) - 接口 中的方法org.springframework.core.io.support.PropertySourceFactory
  Create a `PropertySource` that wraps the given resource.
createReference(ConcurrentReferenceHashMap.Entry<K, V>, int, ConcurrentReferenceHashMap.Reference<K, V>) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.ReferenceManager
  Factory method used to create a new `ConcurrentReferenceHashMap.Reference`.
createReferenceManager() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
  Factory method that returns the `ConcurrentReferenceHashMap.ReferenceManager`.
createRelative(String) - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation throws a FileNotFoundException, assuming that relative resources cannot be created for this resource.
createRelative(String) - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation creates a ClassPathResource, applying the given path relative to the path of the underlying resource of this descriptor.
createRelative(String) - 类 中的方法org.springframework.core.io.DefaultResourceLoader.ClassPathContextResource
createRelative(String) - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation creates a FileSystemResource, applying the given path relative to the path of the underlying file of this resource descriptor.
createRelative(String) - 类 中的方法org.springframework.core.io.FileUrlResource
createRelative(String) - 类 中的方法org.springframework.core.io.PathResource
  This implementation creates a PathResource, applying the given path relative to the path of the underlying file of this resource descriptor.
createRelative(String) - 接口 中的方法org.springframework.core.io.Resource
  Create a resource relative to this resource.
createRelative(String) - 类 中的方法org.springframework.core.io.UrlResource
  This implementation creates a `UrlResource`, applying the given path relative to the path of the underlying URL of this resource descriptor.
createRelative(String) - 类 中的方法org.springframework.core.io.VfsResource
createStaxResult(XMLStreamWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a JAXP 1.4 `StAXResult` for the given `XMLStreamWriter`.
createStaxResult(XMLEventWriter) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a JAXP 1.4 `StAXResult` for the given `XMLEventWriter`.
createStaxSource(XMLStreamReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a JAXP 1.4 `StAXSource` for the given `XMLStreamReader`.
createStaxSource(XMLEventReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a JAXP 1.4 `StAXSource` for the given `XMLEventReader`.
createStringAdaptingProperties() - 类 中的静态方法org.springframework.core.CollectionFactory
  Create a variant of `java.util.Properties` that automatically adapts non-String values to String representations on `Properties.getProperty(java.lang.String)`.
createThread(Runnable) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Template method for the creation of a new `Thread`.
createXMLEventReader(List<XMLEvent>) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a `XMLEventReader` from the given list of `XMLEvent`.
createXMLReader(XMLStreamReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a SAX `XMLReader` that reads from the given StAX `XMLStreamReader`.
createXMLReader(XMLEventReader) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Create a SAX `XMLReader` that reads from the given StAX `XMLEventReader`.
currentTaskName() - 类 中的方法org.springframework.util.StopWatch
  Return the name of the currently running task, if any.
CustomizableThreadCreator - org.springframework.util中的类
  Simple customizable helper class for creating new `Thread` instances.
CustomizableThreadCreator() - 类 的构造器org.springframework.util.CustomizableThreadCreator
  Create a new CustomizableThreadCreator with default thread name prefix.
CustomizableThreadCreator(String) - 类 的构造器org.springframework.util.CustomizableThreadCreator
  Create a new CustomizableThreadCreator with the given thread name prefix.
customizeConnection(URLConnection) - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  Customize the given `URLConnection`, obtained in the course of an `AbstractFileResolvingResource.exists()`, `AbstractFileResolvingResource.contentLength()` or `AbstractFileResolvingResource.lastModified()` call.
customizeConnection(HttpURLConnection) - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  Customize the given `HttpURLConnection`, obtained in the course of an `AbstractFileResolvingResource.exists()`, `AbstractFileResolvingResource.contentLength()` or `AbstractFileResolvingResource.lastModified()` call.
customizePropertySources(MutablePropertySources) - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Customize the set of `PropertySource` objects to be searched by this `Environment` during calls to `AbstractEnvironment.getProperty(String)` and related methods.
customizePropertySources(MutablePropertySources) - 类 中的方法org.springframework.core.env.StandardEnvironment
  Customize the set of property sources with those appropriate for any standard Java environment: "systemProperties" "systemEnvironment" Properties present in "systemProperties" will take precedence over those in "systemEnvironment".
cv - 类 中的变量org.springframework.asm.ClassVisitor
  The class visitor to which this visitor must delegate method calls.

## D

D2F - 接口 中的静态变量org.springframework.asm.Opcodes
D2I - 接口 中的静态变量org.springframework.asm.Opcodes
D2L - 接口 中的静态变量org.springframework.asm.Opcodes
DADD - 接口 中的静态变量org.springframework.asm.Opcodes
DALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
DASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
DataBuffer - org.springframework.core.io.buffer中的接口
  Basic abstraction over byte buffers.
DataBufferDecoder - org.springframework.core.codec中的类
  Simple pass-through decoder for `DataBuffer`s.
DataBufferDecoder() - 类 的构造器org.springframework.core.codec.DataBufferDecoder
DataBufferEncoder - org.springframework.core.codec中的类
  Simple pass-through encoder for `DataBuffer`s.
DataBufferEncoder() - 类 的构造器org.springframework.core.codec.DataBufferEncoder
DataBufferFactory - org.springframework.core.io.buffer中的接口
  A factory for `DataBuffers`, allowing for allocation and wrapping of data buffers.
DataBufferUtils - org.springframework.core.io.buffer中的类
  Utility class for working with `DataBuffer`s.
DataBufferUtils() - 类 的构造器org.springframework.core.io.buffer.DataBufferUtils
DCMPG - 接口 中的静态变量org.springframework.asm.Opcodes
DCMPL - 接口 中的静态变量org.springframework.asm.Opcodes
DCONST_0 - 接口 中的静态变量org.springframework.asm.Opcodes
DCONST_1 - 接口 中的静态变量org.springframework.asm.Opcodes
DDIV - 接口 中的静态变量org.springframework.asm.Opcodes
declaresException(Method, Class<?>) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method explicitly declares the given exception or one of its superclasses, which means that an exception of that type can be propagated as-is within a reflective invocation.
declaringClassName - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
decode(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractDataBufferDecoder
decode(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.DataBufferDecoder
decode(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 接口 中的方法org.springframework.core.codec.Decoder
  Decode a `DataBuffer` input stream into a Flux of `T`.
decode(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ResourceDecoder
decode(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.StringDecoder
decode(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-decode the given byte array.
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractDataBufferDecoder
  How to decode a `DataBuffer` to the target element type.
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ByteArrayDecoder
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ByteBufferDecoder
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.DataBufferDecoder
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ResourceDecoder
decodeDataBuffer(DataBuffer, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.StringDecoder
decodeFromString(String) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-decode the given byte array from an UTF-8 String.
decodeFromUrlSafeString(String) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-decode the given byte array from an UTF-8 String using the RFC 4648 "URL and Filename Safe Alphabet".
Decoder<T> - org.springframework.core.codec中的接口
  Strategy for decoding a `DataBuffer` input stream into an output stream of elements of type `<T>`.
decodeToMono(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractDataBufferDecoder
decodeToMono(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractDecoder
decodeToMono(Publisher<DataBuffer>, ResolvableType, MimeType, Map<String, Object>) - 接口 中的方法org.springframework.core.codec.Decoder
  Decode a `DataBuffer` input stream into a Mono of `T`.
decodeUrlSafe(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-decode the given byte array using the RFC 4648 "URL and Filename Safe Alphabet".
DecodingException - org.springframework.core.codec中的异常错误
  Indicates an issue with decoding the input stream with a focus on content related issues such as a parse failure.
DecodingException(String) - 异常错误 的构造器org.springframework.core.codec.DecodingException
  Create a new DecodingException.
DecodingException(String, Throwable) - 异常错误 的构造器org.springframework.core.codec.DecodingException
  Create a new DecodingException.
decorate(Runnable) - 接口 中的方法org.springframework.core.task.TaskDecorator
  Decorate the given `Runnable`, returning a potentially wrapped `Runnable` for actual execution.
DecoratingClassLoader - org.springframework.core中的类
  Base class for decorating ClassLoaders such as `OverridingClassLoader` and `org.springframework.instrument.classloading.ShadowingClassLoader`, providing common handling of excluded packages and classes.
DecoratingClassLoader() - 类 的构造器org.springframework.core.DecoratingClassLoader
  Create a new DecoratingClassLoader with no parent ClassLoader.
DecoratingClassLoader(ClassLoader) - 类 的构造器org.springframework.core.DecoratingClassLoader
  Create a new DecoratingClassLoader using the given parent ClassLoader for delegation.
DecoratingProxy - org.springframework.core中的接口
  Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.
decreaseNestingLevel() - 类 中的方法org.springframework.core.MethodParameter
  Decrease this parameter's nesting level.
deepCopy() - 类 中的方法org.springframework.util.LinkedMultiValueMap
  Create a deep copy of this Map.
DEFAULT_BUFFER_SIZE - 类 中的静态变量org.springframework.core.codec.ResourceEncoder
DEFAULT_BUFFER_SIZE - 类 中的静态变量org.springframework.core.codec.ResourceRegionEncoder
DEFAULT_CACHE_LIMIT - 类 中的静态变量org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Default maximum number of entries for a local MetadataReader cache: 256
DEFAULT_CHARSET - 类 中的静态变量org.springframework.core.codec.CharSequenceEncoder
DEFAULT_CHARSET - 类 中的静态变量org.springframework.core.codec.StringDecoder
  The default charset to use, i.e.
DEFAULT_DELIMITERS - 类 中的静态变量org.springframework.core.codec.StringDecoder
  The default delimiter strings to use, i.e.
DEFAULT_EXCLUDED_PACKAGES - 类 中的静态变量org.springframework.core.OverridingClassLoader
  Packages that are excluded by default
DEFAULT_INDENT_AMOUNT - 类 中的静态变量org.springframework.util.xml.TransformerUtils
  The indent amount of characters if `indenting is enabled`.
DEFAULT_INITIAL_CAPACITY - 类 中的静态变量org.springframework.core.io.buffer.DefaultDataBufferFactory
  The default capacity when none is specified.
DEFAULT_INITIAL_INTERVAL - 类 中的静态变量org.springframework.util.backoff.ExponentialBackOff
  The default initial interval.
DEFAULT_INTERVAL - 类 中的静态变量org.springframework.util.backoff.FixedBackOff
  The default recovery interval: 5000 ms = 5 seconds.
DEFAULT_MAX_ELAPSED_TIME - 类 中的静态变量org.springframework.util.backoff.ExponentialBackOff
  The default maximum elapsed time.
DEFAULT_MAX_INTERVAL - 类 中的静态变量org.springframework.util.backoff.ExponentialBackOff
  The default maximum back off time.
DEFAULT_MULTIPLIER - 类 中的静态变量org.springframework.util.backoff.ExponentialBackOff
  The default multiplier (increases the interval by 50%).
DEFAULT_NON_OPTION_ARGS_PROPERTY_NAME - 类 中的静态变量org.springframework.core.env.CommandLinePropertySource
  The default name of the property representing non-option arguments: "nonOptionArgs"
DEFAULT_PATH_SEPARATOR - 类 中的静态变量org.springframework.util.AntPathMatcher
  Default path separator: "/"
DEFAULT_PROFILES_PROPERTY_NAME - 类 中的静态变量org.springframework.core.env.AbstractEnvironment
  Name of property to set to specify profiles active by default: "spring.profiles.default".
DEFAULT_SEPARATOR - 类 中的静态变量org.springframework.core.io.support.LocalizedResourceHelper
  The default separator to use in-between file name parts: an underscore.
DefaultConversionService - org.springframework.core.convert.support中的类
  A specialization of `GenericConversionService` configured by default with converters appropriate for most environments.
DefaultConversionService() - 类 的构造器org.springframework.core.convert.support.DefaultConversionService
  Create a new `DefaultConversionService` with the set of default converters.
DefaultDataBuffer - org.springframework.core.io.buffer中的类
  Default implementation of the `DataBuffer` interface that uses a `ByteBuffer` internally. with separate read and write positions.
DefaultDataBufferFactory - org.springframework.core.io.buffer中的类
  Default implementation of the `DataBufferFactory` interface.
DefaultDataBufferFactory() - 类 的构造器org.springframework.core.io.buffer.DefaultDataBufferFactory
  Creates a new `DefaultDataBufferFactory` with default settings.
DefaultDataBufferFactory(boolean) - 类 的构造器org.springframework.core.io.buffer.DefaultDataBufferFactory
  Creates a new `DefaultDataBufferFactory`, indicating whether direct buffers should be created by `DefaultDataBufferFactory.allocateBuffer()` and `DefaultDataBufferFactory.allocateBuffer(int)`.
DefaultDataBufferFactory(boolean, int) - 类 的构造器org.springframework.core.io.buffer.DefaultDataBufferFactory
  Creates a new `DefaultDataBufferFactory`, indicating whether direct buffers should be created by `DefaultDataBufferFactory.allocateBuffer()` and `DefaultDataBufferFactory.allocateBuffer(int)`, and what the capacity is to be used for `DefaultDataBufferFactory.allocateBuffer()`.
DefaultDeserializer - org.springframework.core.serializer中的类
  A default `Deserializer` implementation that reads an input stream using Java serialization.
DefaultDeserializer() - 类 的构造器org.springframework.core.serializer.DefaultDeserializer
  Create a `DefaultDeserializer` with default `ObjectInputStream` configuration, using the "latest user-defined ClassLoader".
DefaultDeserializer(ClassLoader) - 类 的构造器org.springframework.core.serializer.DefaultDeserializer
  Create a `DefaultDeserializer` for using an `ObjectInputStream` with the given `ClassLoader`.
DefaultParameterNameDiscoverer - org.springframework.core中的类
  Default implementation of the `ParameterNameDiscoverer` strategy interface, using the Java 8 standard reflection mechanism (if available), and falling back to the ASM-based `LocalVariableTableParameterNameDiscoverer` for checking debug information in the class file.
DefaultParameterNameDiscoverer() - 类 的构造器org.springframework.core.DefaultParameterNameDiscoverer
DefaultPropertiesPersister - org.springframework.util中的类
  Default implementation of the `PropertiesPersister` interface.
DefaultPropertiesPersister() - 类 的构造器org.springframework.util.DefaultPropertiesPersister
DefaultPropertySourceFactory - org.springframework.core.io.support中的类
  The default implementation for `PropertySourceFactory`, wrapping every resource in a `ResourcePropertySource`.
DefaultPropertySourceFactory() - 类 的构造器org.springframework.core.io.support.DefaultPropertySourceFactory
DefaultResourceLoader - org.springframework.core.io中的类
  Default implementation of the `ResourceLoader` interface.
DefaultResourceLoader() - 类 的构造器org.springframework.core.io.DefaultResourceLoader
  Create a new DefaultResourceLoader.
DefaultResourceLoader(ClassLoader) - 类 的构造器org.springframework.core.io.DefaultResourceLoader
  Create a new DefaultResourceLoader.
DefaultResourceLoader.ClassPathContextResource - org.springframework.core.io中的类
  ClassPathResource that explicitly expresses a context-relative path through implementing the ContextResource interface.
DefaultSerializer - org.springframework.core.serializer中的类
  A `Serializer` implementation that writes an object to an output stream using Java serialization.
DefaultSerializer() - 类 的构造器org.springframework.core.serializer.DefaultSerializer
DefaultToStringStyler - org.springframework.core.style中的类
  Spring's default `toString()` styler.
DefaultToStringStyler(ValueStyler) - 类 的构造器org.springframework.core.style.DefaultToStringStyler
  Create a new DefaultToStringStyler.
DefaultValueStyler - org.springframework.core.style中的类
  Converts objects to String form, generally for debugging purposes, using Spring's `toString` styling conventions.
DefaultValueStyler() - 类 的构造器org.springframework.core.style.DefaultValueStyler
delete(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Delete all occurrences of the given substring.
deleteAny(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Delete any character in a given `String`.
deleteRecursively(File) - 类 中的静态方法org.springframework.util.FileSystemUtils
  Delete the supplied `File` - for directories, recursively delete any nested directories or files as well.
deleteRecursively(Path) - 类 中的静态方法org.springframework.util.FileSystemUtils
  Delete the supplied `File` - for directories, recursively delete any nested directories or files as well.
delimitedListToStringArray(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Take a `String` that is a delimited list and convert it into a `String` array.
delimitedListToStringArray(String, String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Take a `String` that is a delimited list and convert it into a `String` array.
DescriptiveResource - org.springframework.core.io中的类
  Simple `Resource` implementation that holds a resource description but does not point to an actually readable resource.
DescriptiveResource(String) - 类 的构造器org.springframework.core.io.DescriptiveResource
  Create a new DescriptiveResource.
deserialize(InputStream) - 类 中的方法org.springframework.core.serializer.DefaultDeserializer
  Read from the supplied `InputStream` and deserialize the contents into an object.
deserialize(InputStream) - 接口 中的方法org.springframework.core.serializer.Deserializer
  Read (assemble) an object of type T from the given InputStream.
deserialize(InputStream) - 类 中的方法org.springframework.core.serializer.support.SerializationDelegate
deserialize(byte[]) - 类 中的静态方法org.springframework.util.SerializationUtils
  Deserialize the byte array into an object.
Deserializer<T> - org.springframework.core.serializer中的接口
  A strategy interface for converting from data in an InputStream to an Object.
DeserializingConverter - org.springframework.core.serializer.support中的类
  A `Converter` that delegates to a `Deserializer` to convert data in a byte array to an object.
DeserializingConverter() - 类 的构造器org.springframework.core.serializer.support.DeserializingConverter
  Create a `DeserializingConverter` with default `ObjectInputStream` configuration, using the "latest user-defined ClassLoader".
DeserializingConverter(ClassLoader) - 类 的构造器org.springframework.core.serializer.support.DeserializingConverter
  Create a `DeserializingConverter` for using an `ObjectInputStream` with the given `ClassLoader`.
DeserializingConverter(Deserializer<Object>) - 类 的构造器org.springframework.core.serializer.support.DeserializingConverter
  Create a `DeserializingConverter` that delegates to the provided `Deserializer`.
detectValidationMode(InputStream) - 类 中的方法org.springframework.util.xml.XmlValidationModeDetector
  Detect the validation mode for the XML document in the supplied `InputStream`.
determineCommonAncestor(Class<?>, Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine the common ancestor of the given classes, if any.
determineRootDir(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Determine the root directory for the given location.
DigestUtils - org.springframework.util中的类
  Miscellaneous methods for calculating digests.
DigestUtils() - 类 的构造器org.springframework.util.DigestUtils
disableIndenting(Transformer) - 类 中的静态方法org.springframework.util.xml.TransformerUtils
  Disable indenting for the supplied `Transformer`.
DLOAD - 接口 中的静态变量org.springframework.asm.Opcodes
DMUL - 接口 中的静态变量org.springframework.asm.Opcodes
DNEG - 接口 中的静态变量org.springframework.asm.Opcodes
doesNotContain(String, String, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given text does not contain the given substring.
doesNotContain(String, String, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given text does not contain the given substring.
doesNotContain(String, String) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.doesNotContain(String, String, String)`
doExecute(Runnable) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Template method for the actual execution of a task.
doExecute(Executor, TaskDecorator, Runnable) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
  Actually execute the given `Runnable` (which may be a user-supplied task or a wrapper around a user-supplied task) with the given executor.
doFindAllClassPathResources(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all class location resources with the given path via the ClassLoader.
doFindMatchingFileSystemResources(File, String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all resources in the file system that match the given location pattern via the Ant-style PathMatcher.
doFindPathMatchingFileResources(Resource, String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all resources in the file system that match the given location pattern via the Ant-style PathMatcher.
doFindPathMatchingJarResources(Resource, URL, String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all resources in jar files that match the given location pattern via the Ant-style PathMatcher.
doGetActiveProfiles() - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Return the set of active profiles as explicitly set through `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.
doGetDefaultProfiles() - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Return the set of default profiles explicitly set via `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.
doGetPath(Object) - 类 中的静态方法org.springframework.core.io.VfsUtils
doGetVisitorAttributes() - 类 中的静态方法org.springframework.core.io.VfsUtils
doMatch(String, String, boolean, Map<String, String>) - 类 中的方法org.springframework.util.AntPathMatcher
  Actually match the given `path` against the given `pattern`.
DomUtils - org.springframework.util.xml中的类
  Convenience methods for working with the DOM API, in particular for working with DOM Nodes and DOM Elements.
DomUtils() - 类 的构造器org.springframework.util.xml.DomUtils
done() - 类 中的方法org.springframework.util.concurrent.ListenableFutureTask
doRetrieveMatchingFiles(String, File, Set<File>) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Recursively retrieve files that match the given pattern, adding them to the given result list.
doTask(int, Object, ConcurrentReferenceHashMap<K, V>.Task<T>) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
  Apply an update operation to this segment.
DOUBLE - 接口 中的静态变量org.springframework.asm.Opcodes
DOUBLE - 类 中的静态变量org.springframework.asm.Type
  The sort of the `double` type.
DOUBLE_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `double` type.
doWith(Field) - 接口 中的方法org.springframework.util.ReflectionUtils.FieldCallback
  Perform an operation using the given field.
doWith(Method) - 接口 中的方法org.springframework.util.ReflectionUtils.MethodCallback
  Perform an operation using the given method.
doWithFields(Class<?>, ReflectionUtils.FieldCallback) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
doWithFields(Class<?>, ReflectionUtils.FieldCallback, ReflectionUtils.FieldFilter) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
doWithLocalFields(Class<?>, ReflectionUtils.FieldCallback) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Invoke the given callback on all locally declared fields in the given class.
doWithLocalMethods(Class<?>, ReflectionUtils.MethodCallback) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Perform the given callback operation on all matching methods of the given class, as locally declared or equivalent thereof (such as default methods on Java 8 based interfaces that the given class implements).
doWithMethods(Class<?>, ReflectionUtils.MethodCallback) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Perform the given callback operation on all matching methods of the given class and superclasses.
doWithMethods(Class<?>, ReflectionUtils.MethodCallback, ReflectionUtils.MethodFilter) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Perform the given callback operation on all matching methods of the given class and superclasses (or given interface and super-interfaces).
drain(InputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Drain the remaining content of the given InputStream.
DREM - 接口 中的静态变量org.springframework.asm.Opcodes
DRETURN - 接口 中的静态变量org.springframework.asm.Opcodes
DSTORE - 接口 中的静态变量org.springframework.asm.Opcodes
DSUB - 接口 中的静态变量org.springframework.asm.Opcodes
DUP - 接口 中的静态变量org.springframework.asm.Opcodes
DUP2 - 接口 中的静态变量org.springframework.asm.Opcodes
DUP2_X1 - 接口 中的静态变量org.springframework.asm.Opcodes
DUP2_X2 - 接口 中的静态变量org.springframework.asm.Opcodes
DUP_X1 - 接口 中的静态变量org.springframework.asm.Opcodes
DUP_X2 - 接口 中的静态变量org.springframework.asm.Opcodes

## E

ElementInstantiationException(String) - 异常错误 的构造器org.springframework.util.AutoPopulatingList.ElementInstantiationException
ElementInstantiationException(String, Throwable) - 异常错误 的构造器org.springframework.util.AutoPopulatingList.ElementInstantiationException
elementTypeDescriptor(Object) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is a `Collection` or an array, creates a element TypeDescriptor from the provided collection or array element.
emptyInput() - 类 中的静态方法org.springframework.util.StreamUtils
  Return an efficient empty `InputStream`.
enableIndenting(Transformer) - 类 中的静态方法org.springframework.util.xml.TransformerUtils
  Enable indenting for the supplied `Transformer`.
enableIndenting(Transformer, int) - 类 中的静态方法org.springframework.util.xml.TransformerUtils
  Enable indenting for the supplied `Transformer`.
encode(Publisher<? extends T>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractSingleValueEncoder
encode(T, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.AbstractSingleValueEncoder
  Encode `T` to an output `DataBuffer` stream.
encode(Publisher<? extends byte[]>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ByteArrayEncoder
encode(Publisher<? extends ByteBuffer>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ByteBufferEncoder
encode(Publisher<? extends CharSequence>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.CharSequenceEncoder
encode(Publisher<? extends DataBuffer>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.DataBufferEncoder
encode(Publisher<? extends T>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 接口 中的方法org.springframework.core.codec.Encoder
  Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
encode(Resource, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ResourceEncoder
encode(Publisher<? extends ResourceRegion>, DataBufferFactory, ResolvableType, MimeType, Map<String, Object>) - 类 中的方法org.springframework.core.codec.ResourceRegionEncoder
encode(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-encode the given byte array.
EncodedResource - org.springframework.core.io.support中的类
  Holder that combines a `Resource` descriptor with a specific encoding or `Charset` to be used for reading from the resource.
EncodedResource(Resource) - 类 的构造器org.springframework.core.io.support.EncodedResource
  Create a new `EncodedResource` for the given `Resource`, not specifying an explicit encoding or `Charset`.
EncodedResource(Resource, String) - 类 的构造器org.springframework.core.io.support.EncodedResource
  Create a new `EncodedResource` for the given `Resource`, using the specified `encoding`.
EncodedResource(Resource, Charset) - 类 的构造器org.springframework.core.io.support.EncodedResource
  Create a new `EncodedResource` for the given `Resource`, using the specified `Charset`.
Encoder<T> - org.springframework.core.codec中的接口
  Strategy to encode a stream of Objects of type `<T>` into an output stream of bytes.
encodeToString(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-encode the given byte array to a String.
encodeToUrlSafeString(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-encode the given byte array to a String using the RFC 4648 "URL and Filename Safe Alphabet".
encodeUrlSafe(byte[]) - 类 中的静态方法org.springframework.util.Base64Utils
  Base64-encode the given byte array using the RFC 4648 "URL and Filename Safe Alphabet".
EncodingException - org.springframework.core.codec中的异常错误
  Indicates an issue with encoding the input Object stream with a focus on not being able to encode Objects.
EncodingException(String) - 异常错误 的构造器org.springframework.core.codec.EncodingException
  Create a new EncodingException.
EncodingException(String, Throwable) - 异常错误 的构造器org.springframework.core.codec.EncodingException
  Create a new EncodingException.
endsWithIgnoreCase(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Test if the given `String` ends with the specified suffix, ignoring upper/lower case.
Entry(K, V) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap.Entry
entrySet() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
entrySet() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
entrySet() - 类 中的方法org.springframework.util.LinkedMultiValueMap
EnumerablePropertySource<T> - org.springframework.core.env中的类
  A `PropertySource` implementation capable of interrogating its underlying source object to enumerate all possible property name/value pairs.
EnumerablePropertySource(String, T) - 类 的构造器org.springframework.core.env.EnumerablePropertySource
EnumerablePropertySource(String) - 类 的构造器org.springframework.core.env.EnumerablePropertySource
Environment - org.springframework.core.env中的接口
  Interface representing the environment in which the current application is running.
EnvironmentCapable - org.springframework.core.env中的接口
  Interface indicating a component that contains and exposes an `Environment` reference.
equals(Object) - 类 中的方法org.springframework.asm.Handle
equals(Object) - 类 中的方法org.springframework.asm.Type
  Tests if the given object is equal to this type.
equals(Object) - 类 中的方法org.springframework.core.AttributeAccessorSupport
equals(Object) - 类 中的方法org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
equals(Object) - 类 中的方法org.springframework.core.convert.Property
equals(Object) - 类 中的方法org.springframework.core.convert.TypeDescriptor
equals(Object) - 类 中的方法org.springframework.core.env.PropertySource
  This `PropertySource` object is equal to the given object if: they are the same instance the `name` properties for both objects are equal No properties other than `name` are evaluated.
equals(Object) - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation compares description strings.
equals(Object) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
equals(Object) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
equals(Object) - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation compares the underlying byte array.
equals(Object) - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation compares the underlying class path locations.
equals(Object) - 类 中的方法org.springframework.core.io.DescriptiveResource
  This implementation compares the underlying description String.
equals(Object) - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation compares the underlying File references.
equals(Object) - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation compares the underlying InputStream.
equals(Object) - 类 中的方法org.springframework.core.io.PathResource
  This implementation compares the underlying Path references.
equals(Object) - 类 中的方法org.springframework.core.io.support.EncodedResource
equals(Object) - 类 中的方法org.springframework.core.io.UrlResource
  This implementation compares the underlying URL references.
equals(Object) - 类 中的方法org.springframework.core.io.VfsResource
equals(Object) - 类 中的方法org.springframework.core.MethodClassKey
equals(Object) - 类 中的方法org.springframework.core.MethodParameter
equals(Object) - 类 中的方法org.springframework.core.ParameterizedTypeReference
equals(Object) - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
equals(Object) - 类 中的方法org.springframework.core.ResolvableType
equals(Object) - 类 中的方法org.springframework.util.AutoPopulatingList
equals(Object) - 类 中的方法org.springframework.util.comparator.BooleanComparator
equals(Object) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
equals(Object) - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
equals(Object) - 类 中的方法org.springframework.util.comparator.NullSafeComparator
equals(Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
equals(Object) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
equals(Object) - 类 中的方法org.springframework.util.LinkedMultiValueMap
equals(Object) - 类 中的方法org.springframework.util.MimeType
error(SAXParseException) - 类 中的方法org.springframework.util.xml.SimpleSaxErrorHandler
error(TransformerException) - 类 中的方法org.springframework.util.xml.SimpleTransformErrorListener
ErrorHandler - org.springframework.util中的接口
  A strategy for handling errors.
EXCEPTION_PARAMETER - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of the exception of a 'catch' clause in a method.
ExceptionDepthComparator - org.springframework.core中的类
  Comparator capable of sorting exceptions based on their depth from the thrown exception type.
ExceptionDepthComparator(Throwable) - 类 的构造器org.springframework.core.ExceptionDepthComparator
  Create a new ExceptionDepthComparator for the given exception.
ExceptionDepthComparator(Class<? extends Throwable>) - 类 的构造器org.springframework.core.ExceptionDepthComparator
  Create a new ExceptionDepthComparator for the given exception type.
ExceptionTypeFilter - org.springframework.util中的类
  An `InstanceFilter` implementation that handles exception types.
ExceptionTypeFilter(Collection<? extends Class<? extends Throwable>>, Collection<? extends Class<? extends Throwable>>, boolean) - 类 的构造器org.springframework.util.ExceptionTypeFilter
excludeClass(String) - 类 中的方法org.springframework.core.DecoratingClassLoader
  Add a class name to exclude from decoration (e.g. overriding).
excludePackage(String) - 类 中的方法org.springframework.core.DecoratingClassLoader
  Add a package name to exclude from decoration (e.g. overriding).
execute(Runnable, long) - 接口 中的方法org.springframework.core.task.AsyncTaskExecutor
  Execute the given `task`.
execute(Runnable) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Executes the given task, within a concurrency throttle if configured (through the superclass's settings).
execute(Runnable, long) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Executes the given task, within a concurrency throttle if configured (through the superclass's settings).
execute(Runnable) - 类 中的方法org.springframework.core.task.support.ConcurrentExecutorAdapter
execute(Runnable) - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter
execute(Runnable) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
  Delegates to the specified JDK concurrent executor.
execute(Runnable, long) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
execute(Runnable) - 类 中的方法org.springframework.core.task.SyncTaskExecutor
  Executes the given `task` synchronously, through direct invocation of it's `run()` method.
execute(Runnable) - 接口 中的方法org.springframework.core.task.TaskExecutor
  Execute the given `task`.
ExecutorServiceAdapter - org.springframework.core.task.support中的类
  Adapter that takes a Spring `TaskExecutor` and exposes a full `java.util.concurrent.ExecutorService` for it.
ExecutorServiceAdapter(TaskExecutor) - 类 的构造器org.springframework.core.task.support.ExecutorServiceAdapter
  Create a new ExecutorServiceAdapter, using the given target executor.
exists() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
exists() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation checks whether a File can be opened, falling back to whether an InputStream can be opened.
exists() - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation always returns `true`.
exists() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation checks for the resolution of a resource URL.
exists() - 类 中的方法org.springframework.core.io.DescriptiveResource
exists() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns whether the underlying file exists.
exists() - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation always returns `true`.
exists() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns whether the underlying file exists.
exists() - 接口 中的方法org.springframework.core.io.Resource
  Determine whether this resource actually exists in physical form.
exists() - 类 中的方法org.springframework.core.io.VfsResource
EXPAND_FRAMES - 类 中的静态变量org.springframework.asm.ClassReader
  Flag to expand the stack map frames.
ExponentialBackOff - org.springframework.util.backoff中的类
  Implementation of `BackOff` that increases the back off period for each retry attempt.
ExponentialBackOff() - 类 的构造器org.springframework.util.backoff.ExponentialBackOff
  Create an instance with the default settings.
ExponentialBackOff(long, double) - 类 的构造器org.springframework.util.backoff.ExponentialBackOff
  Create an instance with the supplied settings.
extractArchiveURL(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Extract the URL for the outermost archive from the given jar/war URL (which may point to a resource in a jar file or to a jar file itself).
extractJarFileURL(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Extract the URL for the actual jar file from the given URL (which may point to a resource in a jar file or to a jar file itself).
extractPathWithinPattern(String, String) - 类 中的方法org.springframework.util.AntPathMatcher
  Given a pattern and a full path, determine the pattern-mapped part.
extractPathWithinPattern(String, String) - 接口 中的方法org.springframework.util.PathMatcher
  Given a pattern and a full path, determine the pattern-mapped part.
extractUriTemplateVariables(String, String) - 类 中的方法org.springframework.util.AntPathMatcher
extractUriTemplateVariables(String, String) - 接口 中的方法org.springframework.util.PathMatcher
  Given a pattern and a full path, extract the URI template variables.

## F

F2D - 接口 中的静态变量org.springframework.asm.Opcodes
F2I - 接口 中的静态变量org.springframework.asm.Opcodes
F2L - 接口 中的静态变量org.springframework.asm.Opcodes
F_APPEND - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents a compressed frame where locals are the same as the locals in the previous frame, except that additional 1-3 locals are defined, and with an empty stack.
F_CHOP - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents a compressed frame where locals are the same as the locals in the previous frame, except that the last 1-3 locals are absent and with an empty stack.
F_FULL - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents a compressed frame with complete frame data.
F_NEW - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents an expanded frame.
F_SAME - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents a compressed frame with exactly the same locals as the previous frame and with an empty stack.
F_SAME1 - 接口 中的静态变量org.springframework.asm.Opcodes
  Represents a compressed frame with exactly the same locals as the previous frame and with a single value on the stack.
FACTORIES_RESOURCE_LOCATION - 类 中的静态变量org.springframework.core.io.support.SpringFactoriesLoader
  The location to look for factories.
factory() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the `DataBufferFactory` that created this buffer.
factory() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
factory() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
FADD - 接口 中的静态变量org.springframework.asm.Opcodes
failure(Throwable) - 类 中的方法org.springframework.util.concurrent.ListenableFutureCallbackRegistry
  Trigger a `FailureCallback.onFailure(Throwable)` call on all added callbacks with the given `Throwable`.
FailureCallback - org.springframework.util.concurrent中的接口
  Failure callback for a `ListenableFuture`.
FALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
FastByteArrayOutputStream - org.springframework.util中的类
  A speedy alternative to `ByteArrayOutputStream`.
FastByteArrayOutputStream() - 类 的构造器org.springframework.util.FastByteArrayOutputStream
  Create a new `FastByteArrayOutputStream` with the default initial capacity of 256 bytes.
FastByteArrayOutputStream(int) - 类 的构造器org.springframework.util.FastByteArrayOutputStream
  Create a new `FastByteArrayOutputStream` with the specified initial capacity.
FASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
fatalError(SAXParseException) - 类 中的方法org.springframework.util.xml.SimpleSaxErrorHandler
fatalError(TransformerException) - 类 中的方法org.springframework.util.xml.SimpleTransformErrorListener
FCMPG - 接口 中的静态变量org.springframework.asm.Opcodes
FCMPL - 接口 中的静态变量org.springframework.asm.Opcodes
FCONST_0 - 接口 中的静态变量org.springframework.asm.Opcodes
FCONST_1 - 接口 中的静态变量org.springframework.asm.Opcodes
FCONST_2 - 接口 中的静态变量org.springframework.asm.Opcodes
FDIV - 接口 中的静态变量org.springframework.asm.Opcodes
FIELD - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of a field.
FieldVisitor - org.springframework.asm中的类
  A visitor to visit a Java field.
FieldVisitor(int) - 类 的构造器org.springframework.asm.FieldVisitor
  Constructs a new `FieldVisitor`.
FieldVisitor(int, FieldVisitor) - 类 的构造器org.springframework.asm.FieldVisitor
  Constructs a new `FieldVisitor`.
FILE_URL_PREFIX - 类 中的静态变量org.springframework.util.ResourceUtils
  URL prefix for loading from the file system: "file:"
FileCopyUtils - org.springframework.util中的类
  Simple utility methods for file and stream copying.
FileCopyUtils() - 类 的构造器org.springframework.util.FileCopyUtils
FileSystemResource - org.springframework.core.io中的类
  `Resource` implementation for `java.io.File` handles.
FileSystemResource(File) - 类 的构造器org.springframework.core.io.FileSystemResource
  Create a new `FileSystemResource` from a `File` handle.
FileSystemResource(String) - 类 的构造器org.springframework.core.io.FileSystemResource
  Create a new `FileSystemResource` from a file path.
FileSystemResourceLoader - org.springframework.core.io中的类
  `ResourceLoader` implementation that resolves plain paths as file system resources rather than as class path resources (the latter is `DefaultResourceLoader`'s default strategy).
FileSystemResourceLoader() - 类 的构造器org.springframework.core.io.FileSystemResourceLoader
FileSystemUtils - org.springframework.util中的类
  Utility methods for working with the file system.
FileSystemUtils() - 类 的构造器org.springframework.util.FileSystemUtils
FileUrlResource - org.springframework.core.io中的类
  Subclass of `UrlResource` which assumes file resolution, to the degree of implementing the `WritableResource` interface for it.
FileUrlResource(URL) - 类 的构造器org.springframework.core.io.FileUrlResource
  Create a new `FileUrlResource` based on the given URL object.
FileUrlResource(String) - 类 的构造器org.springframework.core.io.FileUrlResource
  Create a new `FileUrlResource` based on the given file location, using the URL protocol "file".
fillProperties(Properties, EncodedResource) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Fill the given properties from the given EncodedResource, potentially defining a specific encoding for the properties file.
fillProperties(Properties, Resource) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Fill the given properties from the given resource (in ISO-8859-1 encoding).
findAllClassPathResources(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all class location resources with the given location via the ClassLoader.
findAllMergedAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find all annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
findAnnotation(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
findAnnotation(Method, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Find a single `Annotation` of `annotationType` on the supplied `Method`, traversing its super methods (i.e. from superclasses and interfaces) if the annotation is not directly present on the given method itself.
findAnnotation(Class<?>, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Find a single `Annotation` of `annotationType` on the supplied `Class`, traversing its interfaces, annotations, and superclasses if the annotation is not directly present on the given class itself.
findAnnotationDeclaringClass(Class<? extends Annotation>, Class<?>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which an annotation of the specified `annotationType` is directly present.
findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>>, Class<?>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Find the first `Class` in the inheritance hierarchy of the specified `clazz` (including the specified `clazz` itself) on which at least one of the specified `annotationTypes` is directly present.
findAvailableTcpPort() - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available TCP port randomly selected from the range [1024, 65535].
findAvailableTcpPort(int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available TCP port randomly selected from the range [`minPort`, 65535].
findAvailableTcpPort(int, int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available TCP port randomly selected from the range [`minPort`, `maxPort`].
findAvailableTcpPorts(int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find the requested number of available TCP ports, each randomly selected from the range [1024, 65535].
findAvailableTcpPorts(int, int, int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find the requested number of available TCP ports, each randomly selected from the range [`minPort`, `maxPort`].
findAvailableUdpPort() - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available UDP port randomly selected from the range [1024, 65535].
findAvailableUdpPort(int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available UDP port randomly selected from the range [`minPort`, 65535].
findAvailableUdpPort(int, int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find an available UDP port randomly selected from the range [`minPort`, `maxPort`].
findAvailableUdpPorts(int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find the requested number of available UDP ports, each randomly selected from the range [1024, 65535].
findAvailableUdpPorts(int, int, int) - 类 中的静态方法org.springframework.util.SocketUtils
  Find the requested number of available UDP ports, each randomly selected from the range [`minPort`, `maxPort`].
findBridgedMethod(Method) - 类 中的静态方法org.springframework.core.BridgeMethodResolver
  Find the original method for the supplied `bridge Method`.
findClosestMatch(Collection<Class<? extends Throwable>>, Throwable) - 类 中的静态方法org.springframework.core.ExceptionDepthComparator
  Obtain the closest match from the given exception types for the given target exception.
findCommonElementType(Collection<?>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Find the common element type of the given Collection, if any.
findField(Class<?>, String) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Attempt to find a `field` on the supplied `Class` with the supplied `name`.
findField(Class<?>, String, Class<?>) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
findFirstMatch(Collection<?>, Collection<E>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Return the first element in '`candidates`' that is contained in '`source`'.
findLocalizedResource(String, String, Locale) - 类 中的方法org.springframework.core.io.support.LocalizedResourceHelper
  Find the most specific localized resource for the given name, extension and locale: The file will be searched with locations in the following order, similar to `java.util.ResourceBundle`'s search order: [name]_[language]_[country]_[variant][extension] [name]_[language]_[country][extension] [name]_[language][extension] [name][extension] If none of the specific files can be found, a resource descriptor for the default location will be returned.
findMatchingMethod() - 类 中的方法org.springframework.util.MethodInvoker
  Find a matching method with the specified name for the specified arguments.
findMergedAnnotation(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element`, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy, and synthesize the result back into an annotation of the specified `annotationType`.
findMergedAnnotationAttributes(AnnotatedElement, Class<? extends Annotation>, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
findMergedAnnotationAttributes(AnnotatedElement, String, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
findMergedRepeatableAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
findMergedRepeatableAnnotations(AnnotatedElement, Class<A>, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Find all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
findMethod(Class<?>, String) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Attempt to find a `Method` on the supplied class with the supplied name and no parameters.
findMethod(Class<?>, String, Class<?>...) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
findOrder(Object) - 类 中的方法org.springframework.core.annotation.AnnotationAwareOrderComparator
  This implementation checks for `@Order` or `@Priority` on various kinds of elements, in addition to the `Ordered` check in the superclass.
findOrder(Object) - 类 中的方法org.springframework.core.OrderComparator
  Find an order value indicated by the given object.
findParameterIndex(Parameter) - 类 中的静态方法org.springframework.core.MethodParameter
findPathMatchingResources(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Find all resources that match the given location pattern via the Ant-style PathMatcher.
findValueOfType(Collection<?>, Class<T>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Find a single value of the given type in the given Collection.
findValueOfType(Collection<?>, Class<?>[]) - 类 中的静态方法org.springframework.util.CollectionUtils
  Find a single value of one of the given types in the given Collection: searching the Collection for a value of the first type, then searching for a value of the second type, etc.
FixedBackOff - org.springframework.util.backoff中的类
  A simple `BackOff` implementation that provides a fixed interval between two attempts and a maximum number of retries.
FixedBackOff() - 类 的构造器org.springframework.util.backoff.FixedBackOff
  Create an instance with an interval of 5000L ms and an unlimited number of attempts.
FixedBackOff(long, long) - 类 的构造器org.springframework.util.backoff.FixedBackOff
  Create an instance.
FLOAD - 接口 中的静态变量org.springframework.asm.Opcodes
FLOAT - 接口 中的静态变量org.springframework.asm.Opcodes
FLOAT - 类 中的静态变量org.springframework.asm.Type
  The sort of the `float` type.
FLOAT_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `float` type.
flush() - 类 中的方法org.springframework.util.CommonsLogWriter
FMUL - 接口 中的静态变量org.springframework.asm.Opcodes
FNEG - 接口 中的静态变量org.springframework.asm.Opcodes
forAnnotations(Annotation...) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Build an adapted `AnnotatedElement` for the given annotations, typically for use with other methods on `AnnotatedElementUtils`.
forArrayComponent(ResolvableType) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` as a array of the specified `componentType`.
forClass(Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks.
forClass(Class<?>, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified base type (interface or base class) with a given implementation class.
forClassWithGenerics(Class<?>, Class<?>...) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Class` with pre-declared generics.
forClassWithGenerics(Class<?>, ResolvableType...) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Class` with pre-declared generics.
forConstructorParameter(Constructor<?>, int) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Constructor` parameter.
forConstructorParameter(Constructor<?>, int, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Constructor` parameter with a given implementation.
forExecutable(Executable, int) - 类 中的静态方法org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new SynthesizingMethodParameter for the given method or constructor.
forExecutable(Executable, int) - 类 中的静态方法org.springframework.core.MethodParameter
  Create a new MethodParameter for the given method or constructor.
forField(Field) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Field`.
forField(Field, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Field` with a given implementation.
forField(Field, ResolvableType) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Field` with a given implementation.
forField(Field, int) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Field` with the given nesting level.
forField(Field, int, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Field` with a given implementation and the given nesting level.
forInstance(Object) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified instance.
forMethodOrConstructor(Object, int) - 类 中的静态方法org.springframework.core.MethodParameter
  已过时。
  as of 5.0, in favor of `MethodParameter.forExecutable(java.lang.reflect.Executable, int)`
forMethodParameter(Method, int) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Method` parameter.
forMethodParameter(Method, int, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Method` parameter with a given implementation.
forMethodParameter(MethodParameter) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `MethodParameter`.
forMethodParameter(MethodParameter, ResolvableType) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
forMethodParameter(MethodParameter, Type) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
forMethodReturnType(Method) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Method` return type.
forMethodReturnType(Method, Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Method` return type.
forName(String, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Replacement for `Class.forName()` that also returns Class instances for primitives (e.g.
forObject(Object) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor for an object.
forParameter(Parameter) - 类 中的静态方法org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new SynthesizingMethodParameter for the given parameter descriptor.
forParameter(Parameter) - 类 中的静态方法org.springframework.core.MethodParameter
  Create a new MethodParameter for the given parameter descriptor.
forRawClass(Class<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Class`, doing assignability checks against the raw class only (analogous to `Class.isAssignableFrom(java.lang.Class<?>)`, which this serves as a wrapper for.
forType(Type) - 类 中的静态方法org.springframework.core.ParameterizedTypeReference
  Build a `ParameterizedTypeReference` wrapping the given type.
forType(Type) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Type`.
forType(Type, ResolvableType) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `Type` backed by the given owner type.
forType(ParameterizedTypeReference<?>) - 类 中的静态方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified `ParameterizedTypeReference`.
FREM - 接口 中的静态变量org.springframework.asm.Opcodes
FRETURN - 接口 中的静态变量org.springframework.asm.Opcodes
fromMap(Map<String, Object>) - 类 中的静态方法org.springframework.core.annotation.AnnotationAttributes
  Return an `AnnotationAttributes` instance based on the given map.
fromPublisher(Publisher<?>) - 类 中的方法org.springframework.core.ReactiveAdapter
  Adapt from the given Reactive Streams Publisher.
fromString(String) - 类 中的静态方法org.springframework.asm.TypePath
  Converts a type path in string form, in the format used by `TypePath.toString()`, into a TypePath object.
FSTORE - 接口 中的静态变量org.springframework.asm.Opcodes
FSUB - 接口 中的静态变量org.springframework.asm.Opcodes
FutureAdapter<T,S> - org.springframework.util.concurrent中的类
  Abstract class that adapts a `Future` parameterized over S into a `Future` parameterized over T.
FutureAdapter(Future<S>) - 类 的构造器org.springframework.util.concurrent.FutureAdapter
  Constructs a new `FutureAdapter` with the given adaptee.
fv - 类 中的变量org.springframework.asm.FieldVisitor
  The field visitor to which this visitor must delegate method calls.

## G

generateId() - 类 中的方法org.springframework.util.AlternativeJdkIdGenerator
generateId() - 接口 中的方法org.springframework.util.IdGenerator
  Generate a new identifier.
generateId() - 类 中的方法org.springframework.util.JdkIdGenerator
generateId() - 类 中的方法org.springframework.util.SimpleIdGenerator
generateMultipartBoundary() - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Generate a random MIME boundary as bytes, often used in multipart mime types.
generateMultipartBoundaryString() - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Generate a random MIME boundary as String, often used in multipart mime types.
GenericConversionService - org.springframework.core.convert.support中的类
  Base `ConversionService` implementation suitable for use in most environments.
GenericConversionService() - 类 的构造器org.springframework.core.convert.support.GenericConversionService
GenericConverter - org.springframework.core.convert.converter中的接口
  Generic converter interface for converting between two or more types.
GenericConverter.ConvertiblePair - org.springframework.core.convert.converter中的类
  Holder for a source-to-target class pair.
GenericTypeResolver - org.springframework.core中的类
  Helper class for resolving generic types against type variables.
GenericTypeResolver() - 类 的构造器org.springframework.core.GenericTypeResolver
get(String) - 类 中的方法org.springframework.core.env.MutablePropertySources
get(String) - 接口 中的方法org.springframework.core.env.PropertySources
  Return the property source with the given name, `null` if not found.
get(int) - 类 中的方法org.springframework.util.AutoPopulatingList
  Get the element at the supplied index, creating it if there is no element at that index.
get() - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
get(long, TimeUnit) - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
get() - 类 中的方法org.springframework.util.concurrent.FutureAdapter
get(long, TimeUnit) - 类 中的方法org.springframework.util.concurrent.FutureAdapter
get() - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
  Retrieve the value.
get(long, TimeUnit) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
  Retrieve the value.
get(Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
get() - 接口 中的方法org.springframework.util.ConcurrentReferenceHashMap.Reference
  Return the referenced entry, or `null` if the entry is no longer available.
get(Object) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
get(Object) - 类 中的方法org.springframework.util.LinkedMultiValueMap
getAccess() - 类 中的方法org.springframework.asm.ClassReader
  Returns the class's access flags (see `Opcodes`).
getActiveProfiles() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getActiveProfiles() - 接口 中的方法org.springframework.core.env.Environment
  Return the set of profiles explicitly made active for this environment.
getAdaptee() - 类 中的方法org.springframework.util.concurrent.FutureAdapter
  Returns the adaptee.
getAdapter(Class<?>) - 类 中的方法org.springframework.core.ReactiveAdapterRegistry
  Get the adapter for the given reactive type.
getAdapter(Class<?>, Object) - 类 中的方法org.springframework.core.ReactiveAdapterRegistry
  Get the adapter for the given reactive type.
getAliases(String) - 接口 中的方法org.springframework.core.AliasRegistry
  Return the aliases for the given name, if defined.
getAliases(String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
getAllAnnotationAttributes(AnnotatedElement, String) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the annotation attributes of all annotations of the specified `annotationName` in the annotation hierarchy above the supplied `AnnotatedElement` and store the results in a `MultiValueMap`.
getAllAnnotationAttributes(AnnotatedElement, String, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the annotation attributes of all annotations of the specified `annotationName` in the annotation hierarchy above the supplied `AnnotatedElement` and store the results in a `MultiValueMap`.
getAllAnnotationAttributes(String) - 接口 中的方法org.springframework.core.type.AnnotatedTypeMetadata
  Retrieve all attributes of all annotations of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation).
getAllAnnotationAttributes(String, boolean) - 接口 中的方法org.springframework.core.type.AnnotatedTypeMetadata
  Retrieve all attributes of all annotations of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation).
getAllAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAllAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAllAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getAllAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getAllAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getAllAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getAllAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getAllAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getAllDeclaredMethods(Class<?>) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Get all declared methods on the leaf class and all superclasses.
getAllInterfaces(Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given instance implements as an array, including ones implemented by superclasses.
getAllInterfacesAsSet(Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given instance implements as a Set, including ones implemented by superclasses.
getAllInterfacesForClass(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
getAllInterfacesForClass(Class<?>, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
getAllInterfacesForClassAsSet(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
getAllInterfacesForClassAsSet(Class<?>, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
getAllMergedAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get all annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
getAnnotatedElement() - 类 中的方法org.springframework.core.MethodParameter
  Return the wrapped annotated element.
getAnnotatedMethods(String) - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Retrieve the method metadata for all methods that are annotated (or meta-annotated) with the given annotation type.
getAnnotatedMethods(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAnnotatedMethods(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getAnnotation(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the `AnnotationAttributes` stored under the specified `attributeName`.
getAnnotation(String, Class<A>) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the annotation of type `annotationType` stored under the specified `attributeName`.
getAnnotation(Annotation, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get a single `Annotation` of `annotationType` from the supplied annotation: either the given annotation itself or a direct meta-annotation thereof.
getAnnotation(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get a single `Annotation` of `annotationType` from the supplied `AnnotatedElement`, where the annotation is either present or meta-present on the `AnnotatedElement`.
getAnnotation(Method, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get a single `Annotation` of `annotationType` from the supplied `Method`, where the annotation is either present or meta-present on the method.
getAnnotation(Class<T>) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Obtain the annotation of the specified `annotationType` that is on this type descriptor.
getAnnotationArray(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the array of `AnnotationAttributes` stored under the specified `attributeName`.
getAnnotationArray(String, Class<A>) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the array of type `annotationType` stored under the specified `attributeName`.
getAnnotationAttributes(Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the given annotation's attributes as a `Map`, preserving all attribute types.
getAnnotationAttributes(Annotation, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the given annotation's attributes as a `Map`.
getAnnotationAttributes(Annotation, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
getAnnotationAttributes(AnnotatedElement, Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
getAnnotationAttributes(AnnotatedElement, Annotation, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
getAnnotationAttributes(String) - 接口 中的方法org.springframework.core.type.AnnotatedTypeMetadata
  Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation), also taking attribute overrides on composed annotations into account.
getAnnotationAttributes(String, boolean) - 接口 中的方法org.springframework.core.type.AnnotatedTypeMetadata
  Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation), also taking attribute overrides on composed annotations into account.
getAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getAnnotationAttributes(String) - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getAnnotationAttributes(String, boolean) - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getAnnotationMetadata() - 接口 中的方法org.springframework.core.type.classreading.MetadataReader
  Read full annotation metadata for the underlying class, including metadata for annotated methods.
getAnnotations(AnnotatedElement) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get all `Annotations` that are present on the supplied `AnnotatedElement`.
getAnnotations(Method) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get all `Annotations` that are present on the supplied `Method`.
getAnnotations() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Return the annotations associated with this type descriptor, if any.
getAnnotationType() - 类 中的方法org.springframework.core.type.filter.AnnotationTypeFilter
  Return the `Annotation` that this instance is using to filter candidates.
getAnnotationTypes() - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Get the fully qualified class names of all annotation types that are present on the underlying class.
getAnnotationTypes() - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getAnnotationTypes() - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getArguments() - 类 中的方法org.springframework.util.MethodInvoker
  Return the arguments for the method invocation.
getArgumentsAndReturnSizes(String) - 类 中的静态方法org.springframework.asm.Type
  Computes the size of the arguments and of the return value of a method.
getArgumentsAndReturnSizes() - 类 中的方法org.springframework.asm.Type
  Returns the size of the arguments and of the return value of methods of this type.
getArgumentTypes(String) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java types corresponding to the argument types of the given method descriptor.
getArgumentTypes(Method) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java types corresponding to the argument types of the given method.
getArgumentTypes() - 类 中的方法org.springframework.asm.Type
  Returns the argument types of methods of this type.
getAsText() - 类 中的方法org.springframework.core.convert.support.ConvertingPropertyEditorAdapter
getAsText() - 类 中的方法org.springframework.core.io.ResourceEditor
getAttribute(String) - 接口 中的方法org.springframework.core.AttributeAccessor
  Get the value of the attribute identified by `name`.
getAttribute(String) - 类 中的方法org.springframework.core.AttributeAccessorSupport
getBoolean(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as a boolean.
getBoundPrefixes() - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Return all declared prefixes.
getByte(int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Read a single byte at the given index from this data buffer.
getByte(int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
getByte(int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
getByteArray() - 类 中的方法org.springframework.core.io.ByteArrayResource
  Return the underlying byte array.
getByteBufAllocator() - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
  Return the `ByteBufAllocator` used by this factory.
getCacheLimit() - 类 中的方法org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Return the maximum number of entries for the MetadataReader cache.
getCharset() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Return the `Charset` to use for reading from the resource, or `null` if none specified.
getCharset() - 类 中的方法org.springframework.util.MimeType
  Return the character set, as indicated by a `charset` parameter, if any.
getChildElementByTagName(Element, String) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Utility method that returns the first child element identified by its name.
getChildElements(Element) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Retrieves all child elements of the given DOM element
getChildElementsByTagName(Element, String...) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Retrieves all child elements of the given DOM element that match any of the given element names.
getChildElementsByTagName(Element, String) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Retrieves all child elements of the given DOM element that match the given element name.
getChildElementValueByTagName(Element, String) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Utility method that returns the first child element value identified by its name.
getClass(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as a class.
getClassArray(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as an array of classes.
getClassFileName(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine the name of the class file, relative to the containing package: e.g.
getClassLoader() - 类 中的方法org.springframework.asm.ClassWriter
getClassLoader() - 类 中的方法org.springframework.core.io.ClassPathResource
  Return the ClassLoader that this resource will be obtained from.
getClassLoader() - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Return the ClassLoader to load class path resources with.
getClassLoader() - 接口 中的方法org.springframework.core.io.ResourceLoader
  Expose the ClassLoader used by this ResourceLoader.
getClassLoader() - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
getClassMetadata() - 接口 中的方法org.springframework.core.type.classreading.MetadataReader
  Read basic class metadata for the underlying class.
getClassName() - 类 中的方法org.springframework.asm.ClassReader
  Returns the internal name of the class (see `getInternalName`).
getClassName() - 类 中的方法org.springframework.asm.Type
  Returns the binary name of the class corresponding to this type.
getClassName() - 类 中的方法org.springframework.core.Constants
  Return the name of the analyzed class.
getClassName() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return the name of the underlying class.
getClassName() - 类 中的方法org.springframework.core.type.StandardClassMetadata
getCommonSuperClass(String, String) - 类 中的方法org.springframework.asm.ClassWriter
  Returns the common super type of the two given types.
getComparatorCount() - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Returns the number of aggregated comparators.
getComponentType() - 类 中的方法org.springframework.core.ResolvableType
  Return the ResolvableType representing the component type of the array or `ResolvableType.NONE` if this type does not represent an array.
getConcurrencyLimit() - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Return the maximum number of parallel accesses allowed.
getConcurrencyLimit() - 类 中的方法org.springframework.util.ConcurrencyThrottleSupport
  Return the maximum number of concurrent access attempts allowed.
getConstructor() - 类 中的方法org.springframework.core.MethodParameter
  Return the wrapped Constructor, if any.
getConstructorDescriptor(Constructor<?>) - 类 中的静态方法org.springframework.asm.Type
  Returns the descriptor corresponding to the given constructor.
getConstructorIfAvailable(Class<T>, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given class has a public constructor with the given signature, and return it if available (else return `null`).
getContainingClass() - 类 中的方法org.springframework.core.MethodParameter
getContentLength(T, MimeType) - 接口 中的方法org.springframework.core.codec.Encoder
  已过时。
  this method was added so `EncoderHttpMessageWriter` can set the content-length header. However after further improvements as of 5.0.7, it is no longer needed, and not used.
getConversionService() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getConversionService() - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getConversionService() - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Return the `ConfigurableConversionService` used when performing type conversions on properties.
getConverter(Class<T>) - 接口 中的方法org.springframework.core.convert.converter.ConverterFactory
  Get the converter to convert from S to target type T, where T is also an instance of R.
getConverter(TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
  Hook method to lookup the converter for a given sourceType/targetType pair.
getConvertibleTypes() - 接口 中的方法org.springframework.core.convert.converter.GenericConverter
  Return the source and target types that this converter can convert between.
getCount() - 类 中的方法org.springframework.core.io.support.ResourceRegion
  Return the byte count of this region in the underlying `Resource`
getCount() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
  Return the total number of references in this segment.
getDeclaredRepeatableAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.
getDeclaredRepeatableAnnotations(AnnotatedElement, Class<A>, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get the declared repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either directly present, indirectly present, or meta-present on the element.
getDeclaringClass() - 类 中的方法org.springframework.core.MethodParameter
  Return the class that declares the underlying Method or Constructor.
getDeclaringClassName() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getDeclaringClassName() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return the fully-qualified name of the class that declares this method.
getDeclaringClassName() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getDecodableMimeTypes() - 类 中的方法org.springframework.core.codec.AbstractDecoder
getDecodableMimeTypes() - 接口 中的方法org.springframework.core.codec.Decoder
  Return the list of MIME types this decoder supports.
getDecoratedClass() - 接口 中的方法org.springframework.core.DecoratingProxy
  Return the (ultimate) decorated class behind this proxy.
getDefaultClassLoader() - 类 中的静态方法org.springframework.util.ClassUtils
  Return the default ClassLoader to use: typically the thread context ClassLoader, if available; the ClassLoader that loaded the ClassUtils class will be used as fallback.
getDefaultConverter(TypeDescriptor, TypeDescriptor) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
  Return the default converter if no converter is found for the given sourceType/targetType pair.
getDefaultProfiles() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getDefaultProfiles() - 接口 中的方法org.springframework.core.env.Environment
  Return the set of profiles to be active by default when no active profiles have been set explicitly.
getDefaultThreadNamePrefix() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Build the default thread name prefix for this factory.
getDefaultValue(Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the default value of the `value` attribute of a single-element Annotation, given an annotation instance.
getDefaultValue(Annotation, String) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the default value of a named attribute, given an annotation instance.
getDefaultValue(Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the default value of the `value` attribute of a single-element Annotation, given the `annotation type`.
getDefaultValue(Class<? extends Annotation>, String) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the default value of a named attribute, given the `annotation type`.
getDesc() - 类 中的方法org.springframework.asm.Handle
  Returns the descriptor of the field or method designated by this handle.
getDescription() - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation returns a description that includes the passed-in `description`, if any.
getDescription() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation returns a description that includes the class path location.
getDescription() - 类 中的方法org.springframework.core.io.DescriptiveResource
getDescription() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns a description that includes the absolute path of the file.
getDescription() - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation returns a description that includes the passed-in description, if any.
getDescription() - 类 中的方法org.springframework.core.io.PathResource
getDescription() - 接口 中的方法org.springframework.core.io.Resource
  Return a description for this resource, to be used for error output when working with the resource.
getDescription() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns a description that includes the URL.
getDescription() - 类 中的方法org.springframework.core.io.VfsResource
getDescriptiveType(Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
getDescriptor() - 类 中的方法org.springframework.asm.Type
  Returns the descriptor corresponding to this Java type.
getDescriptor(Class<?>) - 类 中的静态方法org.springframework.asm.Type
  Returns the descriptor corresponding to the given Java type.
getDescriptor() - 类 中的方法org.springframework.core.ReactiveAdapter
  Return the descriptor of the reactive type for the adapter.
getDimensions() - 类 中的方法org.springframework.asm.Type
  Returns the number of dimensions of this array type.
getDisplayString(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a content-based String representation if `obj` is not `null`; otherwise returns an empty String.
getElementType() - 类 中的方法org.springframework.asm.Type
  Returns the type of the elements of this array type.
getElementTypeDescriptor() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is an array, returns the array's component type.
getEmptyValue() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
  Return an empty-value instance for the underlying reactive or async type.
getEnclosingClassName() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return the name of the enclosing class of the underlying class, or `null` if the underlying class is a top-level class.
getEnclosingClassName() - 类 中的方法org.springframework.core.type.StandardClassMetadata
getEncodableMimeTypes() - 类 中的方法org.springframework.core.codec.AbstractEncoder
getEncodableMimeTypes() - 接口 中的方法org.springframework.core.codec.Encoder
  Return the list of mime types this encoder supports.
getEncoding() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Return the encoding to use for reading from the resource, or `null` if none specified.
getEnum(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as an enum.
getEnvironment() - 接口 中的方法org.springframework.core.env.EnvironmentCapable
  Return the `Environment` associated with this component.
getExceptionIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the exception, in a 'throws' clause of a method, whose type is referenced by this type reference.
getExecutable() - 类 中的方法org.springframework.core.MethodParameter
  Return the wrapped executable.
getFallbackClassLoader() - 类 中的方法org.springframework.core.ConfigurableObjectInputStream
  Return the fallback ClassLoader to use when no ClassLoader was specified and ObjectInputStream's own default class loader failed.
GETFIELD - 接口 中的静态变量org.springframework.asm.Opcodes
getField(Field, Object) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Get the field represented by the supplied `field object` on the specified `target object`.
getFieldCache() - 类 中的方法org.springframework.core.Constants
  Exposes the field cache to subclasses: a Map from String field name to object value.
getFile() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  This implementation returns a File reference for the underlying class path resource, provided that it refers to a file in the file system.
getFile(URI) - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  This implementation returns a File reference for the given URI-identified resource, provided that it refers to a file in the file system.
getFile() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation throws a FileNotFoundException, assuming that the resource cannot be resolved to an absolute file path.
getFile() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns the underlying File reference.
getFile() - 类 中的方法org.springframework.core.io.FileUrlResource
getFile() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns the underlying File reference.
getFile() - 接口 中的方法org.springframework.core.io.Resource
  Return a File handle for this resource.
getFile() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns a File reference for the underlying URL/URI, provided that it refers to a file in the file system.
getFile() - 类 中的方法org.springframework.core.io.VfsResource
getFile(String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource location to a `java.io.File`, i.e. to a file in the file system.
getFile(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource URL to a `java.io.File`, i.e. to a file in the file system.
getFile(URL, String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource URL to a `java.io.File`, i.e. to a file in the file system.
getFile(URI) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource URI to a `java.io.File`, i.e. to a file in the file system.
getFile(URI, String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource URI to a `java.io.File`, i.e. to a file in the file system.
getFileForLastModifiedCheck() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  This implementation determines the underlying File (or jar file, in case of a resource in a jar/zip).
getFileForLastModifiedCheck() - 类 中的方法org.springframework.core.io.AbstractResource
  Determine the File to use for timestamp checking.
getFilename() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation always returns `null`, assuming that this resource type does not have a filename.
getFilename() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation returns the name of the file that this class path resource refers to.
getFilename() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns the name of the file.
getFilename() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns the name of the file.
getFilename() - 接口 中的方法org.springframework.core.io.Resource
  Determine a filename for this resource, i.e. typically the last part of the path: for example, "myfile.txt".
getFilename() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns the name of the file that this URL refers to.
getFilename() - 类 中的方法org.springframework.core.io.VfsResource
getFilename(String) - 类 中的静态方法org.springframework.util.StringUtils
  Extract the filename from the given Java resource path, e.g.
getFilenameExtension(String) - 类 中的静态方法org.springframework.util.StringUtils
  Extract the filename extension from the given Java resource path, e.g.
getFirst(K) - 类 中的方法org.springframework.util.LinkedMultiValueMap
getFirst(K) - 接口 中的方法org.springframework.util.MultiValueMap
  Return the first value for the given key.
getFlag(String) - 类 中的静态方法org.springframework.core.SpringProperties
  Retrieve the flag for the given property key.
getFormalParameterIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the formal parameter whose type is referenced by this type reference.
getGeneric(int...) - 类 中的方法org.springframework.core.ResolvableType
  Return a `ResolvableType` representing the generic parameter for the given indexes.
getGenericParameterType() - 类 中的方法org.springframework.core.MethodParameter
  Return the generic type of the method/constructor parameter.
getGenerics() - 类 中的方法org.springframework.core.ResolvableType
  Return an array of `ResolvableType`s representing the generic parameters of this type.
getHash(Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
  Get the hash for a given object, apply an additional hash function to reduce collisions.
getHash() - 接口 中的方法org.springframework.util.ConcurrentReferenceHashMap.Reference
  Return the hash for the reference.
getId() - 类 中的方法org.springframework.util.StopWatch
  Return the id of this stop watch, as specified on construction.
getIdentityHexString(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hex String form of an object's identity hash code.
getInitialInterval() - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  Return the initial interval in milliseconds.
getInputStream() - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation returns a ByteArrayInputStream for the underlying byte array.
getInputStream() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation opens an InputStream for the given class path resource.
getInputStream() - 类 中的方法org.springframework.core.io.DescriptiveResource
getInputStream() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation opens a NIO file stream for the underlying file.
getInputStream() - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation throws IllegalStateException if attempting to read the underlying stream multiple times.
getInputStream() - 接口 中的方法org.springframework.core.io.InputStreamSource
  Return an `InputStream` for the content of an underlying resource.
getInputStream() - 类 中的方法org.springframework.core.io.PathResource
  This implementation opens a InputStream for the underlying file.
getInputStream() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Open an `InputStream` for the specified resource, ignoring any specified `Charset` or encoding.
getInputStream() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation opens an InputStream for the given URL.
getInputStream() - 类 中的方法org.springframework.core.io.VfsResource
getInputStream() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Get an `InputStream` to retrieve the data in this OutputStream.
getInstantiatorOf(Class<T>) - 类 中的方法org.springframework.objenesis.SpringObjenesis
getInterfaceNames() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return the names of all interfaces that the underlying class implements, or an empty array if there are none.
getInterfaceNames() - 类 中的方法org.springframework.core.type.StandardClassMetadata
getInterfaces() - 类 中的方法org.springframework.asm.ClassReader
  Returns the internal names of the class's interfaces (see `getInternalName`).
getInterfaces() - 类 中的方法org.springframework.core.ResolvableType
  Return a `ResolvableType` array representing the direct interfaces implemented by this type.
getInternalName() - 类 中的方法org.springframework.asm.Type
  Returns the internal name of the class corresponding to this object or array type.
getInternalName(Class<?>) - 类 中的静态方法org.springframework.asm.Type
  Returns the internal name of the given class.
getInterval() - 类 中的方法org.springframework.util.backoff.FixedBackOff
  Return the interval between two attempts in milliseconds.
getIntrospectedClass() - 类 中的方法org.springframework.core.type.StandardClassMetadata
  Return the underlying Class.
getIntrospectedMethod() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
  Return the underlying Method.
getItem(int) - 类 中的方法org.springframework.asm.ClassReader
  Returns the start index of the constant pool item in `b`, plus one.
getItemCount() - 类 中的方法org.springframework.asm.ClassReader
  Returns the number of constant pool items in `b`.
getJarFile(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Resolve the given jar file URL into a JarFile object.
getKey() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
getLabels() - 类 中的方法org.springframework.asm.Attribute
  Returns the labels corresponding to this attribute.
getLastTaskInfo() - 类 中的方法org.springframework.util.StopWatch
  Return the last task as a TaskInfo object.
getLastTaskName() - 类 中的方法org.springframework.util.StopWatch
  Return the name of the last task.
getLastTaskTimeMillis() - 类 中的方法org.springframework.util.StopWatch
  Return the time taken by the last task.
getLength() - 类 中的方法org.springframework.asm.TypePath
  Returns the length of this path.
getLoadFactor() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
getLocale() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
  Return the locale used by this `LinkedCaseInsensitiveMap`.
getMapKeyTypeDescriptor() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is a `Map` and its key type is parameterized, returns the map's key type.
getMapKeyTypeDescriptor(Object) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is a `Map`, creates a mapKey `TypeDescriptor` from the provided map key.
getMapValueTypeDescriptor() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is a `Map` and its value type is parameterized, returns the map's value type.
getMapValueTypeDescriptor(Object) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  If this type is a `Map`, creates a mapValue `TypeDescriptor` from the provided map value.
getMaxAttempts() - 类 中的方法org.springframework.util.backoff.FixedBackOff
  Return the maximum number of attempts in milliseconds.
getMaxElapsedTime() - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  Return the maximum elapsed time in milliseconds after which a call to `BackOffExecution.nextBackOff()` returns `BackOffExecution.STOP`.
getMaxInterval() - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  Return the maximum back off time.
getMaxStringLength() - 类 中的方法org.springframework.asm.ClassReader
  Returns the maximum length of the strings contained in the constant pool of the class.
getMember() - 类 中的方法org.springframework.core.MethodParameter
  Return the wrapped member.
getMemberClassNames() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return the names of all classes declared as members of the class represented by this ClassMetadata object.
getMemberClassNames() - 类 中的方法org.springframework.core.type.StandardClassMetadata
getMergedAnnotation(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element`, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy, and synthesize the result back into an annotation of the specified `annotationType`.
getMergedAnnotationAttributes(AnnotatedElement, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the first annotation of the specified `annotationType` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
getMergedAnnotationAttributes(AnnotatedElement, String) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
getMergedAnnotationAttributes(AnnotatedElement, String, boolean, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the first annotation of the specified `annotationName` within the annotation hierarchy above the supplied `element` and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
getMergedRepeatableAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
getMergedRepeatableAnnotations(AnnotatedElement, Class<A>, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get all repeatable annotations of the specified `annotationType` within the annotation hierarchy above the supplied `element`; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified `annotationType`.
getMessage() - 异常错误 中的方法org.springframework.core.env.MissingRequiredPropertiesException
getMessage() - 异常错误 中的方法org.springframework.core.NestedCheckedException
  Return the detail message, including the message from the nested exception if there is one.
getMessage() - 异常错误 中的方法org.springframework.core.NestedIOException
  Return the detail message, including the message from the nested exception if there is one.
getMessage() - 异常错误 中的方法org.springframework.core.NestedRuntimeException
  Return the detail message, including the message from the nested exception if there is one.
getMetaAnnotationTypes(AnnotatedElement, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the fully qualified class names of all meta-annotation types present on the annotation (of the specified `annotationType`) on the supplied `AnnotatedElement`.
getMetaAnnotationTypes(AnnotatedElement, String) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Get the fully qualified class names of all meta-annotation types present on the annotation (of the specified `annotationName`) on the supplied `AnnotatedElement`.
getMetaAnnotationTypes(String) - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Get the fully qualified class names of all meta-annotation types that are present on the given annotation type on the underlying class.
getMetaAnnotationTypes(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
getMetaAnnotationTypes(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
getMetadataReader(Resource) - 类 中的方法org.springframework.core.type.classreading.CachingMetadataReaderFactory
getMetadataReader(String) - 接口 中的方法org.springframework.core.type.classreading.MetadataReaderFactory
  Obtain a MetadataReader for the given class name.
getMetadataReader(Resource) - 接口 中的方法org.springframework.core.type.classreading.MetadataReaderFactory
  Obtain a MetadataReader for the given resource.
getMetadataReader(String) - 类 中的方法org.springframework.core.type.classreading.SimpleMetadataReaderFactory
getMetadataReader(Resource) - 类 中的方法org.springframework.core.type.classreading.SimpleMetadataReaderFactory
getMethod() - 类 中的方法org.springframework.core.MethodParameter
  Return the wrapped Method, if any.
getMethod(Class<?>, String, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given class has a public method with the given signature, and return it if available (else throws an `IllegalStateException`).
getMethodAnnotation(Class<A>) - 类 中的方法org.springframework.core.MethodParameter
  Return the method/constructor annotation of the given type, if available.
getMethodAnnotations() - 类 中的方法org.springframework.core.MethodParameter
  Return the annotations associated with the target method/constructor itself.
getMethodCountForName(Class<?>, String) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the number of methods with a given name (with any argument types), for the given class and/or its superclasses.
getMethodDescriptor(Type, Type...) - 类 中的静态方法org.springframework.asm.Type
  Returns the descriptor corresponding to the given argument and return types.
getMethodDescriptor(Method) - 类 中的静态方法org.springframework.asm.Type
  Returns the descriptor corresponding to the given method.
getMethodIfAvailable(Class<?>, String, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
getMethodName() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getMethodName() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return the name of the method.
getMethodName() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getMethodType(String) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the given method descriptor.
getMethodType(Type, Type...) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java method type corresponding to the given argument and return types.
getMimeType() - 异常错误 中的方法org.springframework.util.InvalidMimeTypeException
  Return the offending content type.
getMissingRequiredProperties() - 异常错误 中的方法org.springframework.core.env.MissingRequiredPropertiesException
  Return the set of properties marked as required but not present upon validation.
getMostSpecificCause() - 异常错误 中的方法org.springframework.core.NestedCheckedException
  Retrieve the most specific cause of this exception, that is, either the innermost cause (root cause) or this exception itself.
getMostSpecificCause(Throwable) - 类 中的静态方法org.springframework.core.NestedExceptionUtils
  Retrieve the most specific cause of the given exception, that is, either the innermost cause (root cause) or the exception itself.
getMostSpecificCause() - 异常错误 中的方法org.springframework.core.NestedRuntimeException
  Retrieve the most specific cause of this exception, that is, either the innermost cause (root cause) or this exception itself.
getMostSpecificMethod(Method, Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Given a method, which may come from an interface, and a target class used in the current reflective invocation, find the corresponding target method if there is one.
getMultiplier() - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  Return the value to multiply the current interval by for each retry attempt.
getName() - 类 中的方法org.springframework.asm.Handle
  Returns the name of the field or method designated by this handle.
getName() - 类 中的方法org.springframework.core.convert.Property
  The name of the property: e.g.
getName() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Return the name of this type: the fully qualified class name.
getName() - 类 中的方法org.springframework.core.env.PropertySource
  Return the name of this `PropertySource`
getNames(String) - 类 中的方法org.springframework.core.Constants
  Return all names of the given group of constants.
getNamesForProperty(String) - 类 中的方法org.springframework.core.Constants
  Return all names of the group of constants for the given bean property name.
getNamesForSuffix(String) - 类 中的方法org.springframework.core.Constants
  Return all names of the given group of constants.
getNamespaceURI(String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
getNativeBuffer() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
  Directly exposes the native `ByteBuffer` that this buffer is based on.
getNativeBuffer() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
  Directly exposes the native `ByteBuf` that this buffer is based on.
getNested(int) - 类 中的方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified nesting level.
getNested(int, Map<Integer, Integer>) - 类 中的方法org.springframework.core.ResolvableType
  Return a `ResolvableType` for the specified nesting level.
getNestedGenericParameterType() - 类 中的方法org.springframework.core.MethodParameter
  Return the nested generic type of the method/constructor parameter.
getNestedParameterType() - 类 中的方法org.springframework.core.MethodParameter
  Return the nested type of the method/constructor parameter.
getNestingLevel() - 类 中的方法org.springframework.core.MethodParameter
  Return the nesting level of the target type (typically 1; e.g. in case of a List of Lists, 1 would indicate the nested List, whereas 2 would indicate the element of the nested List).
getNext() - 接口 中的方法org.springframework.util.ConcurrentReferenceHashMap.Reference
  Return the next reference in the chain, or `null` if none.
getNonOptionArgs() - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  Return the collection of non-option arguments parsed from the command line.
getNonOptionArgs() - 类 中的方法org.springframework.core.env.JOptCommandLinePropertySource
getNonOptionArgs() - 类 中的方法org.springframework.core.env.SimpleCommandLinePropertySource
getNumber(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as a number.
getObjectType(String) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the given internal name.
getObjectType() - 类 中的方法org.springframework.core.convert.Property
  The object declaring this property, either directly or in a superclass the object extends.
getObjectType() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Variation of `TypeDescriptor.getType()` that accounts for a primitive type by returning its object wrapper type.
getOffset() - 类 中的方法org.springframework.asm.Label
  Returns the offset corresponding to this label.
getOpcode(int) - 类 中的方法org.springframework.asm.Type
  Returns a JVM instruction opcode adapted to this Java type.
getOptionValues(String) - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  Return the collection of values associated with the command line option having the given name.
getOptionValues(String) - 类 中的方法org.springframework.core.env.JOptCommandLinePropertySource
getOptionValues(String) - 类 中的方法org.springframework.core.env.SimpleCommandLinePropertySource
getOrDefault(Object, V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
getOrDefault(Object, V) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
getOrder(Class<?>, int) - 类 中的静态方法org.springframework.core.annotation.OrderUtils
  Return the order on the specified `type`, or the specified default value if none can be found.
getOrder(Class<?>, Integer) - 类 中的静态方法org.springframework.core.annotation.OrderUtils
  Return the order on the specified `type`, or the specified default value if none can be found.
getOrder(Class<?>) - 类 中的静态方法org.springframework.core.annotation.OrderUtils
  Return the order on the specified `type`.
getOrder(Object) - 类 中的方法org.springframework.core.OrderComparator
  Determine the order value for the given object.
getOrder() - 接口 中的方法org.springframework.core.Ordered
  Get the order value of this object.
getOrderSource(Object) - 接口 中的方法org.springframework.core.OrderComparator.OrderSourceProvider
  Return an order source for the specified object, i.e. an object that should be checked for an order value as a replacement to the given object.
getOutputStream() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation opens a FileOutputStream for the underlying file.
getOutputStream() - 类 中的方法org.springframework.core.io.FileUrlResource
getOutputStream() - 类 中的方法org.springframework.core.io.PathResource
  This implementation opens a OutputStream for the underlying file.
getOutputStream() - 接口 中的方法org.springframework.core.io.WritableResource
  Return an `OutputStream` for the underlying resource, allowing to (over-)write its content.
getOwner() - 类 中的方法org.springframework.asm.Handle
  Returns the internal name of the class that owns the field or method designated by this handle.
getPackageName(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine the name of the package of the given class, e.g.
getPackageName(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine the name of the package of the given fully-qualified class name, e.g.
getParameter() - 类 中的方法org.springframework.core.MethodParameter
  Return the `Parameter` descriptor for method/constructor parameter.
getParameter(String) - 类 中的方法org.springframework.util.MimeType
  Return a generic parameter value, given a parameter name.
getParameterAnnotation(Class<A>) - 类 中的方法org.springframework.core.MethodParameter
  Return the parameter annotation of the given type, if available.
getParameterAnnotations() - 类 中的方法org.springframework.core.MethodParameter
  Return the annotations associated with the specific method/constructor parameter.
getParameterIndex() - 类 中的方法org.springframework.core.MethodParameter
  Return the index of the method/constructor parameter.
getParameterName() - 类 中的方法org.springframework.core.MethodParameter
  Return the name of the method/constructor parameter.
getParameterNames(Method) - 类 中的方法org.springframework.core.KotlinReflectionParameterNameDiscoverer
getParameterNames(Constructor<?>) - 类 中的方法org.springframework.core.KotlinReflectionParameterNameDiscoverer
getParameterNames(Method) - 类 中的方法org.springframework.core.LocalVariableTableParameterNameDiscoverer
getParameterNames(Constructor<?>) - 类 中的方法org.springframework.core.LocalVariableTableParameterNameDiscoverer
getParameterNames(Method) - 接口 中的方法org.springframework.core.ParameterNameDiscoverer
  Return parameter names for a method, or `null` if they cannot be determined.
getParameterNames(Constructor<?>) - 接口 中的方法org.springframework.core.ParameterNameDiscoverer
  Return parameter names for a constructor, or `null` if they cannot be determined.
getParameterNames(Method) - 类 中的方法org.springframework.core.PrioritizedParameterNameDiscoverer
getParameterNames(Constructor<?>) - 类 中的方法org.springframework.core.PrioritizedParameterNameDiscoverer
getParameterNames(Method) - 类 中的方法org.springframework.core.StandardReflectionParameterNameDiscoverer
getParameterNames(Constructor<?>) - 类 中的方法org.springframework.core.StandardReflectionParameterNameDiscoverer
getParameters() - 类 中的方法org.springframework.util.MimeType
  Return all generic parameter values.
getParameterType() - 类 中的方法org.springframework.core.MethodParameter
  Return the type of the method/constructor parameter.
getPath() - 类 中的方法org.springframework.core.io.ClassPathResource
  Return the path for this resource (as resource path within the class path).
getPath() - 类 中的方法org.springframework.core.io.FileSystemResource
  Return the file path for this resource.
getPath() - 类 中的方法org.springframework.core.io.PathResource
  Return the file path for this resource.
getPathMatcher() - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Return the PathMatcher that this resource pattern resolver uses.
getPathWithinContext() - 接口 中的方法org.springframework.core.io.ContextResource
  Return the path within the enclosing 'context'.
getPathWithinContext() - 类 中的方法org.springframework.core.io.DefaultResourceLoader.ClassPathContextResource
getPatternComparator(String) - 类 中的方法org.springframework.util.AntPathMatcher
  Given a full path, returns a `Comparator` suitable for sorting patterns in order of explicitness.
getPatternComparator(String) - 接口 中的方法org.springframework.util.PathMatcher
  Given a full path, returns a `Comparator` suitable for sorting patterns in order of explicitness for that path.
getPosition() - 类 中的方法org.springframework.core.io.support.ResourceRegion
  Return the start position of this region in the underlying `Resource`
getPrefix(String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
getPrefixes(String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
getPreparedMethod() - 类 中的方法org.springframework.util.MethodInvoker
  Return the prepared Method object that will be invoked.
getPriority(Object) - 类 中的方法org.springframework.core.annotation.AnnotationAwareOrderComparator
  This implementation retrieves an @`Priority` value, allowing for additional semantics over the regular @`Order` annotation: typically, selecting one object over another in case of multiple matches but only one object to be returned.
getPriority(Class<?>) - 类 中的静态方法org.springframework.core.annotation.OrderUtils
  Return the value of the `javax.annotation.Priority` annotation declared on the specified type, or `null` if none.
getPriority(Object) - 类 中的方法org.springframework.core.OrderComparator
  Determine a priority value for the given object, if any.
getProperty(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getProperty(String, String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getProperty(String, Class<T>) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getProperty(String, Class<T>, T) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getProperty(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getProperty(String, String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getProperty(String, Class<T>, T) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getProperty(String) - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  This implementation first checks to see if the name specified is the special "non-option arguments" property, and if so delegates to the abstract `CommandLinePropertySource.getNonOptionArgs()` method.
getProperty(String) - 类 中的方法org.springframework.core.env.CompositePropertySource
getProperty(String) - 类 中的方法org.springframework.core.env.MapPropertySource
getProperty(String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key, or `null` if the key cannot be resolved.
getProperty(String, String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
getProperty(String, Class<T>) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key, or `null` if the key cannot be resolved.
getProperty(String, Class<T>, T) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key, or `defaultValue` if the key cannot be resolved.
getProperty(String) - 类 中的方法org.springframework.core.env.PropertySource
  Return the value associated with the given name, or `null` if not found.
getProperty(String) - 类 中的方法org.springframework.core.env.PropertySource.StubPropertySource
  Always returns `null`.
getProperty(String) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
getProperty(String, Class<T>) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
getProperty(String, Class<T>, boolean) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
getProperty(String) - 类 中的方法org.springframework.core.env.SystemEnvironmentPropertySource
  This implementation returns `true` if a property with the given name or any underscore/uppercase variant thereof exists in this property source.
getProperty(String) - 类 中的静态方法org.springframework.core.SpringProperties
  Retrieve the property value for the given key, checking local Spring properties first and falling back to JVM-level system properties.
getPropertyAsRawString(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Retrieve the specified property as a raw String, i.e. without resolution of nested placeholders.
getPropertyAsRawString(String) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
getPropertyNames() - 类 中的方法org.springframework.core.env.CompositePropertySource
getPropertyNames() - 类 中的方法org.springframework.core.env.EnumerablePropertySource
  Return the names of all properties contained by the source object (never `null`).
getPropertyNames() - 类 中的方法org.springframework.core.env.JOptCommandLinePropertySource
getPropertyNames() - 类 中的方法org.springframework.core.env.MapPropertySource
getPropertyNames() - 类 中的方法org.springframework.core.env.PropertiesPropertySource
getPropertyNames() - 类 中的方法org.springframework.core.env.SimpleCommandLinePropertySource
  Get the property names for the option arguments.
getPropertySources() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getPropertySources() - 类 中的方法org.springframework.core.env.CompositePropertySource
  Return all property sources that this composite source holds.
getPropertySources() - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Return the `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.
getProtocolResolvers() - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Return the collection of currently registered protocol resolvers, allowing for introspection as well as modification.
getQualifiedAttributeName(Class<?>, String) - 类 中的静态方法org.springframework.core.Conventions
  Return an attribute name qualified by the given enclosing `Class`.
getQualifiedMethodName(Method) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
getQualifiedMethodName(Method, Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
getQualifiedName(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the qualified name of the given class: usually simply the class name, but component type class name + "[]" for arrays.
getRawClass() - 类 中的方法org.springframework.core.ResolvableType
  Return the underlying Java `Class` being managed, if available; otherwise `null`.
getReactiveType() - 类 中的方法org.springframework.core.ReactiveAdapter
  Shortcut for `getDescriptor().getReactiveType()`.
getReactiveType() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
  Return the reactive type for this descriptor.
getReader() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Open a `java.io.Reader` for the specified resource, using the specified `Charset` or encoding (if any).
getReadMethod() - 类 中的方法org.springframework.core.convert.Property
  The property getter method: e.g.
getReference(Object, ConcurrentReferenceHashMap.Restructure) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
  Return a `ConcurrentReferenceHashMap.Reference` to the `ConcurrentReferenceHashMap.Entry` for the specified `key`, or `null` if not found.
getReference(Object, int, ConcurrentReferenceHashMap.Restructure) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
getRepeatableAnnotations(AnnotatedElement, Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.
getRepeatableAnnotations(AnnotatedElement, Class<A>, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.
getRequiredProperty(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getRequiredProperty(String, Class<T>) - 类 中的方法org.springframework.core.env.AbstractEnvironment
getRequiredProperty(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getRequiredProperty(String, Class<T>) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
getRequiredProperty(String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key (never `null`).
getRequiredProperty(String, Class<T>) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Return the property value associated with the given key, converted to the given targetType (never `null`).
getReservedDefaultProfiles() - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Return the set of reserved default profile names.
getResolvableType() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Return the underlying `ResolvableType`.
getResolvableType() - 接口 中的方法org.springframework.core.ResolvableTypeProvider
  Return the `ResolvableType` describing this instance (or `null` if some sort of default should be applied instead).
getResource(String) - 类 中的方法org.springframework.core.io.DefaultResourceLoader
getResource(String) - 接口 中的方法org.springframework.core.io.ResourceLoader
  Return a Resource handle for the specified resource location.
getResource() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Return the `Resource` held by this `EncodedResource`.
getResource(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
getResource() - 类 中的方法org.springframework.core.io.support.ResourceRegion
  Return the underlying `Resource` for this `ResourceRegion`
getResource() - 接口 中的方法org.springframework.core.type.classreading.MetadataReader
  Return the resource reference for the class file.
getResourceByPath(String) - 类 中的方法org.springframework.core.io.ClassRelativeResourceLoader
getResourceByPath(String) - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Return a Resource handle for the resource at the given path.
getResourceByPath(String) - 类 中的方法org.springframework.core.io.FileSystemResourceLoader
  Resolve resource paths as file system paths.
getResourceCache(Class<T>) - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Obtain a cache for the given value type, keyed by `Resource`.
getResourceLoader() - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Return the ResourceLoader that this pattern resolver works with.
getResourceLoader() - 类 中的方法org.springframework.core.type.classreading.SimpleMetadataReaderFactory
  Return the ResourceLoader that this MetadataReaderFactory has been constructed with.
getResourcePatternResolver(ResourceLoader) - 类 中的静态方法org.springframework.core.io.support.ResourcePatternUtils
  Return a default `ResourcePatternResolver` for the given `ResourceLoader`.
getResources(String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
getResources(String) - 接口 中的方法org.springframework.core.io.support.ResourcePatternResolver
  Resolve the given location pattern into Resource objects.
getReturnType(String) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the return type of the given method descriptor.
getReturnType(Method) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the return type of the given method.
getReturnType() - 类 中的方法org.springframework.asm.Type
  Returns the return type of methods of this type.
getReturnTypeName() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
getReturnTypeName() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return the fully-qualified name of this method's declared return type.
getReturnTypeName() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
getRoot(URL) - 类 中的静态方法org.springframework.core.io.VfsUtils
getRootCause() - 异常错误 中的方法org.springframework.core.NestedCheckedException
  Retrieve the innermost cause of this exception, if any.
getRootCause(Throwable) - 类 中的静态方法org.springframework.core.NestedExceptionUtils
  Retrieve the innermost cause of the given exception, if any.
getRootCause() - 异常错误 中的方法org.springframework.core.NestedRuntimeException
  Retrieve the innermost cause of this exception, if any.
getSegment(int) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
getSegmentsSize() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
getSharedInstance() - 类 中的静态方法org.springframework.core.convert.support.DefaultConversionService
  Return a shared default `ConversionService` instance, lazily building it once needed.
getSharedInstance() - 类 中的静态方法org.springframework.core.ReactiveAdapterRegistry
  Return a shared default `ReactiveAdapterRegistry` instance, lazily building it once needed.
getShortName(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Get the class name without the qualified package name.
getShortName(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Get the class name without the qualified package name.
getShortNameAsProperty(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the short string name of a Java class in uncapitalized JavaBeans property format.
getSize() - 类 中的方法org.springframework.asm.Type
  Returns the size of values of this type.
getSize() - 类 中的方法org.springframework.core.Constants
  Return the number of constants exposed.
getSize() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
  Return the size of the current references array.
getSort() - 类 中的方法org.springframework.asm.Type
  Returns the sort of this Java type.
getSort() - 类 中的方法org.springframework.asm.TypeReference
  Returns the sort of this type reference.
getSource() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Return the underlying source of the descriptor.
getSource() - 类 中的方法org.springframework.core.env.PropertySource
  Return the underlying source object for this `PropertySource`.
getSource() - 类 中的方法org.springframework.core.ResolvableType
  Return the underlying source of the resolvable type.
getSourceType() - 异常错误 中的方法org.springframework.core.convert.ConversionFailedException
  Return the source type we tried to convert the value from.
getSourceType() - 类 中的方法org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
getSourceType() - 异常错误 中的方法org.springframework.core.convert.ConverterNotFoundException
  Return the source type that was requested to convert from.
GETSTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
getStaticMethod(Class<?>, String, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Return a public static method of a class.
getStep(int) - 类 中的方法org.springframework.asm.TypePath
  Returns the value of the given step of this path.
getStepArgument(int) - 类 中的方法org.springframework.asm.TypePath
  Returns the index of the type argument that the given step is stepping into.
getString(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as a string.
getStringArray(String) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Get the value stored under the specified `attributeName` as an array of strings.
getStringMatcher(String) - 类 中的方法org.springframework.util.AntPathMatcher
  Build or retrieve an `AntPathMatcher.AntPathStringMatcher` for the given pattern.
getSubtype() - 类 中的方法org.springframework.util.MimeType
  Return the subtype.
getSuperClassName() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return the name of the super class of the underlying class, or `null` if there is no super class defined.
getSuperClassName() - 类 中的方法org.springframework.core.type.StandardClassMetadata
getSuperName() - 类 中的方法org.springframework.asm.ClassReader
  Returns the internal of name of the super class (see `getInternalName`).
getSuperType() - 类 中的方法org.springframework.core.ResolvableType
  Return a `ResolvableType` representing the direct supertype of this type.
getSuperTypeIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the "super type" of a class that is referenced by this type reference.
getSystemEnvironment() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getSystemEnvironment() - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Return the value of `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)`.
getSystemProperties() - 类 中的方法org.springframework.core.env.AbstractEnvironment
getSystemProperties() - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Return the value of `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)`.
getTag() - 类 中的方法org.springframework.asm.Handle
  Returns the kind of field or method designated by this handle.
getTag() - 类 中的方法org.springframework.cglib.core.SpringNamingPolicy
getTargetClass() - 类 中的方法org.springframework.util.MethodInvoker
  Return the target class on which to call the target method.
getTargetMethod() - 类 中的方法org.springframework.util.MethodInvoker
  Return the name of the method to be invoked.
getTargetObject() - 类 中的方法org.springframework.util.MethodInvoker
  Return the target object on which to call the target method.
getTargetType() - 异常错误 中的方法org.springframework.core.convert.ConversionFailedException
  Return the target type we tried to convert the value to.
getTargetType() - 类 中的方法org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
getTargetType() - 异常错误 中的方法org.springframework.core.convert.ConverterNotFoundException
  Return the target type that was requested to convert to.
getTargetType() - 类 中的方法org.springframework.core.type.filter.AssignableTypeFilter
  Return the `type` that this instance is using to filter candidates.
getTaskCount() - 类 中的方法org.springframework.util.StopWatch
  Return the number of tasks timed.
getTaskInfo() - 类 中的方法org.springframework.util.StopWatch
  Return an array of the data for tasks performed.
getTaskName() - 类 中的方法org.springframework.util.StopWatch.TaskInfo
  Return the name of this task.
getTextValue(Element) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Extracts the text value from the given DOM element, ignoring XML comments.
getThreadFactory() - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Return the external factory to use for creating new Threads, if any.
getThreadGroup() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Return the thread group that threads should be created in (or `null` for the default group).
getThreadNamePrefix() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Return the thread name prefix to use for the names of newly created threads.
getThreadPriority() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Return the priority of the threads that this factory creates.
getTimeMillis() - 类 中的方法org.springframework.util.StopWatch.TaskInfo
  Return the time in milliseconds this task took.
getTimeSeconds() - 类 中的方法org.springframework.util.StopWatch.TaskInfo
  Return the time in seconds this task took.
getTotalTimeMillis() - 类 中的方法org.springframework.util.StopWatch
  Return the total time in milliseconds for all tasks.
getTotalTimeSeconds() - 类 中的方法org.springframework.util.StopWatch
  Return the total time in seconds for all tasks.
getTryCatchBlockIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the try catch block (using the order in which they are visited with visitTryCatchBlock), whose 'catch' type is referenced by this type reference.
getType(String) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the given type descriptor.
getType(Class<?>) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java type corresponding to the given class.
getType(Constructor<?>) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java method type corresponding to the given constructor.
getType(Method) - 类 中的静态方法org.springframework.asm.Type
  Returns the Java method type corresponding to the given method.
getType() - 类 中的方法org.springframework.core.convert.Property
  The property type: e.g.
getType() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  The type of the backing class, method parameter, field, or property described by this TypeDescriptor.
getType() - 类 中的方法org.springframework.core.ParameterizedTypeReference
getType() - 类 中的方法org.springframework.core.ResolvableType
  Return the underling Java `Type` being managed.
getType() - 类 中的方法org.springframework.util.MimeType
  Return the primary type.
getTypeArgumentIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the type argument referenced by this type reference.
getTypeDifferenceWeight(Class<?>[], Object[]) - 类 中的静态方法org.springframework.util.MethodInvoker
  Algorithm that judges the match between the declared parameter types of a candidate method and a specific list of arguments that this method is supposed to be invoked with.
getTypeIndexForCurrentLevel() - 类 中的方法org.springframework.core.MethodParameter
  Return the type index for the current nesting level.
getTypeIndexForLevel(int) - 类 中的方法org.springframework.core.MethodParameter
  Return the type index for the specified nesting level.
getTypeParameterBoundIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the type parameter bound, within the type parameter `TypeReference.getTypeParameterIndex()`, referenced by this type reference.
getTypeParameterIndex() - 类 中的方法org.springframework.asm.TypeReference
  Returns the index of the type parameter referenced by this type reference.
getTypeVariableMap(Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Build a mapping of `TypeVariable names` to `concrete classes` for the specified `Class`.
getUniqueDeclaredMethods(Class<?>) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Get the unique set of declared methods on the leaf class and all superclasses.
getURI() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation builds a URI based on the URL returned by `AbstractResource.getURL()`.
getURI() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns a URI for the underlying file.
getURI() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns a URI for the underlying file.
getURI() - 接口 中的方法org.springframework.core.io.Resource
  Return a URI handle for this resource.
getURI() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns the underlying URI directly, if possible.
getURI() - 类 中的方法org.springframework.core.io.VfsResource
getURL() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation throws a FileNotFoundException, assuming that the resource cannot be resolved to a URL.
getURL() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation returns a URL for the underlying class path resource, if available.
getURL() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns a URL for the underlying file.
getURL() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns a URL for the underlying file.
getURL() - 接口 中的方法org.springframework.core.io.Resource
  Return a URL handle for this resource.
getURL() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns the underlying URL reference.
getURL() - 类 中的方法org.springframework.core.io.VfsResource
getURL(String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Resolve the given resource location to a `java.net.URL`.
getUserClass(Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the user-defined class for the given instance: usually simply the class of the given instance, but the original class in case of a CGLIB-generated subclass.
getUserClass(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Return the user-defined class for the given class: usually simply the given class, but the original class in case of a CGLIB-generated subclass.
getValue() - 类 中的方法org.springframework.asm.TypeReference
  Returns the int encoded value of this type reference, suitable for use in visit methods related to type annotations, like visitTypeAnnotation.
getValue(Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the value of the `value` attribute of a single-element Annotation, given an annotation instance.
getValue(Annotation, String) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Retrieve the value of a named attribute, given an annotation instance.
getValue() - 异常错误 中的方法org.springframework.core.convert.ConversionFailedException
  Return the offending value.
getValue() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
getValues(String) - 类 中的方法org.springframework.core.Constants
  Return all values of the given group of constants.
getValuesForProperty(String) - 类 中的方法org.springframework.core.Constants
  Return all values of the group of constants for the given bean property name.
getValuesForSuffix(String) - 类 中的方法org.springframework.core.Constants
  Return all values of the given group of constants.
getValueStyler() - 类 中的方法org.springframework.core.style.DefaultToStringStyler
  Return the ValueStyler used by this ToStringStyler.
getVariableName(Object) - 类 中的静态方法org.springframework.core.Conventions
  Determine the conventional variable name for the supplied `Object` based on its concrete type.
getVariableNameForParameter(MethodParameter) - 类 中的静态方法org.springframework.core.Conventions
  Determine the conventional variable name for the given parameter taking the generic collection type, if any, into account.
getVariableNameForReturnType(Method) - 类 中的静态方法org.springframework.core.Conventions
  Determine the conventional variable name for the return type of the given method, taking the generic collection type, if any, into account.
getVariableNameForReturnType(Method, Object) - 类 中的静态方法org.springframework.core.Conventions
  Determine the conventional variable name for the return type of the given method, taking the generic collection type, if any, into account, falling back on the given actual return value if the method declaration is not specific enough, e.g.
getVariableNameForReturnType(Method, Class<?>, Object) - 类 中的静态方法org.springframework.core.Conventions
  Determine the conventional variable name for the return type of the given method, taking the generic collection type, if any, into account, falling back on the given return value if the method declaration is not specific enough, e.g.
getVersion() - 类 中的静态方法org.springframework.core.SpringVersion
  Return the full version string of the present Spring codebase, or `null` if it cannot be determined.
getWrappedObject() - 接口 中的方法org.springframework.core.InfrastructureProxy
  Return the underlying resource (never `null`).
getWriteMethod() - 类 中的方法org.springframework.core.convert.Property
  The property setter method: e.g.
getXMLEventReader(Source) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return the `XMLEventReader` for the given StAX Source.
getXMLEventWriter(Result) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return the `XMLEventWriter` for the given StAX Result.
getXMLStreamReader(Source) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return the `XMLStreamReader` for the given StAX Source.
getXMLStreamWriter(Result) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Return the `XMLStreamWriter` for the given StAX Result.
GOTO - 接口 中的静态变量org.springframework.asm.Opcodes
grow(int) - 类 中的方法org.springframework.util.ResizableByteArrayOutputStream
  Grow the internal buffer size.

## H

H_GETFIELD - 接口 中的静态变量org.springframework.asm.Opcodes
H_GETSTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
H_INVOKEINTERFACE - 接口 中的静态变量org.springframework.asm.Opcodes
H_INVOKESPECIAL - 接口 中的静态变量org.springframework.asm.Opcodes
H_INVOKESTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
H_INVOKEVIRTUAL - 接口 中的静态变量org.springframework.asm.Opcodes
H_NEWINVOKESPECIAL - 接口 中的静态变量org.springframework.asm.Opcodes
H_PUTFIELD - 接口 中的静态变量org.springframework.asm.Opcodes
H_PUTSTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
Handle - org.springframework.asm中的类
  A reference to a field or a method.
Handle(int, String, String, String) - 类 的构造器org.springframework.asm.Handle
  已过时。
  this constructor has been superseded by `Handle.Handle(int, String, String, String, boolean)`.
Handle(int, String, String, String, boolean) - 类 的构造器org.springframework.asm.Handle
  Constructs a new field or method handle.
handleError(Throwable) - 接口 中的方法org.springframework.util.ErrorHandler
  Handle the given error, possibly rethrowing it as a fatal exception.
handleInvocationTargetException(InvocationTargetException) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Handle the given invocation target exception.
handleReflectionException(Exception) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Handle the given reflection exception.
hasAdapters() - 类 中的方法org.springframework.core.ReactiveAdapterRegistry
  Whether the registry has any adapters which would be the case if any of Reactor, RxJava 2, or RxJava 1 (+ RxJava Reactive Streams bridge) are present on the classpath.
hasAlias(String, String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
  Determine whether the given name has the given alias registered.
hasAnnotatedMethods(String) - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Determine whether the underlying class has any methods that are annotated (or meta-annotated) with the given annotation type.
hasAnnotatedMethods(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
hasAnnotatedMethods(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
hasAnnotation(AnnotatedElement, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Determine if an annotation of the specified `annotationType` is available on the supplied `AnnotatedElement` or within the annotation hierarchy above the specified element.
hasAnnotation(Class<? extends Annotation>) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Determine if this type descriptor has the specified annotation.
hasAnnotation(String) - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Determine whether an annotation of the given type is present on the underlying class.
hasAnnotation(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
hasAnnotation(String) - 类 中的方法org.springframework.core.type.filter.AnnotationTypeFilter
hasAnnotation(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
hasAtLeastOneMethodWithName(Class<?>, String) - 类 中的静态方法org.springframework.util.ClassUtils
  Does the given class or one of its superclasses at least have one or more methods with the supplied name (with any argument types)?
hasAttribute(String) - 接口 中的方法org.springframework.core.AttributeAccessor
  Return `true` if the attribute identified by `name` exists.
hasAttribute(String) - 类 中的方法org.springframework.core.AttributeAccessorSupport
hasConstructor(Class<?>, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given class has a public constructor with the given signature.
hasEnclosingClass() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class is declared within an enclosing class (i.e. the underlying class is an inner/nested class or a local class within a method).
hasEnclosingClass() - 类 中的方法org.springframework.core.type.StandardClassMetadata
hasGenerics() - 类 中的方法org.springframework.core.ResolvableType
  Return `true` if this type contains generic parameters.
hashCode() - 类 中的方法org.springframework.asm.Handle
hashCode() - 类 中的方法org.springframework.asm.Type
  Returns a hash code value for this type.
hashCode() - 类 中的方法org.springframework.core.AttributeAccessorSupport
hashCode() - 类 中的方法org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
hashCode() - 类 中的方法org.springframework.core.convert.Property
hashCode() - 类 中的方法org.springframework.core.convert.TypeDescriptor
hashCode() - 类 中的方法org.springframework.core.env.PropertySource
  Return a hash code derived from the `name` property of this `PropertySource` object.
hashCode() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation returns the description's hash code.
hashCode() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
hashCode() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
hashCode() - 类 中的方法org.springframework.core.io.ByteArrayResource
  This implementation returns the hash code based on the underlying byte array.
hashCode() - 类 中的方法org.springframework.core.io.ClassPathResource
  This implementation returns the hash code of the underlying class path location.
hashCode() - 类 中的方法org.springframework.core.io.DescriptiveResource
  This implementation returns the hash code of the underlying description String.
hashCode() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation returns the hash code of the underlying File reference.
hashCode() - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation returns the hash code of the underlying InputStream.
hashCode() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns the hash code of the underlying Path reference.
hashCode() - 类 中的方法org.springframework.core.io.support.EncodedResource
hashCode() - 类 中的方法org.springframework.core.io.UrlResource
  This implementation returns the hash code of the underlying URL reference.
hashCode() - 类 中的方法org.springframework.core.io.VfsResource
hashCode() - 类 中的方法org.springframework.core.MethodClassKey
hashCode() - 类 中的方法org.springframework.core.MethodParameter
hashCode() - 类 中的方法org.springframework.core.ParameterizedTypeReference
hashCode() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
hashCode() - 类 中的方法org.springframework.core.ResolvableType
hashCode() - 类 中的方法org.springframework.util.AutoPopulatingList
hashCode() - 类 中的方法org.springframework.util.comparator.BooleanComparator
hashCode() - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
hashCode() - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
hashCode() - 类 中的方法org.springframework.util.comparator.NullSafeComparator
hashCode() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
hashCode() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
hashCode() - 类 中的方法org.springframework.util.LinkedMultiValueMap
hashCode() - 类 中的方法org.springframework.util.MimeType
hashCode(boolean) - 类 中的静态方法org.springframework.util.ObjectUtils
  已过时。
  as of Spring Framework 5.0, in favor of the native JDK 8 variant
hashCode(double) - 类 中的静态方法org.springframework.util.ObjectUtils
  已过时。
  as of Spring Framework 5.0, in favor of the native JDK 8 variant
hashCode(float) - 类 中的静态方法org.springframework.util.ObjectUtils
  已过时。
  as of Spring Framework 5.0, in favor of the native JDK 8 variant
hashCode(long) - 类 中的静态方法org.springframework.util.ObjectUtils
  已过时。
  as of Spring Framework 5.0, in favor of the native JDK 8 variant
hasLength(String, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
hasLength(String, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
hasLength(String) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.hasLength(String, String)`
hasLength(CharSequence) - 类 中的静态方法org.springframework.util.StringUtils
  Check that the given `CharSequence` is neither `null` nor of length 0.
hasLength(String) - 类 中的静态方法org.springframework.util.StringUtils
  Check that the given `String` is neither `null` nor of length 0.
hasMetaAnnotation(String) - 接口 中的方法org.springframework.core.type.AnnotationMetadata
  Determine whether the underlying class has an annotation that is itself annotated with the meta-annotation of the given type.
hasMetaAnnotation(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
hasMetaAnnotation(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
hasMetaAnnotationTypes(AnnotatedElement, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Determine if the supplied `AnnotatedElement` is annotated with a composed annotation that is meta-annotated with an annotation of the specified `annotationType`.
hasMetaAnnotationTypes(AnnotatedElement, String) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Determine if the supplied `AnnotatedElement` is annotated with a composed annotation that is meta-annotated with an annotation of the specified `annotationName`.
hasMethod(Class<?>, String, Class<?>...) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given class has a public method with the given signature.
hasMethodAnnotation(Class<A>) - 类 中的方法org.springframework.core.MethodParameter
  Return whether the method/constructor is annotated with the given type.
hasNext() - 类 中的方法org.springframework.util.CompositeIterator
hasParameterAnnotation(Class<A>) - 类 中的方法org.springframework.core.MethodParameter
  Return whether the parameter is declared with the given annotation type.
hasParameterAnnotations() - 类 中的方法org.springframework.core.MethodParameter
  Return `true` if the parameter has at least one annotation, `false` if it has none.
hasSuperClass() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class has a super class.
hasSuperClass() - 类 中的方法org.springframework.core.type.StandardClassMetadata
hasText(String, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given String contains valid text content; that is, it must not be `null` and must contain at least one non-whitespace character.
hasText(String, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that the given String contains valid text content; that is, it must not be `null` and must contain at least one non-whitespace character.
hasText(String) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.hasText(String, String)`
hasText(CharSequence) - 类 中的静态方法org.springframework.util.StringUtils
  Check whether the given `CharSequence` contains actual text.
hasText(String) - 类 中的静态方法org.springframework.util.StringUtils
  Check whether the given `String` contains actual text.
hasUniqueObject(Collection<?>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Determine whether the given Collection only contains a single unique object.
hasUnresolvableGenerics() - 类 中的方法org.springframework.core.ResolvableType
  Determine whether the underlying type has any unresolvable generics: either through an unresolvable type variable on the type itself or through implementing a generic interface in a raw fashion, i.e. without substituting that interface's type variables.
header - 类 中的变量org.springframework.asm.ClassReader
  Start index of the class header information (access, name...) in `b`.
HIGHEST_PRECEDENCE - 接口 中的静态变量org.springframework.core.Ordered
  Useful constant for the highest precedence value.

## I

I2B - 接口 中的静态变量org.springframework.asm.Opcodes
I2C - 接口 中的静态变量org.springframework.asm.Opcodes
I2D - 接口 中的静态变量org.springframework.asm.Opcodes
I2F - 接口 中的静态变量org.springframework.asm.Opcodes
I2L - 接口 中的静态变量org.springframework.asm.Opcodes
I2S - 接口 中的静态变量org.springframework.asm.Opcodes
IADD - 接口 中的静态变量org.springframework.asm.Opcodes
IALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
IAND - 接口 中的静态变量org.springframework.asm.Opcodes
IASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_0 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_1 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_2 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_3 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_4 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_5 - 接口 中的静态变量org.springframework.asm.Opcodes
ICONST_M1 - 接口 中的静态变量org.springframework.asm.Opcodes
identityToString(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of an object's overall identity.
IdGenerator - org.springframework.util中的接口
  Contract for generating universally unique identifiers `(UUIDs)`.
IDIV - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ACMPEQ - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ACMPNE - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPEQ - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPGE - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPGT - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPLE - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPLT - 接口 中的静态变量org.springframework.asm.Opcodes
IF_ICMPNE - 接口 中的静态变量org.springframework.asm.Opcodes
IFEQ - 接口 中的静态变量org.springframework.asm.Opcodes
IFGE - 接口 中的静态变量org.springframework.asm.Opcodes
IFGT - 接口 中的静态变量org.springframework.asm.Opcodes
IFLE - 接口 中的静态变量org.springframework.asm.Opcodes
IFLT - 接口 中的静态变量org.springframework.asm.Opcodes
IFNE - 接口 中的静态变量org.springframework.asm.Opcodes
IFNONNULL - 接口 中的静态变量org.springframework.asm.Opcodes
IFNULL - 接口 中的静态变量org.springframework.asm.Opcodes
IGNORE_GETENV_PROPERTY_NAME - 类 中的静态变量org.springframework.core.env.AbstractEnvironment
  System property that instructs Spring to ignore system environment variables, i.e. to never attempt to retrieve such a variable via `System.getenv()`.
IGNORE_OBJENESIS_PROPERTY_NAME - 类 中的静态变量org.springframework.objenesis.SpringObjenesis
  System property that instructs Spring to ignore Objenesis, not even attempting to use it.
IINC - 接口 中的静态变量org.springframework.asm.Opcodes
ILOAD - 接口 中的静态变量org.springframework.asm.Opcodes
IMAGE_GIF - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `image/gif`.
IMAGE_GIF_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.IMAGE_GIF`.
IMAGE_JPEG - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `image/jpeg`.
IMAGE_JPEG_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.IMAGE_JPEG`.
IMAGE_PNG - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `image/png`.
IMAGE_PNG_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.IMAGE_PNG`.
IMUL - 接口 中的静态变量org.springframework.asm.Opcodes
includes(MimeType) - 类 中的方法org.springframework.util.MimeType
  Indicate whether this MIME Type includes the given MIME Type.
increaseNestingLevel() - 类 中的方法org.springframework.core.MethodParameter
  Increase this parameter's nesting level.
indexOf(IntPredicate, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the index of the first byte in this buffer that matches the given predicate.
indexOf(IntPredicate, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
indexOf(IntPredicate, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
indexOf(Object) - 类 中的方法org.springframework.util.AutoPopulatingList
INEG - 接口 中的静态变量org.springframework.asm.Opcodes
info - 类 中的变量org.springframework.asm.Label
  Field used to associate user information to a label.
InfrastructureProxy - org.springframework.core中的接口
  Interface to be implemented by transparent resource proxies that need to be considered as equal to the underlying resource, for example for consistent lookup key comparisons.
initParameterNameDiscovery(ParameterNameDiscoverer) - 类 中的方法org.springframework.core.MethodParameter
  Initialize parameter name discovery for this method parameter.
INNER_TYPE - 类 中的静态变量org.springframework.asm.TypePath
  A type path step that steps into the nested type of a class type.
InputStreamResource - org.springframework.core.io中的类
  `Resource` implementation for a given `InputStream`.
InputStreamResource(InputStream) - 类 的构造器org.springframework.core.io.InputStreamResource
  Create a new InputStreamResource.
InputStreamResource(InputStream, String) - 类 的构造器org.springframework.core.io.InputStreamResource
  Create a new InputStreamResource.
InputStreamSource - org.springframework.core.io中的接口
  Simple interface for objects that are sources for an `InputStream`.
inspect(Method) - 接口 中的方法org.springframework.core.MethodIntrospector.MetadataLookup
  Perform a lookup on the given method and return associated metadata, if any.
INSTANCE - 类 中的静态变量org.springframework.cglib.core.SpringNamingPolicy
INSTANCE - 类 中的静态变量org.springframework.core.annotation.AnnotationAwareOrderComparator
  Shared default instance of `AnnotationAwareOrderComparator`.
INSTANCE - 类 中的静态变量org.springframework.core.OrderComparator
  Shared default instance of `OrderComparator`.
INSTANCE - 类 中的静态变量org.springframework.util.comparator.ComparableComparator
  A shared instance of this default comparator
InstanceComparator<T> - org.springframework.util.comparator中的类
  Compares objects based on an arbitrary class order.
InstanceComparator(Class<?>...) - 类 的构造器org.springframework.util.comparator.InstanceComparator
  Create a new `InstanceComparator` instance.
InstanceFilter<T> - org.springframework.util中的类
  A simple instance filter that checks if a given instance match based on a collection of includes and excludes element.
InstanceFilter(Collection<? extends T>, Collection<? extends T>, boolean) - 类 的构造器org.springframework.util.InstanceFilter
  Create a new instance based on includes/excludes collections.
INSTANCEOF - 接口 中的静态变量org.springframework.asm.Opcodes
INSTANCEOF - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type declared in an 'instanceof' instruction.
INT - 类 中的静态变量org.springframework.asm.Type
  The sort of the `int` type.
INT_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `int` type.
INTEGER - 接口 中的静态变量org.springframework.asm.Opcodes
interruptTask() - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
  Subclasses can override this method to implement interruption of the future's computation.
InvalidMimeTypeException - org.springframework.util中的异常错误
  Exception thrown from `MimeTypeUtils.parseMimeType(String)` in case of encountering an invalid content type specification String.
InvalidMimeTypeException(String, String) - 异常错误 的构造器org.springframework.util.InvalidMimeTypeException
  Create a new InvalidContentTypeException for the given content type.
InvertibleComparator<T> - org.springframework.util.comparator中的类
  已过时。
  as of Spring Framework 5.0, in favor of the standard JDK 8 `Comparator.reversed()`
InvertibleComparator(Comparator<T>) - 类 的构造器org.springframework.util.comparator.InvertibleComparator
  已过时。
  Create an InvertibleComparator that sorts ascending by default.
InvertibleComparator(Comparator<T>, boolean) - 类 的构造器org.springframework.util.comparator.InvertibleComparator
  已过时。
  Create an InvertibleComparator that sorts based on the provided order.
invertOrder() - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Invert the sort order of each sort definition contained by this compound comparator.
invertOrder(int) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Invert the sort order of the sort definition at the specified index.
invertOrder() - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
  Invert the sort order: ascending -> descending or descending -> ascending.
invoke() - 类 中的方法org.springframework.util.MethodInvoker
  Invoke the specified method.
INVOKEDYNAMIC - 接口 中的静态变量org.springframework.asm.Opcodes
INVOKEINTERFACE - 接口 中的静态变量org.springframework.asm.Opcodes
invokeJdbcMethod(Method, Object) - 类 中的静态方法org.springframework.util.ReflectionUtils
  已过时。
  as of 5.0.11, in favor of custom SQLException handling
invokeJdbcMethod(Method, Object, Object...) - 类 中的静态方法org.springframework.util.ReflectionUtils
  已过时。
  as of 5.0.11, in favor of custom SQLException handling
invokeMethod(Method, Object) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Invoke the specified `Method` against the supplied target object with no arguments.
invokeMethod(Method, Object, Object...) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Invoke the specified `Method` against the supplied target object with the supplied arguments.
INVOKESPECIAL - 接口 中的静态变量org.springframework.asm.Opcodes
INVOKESTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
invokeVfsMethod(Method, Object, Object...) - 类 中的静态方法org.springframework.core.io.VfsUtils
INVOKEVIRTUAL - 接口 中的静态变量org.springframework.asm.Opcodes
IOR - 接口 中的静态变量org.springframework.asm.Opcodes
IREM - 接口 中的静态变量org.springframework.asm.Opcodes
IRETURN - 接口 中的静态变量org.springframework.asm.Opcodes
isAbstract() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class is marked as abstract.
isAbstract() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
isAbstract() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return whether the underlying method is effectively abstract: i.e. marked as abstract on a class or declared as a regular, non-default method in an interface.
isAbstract() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isAbstract() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
isAlias(String) - 接口 中的方法org.springframework.core.AliasRegistry
  Determine whether this given name is defines as an alias (as opposed to the name of an actually registered component).
isAlias(String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
isAnnotated(AnnotatedElement, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Determine if an annotation of the specified `annotationType` is present on the supplied `AnnotatedElement` or within the annotation hierarchy above the specified element.
isAnnotated(AnnotatedElement, String) - 类 中的静态方法org.springframework.core.annotation.AnnotatedElementUtils
  Determine if an annotation of the specified `annotationName` is present on the supplied `AnnotatedElement` or within the annotation hierarchy above the specified element.
isAnnotated(String) - 接口 中的方法org.springframework.core.type.AnnotatedTypeMetadata
  Determine whether the underlying element has an annotation or meta-annotation of the given type defined.
isAnnotated(String) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
isAnnotated(String) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
isAnnotated(String) - 类 中的方法org.springframework.core.type.StandardAnnotationMetadata
isAnnotated(String) - 类 中的方法org.springframework.core.type.StandardMethodMetadata
isAnnotation() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class represents an annotation.
isAnnotation() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isAnnotationDeclaredLocally(Class<? extends Annotation>, Class<?>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Determine whether an annotation of the specified `annotationType` is declared locally (i.e.
isAnnotationInherited(Class<? extends Annotation>, Class<?>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Determine whether an annotation of the specified `annotationType` is present on the supplied `clazz` and is inherited (i.e. not directly present).
isAnnotationMetaPresent(Class<? extends Annotation>, Class<? extends Annotation>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Determine if an annotation of type `metaAnnotationType` is meta-present on the supplied `annotationType`.
isApproximableCollectionType(Class<?>) - 类 中的静态方法org.springframework.core.CollectionFactory
  Determine whether the given collection type is an approximable type, i.e. a type that `CollectionFactory.createApproximateCollection(java.lang.Object, int)` can approximate.
isApproximableMapType(Class<?>) - 类 中的静态方法org.springframework.core.CollectionFactory
  Determine whether the given map type is an approximable type, i.e. a type that `CollectionFactory.createApproximateMap(java.lang.Object, int)` can approximate.
isArray() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Is this type an array type?
isArray() - 类 中的方法org.springframework.core.ResolvableType
  Return `true` if this type resolves to a Class that represents an array.
isArray(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Determine whether the given object is an array: either an Object array or a primitive array.
isAscending() - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
  Return the sort order: ascending (true) or descending (false).
isAssignable(Class<?>, Class<?>, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that `superType.isAssignableFrom(subType)` is `true`.
isAssignable(Class<?>, Class<?>, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that `superType.isAssignableFrom(subType)` is `true`.
isAssignable(Class<?>, Class<?>) - 类 中的静态方法org.springframework.util.Assert
  Assert that `superType.isAssignableFrom(subType)` is `true`.
isAssignable(Class<?>, Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check if the right-hand side type may be assigned to the left-hand side type, assuming setting by reflection.
isAssignable(Type, Type) - 类 中的静态方法org.springframework.util.TypeUtils
  Check if the right-hand side type may be assigned to the left-hand side type following the Java generics rules.
isAssignableBound(Type, Type) - 类 中的静态方法org.springframework.util.TypeUtils
isAssignableFrom(Class<?>) - 类 中的方法org.springframework.core.ResolvableType
  Determine whether this `ResolvableType` is assignable from the specified other type.
isAssignableFrom(ResolvableType) - 类 中的方法org.springframework.core.ResolvableType
  Determine whether this `ResolvableType` is assignable from the specified other type.
isAssignableTo(TypeDescriptor) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Returns true if an object of this type descriptor can be assigned to the location described by the given type descriptor.
isAssignableValue(Class<?>, Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine if the given type is assignable from the given value, assuming setting by reflection.
isCacheSafe(Class<?>, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the given class is cache-safe in the given context, i.e. whether it is loaded by the given ClassLoader or a parent of it.
isCancelled() - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
isCancelled() - 类 中的方法org.springframework.util.concurrent.FutureAdapter
isCancelled() - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
isCglibProxy(Object) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the given object is a CGLIB proxy.
isCglibProxyClass(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the specified class is a CGLIB-generated class.
isCglibProxyClassName(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the specified class name is a CGLIB-generated class.
isCglibRenamedMethod(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method is a CGLIB 'renamed' method, following the pattern "CGLIB$methodName$0".
isCheckedException(Throwable) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return whether the given throwable is a checked exception: that is, neither a RuntimeException nor an Error.
isClassReloadable(Class<?>) - 接口 中的方法org.springframework.core.SmartClassLoader
  Determine whether the given class is reloadable (in this ClassLoader).
isCodeAttribute() - 类 中的方法org.springframework.asm.Attribute
  Returns `true` if this type of attribute is a code attribute.
isCollection() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Is this type a `Collection` type?
isCompatibleWith(MimeType) - 类 中的方法org.springframework.util.MimeType
  Indicate whether this MIME Type is compatible with the given MIME Type.
isCompatibleWithThrowsClause(Throwable, Class<?>...) - 类 中的静态方法org.springframework.util.ObjectUtils
  Check whether the given exception is compatible with the specified exception types, as declared in a throws clause.
isConcrete() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class represents a concrete class, i.e. neither an interface nor an abstract class.
isConcrete() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isConcrete() - 类 中的方法org.springframework.util.MimeType
  Indicates whether this MIME Type is concrete, i.e. whether neither the type nor the subtype is a wildcard character `*`.
isDaemon() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Return whether this factory should create daemon threads.
isDone() - 类 中的方法org.springframework.util.concurrent.CompletableToListenableFutureAdapter
isDone() - 类 中的方法org.springframework.util.concurrent.FutureAdapter
isDone() - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
isEligibleForOverriding(String) - 类 中的方法org.springframework.core.OverridingClassLoader
  Determine whether the specified class is eligible for overriding by this class loader.
isEmpty() - 类 中的方法org.springframework.util.AutoPopulatingList
isEmpty(Collection<?>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Return `true` if the supplied Collection is `null` or empty.
isEmpty(Map<?, ?>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Return `true` if the supplied Map is `null` or empty.
isEmpty() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
isEmpty() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
isEmpty() - 类 中的方法org.springframework.util.LinkedMultiValueMap
isEmpty(Object[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Determine whether the given array is empty: i.e.
isEmpty(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Determine whether the given object is empty.
isEmpty(Object) - 类 中的静态方法org.springframework.util.StringUtils
  Check whether the given object (possibly a `String`) is empty.
isEqualsMethod(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method is an "equals" method.
isExcluded(String) - 类 中的方法org.springframework.core.DecoratingClassLoader
  Determine whether the specified class is excluded from decoration by this class loader.
isFile() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
isFile(URI) - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  This implementation returns a File reference for the given URI-identified resource, provided that it refers to a file in the file system.
isFile() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation always returns `false`.
isFile() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation always indicates a file.
isFile() - 类 中的方法org.springframework.core.io.PathResource
  This implementation always indicates a file.
isFile() - 接口 中的方法org.springframework.core.io.Resource
  Determine whether this resource represents a file in a file system.
isFile() - 类 中的方法org.springframework.core.io.UrlResource
isFileURL(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Determine whether the given URL points to a resource in the file system, i.e. has protocol "file", "vfsfile" or "vfs".
isFinal() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class is marked as 'final'.
isFinal() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
isFinal() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return whether the underlying method is marked as 'final'.
isFinal() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isFinal() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
isHashCodeMethod(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method is a "hashCode" method.
ISHL - 接口 中的静态变量org.springframework.asm.Opcodes
ISHR - 接口 中的静态变量org.springframework.asm.Opcodes
isIndependent() - 接口 中的方法org.springframework.core.type.ClassMetadata
  确定基础类是否独立，即它是顶级类或嵌套类（静态内部类） 可以独立于封闭类构造。
isIndependent() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isInJavaLangAnnotationPackage(Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Determine if the supplied `Annotation` is defined in the core JDK `java.lang.annotation` package.
isInJavaLangAnnotationPackage(String) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Determine if the `Annotation` with the supplied name is defined in the core JDK `java.lang.annotation` package.
isInnerClass(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine if the supplied class is an inner class, i.e. a non-static member of an enclosing class.
isInstance(Object) - 类 中的方法org.springframework.core.ResolvableType
  Determine whether the given object is an instance of this `ResolvableType`.
isInstanceOf(Class<?>, Object, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that the provided object is an instance of the provided class.
isInstanceOf(Class<?>, Object, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that the provided object is an instance of the provided class.
isInstanceOf(Class<?>, Object) - 类 中的静态方法org.springframework.util.Assert
  Assert that the provided object is an instance of the provided class.
isInterface() - 类 中的方法org.springframework.asm.Handle
  Returns true if the owner of the field or method designated by this handle is an interface.
isInterface() - 接口 中的方法org.springframework.core.type.ClassMetadata
  Return whether the underlying class represents an interface.
isInterface() - 类 中的方法org.springframework.core.type.StandardClassMetadata
isJarFileURL(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Determine whether the given URL points to a jar file itself, that is, has protocol "file" and ends with the ".jar" extension.
isJarResource(Resource) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Return whether the given resource handle indicates a jar resource that the `doFindPathMatchingJarResources` method can handle.
isJarURL(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Determine whether the given URL points to a resource in a jar file.
isJavaLanguageInterface(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given interface is a common Java language interface: `Serializable`, `Externalizable`, `Closeable`, `AutoCloseable`, `Cloneable`, `Comparable` - all of which can be ignored when looking for 'primary' user-level interfaces.
isKotlinPresent() - 类 中的静态方法org.springframework.core.KotlinDetector
  Determine whether Kotlin is present in general.
isKotlinType(Class<?>) - 类 中的静态方法org.springframework.core.KotlinDetector
  Determine whether the given `Class` is a Kotlin type (with Kotlin metadata present on it).
isMap() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Is this type a `Map` type?
isMultiValue() - 类 中的方法org.springframework.core.ReactiveAdapter
  Shortcut for `getDescriptor().isMultiValue()`.
isMultiValue() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
  Return `true` if the reactive type can produce more than 1 value can be produced and is therefore a good fit to adapt to `Flux`.
isNoValue() - 类 中的方法org.springframework.core.ReactiveAdapter
  Shortcut for `getDescriptor().isNoValue()`.
isNoValue() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
  Return `true` if the reactive type does not produce any values and only provides completion and error signals.
isNull(Object, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that an object is `null`.
isNull(Object, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that an object is `null`.
isNull(Object) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.isNull(Object, String)`
isObjectMethod(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method is originally declared by `Object`.
isOpen() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation always returns `false`.
isOpen() - 类 中的方法org.springframework.core.io.InputStreamResource
  This implementation always returns `true`.
isOpen() - 接口 中的方法org.springframework.core.io.Resource
  Indicate whether this resource represents a handle with an open stream.
isOptional() - 类 中的方法org.springframework.core.MethodParameter
  Return whether this method indicates a parameter which is not required: either in the form of Java 8's `Optional`, any variant of a parameter-level `Nullable` annotation (such as from JSR-305 or the FindBugs set of annotations), or a language-level nullable type declaration in Kotlin.
isOverridable() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
isOverridable() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return whether the underlying method is overridable, i.e. not marked as static, final or private.
isOverridable() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
isPattern(String) - 类 中的方法org.springframework.util.AntPathMatcher
isPattern(String) - 接口 中的方法org.springframework.util.PathMatcher
  Does the given `path` represent a pattern that can be matched by an implementation of this interface?
isPrepared() - 类 中的方法org.springframework.util.MethodInvoker
  Return whether this invoker has been prepared already, i.e. whether it allows access to `MethodInvoker.getPreparedMethod()` already.
isPresent(String, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the `Class` identified by the supplied name is present and can be loaded.
isPrimitive() - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Is this type a primitive type?
isPrimitiveArray(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check if the given class represents an array of primitives, i.e. boolean, byte, char, short, int, long, float, or double.
isPrimitiveOrWrapper(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check if the given class represents a primitive (i.e. boolean, byte, char, short, int, long, float, or double) or a primitive wrapper (i.e.
isPrimitiveWrapper(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check if the given class represents a primitive wrapper, i.e.
isPrimitiveWrapperArray(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Check if the given class represents an array of primitive wrappers, i.e.
isProfileActive(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Return whether the given profile is active, or if active profiles are empty whether the profile should be active by default.
isPublicStaticFinal(Field) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given field is a "public static final" constant.
isReadable() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
isReadable() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation always returns `true`.
isReadable() - 类 中的方法org.springframework.core.io.DescriptiveResource
isReadable() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation checks whether the underlying file is marked as readable (and corresponds to an actual file with content, not to a directory).
isReadable() - 类 中的方法org.springframework.core.io.PathResource
  This implementation checks whether the underlying file is marked as readable (and corresponds to an actual file with content, not to a directory).
isReadable() - 接口 中的方法org.springframework.core.io.Resource
  Indicate whether the contents of this resource can be read via `InputStreamSource.getInputStream()`.
isReadable() - 类 中的方法org.springframework.core.io.VfsResource
isRunning() - 类 中的方法org.springframework.util.StopWatch
  Return whether the stop watch is currently running.
isSecurityManagerPresent() - 类 中的方法org.springframework.core.env.SystemEnvironmentPropertySource
isShutdown() - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter
isStatic() - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
isStatic() - 接口 中的方法org.springframework.core.type.MethodMetadata
  Return whether the underlying method is declared as 'static'.
isStatic() - 类 中的方法org.springframework.core.type.StandardMethodMetadata
isStaxResult(Result) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Indicate whether the given `Result` is a JAXP 1.4 StAX Result or custom StAX Result.
isStaxSource(Source) - 类 中的静态方法org.springframework.util.xml.StaxUtils
  Indicate whether the given `Source` is a JAXP 1.4 StAX Source or custom StAX Source.
isTerminated() - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter
isThrottleActive() - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Return whether this throttle is currently active.
isThrottleActive() - 类 中的方法org.springframework.util.ConcurrencyThrottleSupport
  Return whether this throttle is currently active.
ISTORE - 接口 中的静态变量org.springframework.asm.Opcodes
isToStringMethod(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Determine whether the given method is a "toString" method.
isTrue(boolean, String) - 类 中的静态方法org.springframework.util.Assert
  Assert a boolean expression, throwing an `IllegalArgumentException` if the expression evaluates to `false`.
isTrue(boolean, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert a boolean expression, throwing an `IllegalArgumentException` if the expression evaluates to `false`.
isTrue(boolean) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.isTrue(boolean, String)`
ISUB - 接口 中的静态变量org.springframework.asm.Opcodes
isUnknown() - 类 中的方法org.springframework.asm.Attribute
  Returns `true` if this type of attribute is unknown.
isUrl(String) - 类 中的静态方法org.springframework.core.io.support.ResourcePatternUtils
  Return whether the given resource location is a URL: either a special "classpath" or "classpath*" pseudo URL or a standard URL.
isUrl(String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Return whether the given resource location is a URL: either a special "classpath" pseudo URL or a standard URL.
isUserLevelMethod(Method) - 类 中的静态方法org.springframework.util.ClassUtils
  Determine whether the given method is declared by the user or at least pointing to a user-declared method.
isVisibilityBridgeMethodPair(Method, Method) - 类 中的静态方法org.springframework.core.BridgeMethodResolver
  Compare the signatures of the bridge method and the method which it bridges.
isVisible(Class<?>, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the given class is visible in the given ClassLoader.
isWildcardSubtype() - 类 中的方法org.springframework.util.MimeType
  Indicates whether the subtype is the wildcard character `*` or the wildcard character followed by a suffix (e.g.
isWildcardType() - 类 中的方法org.springframework.util.MimeType
  Indicates whether the type is the wildcard character `*` or not.
isWorthTrying() - 类 中的方法org.springframework.objenesis.SpringObjenesis
  Return whether this Objenesis instance is worth trying for instance creation, i.e. whether it hasn't been used yet or is known to work.
isWritable() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation checks whether the underlying file is marked as writable (and corresponds to an actual file with content, not to a directory).
isWritable() - 类 中的方法org.springframework.core.io.FileUrlResource
isWritable() - 类 中的方法org.springframework.core.io.PathResource
  This implementation checks whether the underlying file is marked as writable (and corresponds to an actual file with content, not to a directory).
isWritable() - 接口 中的方法org.springframework.core.io.WritableResource
  Indicate whether the contents of this resource can be written via `WritableResource.getOutputStream()`.
iterator() - 类 中的方法org.springframework.core.env.MutablePropertySources
iterator() - 类 中的方法org.springframework.util.AutoPopulatingList
IUSHR - 接口 中的静态变量org.springframework.asm.Opcodes
IXOR - 接口 中的静态变量org.springframework.asm.Opcodes

## J

JAR_FILE_EXTENSION - 类 中的静态变量org.springframework.util.ResourceUtils
  File extension for a regular jar file: ".jar"
JAR_URL_PREFIX - 类 中的静态变量org.springframework.util.ResourceUtils
  URL prefix for loading from a jar file: "jar:"
JAR_URL_SEPARATOR - 类 中的静态变量org.springframework.util.ResourceUtils
  Separator between JAR URL and file path within the JAR: "!
JdkIdGenerator - org.springframework.util中的类
  An `IdGenerator` that calls `UUID.randomUUID()`.
JdkIdGenerator() - 类 的构造器org.springframework.util.JdkIdGenerator
join(List<? extends DataBuffer>) - 接口 中的方法org.springframework.core.io.buffer.DataBufferFactory
  Return a new `DataBuffer` composed of the `dataBuffers` elements joined together.
join(Publisher<DataBuffer>) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Return a new `DataBuffer` composed of the `dataBuffers` elements joined together.
join(List<? extends DataBuffer>) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
  Return a new `DataBuffer` composed of the `dataBuffers` elements joined together.
join(List<? extends DataBuffer>) - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
  Return a new `DataBuffer` composed of the `dataBuffers` elements joined together.
JOptCommandLinePropertySource - org.springframework.core.env中的类
  `CommandLinePropertySource` implementation backed by a JOpt `OptionSet`.
JOptCommandLinePropertySource(OptionSet) - 类 的构造器org.springframework.core.env.JOptCommandLinePropertySource
  Create a new `JOptCommandLinePropertySource` having the default name and backed by the given `OptionSet`.
JOptCommandLinePropertySource(String, OptionSet) - 类 的构造器org.springframework.core.env.JOptCommandLinePropertySource
  Create a new `JOptCommandLinePropertySource` having the given name and backed by the given `OptionSet`.
JSR - 接口 中的静态变量org.springframework.asm.Opcodes

## K

keySet() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
keySet() - 类 中的方法org.springframework.util.LinkedMultiValueMap
KotlinDetector - org.springframework.core中的类
  A common delegate for detecting Kotlin's presence and for identifying Kotlin types.
KotlinDetector() - 类 的构造器org.springframework.core.KotlinDetector
KotlinReflectionParameterNameDiscoverer - org.springframework.core中的类
  `ParameterNameDiscoverer` implementation which uses Kotlin's reflection facilities for introspecting parameter names.
KotlinReflectionParameterNameDiscoverer() - 类 的构造器org.springframework.core.KotlinReflectionParameterNameDiscoverer

## L

L2D - 接口 中的静态变量org.springframework.asm.Opcodes
L2F - 接口 中的静态变量org.springframework.asm.Opcodes
L2I - 接口 中的静态变量org.springframework.asm.Opcodes
Label - org.springframework.asm中的类
  A label represents a position in the bytecode of a method.
Label() - 类 的构造器org.springframework.asm.Label
  Constructs a new label.
LADD - 接口 中的静态变量org.springframework.asm.Opcodes
LALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
LAND - 接口 中的静态变量org.springframework.asm.Opcodes
lastElement(Set<T>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Retrieve the last element of the given Set, using `SortedSet.last()` or otherwise iterating over all elements (assuming a linked set).
lastElement(List<T>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Retrieve the last element of the given List, accessing the highest index.
lastIndexOf(IntPredicate, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the index of the last byte in this buffer that matches the given predicate.
lastIndexOf(IntPredicate, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
lastIndexOf(IntPredicate, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
lastIndexOf(Object) - 类 中的方法org.springframework.util.AutoPopulatingList
lastModified() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
lastModified() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation checks the timestamp of the underlying File, if available.
lastModified() - 类 中的方法org.springframework.core.io.PathResource
  This implementation returns the underlying File's timestamp.
lastModified() - 接口 中的方法org.springframework.core.io.Resource
  Determine the last-modified timestamp for this resource.
lastModified() - 类 中的方法org.springframework.core.io.VfsResource
LASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
LCMP - 接口 中的静态变量org.springframework.asm.Opcodes
LCONST_0 - 接口 中的静态变量org.springframework.asm.Opcodes
LCONST_1 - 接口 中的静态变量org.springframework.asm.Opcodes
LDC - 接口 中的静态变量org.springframework.asm.Opcodes
LDIV - 接口 中的静态变量org.springframework.asm.Opcodes
LinkedCaseInsensitiveMap<V> - org.springframework.util中的类
  `LinkedHashMap` variant that stores String keys in a case-insensitive manner, for example for key-based access in a results table.
LinkedCaseInsensitiveMap() - 类 的构造器org.springframework.util.LinkedCaseInsensitiveMap
  Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys according to the default Locale (by default in lower case).
LinkedCaseInsensitiveMap(Locale) - 类 的构造器org.springframework.util.LinkedCaseInsensitiveMap
  Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys according to the given Locale (by default in lower case).
LinkedCaseInsensitiveMap(int) - 类 的构造器org.springframework.util.LinkedCaseInsensitiveMap
  Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores case-insensitive keys according to the default Locale (by default in lower case).
LinkedCaseInsensitiveMap(int, Locale) - 类 的构造器org.springframework.util.LinkedCaseInsensitiveMap
  Create a new LinkedCaseInsensitiveMap that wraps a `LinkedHashMap` with the given initial capacity and stores case-insensitive keys according to the given Locale (by default in lower case).
LinkedMultiValueMap<K,V> - org.springframework.util中的类
  Simple implementation of `MultiValueMap` that wraps a `LinkedHashMap`, storing multiple values in a `LinkedList`.
LinkedMultiValueMap() - 类 的构造器org.springframework.util.LinkedMultiValueMap
  Create a new LinkedMultiValueMap that wraps a `LinkedHashMap`.
LinkedMultiValueMap(int) - 类 的构造器org.springframework.util.LinkedMultiValueMap
  Create a new LinkedMultiValueMap that wraps a `LinkedHashMap` with the given initial capacity.
LinkedMultiValueMap(Map<K, List<V>>) - 类 的构造器org.springframework.util.LinkedMultiValueMap
  Copy constructor: Create a new LinkedMultiValueMap with the same mappings as the specified Map.
ListenableFuture<T> - org.springframework.util.concurrent中的接口
  Extend `Future` with the capability to accept completion callbacks.
ListenableFutureAdapter<T,S> - org.springframework.util.concurrent中的类
  Abstract class that adapts a `ListenableFuture` parameterized over S into a `ListenableFuture` parameterized over T.
ListenableFutureAdapter(ListenableFuture<S>) - 类 的构造器org.springframework.util.concurrent.ListenableFutureAdapter
  Construct a new `ListenableFutureAdapter` with the given adaptee.
ListenableFutureCallback<T> - org.springframework.util.concurrent中的接口
  Callback mechanism for the outcome, success or failure, from a `ListenableFuture`.
ListenableFutureCallbackRegistry<T> - org.springframework.util.concurrent中的类
  Helper class for `ListenableFuture` implementations that maintains a of success and failure callbacks and helps to notify them.
ListenableFutureCallbackRegistry() - 类 的构造器org.springframework.util.concurrent.ListenableFutureCallbackRegistry
ListenableFutureTask<T> - org.springframework.util.concurrent中的类
  Extension of `FutureTask` that implements `ListenableFuture`.
ListenableFutureTask(Callable<T>) - 类 的构造器org.springframework.util.concurrent.ListenableFutureTask
  Create a new `ListenableFutureTask` that will, upon running, execute the given `Callable`.
ListenableFutureTask(Runnable, T) - 类 的构造器org.springframework.util.concurrent.ListenableFutureTask
  Create a `ListenableFutureTask` that will, upon running, execute the given `Runnable`, and arrange that `FutureTask.get()` will return the given result on successful completion.
listIterator() - 类 中的方法org.springframework.util.AutoPopulatingList
listIterator(int) - 类 中的方法org.springframework.util.AutoPopulatingList
LLOAD - 接口 中的静态变量org.springframework.asm.Opcodes
LMUL - 接口 中的静态变量org.springframework.asm.Opcodes
LNEG - 接口 中的静态变量org.springframework.asm.Opcodes
load(Properties, InputStream) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
load(Properties, Reader) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
load(Properties, InputStream) - 接口 中的方法org.springframework.util.PropertiesPersister
  Load properties from the given InputStream into the given Properties object.
load(Properties, Reader) - 接口 中的方法org.springframework.util.PropertiesPersister
  Load properties from the given Reader into the given Properties object.
loadAllProperties(String) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Load all properties from the specified class path resource (in ISO-8859-1 encoding), using the default class loader.
loadAllProperties(String, ClassLoader) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Load all properties from the specified class path resource (in ISO-8859-1 encoding), using the given class loader.
loadBytesForClass(String) - 类 中的方法org.springframework.core.OverridingClassLoader
  Load the defining bytes for the given class, to be turned into a Class object through a `ClassLoader.defineClass(byte[], int, int)` call.
loadClass(String) - 类 中的方法org.springframework.core.OverridingClassLoader
loadClass(String, boolean) - 类 中的方法org.springframework.core.OverridingClassLoader
loadClassForOverriding(String) - 类 中的方法org.springframework.core.OverridingClassLoader
  Load the specified class for overriding purposes in this ClassLoader.
loadFactories(Class<T>, ClassLoader) - 类 中的静态方法org.springframework.core.io.support.SpringFactoriesLoader
  Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the given class loader.
loadFactoryNames(Class<?>, ClassLoader) - 类 中的静态方法org.springframework.core.io.support.SpringFactoriesLoader
  Load the fully qualified class names of factory implementations of the given type from "META-INF/spring.factories", using the given class loader.
loadFromXml(Properties, InputStream) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
loadFromXml(Properties, InputStream) - 接口 中的方法org.springframework.util.PropertiesPersister
  Load properties from the given XML InputStream into the given Properties object.
loadProperties(Properties) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Load properties into the given instance.
loadProperties(EncodedResource) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Load properties from the given EncodedResource, potentially defining a specific encoding for the properties file.
loadProperties(Resource) - 类 中的静态方法org.springframework.core.io.support.PropertiesLoaderUtils
  Load properties from the given resource (in ISO-8859-1 encoding).
LOCAL_VARIABLE - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of a local variable in a method.
LocalizedResourceHelper - org.springframework.core.io.support中的类
  Helper class for loading a localized resource, specified through name, extension and current locale.
LocalizedResourceHelper() - 类 的构造器org.springframework.core.io.support.LocalizedResourceHelper
  Create a new LocalizedResourceHelper with a DefaultResourceLoader.
LocalizedResourceHelper(ResourceLoader) - 类 的构造器org.springframework.core.io.support.LocalizedResourceHelper
  Create a new LocalizedResourceHelper with the given ResourceLoader.
localOverride - 类 中的变量org.springframework.core.io.support.PropertiesLoaderSupport
localProperties - 类 中的变量org.springframework.core.io.support.PropertiesLoaderSupport
LocalVariableTableParameterNameDiscoverer - org.springframework.core中的类
  Implementation of `ParameterNameDiscoverer` that uses the LocalVariableTable information in the method attributes to discover parameter names.
LocalVariableTableParameterNameDiscoverer() - 类 的构造器org.springframework.core.LocalVariableTableParameterNameDiscoverer
logger - 类 中的变量org.springframework.core.env.AbstractEnvironment
logger - 类 中的变量org.springframework.core.env.AbstractPropertyResolver
logger - 类 中的变量org.springframework.core.env.PropertySource
logger - 类 中的变量org.springframework.core.io.support.PropertiesLoaderSupport
  Logger available to subclasses
logger - 类 中的变量org.springframework.core.SimpleAliasRegistry
  Logger available to subclasses
logger - 类 中的变量org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
logger - 类 中的变量org.springframework.util.ConcurrencyThrottleSupport
  Transient to optimize serialization
logKeyFound(String, PropertySource<?>, Object) - 类 中的方法org.springframework.core.env.PropertySourcesPropertyResolver
  Log the given key as found in the given `PropertySource`, resulting in the given value.
LONG - 接口 中的静态变量org.springframework.asm.Opcodes
LONG - 类 中的静态变量org.springframework.asm.Type
  The sort of the `long` type.
LONG_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `long` type.
LOOKUPSWITCH - 接口 中的静态变量org.springframework.asm.Opcodes
LOR - 接口 中的静态变量org.springframework.asm.Opcodes
LOWEST_PRECEDENCE - 接口 中的静态变量org.springframework.core.Ordered
  Useful constant for the lowest precedence value.
LREM - 接口 中的静态变量org.springframework.asm.Opcodes
LRETURN - 接口 中的静态变量org.springframework.asm.Opcodes
LSHL - 接口 中的静态变量org.springframework.asm.Opcodes
LSHR - 接口 中的静态变量org.springframework.asm.Opcodes
LSTORE - 接口 中的静态变量org.springframework.asm.Opcodes
LSUB - 接口 中的静态变量org.springframework.asm.Opcodes
LUSHR - 接口 中的静态变量org.springframework.asm.Opcodes
LXOR - 接口 中的静态变量org.springframework.asm.Opcodes

## M

makeAccessible(Constructor<?>) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Make the given constructor accessible, explicitly setting it accessible if necessary.
makeAccessible(Method) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Make the given method accessible, explicitly setting it accessible if necessary.
makeAccessible(Field) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Make the given field accessible, explicitly setting it accessible if necessary.
map(Class<?>, TypeDescriptor, TypeDescriptor) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `Map` type.
mapEntryKeys(Comparator<K>) - 类 中的静态方法org.springframework.core.convert.converter.ConvertingComparator
  Create a new `ConvertingComparator` that compares `map * entries` based on their `keys`.
mapEntryValues(Comparator<V>) - 类 中的静态方法org.springframework.core.convert.converter.ConvertingComparator
  Create a new `ConvertingComparator` that compares `map entries` based on their `values`.
MapPropertySource - org.springframework.core.env中的类
  `PropertySource` that reads keys and values from a `Map` object.
MapPropertySource(String, Map<String, Object>) - 类 的构造器org.springframework.core.env.MapPropertySource
match(MetadataReader, MetadataReaderFactory) - 类 中的方法org.springframework.core.type.filter.AbstractClassTestingTypeFilter
match(ClassMetadata) - 类 中的方法org.springframework.core.type.filter.AbstractClassTestingTypeFilter
  Determine a match based on the given ClassMetadata object.
match(MetadataReader, MetadataReaderFactory) - 类 中的方法org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
match(MetadataReader, MetadataReaderFactory) - 类 中的方法org.springframework.core.type.filter.AspectJTypeFilter
match(ClassMetadata) - 类 中的方法org.springframework.core.type.filter.RegexPatternTypeFilter
match(MetadataReader, MetadataReaderFactory) - 接口 中的方法org.springframework.core.type.filter.TypeFilter
  Determine whether this filter matches for the class described by the given metadata.
match(String, String) - 类 中的方法org.springframework.util.AntPathMatcher
match(Class<? extends Throwable>, Class<? extends Throwable>) - 类 中的方法org.springframework.util.ExceptionTypeFilter
match(T) - 类 中的方法org.springframework.util.InstanceFilter
  Determine if the specified {code instance} matches this filter.
match(T, T) - 类 中的方法org.springframework.util.InstanceFilter
  Determine if the specified `instance` is equal to the specified `candidate`.
match(T, Collection<? extends T>) - 类 中的方法org.springframework.util.InstanceFilter
  Determine if the specified `instance` matches one of the candidates.
match(String, String) - 接口 中的方法org.springframework.util.PathMatcher
  Match the given `path` against the given `pattern`, according to this PathMatcher's matching strategy.
matchClassName(String) - 类 中的方法org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
  Override this to match on type name.
matchClassName(String) - 类 中的方法org.springframework.core.type.filter.AssignableTypeFilter
matches(TypeDescriptor, TypeDescriptor) - 接口 中的方法org.springframework.core.convert.converter.ConditionalConverter
  Should the conversion from `sourceType` to `targetType` currently under consideration be selected?
matches(Field) - 接口 中的方法org.springframework.util.ReflectionUtils.FieldFilter
  Determine whether the given field matches.
matches(Method) - 接口 中的方法org.springframework.util.ReflectionUtils.MethodFilter
  Determine whether the given method matches.
matchesTypeName(Class<?>, String) - 类 中的静态方法org.springframework.util.ClassUtils
  Check whether the given class matches the user-specified type name.
matchInterface(String) - 类 中的方法org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
  Override this to match on interface type name.
matchInterface(String) - 类 中的方法org.springframework.core.type.filter.AnnotationTypeFilter
matchInterface(String) - 类 中的方法org.springframework.core.type.filter.AssignableTypeFilter
matchSelf(MetadataReader) - 类 中的方法org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
  Override this to match self characteristics alone.
matchSelf(MetadataReader) - 类 中的方法org.springframework.core.type.filter.AnnotationTypeFilter
matchStart(String, String) - 类 中的方法org.springframework.util.AntPathMatcher
matchStart(String, String) - 接口 中的方法org.springframework.util.PathMatcher
  Match the given `path` against the corresponding part of the given `pattern`, according to this PathMatcher's matching strategy.
matchStrings(String, Map<String, String>) - 类 中的方法org.springframework.util.AntPathMatcher.AntPathStringMatcher
  Main entry point.
matchSuperClass(String) - 类 中的方法org.springframework.core.type.filter.AbstractTypeHierarchyTraversingFilter
  Override this to match on super type name.
matchSuperClass(String) - 类 中的方法org.springframework.core.type.filter.AnnotationTypeFilter
matchSuperClass(String) - 类 中的方法org.springframework.core.type.filter.AssignableTypeFilter
matchTargetType(String) - 类 中的方法org.springframework.core.type.filter.AssignableTypeFilter
md5Digest(byte[]) - 类 中的静态方法org.springframework.util.DigestUtils
  Calculate the MD5 digest of the given bytes.
md5Digest(InputStream) - 类 中的静态方法org.springframework.util.DigestUtils
  Calculate the MD5 digest of the given stream.
md5DigestAsHex(byte[]) - 类 中的静态方法org.springframework.util.DigestUtils
  Return a hexadecimal string representation of the MD5 digest of the given bytes.
md5DigestAsHex(InputStream) - 类 中的静态方法org.springframework.util.DigestUtils
  Return a hexadecimal string representation of the MD5 digest of the given stream.
merge(ConfigurableEnvironment) - 类 中的方法org.springframework.core.env.AbstractEnvironment
merge(ConfigurableEnvironment) - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Append the given parent environment's active profiles, default profiles and property sources to this (child) environment's respective collections of each.
mergeArrayIntoCollection(Object, Collection<E>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Merge the given array into the given Collection.
mergeProperties() - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Return a merged Properties instance containing both the loaded properties and properties set on this FactoryBean.
mergePropertiesIntoMap(Properties, Map<K, V>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Merge the given Properties instance into the given Map, copying all properties (key-value pairs) over.
mergeStringArrays(String[], String[]) - 类 中的静态方法org.springframework.util.StringUtils
  已过时。
  as of 4.3.15, in favor of manual merging via `LinkedHashSet` (with every entry included at most once, even entries within the first array)
metaAnnotationMap - 类 中的变量org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
metaAnnotationMap - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
MetadataReader - org.springframework.core.type.classreading中的接口
  Simple facade for accessing class metadata, as read by an ASM `ClassReader`.
MetadataReaderFactory - org.springframework.core.type.classreading中的接口
  Factory interface for `MetadataReader` instances.
METHOD - 类 中的静态变量org.springframework.asm.Type
  The sort of method types.
METHOD_FORMAL_PARAMETER - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of a formal parameter of a method.
METHOD_INVOCATION_TYPE_ARGUMENT - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic method in a method call.
METHOD_RECEIVER - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the receiver type of a method.
METHOD_REFERENCE - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the receiver type of a method reference.
METHOD_REFERENCE_TYPE_ARGUMENT - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic method in a method reference.
METHOD_RETURN - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the return type of a method.
METHOD_TYPE_PARAMETER - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a type parameter of a generic method.
METHOD_TYPE_PARAMETER_BOUND - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target a bound of a type parameter of a generic method.
MethodClassKey - org.springframework.core中的类
  A common key class for a method against a specific target class, including `MethodClassKey.toString()` representation and `Comparable` support (as suggested for custom `HashMap` keys as of Java 8).
MethodClassKey(Method, Class<?>) - 类 的构造器org.springframework.core.MethodClassKey
  Create a key object for the given method and target class.
MethodIntrospector - org.springframework.core中的类
  Defines the algorithm for searching for metadata-associated methods exhaustively including interfaces and parent classes while also dealing with parameterized methods as well as common scenarios encountered with interface and class-based proxies.
MethodIntrospector() - 类 的构造器org.springframework.core.MethodIntrospector
MethodIntrospector.MetadataLookup<T> - org.springframework.core中的接口
  A callback interface for metadata lookup on a given method.
MethodInvoker - org.springframework.util中的类
  Helper class that allows for specifying a method to invoke in a declarative fashion, be it static or non-static.
MethodInvoker() - 类 的构造器org.springframework.util.MethodInvoker
MethodMetadata - org.springframework.core.type中的接口
  Interface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet.
MethodMetadataReadingVisitor - org.springframework.core.type.classreading中的类
  ASM method visitor which looks for the annotations defined on a method, exposing them through the `MethodMetadata` interface.
MethodMetadataReadingVisitor(String, int, String, String, ClassLoader, Set<MethodMetadata>) - 类 的构造器org.springframework.core.type.classreading.MethodMetadataReadingVisitor
methodMetadataSet - 类 中的变量org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
methodMetadataSet - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
methodName - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor
MethodParameter - org.springframework.core中的类
  Helper class that encapsulates the specification of a method parameter, i.e. a `Method` or `Constructor` plus a parameter index and a nested type index for a declared generic type.
MethodParameter(Method, int) - 类 的构造器org.springframework.core.MethodParameter
  Create a new `MethodParameter` for the given method, with nesting level 1.
MethodParameter(Method, int, int) - 类 的构造器org.springframework.core.MethodParameter
  Create a new `MethodParameter` for the given method.
MethodParameter(Constructor<?>, int) - 类 的构造器org.springframework.core.MethodParameter
  Create a new MethodParameter for the given constructor, with nesting level 1.
MethodParameter(Constructor<?>, int, int) - 类 的构造器org.springframework.core.MethodParameter
  Create a new MethodParameter for the given constructor.
MethodParameter(MethodParameter) - 类 的构造器org.springframework.core.MethodParameter
  Copy constructor, resulting in an independent MethodParameter object based on the same metadata and cache state that the original object was in.
MethodVisitor - org.springframework.asm中的类
  A visitor to visit a Java method.
MethodVisitor(int) - 类 的构造器org.springframework.asm.MethodVisitor
  Constructs a new `MethodVisitor`.
MethodVisitor(int, MethodVisitor) - 类 的构造器org.springframework.asm.MethodVisitor
  Constructs a new `MethodVisitor`.
MimeType - org.springframework.util中的类
  Represents a MIME Type, as originally defined in RFC 2046 and subsequently used in other Internet protocols including HTTP.
MimeType(String) - 类 的构造器org.springframework.util.MimeType
  Create a new `MimeType` for the given primary type.
MimeType(String, String) - 类 的构造器org.springframework.util.MimeType
  Create a new `MimeType` for the given primary type and subtype.
MimeType(String, String, Charset) - 类 的构造器org.springframework.util.MimeType
  Create a new `MimeType` for the given type, subtype, and character set.
MimeType(MimeType, Charset) - 类 的构造器org.springframework.util.MimeType
  Copy-constructor that copies the type, subtype, parameters of the given `MimeType`, and allows to set the specified character set.
MimeType(MimeType, Map<String, String>) - 类 的构造器org.springframework.util.MimeType
  Copy-constructor that copies the type and subtype of the given `MimeType`, and allows for different parameter.
MimeType(String, String, Map<String, String>) - 类 的构造器org.springframework.util.MimeType
  Create a new `MimeType` for the given type, subtype, and parameters.
MimeType.SpecificityComparator<T extends MimeType> - org.springframework.util中的类
MimeTypeUtils - org.springframework.util中的类
  Miscellaneous `MimeType` utility methods.
MimeTypeUtils() - 类 的构造器org.springframework.util.MimeTypeUtils
MissingRequiredPropertiesException - org.springframework.core.env中的异常错误
  Exception thrown when required properties are not found.
MissingRequiredPropertiesException() - 异常错误 的构造器org.springframework.core.env.MissingRequiredPropertiesException
ModuleVisitor - org.springframework.asm中的类
  A visitor to visit a Java module.
ModuleVisitor(int) - 类 的构造器org.springframework.asm.ModuleVisitor
ModuleVisitor(int, ModuleVisitor) - 类 的构造器org.springframework.asm.ModuleVisitor
  Constructs a new `MethodVisitor`.
MONITORENTER - 接口 中的静态变量org.springframework.asm.Opcodes
MONITOREXIT - 接口 中的静态变量org.springframework.asm.Opcodes
MULTIANEWARRAY - 接口 中的静态变量org.springframework.asm.Opcodes
multiValue(Class<?>, Supplier<?>) - 类 中的静态方法org.springframework.core.ReactiveTypeDescriptor
  Descriptor for a reactive type that can produce 0..N values.
MultiValueMap<K,V> - org.springframework.util中的接口
  Extension of the `Map` interface that stores multiple values.
MutablePropertySources - org.springframework.core.env中的类
  The default implementation of the `PropertySources` interface.
MutablePropertySources() - 类 的构造器org.springframework.core.env.MutablePropertySources
  Create a new `MutablePropertySources` object.
MutablePropertySources(PropertySources) - 类 的构造器org.springframework.core.env.MutablePropertySources
  Create a new `MutablePropertySources` from the given propertySources object, preserving the original order of contained `PropertySource` objects.
mv - 类 中的变量org.springframework.asm.MethodVisitor
  The method visitor to which this visitor must delegate method calls.
mv - 类 中的变量org.springframework.asm.ModuleVisitor
  The module visitor to which this visitor must delegate method calls.

## N

name - 类 中的变量org.springframework.core.env.PropertySource
named(String) - 类 中的静态方法org.springframework.core.env.PropertySource
  Return a `PropertySource` implementation intended for collection comparison purposes only.
NamedInheritableThreadLocal<T> - org.springframework.core中的类
  `InheritableThreadLocal` subclass that exposes a specified name as `NamedInheritableThreadLocal.toString()` result (allowing for introspection).
NamedInheritableThreadLocal(String) - 类 的构造器org.springframework.core.NamedInheritableThreadLocal
  Create a new NamedInheritableThreadLocal with the given name.
NamedThreadLocal<T> - org.springframework.core中的类
  `ThreadLocal` subclass that exposes a specified name as `NamedThreadLocal.toString()` result (allowing for introspection).
NamedThreadLocal(String) - 类 的构造器org.springframework.core.NamedThreadLocal
  Create a new NamedThreadLocal with the given name.
narrow(Object) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Narrows this `TypeDescriptor` by setting its type to the class of the provided value.
nested(MethodParameter, int) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a type descriptor for a nested type declared within the method parameter.
nested(Field, int) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a type descriptor for a nested type declared within the field.
nested(Property, int) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a type descriptor for a nested type declared within the property.
nested() - 类 中的方法org.springframework.core.MethodParameter
  Return a variant of this `MethodParameter` which points to the same parameter but one nesting level deeper.
NestedCheckedException - org.springframework.core中的异常错误
  Handy class for wrapping checked `Exceptions` with a root cause.
NestedCheckedException(String) - 异常错误 的构造器org.springframework.core.NestedCheckedException
  Construct a `NestedCheckedException` with the specified detail message.
NestedCheckedException(String, Throwable) - 异常错误 的构造器org.springframework.core.NestedCheckedException
  Construct a `NestedCheckedException` with the specified detail message and nested exception.
NestedExceptionUtils - org.springframework.core中的类
  Helper class for implementing exception classes which are capable of holding nested exceptions.
NestedExceptionUtils() - 类 的构造器org.springframework.core.NestedExceptionUtils
nestedIfOptional() - 类 中的方法org.springframework.core.MethodParameter
  Return a variant of this `MethodParameter` which points to the same parameter but one nesting level deeper in case of a `Optional` declaration.
NestedIOException - org.springframework.core中的异常错误
  Subclass of `IOException` that properly handles a root cause, exposing the root cause just like NestedChecked/RuntimeException does.
NestedIOException(String) - 异常错误 的构造器org.springframework.core.NestedIOException
  Construct a `NestedIOException` with the specified detail message.
NestedIOException(String, Throwable) - 异常错误 的构造器org.springframework.core.NestedIOException
  Construct a `NestedIOException` with the specified detail message and nested exception.
NestedRuntimeException - org.springframework.core中的异常错误
  Handy class for wrapping runtime `Exceptions` with a root cause.
NestedRuntimeException(String) - 异常错误 的构造器org.springframework.core.NestedRuntimeException
  Construct a `NestedRuntimeException` with the specified detail message.
NestedRuntimeException(String, Throwable) - 异常错误 的构造器org.springframework.core.NestedRuntimeException
  Construct a `NestedRuntimeException` with the specified detail message and nested exception.
NettyDataBuffer - org.springframework.core.io.buffer中的类
  Implementation of the `DataBuffer` interface that wraps a Netty `ByteBuf`.
NettyDataBufferFactory - org.springframework.core.io.buffer中的类
  Implementation of the `DataBufferFactory` interface based on a Netty `ByteBufAllocator`.
NettyDataBufferFactory(ByteBufAllocator) - 类 的构造器org.springframework.core.io.buffer.NettyDataBufferFactory
  Create a new `NettyDataBufferFactory` based on the given factory.
NEW - 接口 中的静态变量org.springframework.asm.Opcodes
NEW - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of the object created by a 'new' instruction.
NEWARRAY - 接口 中的静态变量org.springframework.asm.Opcodes
newClass(String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a class reference to the constant pool of the class being build.
newConst(Object) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a number or string constant to the constant pool of the class being build.
newExceptionReference(int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to the type of an exception, in a 'throws' clause of a method.
newField(String, String, String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a field reference to the constant pool of the class being build.
newFormalParameterReference(int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to the type of a formal parameter of a method.
newHandle(int, String, String, String) - 类 中的方法org.springframework.asm.ClassWriter
  已过时。
  this method is superseded by `ClassWriter.newHandle(int, String, String, String, boolean)`.
newHandle(int, String, String, String, boolean) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a handle to the constant pool of the class being build.
newInstance(Class<T>, boolean) - 类 中的方法org.springframework.objenesis.SpringObjenesis
  Create a new instance of the given class via Objenesis.
newInstance(Class<T>) - 类 中的方法org.springframework.objenesis.SpringObjenesis
newInstantiatorOf(Class<T>) - 类 中的方法org.springframework.objenesis.SpringObjenesis
newInvokeDynamic(String, String, Handle, Object...) - 类 中的方法org.springframework.asm.ClassWriter
  Adds an invokedynamic reference to the constant pool of the class being build.
newMethod(String, String, String, boolean) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a method reference to the constant pool of the class being build.
newMethodType(String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a method type reference to the constant pool of the class being build.
newModule(String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a module reference to the constant pool of the class being build.
newNameType(String, String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a name and type to the constant pool of the class being build.
newPackage(String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds a package reference to the constant pool of the class being build.
newSuperTypeReference(int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to the super class or to an interface of the 'implements' clause of a class.
newTryCatchReference(int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to the type of the exception declared in a 'catch' clause of a method.
newTypeArgumentReference(int, int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to the type of a type argument in a constructor or method call or reference.
newTypeParameterBoundReference(int, int, int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to a type parameter bound of a generic class or method.
newTypeParameterReference(int, int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a reference to a type parameter of a generic class or method.
newTypeReference(int) - 类 中的静态方法org.springframework.asm.TypeReference
  Returns a type reference of the given sort.
newUTF8(String) - 类 中的方法org.springframework.asm.ClassWriter
  Adds an UTF8 string to the constant pool of the class being build.
next() - 类 中的方法org.springframework.util.CompositeIterator
nextBackOff() - 接口 中的方法org.springframework.util.backoff.BackOffExecution
  Return the number of milliseconds to wait before retrying the operation or `BackOffExecution.STOP` (-1L) to indicate that no further attempt should be made for the operation.
nextThreadName() - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Return the thread name to use for a newly created `Thread`.
NO_CONCURRENCY - 类 中的静态变量org.springframework.core.task.SimpleAsyncTaskExecutor
  Switch concurrency 'off': that is, don't allow any concurrent invocations.
NO_CONCURRENCY - 类 中的静态变量org.springframework.util.ConcurrencyThrottleSupport
  Switch concurrency 'off': that is, don't allow any concurrent invocations.
nodeNameEquals(Node, String) - 类 中的静态方法org.springframework.util.xml.DomUtils
  Namespace-aware equals comparison.
NON_BRIDGED_METHODS - 类 中的静态变量org.springframework.util.ReflectionUtils
  已过时。
  as of 5.0.11, in favor of a custom `ReflectionUtils.MethodFilter`
nonClosing(InputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Return a variant of the given `InputStream` where calling `close()` has no effect.
nonClosing(OutputStream) - 类 中的静态方法org.springframework.util.StreamUtils
  Return a variant of the given `OutputStream` where calling `close()` has no effect.
NONE - 类 中的静态变量org.springframework.core.ResolvableType
  `ResolvableType` returned when no value is available.
NonNull - org.springframework.lang中的注释类型
  A common Spring annotation to declare that annotated elements cannot be `null`.
NonNullApi - org.springframework.lang中的注释类型
  A common Spring annotation to declare that parameters and return values are to be considered as non-nullable by default for a given package.
NonNullFields - org.springframework.lang中的注释类型
  A common Spring annotation to declare that fields are to be considered as non-nullable by default for a given package.
noNullElements(Object[], String) - 类 中的静态方法org.springframework.util.Assert
  Assert that an array contains no `null` elements.
noNullElements(Object[], Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that an array contains no `null` elements.
noNullElements(Object[]) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.noNullElements(Object[], String)`
NOP - 接口 中的静态变量org.springframework.asm.Opcodes
notEmpty(Object[], String) - 类 中的静态方法org.springframework.util.Assert
  Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
notEmpty(Object[], Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
notEmpty(Object[]) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.notEmpty(Object[], String)`
notEmpty(Collection<?>, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
notEmpty(Collection<?>, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
notEmpty(Collection<?>) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.notEmpty(Collection, String)`
notEmpty(Map<?, ?>, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
notEmpty(Map<?, ?>, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
notEmpty(Map<?, ?>) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.notEmpty(Map, String)`
notNull(Object, String) - 类 中的静态方法org.springframework.util.Assert
  Assert that an object is not `null`.
notNull(Object, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert that an object is not `null`.
notNull(Object) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.notNull(Object, String)`
noValue(Class<?>, Supplier<?>) - 类 中的静态方法org.springframework.core.ReactiveTypeDescriptor
  Descriptor for a reactive type that does not produce any values.
NULL - 接口 中的静态变量org.springframework.asm.Opcodes
Nullable - org.springframework.lang中的注释类型
  A common Spring annotation to declare that annotated elements can be `null` under some circumstance.
NULLS_HIGH - 类 中的静态变量org.springframework.util.comparator.NullSafeComparator
  A shared default instance of this comparator, treating nulls higher than non-null objects.
NULLS_LOW - 类 中的静态变量org.springframework.util.comparator.NullSafeComparator
  A shared default instance of this comparator, treating nulls lower than non-null objects.
nullSafeClassName(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Determine the class name for the given object.
NullSafeComparator<T> - org.springframework.util.comparator中的类
  A Comparator that will safely compare nulls to be lower or higher than other objects.
NullSafeComparator(Comparator<T>, boolean) - 类 的构造器org.springframework.util.comparator.NullSafeComparator
  Create a NullSafeComparator that sorts `null` based on the provided flag, decorating the given Comparator.
nullSafeEquals(Object, Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Determine if the given objects are equal, returning `true` if both are `null` or `false` if only one is `null`.
nullSafeHashCode(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return as hash code for the given object; typically the value of `Object#hashCode()`}.
nullSafeHashCode(Object[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(boolean[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(byte[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(char[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(double[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(float[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(int[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(long[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeHashCode(short[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a hash code based on the contents of the specified array.
nullSafeToString(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the specified Object.
nullSafeToString(Object[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(boolean[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(byte[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(char[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(double[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(float[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(int[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(long[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullSafeToString(short[]) - 类 中的静态方法org.springframework.util.ObjectUtils
  Return a String representation of the contents of the specified array.
nullsHigh() - 类 中的静态方法org.springframework.util.comparator.Comparators
  Return a `Comparable` adapter which accepts null values and sorts them higher than non-null values.
nullsHigh(Comparator<T>) - 类 中的静态方法org.springframework.util.comparator.Comparators
  Return a decorator for the given comparator which accepts null values and sorts them higher than non-null values.
nullsLow() - 类 中的静态方法org.springframework.util.comparator.Comparators
  Return a `Comparable` adapter which accepts null values and sorts them lower than non-null values.
nullsLow(Comparator<T>) - 类 中的静态方法org.springframework.util.comparator.Comparators
  Return a decorator for the given comparator which accepts null values and sorts them lower than non-null values.
NumberUtils - org.springframework.util中的类
  Miscellaneous utility methods for number conversion and parsing.
NumberUtils() - 类 的构造器org.springframework.util.NumberUtils

## O

OBJECT - 类 中的静态变量org.springframework.asm.Type
  The sort of object reference types.
ObjectUtils - org.springframework.util中的类
  Miscellaneous object utility methods.
ObjectUtils() - 类 的构造器org.springframework.util.ObjectUtils
onFailure(Throwable) - 接口 中的方法org.springframework.util.concurrent.FailureCallback
  Called when the `ListenableFuture` completes with failure.
onSuccess(T) - 接口 中的方法org.springframework.util.concurrent.SuccessCallback
  Called when the `ListenableFuture` completes with success.
Opcodes - org.springframework.asm中的接口
  Defines the JVM opcodes, access flags and array type codes.
openStreamForClass(String) - 类 中的方法org.springframework.core.OverridingClassLoader
  Open an InputStream for the specified class.
Order - org.springframework.core.annotation中的注释类型
  `@Order` defines the sort order for an annotated component.
OrderComparator - org.springframework.core中的类
  `Comparator` implementation for `Ordered` objects, sorting by order value ascending, respectively by priority descending.
OrderComparator() - 类 的构造器org.springframework.core.OrderComparator
OrderComparator.OrderSourceProvider - org.springframework.core中的接口
  Strategy interface to provide an order source for a given object.
Ordered - org.springframework.core中的接口
  `Ordered` is an interface that can be implemented by objects that should be orderable, for example in a `Collection`.
OrderUtils - org.springframework.core.annotation中的类
  General utility for determining the order of an object based on its type declaration.
OrderUtils() - 类 的构造器org.springframework.core.annotation.OrderUtils
org.springframework.asm - 程序包 org.springframework.asm
  Spring's repackaging of ASM 6.0 (with Spring-specific patches; for internal use only).
org.springframework.cglib - 程序包 org.springframework.cglib
  Spring's repackaging of CGLIB 3.2 (with Spring naming strategy; for internal use only).
org.springframework.cglib.core - 程序包 org.springframework.cglib.core
org.springframework.core - 程序包 org.springframework.core
  Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.annotation - 程序包 org.springframework.core.annotation
  Core support package for annotations, meta-annotations, and composed annotations with attribute overrides.
org.springframework.core.codec - 程序包 org.springframework.core.codec
  `Encoder` and `Decoder` abstractions to convert between a reactive stream of bytes and Java objects.
org.springframework.core.convert - 程序包 org.springframework.core.convert
  Type conversion system API.
org.springframework.core.convert.converter - 程序包 org.springframework.core.convert.converter
  SPI to implement Converters for the type conversion system.
org.springframework.core.convert.support - 程序包 org.springframework.core.convert.support
  Default implementation of the type conversion system.
org.springframework.core.env - 程序包 org.springframework.core.env
  Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
org.springframework.core.io - 程序包 org.springframework.core.io
  Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.io.buffer - 程序包 org.springframework.core.io.buffer
  Generic abstraction for working with byte buffer implementations.
org.springframework.core.io.support - 程序包 org.springframework.core.io.support
  Support classes for Spring's resource abstraction.
org.springframework.core.serializer - 程序包 org.springframework.core.serializer
  Root package for Spring's serializer interfaces and implementations.
org.springframework.core.serializer.support - 程序包 org.springframework.core.serializer.support
  Support classes for Spring's serializer abstraction.
org.springframework.core.style - 程序包 org.springframework.core.style
  Support for styling values as Strings, with ToStringCreator as central class.
org.springframework.core.task - 程序包 org.springframework.core.task
  This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
org.springframework.core.task.support - 程序包 org.springframework.core.task.support
  Support classes for Spring's TaskExecutor abstraction.
org.springframework.core.type - 程序包 org.springframework.core.type
  Core support package for type introspection.
org.springframework.core.type.classreading - 程序包 org.springframework.core.type.classreading
  Support classes for reading annotation and class-level metadata.
org.springframework.core.type.filter - 程序包 org.springframework.core.type.filter
  Core support package for type filtering (e.g. for classpath scanning).
org.springframework.lang - 程序包 org.springframework.lang
  Common annotations with language-level semantics: nullability as well as JDK API indications.
org.springframework.objenesis - 程序包 org.springframework.objenesis
  Spring's repackaging of Objenesis 2.6 (with SpringObjenesis entry point; for internal use only).
org.springframework.util - 程序包 org.springframework.util
  Miscellaneous utility classes, such as String manipulation utilities, a Log4J configurer, and a state holder for paged lists of objects.
org.springframework.util.backoff - 程序包 org.springframework.util.backoff
  A generic back-off abstraction.
org.springframework.util.comparator - 程序包 org.springframework.util.comparator
  Useful generic `java.util.Comparator` implementations, such as an invertible comparator and a compound comparator.
org.springframework.util.concurrent - 程序包 org.springframework.util.concurrent
  Useful generic `java.util.concurrent.Future` extension.
org.springframework.util.xml - 程序包 org.springframework.util.xml
  Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.
overrideThreadContextClassLoader(ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.
OverridingClassLoader - org.springframework.core中的类
  `ClassLoader` that does not always delegate to the parent loader as normal class loaders do.
OverridingClassLoader(ClassLoader) - 类 的构造器org.springframework.core.OverridingClassLoader
  Create a new OverridingClassLoader for the given ClassLoader.
OverridingClassLoader(ClassLoader, ClassLoader) - 类 的构造器org.springframework.core.OverridingClassLoader
  Create a new OverridingClassLoader for the given ClassLoader.

## P

ParameterizedTypeReference<T> - org.springframework.core中的类
  The purpose of this class is to enable capturing and passing a generic `Type`.
ParameterizedTypeReference() - 类 的构造器org.springframework.core.ParameterizedTypeReference
ParameterNameDiscoverer - org.springframework.core中的接口
  Interface to discover parameter names for methods and constructors.
parseLocale(String) - 类 中的静态方法org.springframework.util.StringUtils
  Parse the given `String` value into a `Locale`, accepting the `Locale.toString()` format as well as BCP 47 language tags.
parseLocaleString(String) - 类 中的静态方法org.springframework.util.StringUtils
  Parse the given `String` representation into a `Locale`.
parseMimeType(String) - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Parse the given String into a single `MimeType`.
parseMimeTypes(String) - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Parse the given, comma-separated string into a list of `MimeType` objects.
parseNumber(String, Class<T>) - 类 中的静态方法org.springframework.util.NumberUtils
  Parse the given `text` into a `Number` instance of the given target class, using the corresponding `decode` / `valueOf` method.
parseNumber(String, Class<T>, NumberFormat) - 类 中的静态方法org.springframework.util.NumberUtils
  Parse the given `text` into a `Number` instance of the given target class, using the supplied `NumberFormat`.
parseStringValue(String, PropertyPlaceholderHelper.PlaceholderResolver, Set<String>) - 类 中的方法org.springframework.util.PropertyPlaceholderHelper
parseTimeZoneString(String) - 类 中的静态方法org.springframework.util.StringUtils
  Parse the given `timeZoneString` value into a `TimeZone`.
pathEquals(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Compare two paths after normalization of them.
PathMatcher - org.springframework.util中的接口
  Strategy interface for `String`-based path matching.
PathMatchingResourcePatternResolver - org.springframework.core.io.support中的类
  A `ResourcePatternResolver` implementation that is able to resolve a specified resource location path into one or more matching Resources.
PathMatchingResourcePatternResolver() - 类 的构造器org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
PathMatchingResourcePatternResolver(ResourceLoader) - 类 的构造器org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Create a new PathMatchingResourcePatternResolver.
PathMatchingResourcePatternResolver(ClassLoader) - 类 的构造器org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
PathResource - org.springframework.core.io中的类
  `Resource` implementation for `java.nio.file.Path` handles.
PathResource(Path) - 类 的构造器org.springframework.core.io.PathResource
  Create a new PathResource from a Path handle.
PathResource(String) - 类 的构造器org.springframework.core.io.PathResource
  Create a new PathResource from a Path handle.
PathResource(URI) - 类 的构造器org.springframework.core.io.PathResource
  Create a new PathResource from a Path handle.
PatternMatchUtils - org.springframework.util中的类
  Utility methods for simple pattern matching, in particular for Spring's typical "xxx*", "*xxx" and "*xxx*" pattern styles.
PatternMatchUtils() - 类 的构造器org.springframework.util.PatternMatchUtils
PLACEHOLDER_PREFIX - 类 中的静态变量org.springframework.util.SystemPropertyUtils
  Prefix for system property placeholders: "${"
PLACEHOLDER_SUFFIX - 类 中的静态变量org.springframework.util.SystemPropertyUtils
  Suffix for system property placeholders: "}"
pollForPurge() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.ReferenceManager
  Return any reference that has been garbage collected and can be purged from the underlying structure or `null` if no references need purging.
PooledDataBuffer - org.springframework.core.io.buffer中的接口
  Extension of `DataBuffer` that allows for buffer that share a memory pool.
POP - 接口 中的静态变量org.springframework.asm.Opcodes
POP2 - 接口 中的静态变量org.springframework.asm.Opcodes
PORT_RANGE_MAX - 类 中的静态变量org.springframework.util.SocketUtils
  The default maximum value for port ranges used when finding an available socket port.
PORT_RANGE_MIN - 类 中的静态变量org.springframework.util.SocketUtils
  The default minimum value for port ranges used when finding an available socket port.
postProcessAnnotationAttributes(Object, AnnotationAttributes, boolean) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.
precedenceOf(PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Return the precedence of the given property source, `-1` if not found.
prepare() - 类 中的方法org.springframework.util.MethodInvoker
  Prepare the specified method.
prettyPrint() - 类 中的方法org.springframework.util.StopWatch
  Return a string with a table describing all tasks performed.
PrioritizedParameterNameDiscoverer - org.springframework.core中的类
  `ParameterNameDiscoverer` implementation that tries several discoverer delegates in succession.
PrioritizedParameterNameDiscoverer() - 类 的构造器org.springframework.core.PrioritizedParameterNameDiscoverer
PriorityOrdered - org.springframework.core中的接口
  Extension of the `Ordered` interface, expressing a priority ordering: order values expressed by `PriorityOrdered` objects always apply before same order values expressed by plain `Ordered` objects.
PropertiesLoaderSupport - org.springframework.core.io.support中的类
  Base class for JavaBean-style components that need to load properties from one or more resources.
PropertiesLoaderSupport() - 类 的构造器org.springframework.core.io.support.PropertiesLoaderSupport
PropertiesLoaderUtils - org.springframework.core.io.support中的类
  Convenient utility methods for loading of `java.util.Properties`, performing standard handling of input streams.
PropertiesLoaderUtils() - 类 的构造器org.springframework.core.io.support.PropertiesLoaderUtils
PropertiesPersister - org.springframework.util中的接口
  Strategy interface for persisting `java.util.Properties`, allowing for pluggable parsing strategies.
PropertiesPropertySource - org.springframework.core.env中的类
  `PropertySource` implementation that extracts properties from a `Properties` object.
PropertiesPropertySource(String, Properties) - 类 的构造器org.springframework.core.env.PropertiesPropertySource
PropertiesPropertySource(String, Map<String, Object>) - 类 的构造器org.springframework.core.env.PropertiesPropertySource
Property - org.springframework.core.convert中的类
  A description of a JavaBeans Property that allows us to avoid a dependency on `java.beans.PropertyDescriptor`.
Property(Class<?>, Method, Method) - 类 的构造器org.springframework.core.convert.Property
Property(Class<?>, Method, Method, String) - 类 的构造器org.springframework.core.convert.Property
PropertyPlaceholderHelper - org.springframework.util中的类
  Utility class for working with Strings that have placeholder values in them.
PropertyPlaceholderHelper(String, String) - 类 的构造器org.springframework.util.PropertyPlaceholderHelper
  Creates a new `PropertyPlaceholderHelper` that uses the supplied prefix and suffix.
PropertyPlaceholderHelper(String, String, String, boolean) - 类 的构造器org.springframework.util.PropertyPlaceholderHelper
  Creates a new `PropertyPlaceholderHelper` that uses the supplied prefix and suffix.
PropertyPlaceholderHelper.PlaceholderResolver - org.springframework.util中的接口
  Strategy interface used to resolve replacement values for placeholders contained in Strings.
PropertyResolver - org.springframework.core.env中的接口
  Interface for resolving properties against any underlying source.
PropertySource<T> - org.springframework.core.env中的类
  Abstract base class representing a source of name/value property pairs.
PropertySource(String, T) - 类 的构造器org.springframework.core.env.PropertySource
  Create a new `PropertySource` with the given name and source object.
PropertySource(String) - 类 的构造器org.springframework.core.env.PropertySource
  Create a new `PropertySource` with the given name and with a new `Object` instance as the underlying source.
PropertySource.StubPropertySource - org.springframework.core.env中的类
  `PropertySource` to be used as a placeholder in cases where an actual property source cannot be eagerly initialized at application context creation time.
PropertySourceFactory - org.springframework.core.io.support中的接口
  Strategy interface for creating resource-based `PropertySource` wrappers.
PropertySources - org.springframework.core.env中的接口
  Holder containing one or more `PropertySource` objects.
PropertySourcesPropertyResolver - org.springframework.core.env中的类
  `PropertyResolver` implementation that resolves property values against an underlying set of `PropertySources`.
PropertySourcesPropertyResolver(PropertySources) - 类 的构造器org.springframework.core.env.PropertySourcesPropertyResolver
  Create a new resolver against the given property sources.
propertyToConstantNamePrefix(String) - 类 中的方法org.springframework.core.Constants
  Convert the given bean property name to a constant name prefix.
ProtocolResolver - org.springframework.core.io中的接口
  A resolution strategy for protocol-specific resource handles.
purgeUnreferencedEntries() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
  Remove any entries that have been garbage collected and are no longer referenced.
put(K, V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
put(String, V) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
put(K, List<V>) - 类 中的方法org.springframework.util.LinkedMultiValueMap
putAll(Map<? extends String, ? extends V>) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
putAll(Map<? extends K, ? extends List<V>>) - 类 中的方法org.springframework.util.LinkedMultiValueMap
putByte(int) - 类 中的方法org.springframework.asm.ByteVector
  Puts a byte into this byte vector.
putByteArray(byte[], int, int) - 类 中的方法org.springframework.asm.ByteVector
  Puts an array of bytes into this byte vector.
PUTFIELD - 接口 中的静态变量org.springframework.asm.Opcodes
putIfAbsent(String, Object) - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
  Store the supplied `value` in this map under the specified `key`, unless a value is already stored under the key.
putIfAbsent(K, V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
putInt(int) - 类 中的方法org.springframework.asm.ByteVector
  Puts an int into this byte vector.
putLong(long) - 类 中的方法org.springframework.asm.ByteVector
  Puts a long into this byte vector.
putShort(int) - 类 中的方法org.springframework.asm.ByteVector
  Puts a short into this byte vector.
PUTSTATIC - 接口 中的静态变量org.springframework.asm.Opcodes
putUTF8(String) - 类 中的方法org.springframework.asm.ByteVector
  Puts an UTF8 string into this byte vector.

## Q

quote(String) - 类 中的静态方法org.springframework.util.StringUtils
  Quote the given `String` with single quotes.
quoteIfString(Object) - 类 中的静态方法org.springframework.util.StringUtils
  Turn the given Object into a `String` with single quotes if it is a `String`; keeping the Object as-is else.

## R

ReactiveAdapter - org.springframework.core中的类
  Adapter for a Reactive Streams `Publisher` to and from an async/reactive type such as `CompletableFuture`, RxJava `Observable`, and others.
ReactiveAdapter(ReactiveTypeDescriptor, Function<Object, Publisher<?>>, Function<Publisher<?>, Object>) - 类 的构造器org.springframework.core.ReactiveAdapter
  Constructor for an adapter with functions to convert the target reactive or async type to and from a Reactive Streams Publisher.
ReactiveAdapterRegistry - org.springframework.core中的类
  A registry of adapters to adapt Reactive Streams `Publisher` to/from various async/reactive types such as `CompletableFuture`, RxJava `Observable`, and others.
ReactiveAdapterRegistry() - 类 的构造器org.springframework.core.ReactiveAdapterRegistry
  Create a registry and auto-register default adapters.
ReactiveTypeDescriptor - org.springframework.core中的类
  Describes the semantics of a reactive type including boolean checks for `ReactiveTypeDescriptor.isMultiValue()`, `ReactiveTypeDescriptor.isNoValue()`, and `ReactiveTypeDescriptor.supportsEmpty()`.
read(ClassReader, int, int, char[], int, Label[]) - 类 中的方法org.springframework.asm.Attribute
  Reads a `type` attribute.
read() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Read a single byte from the current reading position from this data buffer.
read(byte[]) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Read this buffer's data into the specified destination, starting at the current reading position of this buffer.
read(byte[], int, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Read at most `length` bytes of this buffer into the specified destination, starting at the current reading position of this buffer.
read(InputStream, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  已过时。
  as of Spring 5.0.3, in favor of `DataBufferUtils.readInputStream(Callable, DataBufferFactory, int)`, to be removed in Spring 5.1
read(ReadableByteChannel, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  已过时。
  as of Spring 5.0.3, in favor of `DataBufferUtils.readByteChannel(Callable, DataBufferFactory, int)`, to be removed in Spring 5.1
read(AsynchronousFileChannel, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  已过时。
  as of Spring 5.0.3, in favor of `DataBufferUtils.readAsynchronousFileChannel(Callable, DataBufferFactory, int)`, to be removed in Spring 5.1
read(AsynchronousFileChannel, long, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  已过时。
  as of Spring 5.0.3, in favor of `DataBufferUtils.readAsynchronousFileChannel(Callable, long, DataBufferFactory, int)`, to be removed in Spring 5.1
read(Resource, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Read the given `Resource` into a `Flux` of `DataBuffer`s.
read(Resource, long, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Read the given `Resource` into a `Flux` of `DataBuffer`s starting at the given position.
read() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
read(byte[]) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
read(byte[], int, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
read() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
read(byte[]) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
read(byte[], int, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
readableByteCount() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the number of bytes that can be read from this data buffer.
readableByteCount() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
readableByteCount() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
readableChannel() - 类 中的方法org.springframework.core.io.AbstractFileResolvingResource
  This implementation returns a FileChannel for the given URI-identified resource, provided that it refers to a file in the file system.
readableChannel() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation returns `Channels.newChannel(InputStream)` with the result of `InputStreamSource.getInputStream()`.
readableChannel() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation opens a FileChannel for the underlying file.
readableChannel() - 类 中的方法org.springframework.core.io.PathResource
  This implementation opens a Channel for the underlying file.
readableChannel() - 接口 中的方法org.springframework.core.io.Resource
  Return a `ReadableByteChannel`.
readAsynchronousFileChannel(Callable<AsynchronousFileChannel>, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Obtain a `AsynchronousFileChannel` from the given supplier, and read it into a `Flux` of `DataBuffer`s.
readAsynchronousFileChannel(Callable<AsynchronousFileChannel>, long, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Obtain a `AsynchronousFileChannel` from the given supplier, and read it into a `Flux` of `DataBuffer`s, starting at the given position.
readByte(int) - 类 中的方法org.springframework.asm.ClassReader
  Reads a byte value in `b`.
readByteChannel(Callable<ReadableByteChannel>, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Obtain a `ReadableByteChannel` from the given supplier, and read it into a `Flux` of `DataBuffer`s.
readClass(int, char[]) - 类 中的方法org.springframework.asm.ClassReader
  Reads a class constant pool item in `b`.
readConst(int, char[]) - 类 中的方法org.springframework.asm.ClassReader
  Reads a numeric or string constant pool item in `b`.
readInputStream(Callable<InputStream>, DataBufferFactory, int) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Obtain a `InputStream` from the given supplier, and read it into a `Flux` of `DataBuffer`s.
readInt(int) - 类 中的方法org.springframework.asm.ClassReader
  Reads a signed int value in `b`.
readLabel(int, Label[]) - 类 中的方法org.springframework.asm.ClassReader
  Returns the label corresponding to the given offset.
readLong(int) - 类 中的方法org.springframework.asm.ClassReader
  Reads a signed long value in `b`.
readModule(int, char[]) - 类 中的方法org.springframework.asm.ClassReader
  Reads a module constant pool item in `b`.
readPackage(int, char[]) - 类 中的方法org.springframework.asm.ClassReader
  Reads a module constant pool item in `b`.
readPosition() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the position from which this buffer will read.
readPosition(int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Set the position from which this buffer will read.
readPosition() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
readPosition(int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
readPosition() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
readPosition(int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
readShort(int) - 类 中的方法org.springframework.asm.ClassReader
  Reads a signed short value in `b`.
readUnsignedShort(int) - 类 中的方法org.springframework.asm.ClassReader
  Reads an unsigned short value in `b`.
readUTF8(int, char[]) - 类 中的方法org.springframework.asm.ClassReader
  Reads an UTF8 string constant pool item in `b`.
ReferenceManager() - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap.ReferenceManager
ReflectionUtils - org.springframework.util中的类
  Simple utility class for working with the reflection API and handling reflection exceptions.
ReflectionUtils() - 类 的构造器org.springframework.util.ReflectionUtils
ReflectionUtils.FieldCallback - org.springframework.util中的接口
  Callback interface invoked on each field in the hierarchy.
ReflectionUtils.FieldFilter - org.springframework.util中的接口
  Callback optionally used to filter fields to be operated on by a field callback.
ReflectionUtils.MethodCallback - org.springframework.util中的接口
  Action to take on each method.
ReflectionUtils.MethodFilter - org.springframework.util中的接口
  Callback optionally used to filter methods to be operated on by a method callback.
RegexPatternTypeFilter - org.springframework.core.type.filter中的类
  A simple filter for matching a fully-qualified class name with a regex `Pattern`.
RegexPatternTypeFilter(Pattern) - 类 的构造器org.springframework.core.type.filter.RegexPatternTypeFilter
registerAlias(String, String) - 接口 中的方法org.springframework.core.AliasRegistry
  Given a name, register an alias for it.
registerAlias(String, String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
registerConverters(Set<?>, ConverterRegistry) - 类 中的静态方法org.springframework.core.convert.support.ConversionServiceFactory
  Register the given Converter objects with the given target ConverterRegistry.
registerDefaultValues(AnnotationAttributes) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Register the annotation-declared default values for the given attributes, if available.
registerReactiveType(ReactiveTypeDescriptor, Function<Object, Publisher<?>>, Function<Publisher<?>, Object>) - 类 中的方法org.springframework.core.ReactiveAdapterRegistry
  Register a reactive type along with functions to adapt to and from a Reactive Streams `Publisher`.
release(DataBuffer) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Release the given data buffer, if it is a `PooledDataBuffer`.
release() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
release() - 接口 中的方法org.springframework.core.io.buffer.PooledDataBuffer
  Decrease the reference count for this buffer by one, and release it once the count reaches zero.
release() - 接口 中的方法org.springframework.util.ConcurrentReferenceHashMap.Reference
  Release this entry and ensure that it will be returned from `ReferenceManager#pollForPurge()`.
releaseConsumer() - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Return a consumer that calls `DataBufferUtils.release(DataBuffer)` on all passed data buffers.
remove(String) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Remove and return the property source with the given name, `null` if not found.
remove(int) - 类 中的方法org.springframework.util.AutoPopulatingList
remove(Object) - 类 中的方法org.springframework.util.AutoPopulatingList
remove() - 类 中的方法org.springframework.util.CompositeIterator
remove(Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
remove(Object, Object) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
remove(Object) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
remove(Object) - 类 中的方法org.springframework.util.LinkedMultiValueMap
removeAlias(String) - 接口 中的方法org.springframework.core.AliasRegistry
  Remove the specified alias from this registry.
removeAlias(String) - 类 中的方法org.springframework.core.SimpleAliasRegistry
removeAll(Collection<?>) - 类 中的方法org.springframework.util.AutoPopulatingList
removeAttribute(String) - 接口 中的方法org.springframework.core.AttributeAccessor
  Remove the attribute identified by `name` and return its value.
removeAttribute(String) - 类 中的方法org.springframework.core.AttributeAccessorSupport
removeBinding(String) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Remove the given prefix from this context.
removeConvertible(Class<?>, Class<?>) - 接口 中的方法org.springframework.core.convert.converter.ConverterRegistry
  Remove any converters from `sourceType` to `targetType`.
removeConvertible(Class<?>, Class<?>) - 类 中的方法org.springframework.core.convert.support.GenericConversionService
removeDuplicateStrings(String[]) - 类 中的静态方法org.springframework.util.StringUtils
  Remove duplicate strings from the given array.
removeEldestEntry(Map.Entry<String, V>) - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
  Determine whether this map should remove the given eldest entry.
removeIfPresent(PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Remove the given property source if it is present.
replace(String, PropertySource<?>) - 类 中的方法org.springframework.core.env.MutablePropertySources
  Replace the property source with the given name with the given property source object.
replace(K, V, V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
replace(K, V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
replace(String, String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Replace all occurrences of a substring within a string with another string.
replacePlaceholders(String, Properties) - 类 中的方法org.springframework.util.PropertyPlaceholderHelper
  Replaces all placeholders of format `${name}` with the corresponding property from the supplied `Properties`.
replacePlaceholders(String, PropertyPlaceholderHelper.PlaceholderResolver) - 类 中的方法org.springframework.util.PropertyPlaceholderHelper
  Replaces all placeholders of format `${name}` with the value returned from the supplied `PropertyPlaceholderHelper.PlaceholderResolver`.
requiresReader() - 类 中的方法org.springframework.core.io.support.EncodedResource
  Determine whether a `Reader` is required as opposed to an `InputStream`, i.e. whether an encoding or a `Charset` has been specified.
RESERVED_DEFAULT_PROFILE_NAME - 类 中的静态变量org.springframework.core.env.AbstractEnvironment
  Name of reserved default profile name: "default".
reset() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Reset the contents of this `FastByteArrayOutputStream`.
ResizableByteArrayOutputStream - org.springframework.util中的类
  An extension of `ByteArrayOutputStream` that: has public `ResizableByteArrayOutputStream.grow(int)` and `ResizableByteArrayOutputStream.resize(int)` methods to get more control over the size of the internal buffer has a higher initial capacity (256) by default As of 4.2, this class has been superseded by `FastByteArrayOutputStream` for Spring's internal use where no assignability to `ByteArrayOutputStream` is needed (since `FastByteArrayOutputStream` is more efficient with buffer resize management but doesn't extend the standard `ByteArrayOutputStream`).
ResizableByteArrayOutputStream() - 类 的构造器org.springframework.util.ResizableByteArrayOutputStream
  Create a new `ResizableByteArrayOutputStream` with the default initial capacity of 256 bytes.
ResizableByteArrayOutputStream(int) - 类 的构造器org.springframework.util.ResizableByteArrayOutputStream
  Create a new `ResizableByteArrayOutputStream` with the specified initial capacity.
resize(int) - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Resize the internal buffer size to a specified capacity.
resize(int) - 类 中的方法org.springframework.util.ResizableByteArrayOutputStream
  Resize the internal buffer size to a specified capacity.
ResolvableType - org.springframework.core中的类
  Encapsulates a Java `Type`, providing access to `supertypes`, `interfaces`, and `generic parameters` along with the ability to ultimately `resolve` to a `Class`.
ResolvableTypeProvider - org.springframework.core中的接口
  Any object can implement this interface to provide its actual `ResolvableType`.
resolve(String, ResourceLoader) - 接口 中的方法org.springframework.core.io.ProtocolResolver
  Resolve the given location against the given resource loader if this implementation's protocol matches.
resolve() - 类 中的方法org.springframework.core.ResolvableType
  Resolve this type to a `Class`, returning `null` if the type cannot be resolved.
resolve(Class<?>) - 类 中的方法org.springframework.core.ResolvableType
  Resolve this type to a `Class`, returning the specified `fallback` if the type cannot be resolved.
resolveAliases(StringValueResolver) - 类 中的方法org.springframework.core.SimpleAliasRegistry
  Resolve all alias target names and aliases registered in this factory, applying the given StringValueResolver to them.
resolveClass(ObjectStreamClass) - 类 中的方法org.springframework.core.ConfigurableObjectInputStream
resolveClassName(String, ClassLoader) - 类 中的静态方法org.springframework.util.ClassUtils
  Resolve the given class name into a Class instance.
resolveClassName(String) - 类 中的方法org.springframework.util.MethodInvoker
  Resolve the given class name into a Class.
resolveFallbackIfPossible(String, ClassNotFoundException) - 类 中的方法org.springframework.core.ConfigurableObjectInputStream
  Resolve the given class name against a fallback class loader.
resolveGeneric(int...) - 类 中的方法org.springframework.core.ResolvableType
  Convenience method that will `get` and `resolve` a specific generic parameters.
resolveGenerics() - 类 中的方法org.springframework.core.ResolvableType
  Convenience method that will `get` and `resolve` generic parameters.
resolveGenerics(Class<?>) - 类 中的方法org.springframework.core.ResolvableType
  Convenience method that will `get` and `resolve` generic parameters, using the specified `fallback` if any type cannot be resolved.
resolveNestedPlaceholders(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Resolve placeholders within the given string, deferring to the value of `AbstractPropertyResolver.setIgnoreUnresolvableNestedPlaceholders(boolean)` to determine whether any unresolvable placeholders should raise an exception or be ignored.
resolveParameterType(MethodParameter, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Determine the target type for the given generic parameter type.
resolvePath(String) - 类 中的方法org.springframework.core.io.ResourceEditor
  Resolve the given path, replacing placeholders with corresponding property values from the `environment` if necessary.
resolvePath(String) - 类 中的方法org.springframework.core.io.support.ResourceArrayPropertyEditor
  Resolve the given path, replacing placeholders with corresponding system property values if necessary.
resolvePlaceholder(String) - 接口 中的方法org.springframework.util.PropertyPlaceholderHelper.PlaceholderResolver
  Resolve the supplied placeholder name to the replacement value.
resolvePlaceholders(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
resolvePlaceholders(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
resolvePlaceholders(String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`.
resolvePlaceholders(String) - 类 中的静态方法org.springframework.util.SystemPropertyUtils
  Resolve `${...}` placeholders in the given text, replacing them with corresponding system property values.
resolvePlaceholders(String, boolean) - 类 中的静态方法org.springframework.util.SystemPropertyUtils
  Resolve `${...}` placeholders in the given text, replacing them with corresponding system property values.
resolvePrimitiveClassName(String) - 类 中的静态方法org.springframework.util.ClassUtils
  Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
resolvePrimitiveIfNecessary(Class<?>) - 类 中的静态方法org.springframework.util.ClassUtils
  Resolve the given class if it is a primitive class, returning the corresponding primitive wrapper type instead.
resolvePropertyName(String) - 类 中的方法org.springframework.core.env.SystemEnvironmentPropertySource
  Check to see if this property source contains a property with the given name, or any underscore / uppercase variation thereof.
resolveProxyClass(String[]) - 类 中的方法org.springframework.core.ConfigurableObjectInputStream
resolveRequiredPlaceholders(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
resolveRequiredPlaceholders(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
resolveRequiredPlaceholders(String) - 接口 中的方法org.springframework.core.env.PropertyResolver
  Resolve ${...} placeholders in the given text, replacing them with corresponding property values as resolved by `PropertyResolver.getProperty(java.lang.String)`.
resolveReturnType(Method, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Determine the target type for the generic return type of the given method, where formal type variables are declared on the given class.
resolveReturnTypeArgument(Method, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Resolve the single type argument of the given generic interface against the given target method which is assumed to return the given interface or an implementation of it.
resolveRootDirResource(Resource) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Resolve the specified resource for path matching.
resolveStringValue(String) - 接口 中的方法org.springframework.util.StringValueResolver
  Resolve the given String value, for example parsing placeholders.
resolveType(Type, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Resolve the given generic type against the given context class, substituting type variables as far as possible.
resolveType(Type, Map<TypeVariable, Type>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Resolve the specified generic type against the given TypeVariable map.
resolveTypeArgument(Class<?>, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Resolve the single type argument of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare a concrete type for its type variable.
resolveTypeArguments(Class<?>, Class<?>) - 类 中的静态方法org.springframework.core.GenericTypeResolver
  Resolve the type arguments of the given generic interface against the given target class which is assumed to implement the generic interface and possibly declare concrete types for its type variables.
resolveURL() - 类 中的方法org.springframework.core.io.ClassPathResource
  Resolves a URL for the underlying class path resource.
Resource - org.springframework.core.io中的接口
  Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.
RESOURCE_VARIABLE - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of a resource variable in a method.
ResourceArrayPropertyEditor - org.springframework.core.io.support中的类
  Editor for `Resource` arrays, to automatically convert `String` location patterns (e.g.
ResourceArrayPropertyEditor() - 类 的构造器org.springframework.core.io.support.ResourceArrayPropertyEditor
  Create a new ResourceArrayPropertyEditor with a default `PathMatchingResourcePatternResolver` and `StandardEnvironment`.
ResourceArrayPropertyEditor(ResourcePatternResolver, PropertyResolver) - 类 的构造器org.springframework.core.io.support.ResourceArrayPropertyEditor
  Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).
ResourceArrayPropertyEditor(ResourcePatternResolver, PropertyResolver, boolean) - 类 的构造器org.springframework.core.io.support.ResourceArrayPropertyEditor
  Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).
ResourceDecoder - org.springframework.core.codec中的类
  Decoder for `Resource`s.
ResourceDecoder() - 类 的构造器org.springframework.core.codec.ResourceDecoder
ResourceEditor - org.springframework.core.io中的类
  `Editor` for `Resource` descriptors, to automatically convert `String` locations e.g.
ResourceEditor() - 类 的构造器org.springframework.core.io.ResourceEditor
  Create a new instance of the `ResourceEditor` class using a `DefaultResourceLoader` and `StandardEnvironment`.
ResourceEditor(ResourceLoader, PropertyResolver) - 类 的构造器org.springframework.core.io.ResourceEditor
  Create a new instance of the `ResourceEditor` class using the given `ResourceLoader` and `PropertyResolver`.
ResourceEditor(ResourceLoader, PropertyResolver, boolean) - 类 的构造器org.springframework.core.io.ResourceEditor
  Create a new instance of the `ResourceEditor` class using the given `ResourceLoader`.
ResourceEncoder - org.springframework.core.codec中的类
  Encoder for `Resource`s.
ResourceEncoder() - 类 的构造器org.springframework.core.codec.ResourceEncoder
ResourceEncoder(int) - 类 的构造器org.springframework.core.codec.ResourceEncoder
ResourceLoader - org.springframework.core.io中的接口
  Strategy interface for loading resources (e.. class path or file system resources).
ResourcePatternResolver - org.springframework.core.io.support中的接口
  Strategy interface for resolving a location pattern (for example, an Ant-style path pattern) into Resource objects.
ResourcePatternUtils - org.springframework.core.io.support中的类
  Utility class for determining whether a given URL is a resource location that can be loaded via a `ResourcePatternResolver`.
ResourcePatternUtils() - 类 的构造器org.springframework.core.io.support.ResourcePatternUtils
ResourcePropertySource - org.springframework.core.io.support中的类
  Subclass of `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.xml"`.
ResourcePropertySource(String, EncodedResource) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource having the given name based on Properties loaded from the given encoded resource.
ResourcePropertySource(EncodedResource) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource based on Properties loaded from the given resource.
ResourcePropertySource(String, Resource) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource having the given name based on Properties loaded from the given encoded resource.
ResourcePropertySource(Resource) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource based on Properties loaded from the given resource.
ResourcePropertySource(String, String, ClassLoader) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource having the given name based on Properties loaded from the given resource location and using the given class loader to load the resource (assuming it is prefixed with `classpath:`).
ResourcePropertySource(String, ClassLoader) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource based on Properties loaded from the given resource location and use the given class loader to load the resource, assuming it is prefixed with `classpath:`.
ResourcePropertySource(String, String) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource having the given name based on Properties loaded from the given resource location.
ResourcePropertySource(String) - 类 的构造器org.springframework.core.io.support.ResourcePropertySource
  Create a PropertySource based on Properties loaded from the given resource location.
ResourceRegion - org.springframework.core.io.support中的类
  Region of a `Resource` implementation, materialized by a `position` within the `Resource` and a byte `count` for the length of that region.
ResourceRegion(Resource, long, long) - 类 的构造器org.springframework.core.io.support.ResourceRegion
  Create a new `ResourceRegion` from a given `Resource`.
ResourceRegionEncoder - org.springframework.core.codec中的类
  Encoder for `ResourceRegion`s.
ResourceRegionEncoder() - 类 的构造器org.springframework.core.codec.ResourceRegionEncoder
ResourceRegionEncoder(int) - 类 的构造器org.springframework.core.codec.ResourceRegionEncoder
ResourceUtils - org.springframework.util中的类
  Utility methods for resolving resource locations to files in the file system.
ResourceUtils() - 类 的构造器org.springframework.util.ResourceUtils
restructureIfNecessary(boolean) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Segment
  Restructure the underlying data structure when it becomes necessary.
RET - 接口 中的静态变量org.springframework.asm.Opcodes
retain(T) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Retain the given data buffer, it it is a `PooledDataBuffer`.
retain() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
retain() - 接口 中的方法org.springframework.core.io.buffer.PooledDataBuffer
  Increase the reference count for this buffer by one.
retainAll(Collection<?>) - 类 中的方法org.springframework.util.AutoPopulatingList
rethrowException(Throwable) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
rethrowRuntimeException(Throwable) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Rethrow the given `exception`, which is presumably the target exception of an `InvocationTargetException`.
retrieveMatchingFiles(File, String) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Retrieve files that match the given path pattern, checking the given directory and its subdirectories.
RETURN - 接口 中的静态变量org.springframework.asm.Opcodes
returnTypeName - 类 中的变量org.springframework.core.type.classreading.MethodMetadataReadingVisitor

## S

SALOAD - 接口 中的静态变量org.springframework.asm.Opcodes
SASTORE - 接口 中的静态变量org.springframework.asm.Opcodes
Segment(int) - 类 的构造器org.springframework.util.ConcurrentReferenceHashMap.Segment
selectInvocableMethod(Method, Class<?>) - 类 中的静态方法org.springframework.core.MethodIntrospector
  Select an invocable method on the target type: either the given method itself if actually exposed on the target type, or otherwise a corresponding method on one of the target type's interfaces or on the target type itself.
selectMethods(Class<?>, MethodIntrospector.MetadataLookup<T>) - 类 中的静态方法org.springframework.core.MethodIntrospector
  方法实现说明:传入class对象，以及metadataLookup接口来获取我们标注了@RequestMapping的方法集合，存放在 Map中
selectMethods(Class<?>, ReflectionUtils.MethodFilter) - 类 中的静态方法org.springframework.core.MethodIntrospector
  Select methods on the given target type based on a filter.
SerializationDelegate - org.springframework.core.serializer.support中的类
  A convenient delegate with pre-arranged configuration state for common serialization needs.
SerializationDelegate(ClassLoader) - 类 的构造器org.springframework.core.serializer.support.SerializationDelegate
  Create a `SerializationDelegate` with a default serializer/deserializer for the given `ClassLoader`.
SerializationDelegate(Serializer<Object>, Deserializer<Object>) - 类 的构造器org.springframework.core.serializer.support.SerializationDelegate
  Create a `SerializationDelegate` with the given serializer/deserializer.
SerializationFailedException - org.springframework.core.serializer.support中的异常错误
  Wrapper for the native IOException (or similar) when a `Serializer` or `Deserializer` failed.
SerializationFailedException(String) - 异常错误 的构造器org.springframework.core.serializer.support.SerializationFailedException
  Construct a `SerializationException` with the specified detail message.
SerializationFailedException(String, Throwable) - 异常错误 的构造器org.springframework.core.serializer.support.SerializationFailedException
  Construct a `SerializationException` with the specified detail message and nested exception.
SerializationUtils - org.springframework.util中的类
  Static utilities for serialization and deserialization.
SerializationUtils() - 类 的构造器org.springframework.util.SerializationUtils
serialize(Object, OutputStream) - 类 中的方法org.springframework.core.serializer.DefaultSerializer
  Writes the source object to an output stream using Java serialization.
serialize(T, OutputStream) - 接口 中的方法org.springframework.core.serializer.Serializer
  Write an object of type T to the given OutputStream.
serialize(Object, OutputStream) - 类 中的方法org.springframework.core.serializer.support.SerializationDelegate
serialize(Object) - 类 中的静态方法org.springframework.util.SerializationUtils
  Serialize the given object to a byte array.
Serializer<T> - org.springframework.core.serializer中的接口
  A strategy interface for streaming an object to an OutputStream.
SerializingConverter - org.springframework.core.serializer.support中的类
  A `Converter` that delegates to a `Serializer` to convert an object to a byte array.
SerializingConverter() - 类 的构造器org.springframework.core.serializer.support.SerializingConverter
  Create a default `SerializingConverter` that uses standard Java serialization.
SerializingConverter(Serializer<Object>) - 类 的构造器org.springframework.core.serializer.support.SerializingConverter
  Create a `SerializingConverter` that delegates to the provided `Serializer`.
set(int, E) - 类 中的方法org.springframework.util.AutoPopulatingList
set(T) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
  Set the value of this future.
set(K, V) - 类 中的方法org.springframework.util.LinkedMultiValueMap
set(K, V) - 接口 中的方法org.springframework.util.MultiValueMap
  Set the given single value under the given key.
setActiveProfiles(String...) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setActiveProfiles(String...) - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Specify the set of profiles active for this `Environment`.
setAll(Map<K, V>) - 类 中的方法org.springframework.util.LinkedMultiValueMap
setAll(Map<K, V>) - 接口 中的方法org.springframework.util.MultiValueMap
  Set the given values under.
setArguments(Object...) - 类 中的方法org.springframework.util.MethodInvoker
  Set arguments for the method invocation.
setAscending(boolean) - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
  Specify the sort order: ascending (true) or descending (false).
setAscendingOrder(int) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Change the sort order at the given index to ascending.
setAsText(String) - 类 中的方法org.springframework.core.convert.support.ConvertingPropertyEditorAdapter
setAsText(String) - 类 中的方法org.springframework.core.io.ResourceEditor
setAsText(String) - 类 中的方法org.springframework.core.io.support.ResourceArrayPropertyEditor
  Treat the given text as a location pattern and convert it to a Resource array.
setAttribute(String, Object) - 接口 中的方法org.springframework.core.AttributeAccessor
  Set the attribute defined by `name` to the supplied `value`.
setAttribute(String, Object) - 类 中的方法org.springframework.core.AttributeAccessorSupport
setBindings(Map<String, String>) - 类 中的方法org.springframework.util.xml.SimpleNamespaceContext
  Set the bindings for this namespace context.
setCacheLimit(int) - 类 中的方法org.springframework.core.type.classreading.CachingMetadataReaderFactory
  Specify the maximum number of entries for the MetadataReader cache.
setCachePatterns(boolean) - 类 中的方法org.springframework.util.AntPathMatcher
  Specify whether to cache parsed pattern metadata for patterns passed into this matcher's `AntPathMatcher.match(java.lang.String, java.lang.String)` method.
setCaseSensitive(boolean) - 类 中的方法org.springframework.util.AntPathMatcher
  Specify whether to perform pattern matching in a case-sensitive fashion.
setClassLoader(ClassLoader) - 类 中的方法org.springframework.core.io.DefaultResourceLoader
  Specify the ClassLoader to load class path resources with, or `null` for using the thread context class loader at the time of actual resource access.
setComparator(int, Comparator<? extends T>) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Replace the Comparator at the given index.
setComparator(int, Comparator<T>, boolean) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Replace the Comparator at the given index using the given sort order.
setConcurrencyLimit(int) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Set the maximum number of parallel accesses allowed
setConcurrencyLimit(int) - 类 中的方法org.springframework.util.ConcurrencyThrottleSupport
  Set the maximum number of concurrent access attempts allowed
setConversionService(ConfigurableConversionService) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setConversionService(ConfigurableConversionService) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
setConversionService(ConfigurableConversionService) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Set the `ConfigurableConversionService` to be used when performing type conversions on properties.
setDaemon(boolean) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Set whether this factory is supposed to create daemon threads, just executing as long as the application itself is running.
setDefaultProfiles(String...) - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Specify the set of profiles to be made active by default if no other profiles are explicitly made active through `AbstractEnvironment.setActiveProfiles(java.lang.String...)`.
setDefaultProfiles(String...) - 接口 中的方法org.springframework.core.env.ConfigurableEnvironment
  Specify the set of profiles to be made active by default if no other profiles are explicitly made active through `ConfigurableEnvironment.setActiveProfiles(java.lang.String...)`.
setDescendingOrder(int) - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
  Change the sort order at the given index to descending sort.
setException(Throwable) - 类 中的方法org.springframework.util.concurrent.SettableListenableFuture
  Set the exception of this future.
setField(Field, Object, Object) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Set the field represented by the supplied `field object` on the specified `target object` to the specified `value`.
setFileEncoding(String) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set the encoding to use for parsing properties files.
setFlag(String) - 类 中的静态方法org.springframework.core.SpringProperties
  Programmatically set a local flag to "true", overriding an entry in the `spring.properties` file (if any).
setIgnoreResourceNotFound(boolean) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set if failure to find the property resource should be ignored.
setIgnoreUnresolvableNestedPlaceholders(boolean) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setIgnoreUnresolvableNestedPlaceholders(boolean) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Set whether to throw an exception when encountering an unresolvable placeholder nested within the value of a given property.
setIgnoreUnresolvableNestedPlaceholders(boolean) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Set whether to throw an exception when encountering an unresolvable placeholder nested within the value of a given property.
setInitialInterval(long) - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  The initial interval in milliseconds.
setInterval(long) - 类 中的方法org.springframework.util.backoff.FixedBackOff
  Set the interval between two attempts in milliseconds.
setKeepTaskList(boolean) - 类 中的方法org.springframework.util.StopWatch
  Determine whether the TaskInfo array is built over time.
setLocalOverride(boolean) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set whether local properties override properties from files.
setLocation(Resource) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set a location of a properties file to be loaded.
setLocations(Resource...) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set locations of properties files to be loaded.
setMaxAttempts(long) - 类 中的方法org.springframework.util.backoff.FixedBackOff
  Set the maximum number of attempts in milliseconds.
setMaxElapsedTime(long) - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  The maximum elapsed time in milliseconds after which a call to `BackOffExecution.nextBackOff()` returns `BackOffExecution.STOP`.
setMaxInterval(long) - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  The maximum back off time.
setMultiplier(double) - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
  The value to multiply the current interval by for each retry attempt.
setNonOptionArgsPropertyName(String) - 类 中的方法org.springframework.core.env.CommandLinePropertySource
  Specify the name of the special "non-option arguments" property.
setPathMatcher(PathMatcher) - 类 中的方法org.springframework.core.io.support.PathMatchingResourcePatternResolver
  Set the PathMatcher implementation to use for this resource pattern resolver.
setPathSeparator(String) - 类 中的方法org.springframework.util.AntPathMatcher
  Set the path separator to use for pattern parsing.
setPlaceholderPrefix(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setPlaceholderPrefix(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Set the prefix that placeholders replaced by this resolver must begin with.
setPlaceholderPrefix(String) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Set the prefix that placeholders replaced by this resolver must begin with.
setPlaceholderSuffix(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setPlaceholderSuffix(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Set the suffix that placeholders replaced by this resolver must end with.
setPlaceholderSuffix(String) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Set the suffix that placeholders replaced by this resolver must end with.
setProperties(Properties) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set local properties, e.g. via the "props" tag in XML bean definitions.
setPropertiesArray(Properties...) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set local properties, e.g. via the "props" tag in XML bean definitions, allowing for merging multiple properties sets into one.
setPropertiesPersister(PropertiesPersister) - 类 中的方法org.springframework.core.io.support.PropertiesLoaderSupport
  Set the PropertiesPersister to use for parsing properties files.
setProperty(String, String) - 类 中的静态方法org.springframework.core.SpringProperties
  Programmatically set a local property, overriding an entry in the `spring.properties` file (if any).
setRequiredProperties(String...) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setRequiredProperties(String...) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
setRequiredProperties(String...) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Specify which properties must be present, to be verified by `ConfigurablePropertyResolver.validateRequiredProperties()`.
setSeparator(String) - 类 中的方法org.springframework.core.io.support.LocalizedResourceHelper
  Set the separator to use in-between file name parts.
setStaticMethod(String) - 类 中的方法org.springframework.util.MethodInvoker
  Set a fully qualified static method name to invoke, e.g.
SettableListenableFuture<T> - org.springframework.util.concurrent中的类
  A `ListenableFuture` whose value can be set via `SettableListenableFuture.set(Object)` or `SettableListenableFuture.setException(Throwable)`.
SettableListenableFuture() - 类 的构造器org.springframework.util.concurrent.SettableListenableFuture
setTargetClass(Class<?>) - 类 中的方法org.springframework.util.MethodInvoker
  Set the target class on which to call the target method.
setTargetMethod(String) - 类 中的方法org.springframework.util.MethodInvoker
  Set the name of the method to be invoked.
setTargetObject(Object) - 类 中的方法org.springframework.util.MethodInvoker
  Set the target object on which to call the target method.
setTaskDecorator(TaskDecorator) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Specify a custom `TaskDecorator` to be applied to any `Runnable` about to be executed.
setTaskDecorator(TaskDecorator) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
  Specify a custom `TaskDecorator` to be applied to any `Runnable` about to be executed.
setThreadFactory(ThreadFactory) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
  Specify an external factory to use for creating new Threads, instead of relying on the local properties of this executor.
setThreadGroup(ThreadGroup) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Specify the thread group that threads should be created in.
setThreadGroupName(String) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Specify the name of the thread group that threads should be created in.
setThreadNamePrefix(String) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Specify the prefix to use for the names of newly created threads.
setThreadPriority(int) - 类 中的方法org.springframework.util.CustomizableThreadCreator
  Set the priority of the threads that this factory creates.
setTrimTokens(boolean) - 类 中的方法org.springframework.util.AntPathMatcher
  Specify whether to trim tokenized paths and patterns.
setTypeIndexForCurrentLevel(int) - 类 中的方法org.springframework.core.MethodParameter
  Set the type index for the current nesting level.
setValue(Object) - 类 中的方法org.springframework.core.io.support.ResourceArrayPropertyEditor
  Treat the given value as a collection or array and convert it to a Resource array.
setValue(V) - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
setValueSeparator(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
setValueSeparator(String) - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
  Specify the separating character between the placeholders replaced by this resolver and their associated default value, or `null` if no such special character should be processed as a value separator.
setValueSeparator(String) - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Specify the separating character between the placeholders replaced by this resolver and their associated default value, or `null` if no such special character should be processed as a value separator.
shallowCopyFieldState(Object, Object) - 类 中的静态方法org.springframework.util.ReflectionUtils
  Given the source object and the destination, which must be the same class or a subclass, copy all fields, including inherited fields.
SHORT - 类 中的静态变量org.springframework.asm.Type
  The sort of the `short` type.
SHORT_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `short` type.
shortSummary() - 类 中的方法org.springframework.util.StopWatch
  Return a short description of the total running time.
shutdown() - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter
shutdownNow() - 类 中的方法org.springframework.core.task.support.ExecutorServiceAdapter
SimpleAliasRegistry - org.springframework.core中的类
  Simple implementation of the `AliasRegistry` interface.
SimpleAliasRegistry() - 类 的构造器org.springframework.core.SimpleAliasRegistry
SimpleAsyncTaskExecutor - org.springframework.core.task中的类
  `TaskExecutor` implementation that fires up a new Thread for each task, executing it asynchronously.
SimpleAsyncTaskExecutor() - 类 的构造器org.springframework.core.task.SimpleAsyncTaskExecutor
  Create a new SimpleAsyncTaskExecutor with default thread name prefix.
SimpleAsyncTaskExecutor(String) - 类 的构造器org.springframework.core.task.SimpleAsyncTaskExecutor
  Create a new SimpleAsyncTaskExecutor with the given thread name prefix.
SimpleAsyncTaskExecutor(ThreadFactory) - 类 的构造器org.springframework.core.task.SimpleAsyncTaskExecutor
  Create a new SimpleAsyncTaskExecutor with the given external thread factory.
SimpleCommandLinePropertySource - org.springframework.core.env中的类
  `CommandLinePropertySource` implementation backed by a simple String array.
SimpleCommandLinePropertySource(String...) - 类 的构造器org.springframework.core.env.SimpleCommandLinePropertySource
  Create a new `SimpleCommandLinePropertySource` having the default name and backed by the given `String[]` of command line arguments.
SimpleCommandLinePropertySource(String, String[]) - 类 的构造器org.springframework.core.env.SimpleCommandLinePropertySource
  Create a new `SimpleCommandLinePropertySource` having the given name and backed by the given `String[]` of command line arguments.
SimpleIdGenerator - org.springframework.util中的类
  A simple `IdGenerator` that starts at 1 and increments by 1 with each call.
SimpleIdGenerator() - 类 的构造器org.springframework.util.SimpleIdGenerator
simpleMatch(String, String) - 类 中的静态方法org.springframework.util.PatternMatchUtils
  Match a String against the given pattern, supporting the following simple pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy" matches (with an arbitrary number of pattern parts), as well as direct equality.
simpleMatch(String[], String) - 类 中的静态方法org.springframework.util.PatternMatchUtils
  Match a String against the given patterns, supporting the following simple pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy" matches (with an arbitrary number of pattern parts), as well as direct equality.
SimpleMetadataReaderFactory - org.springframework.core.type.classreading中的类
  Simple implementation of the `MetadataReaderFactory` interface, creating a new ASM `ClassReader` for every request.
SimpleMetadataReaderFactory() - 类 的构造器org.springframework.core.type.classreading.SimpleMetadataReaderFactory
  Create a new SimpleMetadataReaderFactory for the default class loader.
SimpleMetadataReaderFactory(ResourceLoader) - 类 的构造器org.springframework.core.type.classreading.SimpleMetadataReaderFactory
  Create a new SimpleMetadataReaderFactory for the given resource loader.
SimpleMetadataReaderFactory(ClassLoader) - 类 的构造器org.springframework.core.type.classreading.SimpleMetadataReaderFactory
  Create a new SimpleMetadataReaderFactory for the given class loader.
SimpleNamespaceContext - org.springframework.util.xml中的类
  Simple `javax.xml.namespace.NamespaceContext` implementation.
SimpleNamespaceContext() - 类 的构造器org.springframework.util.xml.SimpleNamespaceContext
SimpleSaxErrorHandler - org.springframework.util.xml中的类
  Simple `org.xml.sax.ErrorHandler` implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
SimpleSaxErrorHandler(Log) - 类 的构造器org.springframework.util.xml.SimpleSaxErrorHandler
  Create a new SimpleSaxErrorHandler for the given Commons Logging logger instance.
SimpleTransformErrorListener - org.springframework.util.xml中的类
  Simple `javax.xml.transform.ErrorListener` implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
SimpleTransformErrorListener(Log) - 类 的构造器org.springframework.util.xml.SimpleTransformErrorListener
  Create a new SimpleTransformErrorListener for the given Commons Logging logger instance.
singleOptionalValue(Class<?>, Supplier<?>) - 类 中的静态方法org.springframework.core.ReactiveTypeDescriptor
  Descriptor for a reactive type that can produce 0..1 values.
singleRequiredValue(Class<?>) - 类 中的静态方法org.springframework.core.ReactiveTypeDescriptor
  Descriptor for a reactive type that must produce 1 value to complete.
SIPUSH - 接口 中的静态变量org.springframework.asm.Opcodes
size() - 类 中的方法org.springframework.core.env.MutablePropertySources
  Return the number of `PropertySource` objects contained.
size() - 类 中的方法org.springframework.util.AutoPopulatingList
size() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap
size() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Return the number of bytes stored in this `FastByteArrayOutputStream`.
size() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
size() - 类 中的方法org.springframework.util.LinkedMultiValueMap
SKIP_CODE - 类 中的静态变量org.springframework.asm.ClassReader
  Flag to skip method code.
SKIP_DEBUG - 类 中的静态变量org.springframework.asm.ClassReader
  Flag to skip the debug information in the class.
SKIP_FRAMES - 类 中的静态变量org.springframework.asm.ClassReader
  Flag to skip the stack map frames in the class.
skipUntilByteCount(Publisher<DataBuffer>, long) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Skip buffers from the given `Publisher` until the total byte count reaches the given maximum byte count, or until the publisher is complete.
slice(int, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Create a new `DataBuffer` whose contents is a shared subsequence of this data buffer's content.
slice(int, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
slice(int, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
SmartClassLoader - org.springframework.core中的接口
  Interface to be implemented by a reloading-aware ClassLoader (e.g. a Groovy-based ClassLoader).
SocketUtils - org.springframework.util中的类
  Simple utility methods for working with network sockets — for example, for finding available ports on `localhost`.
SocketUtils() - 类 的构造器org.springframework.util.SocketUtils
  Although `SocketUtils` consists solely of static utility methods, this constructor is intentionally `public`.
sort(List<?>) - 类 中的静态方法org.springframework.core.annotation.AnnotationAwareOrderComparator
  Sort the given List with a default AnnotationAwareOrderComparator.
sort(Object[]) - 类 中的静态方法org.springframework.core.annotation.AnnotationAwareOrderComparator
  Sort the given array with a default AnnotationAwareOrderComparator.
sort(List<?>) - 类 中的静态方法org.springframework.core.OrderComparator
  Sort the given List with a default OrderComparator.
sort(Object[]) - 类 中的静态方法org.springframework.core.OrderComparator
  Sort the given array with a default OrderComparator.
sortBySpecificity(List<MimeType>) - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Sorts the given list of `MimeType` objects by specificity.
sortIfNecessary(Object) - 类 中的静态方法org.springframework.core.annotation.AnnotationAwareOrderComparator
  Sort the given array or List with a default AnnotationAwareOrderComparator, if necessary.
sortIfNecessary(Object) - 类 中的静态方法org.springframework.core.OrderComparator
  Sort the given array or List with a default OrderComparator, if necessary.
sortStringArray(String[]) - 类 中的静态方法org.springframework.util.StringUtils
  Sort the given `String` array if necessary.
source - 类 中的变量org.springframework.core.env.PropertySource
SPECIFICITY_COMPARATOR - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Comparator used by `MimeTypeUtils.sortBySpecificity(List)`.
SpecificityComparator() - 类 的构造器org.springframework.util.MimeType.SpecificityComparator
split(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Split a `String` at the first occurrence of the delimiter.
splitArrayElementsIntoProperties(String[], String) - 类 中的静态方法org.springframework.util.StringUtils
  Take an array of strings and split each element based on the given delimiter.
splitArrayElementsIntoProperties(String[], String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Take an array of strings and split each element based on the given delimiter.
SpringAsmInfo - org.springframework.asm中的类
  Utility class exposing constants related to Spring's internal repackaging of the ASM bytecode manipulation library (currently based on version 6.0).
SpringAsmInfo() - 类 的构造器org.springframework.asm.SpringAsmInfo
SpringCglibInfo - org.springframework.cglib中的类
  Empty class used to ensure that the `org.springframework.cglib` package is processed during javadoc generation.
SpringCglibInfo() - 类 的构造器org.springframework.cglib.SpringCglibInfo
SpringFactoriesLoader - org.springframework.core.io.support中的类
  General purpose factory loading mechanism for internal use within the framework.
SpringFactoriesLoader() - 类 的构造器org.springframework.core.io.support.SpringFactoriesLoader
SpringNamingPolicy - org.springframework.cglib.core中的类
  Custom extension of CGLIB's `DefaultNamingPolicy`, modifying the tag in generated class names from "ByCGLIB" to "BySpringCGLIB".
SpringNamingPolicy() - 类 的构造器org.springframework.cglib.core.SpringNamingPolicy
SpringObjenesis - org.springframework.objenesis中的类
  Spring-specific variant of `ObjenesisStd` / `ObjenesisBase`, providing a cache based on `Class` keys instead of class names, and allowing for selective use of the cache.
SpringObjenesis() - 类 的构造器org.springframework.objenesis.SpringObjenesis
  Create a new `SpringObjenesis` instance with the standard instantiator strategy.
SpringObjenesis(InstantiatorStrategy) - 类 的构造器org.springframework.objenesis.SpringObjenesis
  Create a new `SpringObjenesis` instance with the given standard instantiator strategy.
SpringProperties - org.springframework.core中的类
  Static holder for local Spring properties, i.e. defined at the Spring library level.
SpringProperties() - 类 的构造器org.springframework.core.SpringProperties
SpringVersion - org.springframework.core中的类
  Class that exposes the Spring version.
SpringVersion() - 类 的构造器org.springframework.core.SpringVersion
STANDARD_NUMBER_TYPES - 类 中的静态变量org.springframework.util.NumberUtils
  Standard number types (all immutable): Byte, Short, Integer, Long, BigInteger, Float, Double, BigDecimal.
StandardAnnotationMetadata - org.springframework.core.type中的类
  `AnnotationMetadata` implementation that uses standard reflection to introspect a given `Class`.
StandardAnnotationMetadata(Class<?>) - 类 的构造器org.springframework.core.type.StandardAnnotationMetadata
  Create a new `StandardAnnotationMetadata` wrapper for the given Class.
StandardAnnotationMetadata(Class<?>, boolean) - 类 的构造器org.springframework.core.type.StandardAnnotationMetadata
  Create a new `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.
StandardClassMetadata - org.springframework.core.type中的类
  `ClassMetadata` implementation that uses standard reflection to introspect a given `Class`.
StandardClassMetadata(Class<?>) - 类 的构造器org.springframework.core.type.StandardClassMetadata
  Create a new StandardClassMetadata wrapper for the given Class.
StandardEnvironment - org.springframework.core.env中的类
  `Environment` implementation suitable for use in 'standard' (i.e. non-web) applications.
StandardEnvironment() - 类 的构造器org.springframework.core.env.StandardEnvironment
StandardMethodMetadata - org.springframework.core.type中的类
  `MethodMetadata` implementation that uses standard reflection to introspect a given `Method`.
StandardMethodMetadata(Method) - 类 的构造器org.springframework.core.type.StandardMethodMetadata
  Create a new StandardMethodMetadata wrapper for the given Method.
StandardMethodMetadata(Method, boolean) - 类 的构造器org.springframework.core.type.StandardMethodMetadata
  Create a new StandardMethodMetadata wrapper for the given Method, providing the option to return any nested annotations or annotation arrays in the form of `AnnotationAttributes` instead of actual `Annotation` instances.
StandardReflectionParameterNameDiscoverer - org.springframework.core中的类
  `ParameterNameDiscoverer` implementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).
StandardReflectionParameterNameDiscoverer() - 类 的构造器org.springframework.core.StandardReflectionParameterNameDiscoverer
start() - 接口 中的方法org.springframework.util.backoff.BackOff
  Start a new back off execution.
start() - 类 中的方法org.springframework.util.backoff.ExponentialBackOff
start() - 类 中的方法org.springframework.util.backoff.FixedBackOff
start() - 类 中的方法org.springframework.util.StopWatch
  Start an unnamed task.
start(String) - 类 中的方法org.springframework.util.StopWatch
  Start a named task.
startsWithIgnoreCase(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Test if the given `String` starts with the specified prefix, ignoring upper/lower case.
state(boolean, String) - 类 中的静态方法org.springframework.util.Assert
  Assert a boolean expression, throwing an `IllegalStateException` if the expression evaluates to `false`.
state(boolean, Supplier<String>) - 类 中的静态方法org.springframework.util.Assert
  Assert a boolean expression, throwing an `IllegalStateException` if the expression evaluates to `false`.
state(boolean) - 类 中的静态方法org.springframework.util.Assert
  已过时。
  as of 4.3.7, in favor of `Assert.state(boolean, String)`
StaxUtils - org.springframework.util.xml中的类
  Convenience methods for working with the StAX API.
StaxUtils() - 类 的构造器org.springframework.util.xml.StaxUtils
STOP - 接口 中的静态变量org.springframework.util.backoff.BackOffExecution
  Return value of `BackOffExecution.nextBackOff()` that indicates that the operation should not be retried.
stop() - 类 中的方法org.springframework.util.StopWatch
  Stop the current task.
StopWatch - org.springframework.util中的类
  Simple stop watch, allowing for timing of a number of tasks, exposing total running time and running time for each named task.
StopWatch() - 类 的构造器org.springframework.util.StopWatch
  Construct a new stop watch.
StopWatch(String) - 类 的构造器org.springframework.util.StopWatch
  Construct a new stop watch with the given id.
StopWatch.TaskInfo - org.springframework.util中的类
  Inner class to hold data about one task executed within the stop watch.
store(Properties, OutputStream, String) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
store(Properties, Writer, String) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
store(Properties, OutputStream, String) - 接口 中的方法org.springframework.util.PropertiesPersister
  Write the contents of the given Properties object to the given OutputStream.
store(Properties, Writer, String) - 接口 中的方法org.springframework.util.PropertiesPersister
  Write the contents of the given Properties object to the given Writer.
storeToXml(Properties, OutputStream, String) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
storeToXml(Properties, OutputStream, String, String) - 类 中的方法org.springframework.util.DefaultPropertiesPersister
storeToXml(Properties, OutputStream, String) - 接口 中的方法org.springframework.util.PropertiesPersister
  Write the contents of the given Properties object to the given XML OutputStream.
storeToXml(Properties, OutputStream, String, String) - 接口 中的方法org.springframework.util.PropertiesPersister
  Write the contents of the given Properties object to the given XML OutputStream.
StreamUtils - org.springframework.util中的类
  Simple utility methods for dealing with streams.
StreamUtils() - 类 的构造器org.springframework.util.StreamUtils
StringDecoder - org.springframework.core.codec中的类
  Decode from a data buffer stream to a `String` stream.
StringUtils - org.springframework.util中的类
  Miscellaneous `String` utility methods.
StringUtils() - 类 的构造器org.springframework.util.StringUtils
StringValueResolver - org.springframework.util中的接口
  Simple strategy interface for resolving a String value.
stripFilenameExtension(String) - 类 中的静态方法org.springframework.util.StringUtils
  Strip the filename extension from the given Java resource path, e.g.
StubPropertySource(String) - 类 的构造器org.springframework.core.env.PropertySource.StubPropertySource
style(Object) - 类 中的方法org.springframework.core.style.DefaultValueStyler
style(Object) - 类 中的静态方法org.springframework.core.style.StylerUtils
  Style the specified value according to default conventions.
style(Object) - 接口 中的方法org.springframework.core.style.ValueStyler
  Style the given value, returning a String representation.
styleEnd(StringBuilder, Object) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleEnd(StringBuilder, Object) - 接口 中的方法org.springframework.core.style.ToStringStyler
  Style a `toString()`'ed object after it's fields are styled.
styleField(StringBuilder, String, Object) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleField(StringBuilder, String, Object) - 接口 中的方法org.springframework.core.style.ToStringStyler
  Style a field value as a string.
styleFieldEnd(StringBuilder, String) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleFieldSeparator(StringBuilder) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleFieldSeparator(StringBuilder) - 接口 中的方法org.springframework.core.style.ToStringStyler
  Style the field separator.
styleFieldStart(StringBuilder, String) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
StylerUtils - org.springframework.core.style中的类
  Simple utility class to allow for convenient access to value styling logic, mainly to support descriptive logging messages.
StylerUtils() - 类 的构造器org.springframework.core.style.StylerUtils
styleStart(StringBuilder, Object) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleStart(StringBuilder, Object) - 接口 中的方法org.springframework.core.style.ToStringStyler
  Style a `toString()`'ed object before its fields are styled.
styleValue(StringBuilder, Object) - 类 中的方法org.springframework.core.style.DefaultToStringStyler
styleValue(StringBuilder, Object) - 接口 中的方法org.springframework.core.style.ToStringStyler
  Style the given value.
subList(int, int) - 类 中的方法org.springframework.util.AutoPopulatingList
submit(Runnable) - 接口 中的方法org.springframework.core.task.AsyncTaskExecutor
  Submit a Runnable task for execution, receiving a Future representing that task.
submit(Callable<T>) - 接口 中的方法org.springframework.core.task.AsyncTaskExecutor
  Submit a Callable task for execution, receiving a Future representing that task.
submit(Runnable) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
submit(Callable<T>) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
submit(Runnable) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
submit(Callable<T>) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
submitListenable(Runnable) - 接口 中的方法org.springframework.core.task.AsyncListenableTaskExecutor
  Submit a `Runnable` task for execution, receiving a `ListenableFuture` representing that task.
submitListenable(Callable<T>) - 接口 中的方法org.springframework.core.task.AsyncListenableTaskExecutor
  Submit a `Callable` task for execution, receiving a `ListenableFuture` representing that task.
submitListenable(Runnable) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
submitListenable(Callable<T>) - 类 中的方法org.springframework.core.task.SimpleAsyncTaskExecutor
submitListenable(Runnable) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
submitListenable(Callable<T>) - 类 中的方法org.springframework.core.task.support.TaskExecutorAdapter
substringMatch(CharSequence, int, CharSequence) - 类 中的静态方法org.springframework.util.StringUtils
  Test whether the given string matches the given substring at the given index.
success(T) - 类 中的方法org.springframework.util.concurrent.ListenableFutureCallbackRegistry
  Trigger a `SuccessCallback.onSuccess(Object)` call on all added callbacks with the given result.
SuccessCallback<T> - org.springframework.util.concurrent中的接口
  Success callback for a `ListenableFuture`.
supportsEmpty() - 类 中的方法org.springframework.core.ReactiveAdapter
  Shortcut for `getDescriptor().supportsEmpty()`.
supportsEmpty() - 类 中的方法org.springframework.core.ReactiveTypeDescriptor
  Return `true` if the reactive type can complete with no values.
suppressGetenvAccess() - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Determine whether to suppress `System.getenv()`/`System.getenv(String)` access for the purposes of `AbstractEnvironment.getSystemEnvironment()`.
SWAP - 接口 中的静态变量org.springframework.asm.Opcodes
SyncTaskExecutor - org.springframework.core.task中的类
  `TaskExecutor` implementation that executes each task synchronously in the calling thread.
SyncTaskExecutor() - 类 的构造器org.springframework.core.task.SyncTaskExecutor
synthesizeAnnotation(A, AnnotatedElement) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Synthesize an annotation from the supplied `annotation` by wrapping it in a dynamic proxy that transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
synthesizeAnnotation(Map<String, Object>, Class<A>, AnnotatedElement) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Synthesize an annotation from the supplied map of annotation attributes by wrapping the map in a dynamic proxy that implements an annotation of the specified `annotationType` and transparently enforces attribute alias semantics for annotation attributes that are annotated with `@AliasFor`.
synthesizeAnnotation(Class<A>) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Synthesize an annotation from its default attributes values.
SynthesizedAnnotation - org.springframework.core.annotation中的接口
  Marker interface implemented by synthesized annotation proxies.
SynthesizingMethodParameter - org.springframework.core.annotation中的类
  A `MethodParameter` variant which synthesizes annotations that declare attribute aliases via `@AliasFor`.
SynthesizingMethodParameter(Method, int) - 类 的构造器org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new `SynthesizingMethodParameter` for the given method, with nesting level 1.
SynthesizingMethodParameter(Method, int, int) - 类 的构造器org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new `SynthesizingMethodParameter` for the given method.
SynthesizingMethodParameter(Constructor<?>, int) - 类 的构造器org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new `SynthesizingMethodParameter` for the given constructor, with nesting level 1.
SynthesizingMethodParameter(Constructor<?>, int, int) - 类 的构造器org.springframework.core.annotation.SynthesizingMethodParameter
  Create a new `SynthesizingMethodParameter` for the given constructor.
SynthesizingMethodParameter(SynthesizingMethodParameter) - 类 的构造器org.springframework.core.annotation.SynthesizingMethodParameter
  Copy constructor, resulting in an independent `SynthesizingMethodParameter` based on the same metadata and cache state that the original object was in.
SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME - 类 中的静态变量org.springframework.core.env.StandardEnvironment
  System environment property source name: "systemEnvironment"
SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME - 类 中的静态变量org.springframework.core.env.StandardEnvironment
  JVM system properties property source name: "systemProperties"
SystemEnvironmentPropertySource - org.springframework.core.env中的类
  Specialization of `MapPropertySource` designed for use with system environment variables.
SystemEnvironmentPropertySource(String, Map<String, Object>) - 类 的构造器org.springframework.core.env.SystemEnvironmentPropertySource
  Create a new `SystemEnvironmentPropertySource` with the given name and delegating to the given `MapPropertySource`.
SystemPropertyUtils - org.springframework.util中的类
  Helper class for resolving placeholders in texts.
SystemPropertyUtils() - 类 的构造器org.springframework.util.SystemPropertyUtils

## T

T_BOOLEAN - 接口 中的静态变量org.springframework.asm.Opcodes
T_BYTE - 接口 中的静态变量org.springframework.asm.Opcodes
T_CHAR - 接口 中的静态变量org.springframework.asm.Opcodes
T_DOUBLE - 接口 中的静态变量org.springframework.asm.Opcodes
T_FLOAT - 接口 中的静态变量org.springframework.asm.Opcodes
T_INT - 接口 中的静态变量org.springframework.asm.Opcodes
T_LONG - 接口 中的静态变量org.springframework.asm.Opcodes
T_SHORT - 接口 中的静态变量org.springframework.asm.Opcodes
TABLESWITCH - 接口 中的静态变量org.springframework.asm.Opcodes
takeUntilByteCount(Publisher<DataBuffer>, long) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Relay buffers from the given `Publisher` until the total byte count reaches the given maximum byte count, or until the publisher is complete.
targetClass - 类 中的变量org.springframework.util.MethodInvoker
TaskDecorator - org.springframework.core.task中的接口
  A callback interface for a decorator to be applied to any `Runnable` about to be executed.
TaskExecutor - org.springframework.core.task中的接口
  Simple task executor interface that abstracts the execution of a `Runnable`.
TaskExecutorAdapter - org.springframework.core.task.support中的类
  Adapter that takes a JDK `java.util.concurrent.Executor` and exposes a Spring `TaskExecutor` for it.
TaskExecutorAdapter(Executor) - 类 的构造器org.springframework.core.task.support.TaskExecutorAdapter
  Create a new TaskExecutorAdapter, using the given JDK concurrent executor.
TaskRejectedException - org.springframework.core.task中的异常错误
  Exception thrown when a `TaskExecutor` rejects to accept a given task for execution.
TaskRejectedException(String) - 异常错误 的构造器org.springframework.core.task.TaskRejectedException
  Create a new `TaskRejectedException` with the specified detail message and no root cause.
TaskRejectedException(String, Throwable) - 异常错误 的构造器org.springframework.core.task.TaskRejectedException
  Create a new `TaskRejectedException` with the specified detail message and the given root cause.
TaskTimeoutException - org.springframework.core.task中的异常错误
  Exception thrown when a `AsyncTaskExecutor` rejects to accept a given task for execution because of the specified timeout.
TaskTimeoutException(String) - 异常错误 的构造器org.springframework.core.task.TaskTimeoutException
  Create a new `TaskTimeoutException` with the specified detail message and no root cause.
TaskTimeoutException(String, Throwable) - 异常错误 的构造器org.springframework.core.task.TaskTimeoutException
  Create a new `TaskTimeoutException` with the specified detail message and the given root cause.
TEXT_HTML - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `text/html`.
TEXT_HTML_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.TEXT_HTML`.
TEXT_PLAIN - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `text/plain`.
TEXT_PLAIN_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.TEXT_PLAIN`.
TEXT_XML - 类 中的静态变量org.springframework.util.MimeTypeUtils
  Public constant mime type for `text/xml`.
TEXT_XML_VALUE - 类 中的静态变量org.springframework.util.MimeTypeUtils
  A String equivalent of `MimeTypeUtils.TEXT_XML`.
textPlainOnly() - 类 中的静态方法org.springframework.core.codec.CharSequenceEncoder
  Create a `CharSequenceEncoder` that supports only "text/plain".
textPlainOnly(boolean) - 类 中的静态方法org.springframework.core.codec.StringDecoder
  已过时。
  as of Spring 5.0.4, in favor of `StringDecoder.textPlainOnly()` or `StringDecoder.textPlainOnly(List, boolean)`
textPlainOnly() - 类 中的静态方法org.springframework.core.codec.StringDecoder
  Create a `StringDecoder` for `"text/plain"`.
textPlainOnly(List<String>, boolean) - 类 中的静态方法org.springframework.core.codec.StringDecoder
  Create a `StringDecoder` for `"text/plain"`.
THROWS - 类 中的静态变量org.springframework.asm.TypeReference
  The sort of type references that target the type of an exception declared in the throws clause of a method.
TIMEOUT_IMMEDIATE - 接口 中的静态变量org.springframework.core.task.AsyncTaskExecutor
  Constant that indicates immediate execution
TIMEOUT_INDEFINITE - 接口 中的静态变量org.springframework.core.task.AsyncTaskExecutor
  Constant that indicates no time limit
toArray() - 类 中的方法org.springframework.util.AutoPopulatingList
toArray(T[]) - 类 中的方法org.springframework.util.AutoPopulatingList
toArray(Enumeration<E>, A[]) - 类 中的静态方法org.springframework.util.CollectionUtils
  Marshal the elements from the given enumeration into an array of the given type.
toByteArray() - 类 中的方法org.springframework.asm.ClassWriter
  Returns the bytecode of the class that was build with this class writer.
toByteArray() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Creates a newly allocated byte array.
toByteArrayUnsafe() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Convert the stream's data to a byte array and return the byte array.
toByteBuf(DataBuffer) - 类 中的静态方法org.springframework.core.io.buffer.NettyDataBufferFactory
  Return the given Netty `DataBuffer` as a `ByteBuf`.
toClassArray(Collection<Class<?>>) - 类 中的静态方法org.springframework.util.ClassUtils
  Copy the given `Collection` into a `Class` array.
toCode(Object, String) - 类 中的方法org.springframework.core.Constants
  Look up the given value within the given group of constants.
toCodeForProperty(Object, String) - 类 中的方法org.springframework.core.Constants
  Look up the given value within the group of constants for the given bean property name.
toCodeForSuffix(Object, String) - 类 中的方法org.springframework.core.Constants
  Look up the given value within the given group of constants.
toIterator(Enumeration<E>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Adapt an `Enumeration` to an `Iterator`.
tokenizePath(String) - 类 中的方法org.springframework.util.AntPathMatcher
  Tokenize the given path String into parts, based on this matcher's settings.
tokenizePattern(String) - 类 中的方法org.springframework.util.AntPathMatcher
  Tokenize the given path pattern into parts, based on this matcher's settings.
tokenizeToStringArray(String, String) - 类 中的静态方法org.springframework.util.StringUtils
  Tokenize the given `String` into a `String` array via a `StringTokenizer`.
tokenizeToStringArray(String, String, boolean, boolean) - 类 中的静态方法org.springframework.util.StringUtils
  Tokenize the given `String` into a `String` array via a `StringTokenizer`.
toLanguageTag(Locale) - 类 中的静态方法org.springframework.util.StringUtils
  已过时。
  as of 5.0.4, in favor of `Locale.toLanguageTag()`
toMultiValueMap(Map<K, List<V>>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Adapt a `Map<K, List<V>>` to an `MultiValueMap<K, V>`.
toObjectArray(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Convert the given array (which may be a primitive array) to an object array (if necessary of primitive wrapper objects).
TOP - 接口 中的静态变量org.springframework.asm.Opcodes
toPublisher(Object) - 类 中的方法org.springframework.core.ReactiveAdapter
  Adapt the given instance to a Reactive Streams `Publisher`.
toSingleValueMap() - 类 中的方法org.springframework.util.LinkedMultiValueMap
toSingleValueMap() - 接口 中的方法org.springframework.util.MultiValueMap
  Return a `Map` with the first values contained in this `MultiValueMap`.
toString() - 类 中的方法org.springframework.asm.Handle
  Returns the textual representation of this handle.
toString() - 类 中的方法org.springframework.asm.Label
  Returns a string representation of this label.
toString() - 类 中的方法org.springframework.asm.Type
  Returns a string representation of this type.
toString() - 类 中的方法org.springframework.asm.TypePath
  Returns a string representation of this type path.
toString() - 类 中的方法org.springframework.core.annotation.AnnotationAttributes
toString() - 类 中的方法org.springframework.core.convert.converter.GenericConverter.ConvertiblePair
toString() - 类 中的方法org.springframework.core.convert.support.GenericConversionService
toString() - 类 中的方法org.springframework.core.convert.TypeDescriptor
toString() - 类 中的方法org.springframework.core.env.AbstractEnvironment
toString() - 类 中的方法org.springframework.core.env.CompositePropertySource
toString() - 类 中的方法org.springframework.core.env.MutablePropertySources
toString() - 类 中的方法org.springframework.core.env.PropertySource
  Produce concise output (type and name) if the current log level does not include debug.
toString() - 类 中的方法org.springframework.core.io.AbstractResource
  This implementation returns the description of this resource.
toString() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
toString() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
toString() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
toString() - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
toString() - 类 中的方法org.springframework.core.io.support.EncodedResource
toString() - 类 中的方法org.springframework.core.MethodClassKey
toString() - 类 中的方法org.springframework.core.MethodParameter
toString() - 类 中的方法org.springframework.core.NamedInheritableThreadLocal
toString() - 类 中的方法org.springframework.core.NamedThreadLocal
toString() - 类 中的方法org.springframework.core.ParameterizedTypeReference
toString() - 类 中的方法org.springframework.core.ResolvableType
  Return a String representation of this type in its fully resolved form (including any generic parameters).
toString() - 类 中的方法org.springframework.core.style.ToStringCreator
  Return the String representation that this ToStringCreator built.
toString() - 类 中的方法org.springframework.util.comparator.BooleanComparator
toString() - 类 中的方法org.springframework.util.comparator.CompoundComparator
  已过时。
toString() - 类 中的方法org.springframework.util.comparator.InvertibleComparator
  已过时。
toString() - 类 中的方法org.springframework.util.comparator.NullSafeComparator
toString() - 类 中的方法org.springframework.util.ConcurrentReferenceHashMap.Entry
toString() - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Convert the buffer's contents into a string decoding bytes using the platform's default character set.
toString() - 类 中的方法org.springframework.util.InstanceFilter
toString() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
toString() - 类 中的方法org.springframework.util.LinkedMultiValueMap
toString() - 类 中的方法org.springframework.util.MimeType
toString(Collection<? extends MimeType>) - 类 中的静态方法org.springframework.util.MimeTypeUtils
  Return a string representation of the given list of `MimeType` objects.
toString() - 类 中的方法org.springframework.util.StopWatch
  Return an informative string describing all tasks performed For custom reporting, call `getTaskInfo()` and use the task info directly.
toStringArray(Collection<String>) - 类 中的静态方法org.springframework.util.StringUtils
  Copy the given `Collection` into a `String` array.
toStringArray(Enumeration<String>) - 类 中的静态方法org.springframework.util.StringUtils
  Copy the given `Enumeration` into a `String` array.
ToStringCreator - org.springframework.core.style中的类
  Utility class that builds pretty-printing `toString()` methods with pluggable styling conventions.
ToStringCreator(Object) - 类 的构造器org.springframework.core.style.ToStringCreator
  Create a ToStringCreator for the given object.
ToStringCreator(Object, ValueStyler) - 类 的构造器org.springframework.core.style.ToStringCreator
  Create a ToStringCreator for the given object, using the provided style.
ToStringCreator(Object, ToStringStyler) - 类 的构造器org.springframework.core.style.ToStringCreator
  Create a ToStringCreator for the given object, using the provided style.
ToStringStyler - org.springframework.core.style中的接口
  A strategy interface for pretty-printing `toString()` methods.
toURI(URL) - 类 中的静态方法org.springframework.util.ResourceUtils
  Create a URI instance for the given URL, replacing spaces with "%20" URI encoding first.
toURI(String) - 类 中的静态方法org.springframework.util.ResourceUtils
  Create a URI instance for the given location String, replacing spaces with "%20" URI encoding first.
TransformerUtils - org.springframework.util.xml中的类
  Contains common behavior relating to `Transformers` and the `javax.xml.transform` package in general.
TransformerUtils() - 类 的构造器org.springframework.util.xml.TransformerUtils
transformIfNecessary(String, byte[]) - 类 中的方法org.springframework.core.OverridingClassLoader
  Transformation hook to be implemented by subclasses.
trimAllWhitespace(String) - 类 中的静态方法org.springframework.util.StringUtils
  Trim all whitespace from the given `String`: leading, trailing, and in between characters.
trimArrayElements(String[]) - 类 中的静态方法org.springframework.util.StringUtils
  Trim the elements of the given `String` array, calling `String.trim()` on each of them.
trimLeadingCharacter(String, char) - 类 中的静态方法org.springframework.util.StringUtils
  Trim all occurrences of the supplied leading character from the given `String`.
trimLeadingWhitespace(String) - 类 中的静态方法org.springframework.util.StringUtils
  Trim leading whitespace from the given `String`.
trimTrailingCharacter(String, char) - 类 中的静态方法org.springframework.util.StringUtils
  Trim all occurrences of the supplied trailing character from the given `String`.
trimTrailingWhitespace(String) - 类 中的静态方法org.springframework.util.StringUtils
  Trim trailing whitespace from the given `String`.
trimWhitespace(String) - 类 中的静态方法org.springframework.util.StringUtils
  Trim leading and trailing whitespace from the given `String`.
TRUE_HIGH - 类 中的静态变量org.springframework.util.comparator.BooleanComparator
  A shared default instance of this comparator, treating `true` higher than `false`.
TRUE_LOW - 类 中的静态变量org.springframework.util.comparator.BooleanComparator
  A shared default instance of this comparator, treating `true` lower than `false`.
type - 类 中的变量org.springframework.asm.Attribute
  The type of this attribute.
Type - org.springframework.asm中的类
  A Java field or method type.
TYPE_ARGUMENT - 类 中的静态变量org.springframework.asm.TypePath
  A type path step that steps into a type argument of a generic type.
TypeDescriptor - org.springframework.core.convert中的类
  Context about a type to convert from or to.
TypeDescriptor(MethodParameter) - 类 的构造器org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `MethodParameter`.
TypeDescriptor(Field) - 类 的构造器org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `Field`.
TypeDescriptor(Property) - 类 的构造器org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `Property`.
TypeDescriptor(ResolvableType, Class<?>, Annotation[]) - 类 的构造器org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from a `ResolvableType`.
TypeFilter - org.springframework.core.type.filter中的接口
  Base interface for type filters using a `MetadataReader`.
TypePath - org.springframework.asm中的类
  The path to a type argument, wildcard bound, array element type, or static inner type within an enclosing type.
TypeReference - org.springframework.asm中的类
  A reference to a type appearing in a class, field or method declaration, or on an instruction.
TypeReference(int) - 类 的构造器org.springframework.asm.TypeReference
  Creates a new TypeReference.
TypeUtils - org.springframework.util中的类
  Utility to work with Java 5 generic type parameters.
TypeUtils() - 类 的构造器org.springframework.util.TypeUtils

## U

UNBOUNDED_CONCURRENCY - 类 中的静态变量org.springframework.core.task.SimpleAsyncTaskExecutor
  Permit any number of concurrent invocations: that is, don't throttle concurrency.
UNBOUNDED_CONCURRENCY - 类 中的静态变量org.springframework.util.ConcurrencyThrottleSupport
  Permit any number of concurrent invocations: that is, don't throttle concurrency.
uncapitalize(String) - 类 中的静态方法org.springframework.util.StringUtils
  Uncapitalize a `String`, changing the first letter to lower case as per `Character.toLowerCase(char)`.
UNINITIALIZED_THIS - 接口 中的静态变量org.springframework.asm.Opcodes
UNLIMITED_ATTEMPTS - 类 中的静态变量org.springframework.util.backoff.FixedBackOff
  Constant value indicating an unlimited number of attempts.
unmodifiableMultiValueMap(MultiValueMap<? extends K, ? extends V>) - 类 中的静态方法org.springframework.util.CollectionUtils
  Return an unmodifiable view of the specified multi-value map.
unqualify(String) - 类 中的静态方法org.springframework.util.StringUtils
  Unqualify a string qualified by a '.' dot character.
unqualify(String, char) - 类 中的静态方法org.springframework.util.StringUtils
  Unqualify a string qualified by a separator character.
unquote(String) - 类 中的方法org.springframework.util.MimeType
unwrapOptional(Object) - 类 中的静态方法org.springframework.util.ObjectUtils
  Unwrap the given object which is potentially a `Optional`.
upcast(Class<?>) - 类 中的方法org.springframework.core.convert.TypeDescriptor
  Cast this `TypeDescriptor` to a superclass or implemented interface preserving annotations and nested type context.
uriDecode(String, Charset) - 类 中的静态方法org.springframework.util.StringUtils
  Decode the given encoded URI component value.
URL_PROTOCOL_FILE - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for a file in the file system: "file"
URL_PROTOCOL_JAR - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for an entry from a jar file: "jar"
URL_PROTOCOL_VFS - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for a general JBoss VFS resource: "vfs"
URL_PROTOCOL_VFSFILE - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for a JBoss file system resource: "vfsfile"
URL_PROTOCOL_VFSZIP - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for an entry from a JBoss jar file: "vfszip"
URL_PROTOCOL_WAR - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for an entry from a war file: "war"
URL_PROTOCOL_WSJAR - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for an entry from a WebSphere jar file: "wsjar"
URL_PROTOCOL_ZIP - 类 中的静态变量org.springframework.util.ResourceUtils
  URL protocol for an entry from a zip file: "zip"
UrlResource - org.springframework.core.io中的类
  `Resource` implementation for `java.net.URL` locators.
UrlResource(URI) - 类 的构造器org.springframework.core.io.UrlResource
  Create a new `UrlResource` based on the given URI object.
UrlResource(URL) - 类 的构造器org.springframework.core.io.UrlResource
  Create a new `UrlResource` based on the given URL object.
UrlResource(String) - 类 的构造器org.springframework.core.io.UrlResource
  Create a new `UrlResource` based on a URL path.
UrlResource(String, String) - 类 的构造器org.springframework.core.io.UrlResource
  Create a new `UrlResource` based on a URI specification.
UrlResource(String, String, String) - 类 的构造器org.springframework.core.io.UrlResource
  Create a new `UrlResource` based on a URI specification.
useCachesIfNecessary(URLConnection) - 类 中的静态方法org.springframework.util.ResourceUtils
  Set the `"useCaches"` flag on the given connection, preferring `false` but leaving the flag at `true` for JNLP based resources.
USER_DECLARED_METHODS - 类 中的静态变量org.springframework.util.ReflectionUtils
  Pre-built MethodFilter that matches all non-bridge non-synthetic methods which are not declared on `java.lang.Object`.
UsesJava7 - org.springframework.lang中的注释类型
  已过时。
  as of 5.0 since the framework is based on Java 8+ now
UsesJava8 - org.springframework.lang中的注释类型
  已过时。
  as of 5.0 since the framework is based on Java 8+ now
UsesSunHttpServer - org.springframework.lang中的注释类型
  Indicates that the annotated element uses the Http Server available in `com.sun.*` classes, which is only available on a Sun/Oracle JVM.
UsesSunMisc - org.springframework.lang中的注释类型
  Indicates that the annotated element uses an API from the `sun.misc` package.

## V

V1_1 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_2 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_3 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_4 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_5 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_6 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_7 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_8 - 接口 中的静态变量org.springframework.asm.Opcodes
V1_9 - 接口 中的静态变量org.springframework.asm.Opcodes
validateAnnotation(Annotation) - 类 中的静态方法org.springframework.core.annotation.AnnotationUtils
  Check the declared attributes of the given annotation, in particular covering Google App Engine's late arrival of `TypeNotPresentExceptionProxy` for `Class` values (instead of early `Class.getAnnotations() failure`.
validateProfile(String) - 类 中的方法org.springframework.core.env.AbstractEnvironment
  Validate the given profile, called internally prior to adding to the set of active or default profiles.
validateRequiredProperties() - 类 中的方法org.springframework.core.env.AbstractEnvironment
validateRequiredProperties() - 类 中的方法org.springframework.core.env.AbstractPropertyResolver
validateRequiredProperties() - 接口 中的方法org.springframework.core.env.ConfigurablePropertyResolver
  Validate that each of the properties specified by `ConfigurablePropertyResolver.setRequiredProperties(java.lang.String...)` is present and resolves to a non-`null` value.
VALIDATION_AUTO - 类 中的静态变量org.springframework.util.xml.XmlValidationModeDetector
  Indicates that the validation mode should be auto-guessed, since we cannot find a clear indication (probably choked on some special characters, or the like).
VALIDATION_DTD - 类 中的静态变量org.springframework.util.xml.XmlValidationModeDetector
  Indicates that DTD validation should be used (we found a "DOCTYPE" declaration).
VALIDATION_NONE - 类 中的静态变量org.springframework.util.xml.XmlValidationModeDetector
  Indicates that the validation should be disabled.
VALIDATION_XSD - 类 中的静态变量org.springframework.util.xml.XmlValidationModeDetector
  Indicates that XSD validation should be used (found no "DOCTYPE" declaration).
VALUE - 类 中的静态变量org.springframework.core.annotation.AnnotationUtils
  The attribute name for annotations with a single element.
VALUE_SEPARATOR - 类 中的静态变量org.springframework.util.SystemPropertyUtils
  Value separator for system property placeholders: ":"
valueOf(Class<?>) - 类 中的静态方法org.springframework.core.convert.TypeDescriptor
  Create a new type descriptor from the given type.
valueOf(String) - 枚举 中的静态方法org.springframework.util.ConcurrentReferenceHashMap.ReferenceType
  返回带有指定名称的该类型的枚举常量。
valueOf(String) - 枚举 中的静态方法org.springframework.util.ConcurrentReferenceHashMap.Restructure
  返回带有指定名称的该类型的枚举常量。
valueOf(String) - 类 中的静态方法org.springframework.util.MimeType
  Parse the given String value into a `MimeType` object, with this method name following the 'valueOf' naming convention (as supported by `ConversionService`.
values() - 枚举 中的静态方法org.springframework.util.ConcurrentReferenceHashMap.ReferenceType
  按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。
values() - 枚举 中的静态方法org.springframework.util.ConcurrentReferenceHashMap.Restructure
  按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。
values() - 类 中的方法org.springframework.util.LinkedCaseInsensitiveMap
values() - 类 中的方法org.springframework.util.LinkedMultiValueMap
ValueStyler - org.springframework.core.style中的接口
  Strategy that encapsulates value String styling algorithms according to Spring conventions.
VfsResource - org.springframework.core.io中的类
  JBoss VFS based `Resource` implementation.
VfsResource(Object) - 类 的构造器org.springframework.core.io.VfsResource
  Create a new `VfsResource` wrapping the given resource handle.
VfsUtils - org.springframework.core.io中的类
  Utility for detecting and accessing JBoss VFS in the classpath.
VfsUtils() - 类 的构造器org.springframework.core.io.VfsUtils
VIRTUAL_FILE_METHOD_VISIT - 类 中的静态变量org.springframework.core.io.VfsUtils
VIRTUAL_FILE_VISITOR_INTERFACE - 类 中的静态变量org.springframework.core.io.VfsUtils
visit(String, Object) - 类 中的方法org.springframework.asm.AnnotationVisitor
  Visits a primitive value of the annotation.
visit(int, int, String, String, String, String[]) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits the header of the class.
visit(int, int, String, String, String, String[]) - 类 中的方法org.springframework.asm.ClassWriter
visitAnnotation(String, String) - 类 中的方法org.springframework.asm.AnnotationVisitor
  Visits a nested annotation value of the annotation.
visitAnnotation(String, boolean) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits an annotation of the class.
visitAnnotation(String, boolean) - 类 中的方法org.springframework.asm.ClassWriter
visitAnnotation(String, boolean) - 类 中的方法org.springframework.asm.FieldVisitor
  Visits an annotation of the field.
visitAnnotation(String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation of this method.
visitAnnotation(String, boolean) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
visitAnnotation(String, boolean) - 类 中的方法org.springframework.core.type.classreading.MethodMetadataReadingVisitor
visitAnnotationDefault() - 类 中的方法org.springframework.asm.MethodVisitor
  Visits the default value of this annotation interface method.
visitArray(String) - 类 中的方法org.springframework.asm.AnnotationVisitor
  Visits an array value of the annotation.
visitAttribute(Attribute) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits a non standard attribute of the class.
visitAttribute(Attribute) - 类 中的方法org.springframework.asm.ClassWriter
visitAttribute(Attribute) - 类 中的方法org.springframework.asm.FieldVisitor
  Visits a non standard attribute of the field.
visitAttribute(Attribute) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a non standard attribute of this method.
visitCode() - 类 中的方法org.springframework.asm.MethodVisitor
  Starts the visit of the method's code, if any (i.e. non abstract method).
visitEnd() - 类 中的方法org.springframework.asm.AnnotationVisitor
  Visits the end of the annotation.
visitEnd() - 类 中的方法org.springframework.asm.ClassVisitor
  Visits the end of the class.
visitEnd() - 类 中的方法org.springframework.asm.ClassWriter
visitEnd() - 类 中的方法org.springframework.asm.FieldVisitor
  Visits the end of the field.
visitEnd() - 类 中的方法org.springframework.asm.MethodVisitor
  Visits the end of the method.
visitEnd() - 类 中的方法org.springframework.asm.ModuleVisitor
visitEnum(String, String, String) - 类 中的方法org.springframework.asm.AnnotationVisitor
  Visits an enumeration value of the annotation.
visitExport(String, int, String...) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit an exported package of the current module.
visitField(int, String, String, String, Object) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits a field of the class.
visitField(int, String, String, String, Object) - 类 中的方法org.springframework.asm.ClassWriter
visitFieldInsn(int, String, String, String) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a field instruction.
visitFrame(int, int, Object[], int, Object[]) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits the current state of the local variables and operand stack elements.
visitIincInsn(int, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an IINC instruction.
visitInnerClass(String, String, String, int) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits information about an inner class.
visitInnerClass(String, String, String, int) - 类 中的方法org.springframework.asm.ClassWriter
visitInsn(int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a zero operand instruction.
visitInsnAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation on an instruction.
visitIntInsn(int, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an instruction with a single int operand.
visitInvokeDynamicInsn(String, String, Handle, Object...) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an invokedynamic instruction.
visitJumpInsn(int, Label) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a jump instruction.
visitLabel(Label) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a label.
visitLdcInsn(Object) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a LDC instruction.
visitLineNumber(int, Label) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a line number declaration.
visitLocalVariable(String, String, String, Label, Label, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a local variable declaration.
visitLocalVariableAnnotation(int, TypePath, Label[], Label[], int[], String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation on a local variable type.
visitLookupSwitchInsn(Label, int[], Label[]) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a LOOKUPSWITCH instruction.
visitMainClass(String) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit the main class of the current module.
visitMaxs(int, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits the maximum stack size and the maximum number of local variables of the method.
visitMethod(int, String, String, String, String[]) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits a method of the class.
visitMethod(int, String, String, String, String[]) - 类 中的方法org.springframework.asm.ClassWriter
visitMethod(int, String, String, String, String[]) - 类 中的方法org.springframework.core.type.classreading.AnnotationMetadataReadingVisitor
visitMethodInsn(int, String, String, String) - 类 中的方法org.springframework.asm.MethodVisitor
  已过时。
visitMethodInsn(int, String, String, String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a method instruction.
visitModule(String, int, String) - 类 中的方法org.springframework.asm.ClassVisitor
  Visit the module corresponding to the class.
visitModule(String, int, String) - 类 中的方法org.springframework.asm.ClassWriter
visitMultiANewArrayInsn(String, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a MULTIANEWARRAY instruction.
visitOpen(String, int, String...) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit an open package of the current module.
visitOuterClass(String, String, String) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits the enclosing class of the class.
visitOuterClass(String, String, String) - 类 中的方法org.springframework.asm.ClassWriter
visitPackage(String) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit a concealed package of the current module.
visitParameter(String, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a parameter of this method.
visitParameterAnnotation(int, String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation of a parameter this method.
visitProvide(String, String...) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit an implementation of a service.
visitRequire(String, int, String) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visits a dependence of the current module.
visitSource(String, String) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits the source of the class.
visitSource(String, String) - 类 中的方法org.springframework.asm.ClassWriter
visitTableSwitchInsn(int, int, Label, Label...) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a TABLESWITCH instruction.
visitTryCatchAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation on an exception handler type.
visitTryCatchBlock(Label, Label, Label, String) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a try catch block.
visitTypeAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.ClassVisitor
  Visits an annotation on a type in the class signature.
visitTypeAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.ClassWriter
visitTypeAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.FieldVisitor
  Visits an annotation on the type of the field.
visitTypeAnnotation(int, TypePath, String, boolean) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits an annotation on a type in the method signature.
visitTypeInsn(int, String) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a type instruction.
visitUse(String) - 类 中的方法org.springframework.asm.ModuleVisitor
  Visit a service used by the current module.
visitVarInsn(int, int) - 类 中的方法org.springframework.asm.MethodVisitor
  Visits a local variable instruction.
VOID - 类 中的静态变量org.springframework.asm.Type
  The sort of the `void` type.
VOID_TYPE - 类 中的静态变量org.springframework.asm.Type
  The `void` type.

## W

WAR_URL_PREFIX - 类 中的静态变量org.springframework.util.ResourceUtils
  URL prefix for loading from a war file on Tomcat: "war:"
WAR_URL_SEPARATOR - 类 中的静态变量org.springframework.util.ResourceUtils
  Special separator between WAR URL and jar part on Tomcat
warning(SAXParseException) - 类 中的方法org.springframework.util.xml.SimpleSaxErrorHandler
warning(TransformerException) - 类 中的方法org.springframework.util.xml.SimpleTransformErrorListener
WILDCARD_BOUND - 类 中的静态变量org.springframework.asm.TypePath
  A type path step that steps into the bound of a wildcard type.
WILDCARD_TYPE - 类 中的静态变量org.springframework.util.MimeType
withName(String) - 类 中的方法org.springframework.core.io.support.ResourcePropertySource
  Return a potentially adapted variant of this `ResourcePropertySource`, overriding the previously given (or derived) name with the specified name.
withResourceName() - 类 中的方法org.springframework.core.io.support.ResourcePropertySource
  Return a potentially adapted variant of this `ResourcePropertySource`, overriding the previously given name (if any) with the original resource name (equivalent to the name generated by the name-less constructor variants).
withSourceProvider(OrderComparator.OrderSourceProvider) - 类 中的方法org.springframework.core.OrderComparator
  Build an adapted order comparator with the given source provider.
wrap(ByteBuffer) - 接口 中的方法org.springframework.core.io.buffer.DataBufferFactory
  Wrap the given `ByteBuffer` in a `DataBuffer`.
wrap(byte[]) - 接口 中的方法org.springframework.core.io.buffer.DataBufferFactory
  Wrap the given `byte` array in a `DataBuffer`.
wrap(ByteBuffer) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
wrap(byte[]) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBufferFactory
wrap(ByteBuffer) - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
wrap(byte[]) - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
wrap(ByteBuf) - 类 中的方法org.springframework.core.io.buffer.NettyDataBufferFactory
  Wrap the given Netty `ByteBuf` in a `NettyDataBuffer`.
writableByteCount() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the number of bytes that can be written to this data buffer.
writableByteCount() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
writableByteCount() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
writableChannel() - 类 中的方法org.springframework.core.io.FileSystemResource
  This implementation opens a FileChannel for the underlying file.
writableChannel() - 类 中的方法org.springframework.core.io.FileUrlResource
writableChannel() - 类 中的方法org.springframework.core.io.PathResource
  This implementation opens a Channel for the underlying file.
writableChannel() - 接口 中的方法org.springframework.core.io.WritableResource
  Return a `WritableByteChannel`.
WritableResource - org.springframework.core.io中的接口
  Extended interface for a resource that supports writing to it.
write(ClassWriter, byte[], int, int, int) - 类 中的方法org.springframework.asm.Attribute
  Returns the byte array form of this attribute.
write(byte) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Write a single byte into this buffer at the current writing position.
write(byte[]) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Write the given source into this buffer, startin at the current writing position of this buffer.
write(byte[], int, int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Write at most `length` bytes of the given source into this buffer, starting at the current writing position of this buffer.
write(DataBuffer...) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Write one or more `DataBuffer`s to this buffer, starting at the current writing position.
write(ByteBuffer...) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Write one or more `ByteBuffer` to this buffer, starting at the current writing position.
write(Publisher<DataBuffer>, OutputStream) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Write the given stream of `DataBuffer`s to the given `OutputStream`.
write(Publisher<DataBuffer>, WritableByteChannel) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Write the given stream of `DataBuffer`s to the given `WritableByteChannel`.
write(Publisher<DataBuffer>, AsynchronousFileChannel) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Write the given stream of `DataBuffer`s to the given `AsynchronousFileChannel`.
write(Publisher<DataBuffer>, AsynchronousFileChannel, long) - 类 中的静态方法org.springframework.core.io.buffer.DataBufferUtils
  Write the given stream of `DataBuffers` to the given `AsynchronousFileChannel`.
write(byte) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
write(byte[]) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
write(byte[], int, int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
write(DataBuffer...) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
write(ByteBuffer...) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
write(byte) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
write(byte[]) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
write(byte[], int, int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
write(DataBuffer...) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
write(ByteBuffer...) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
write(ByteBuf...) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
  Writes one or more Netty `ByteBuf`s to this buffer, starting at the current writing position.
write(char) - 类 中的方法org.springframework.util.CommonsLogWriter
write(char[], int, int) - 类 中的方法org.springframework.util.CommonsLogWriter
write(int) - 类 中的方法org.springframework.util.FastByteArrayOutputStream
write(byte[], int, int) - 类 中的方法org.springframework.util.FastByteArrayOutputStream
writePosition() - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Return the position to which this buffer will write.
writePosition(int) - 接口 中的方法org.springframework.core.io.buffer.DataBuffer
  Set the position to which this buffer will write.
writePosition() - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
writePosition(int) - 类 中的方法org.springframework.core.io.buffer.DefaultDataBuffer
writePosition() - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
writePosition(int) - 类 中的方法org.springframework.core.io.buffer.NettyDataBuffer
writeTo(OutputStream) - 类 中的方法org.springframework.util.FastByteArrayOutputStream
  Write the buffers content to the given OutputStream.

## X

XmlValidationModeDetector - org.springframework.util.xml中的类
  Detects whether an XML stream is using DTD- or XSD-based validation.
XmlValidationModeDetector() - 类 的构造器org.springframework.util.xml.XmlValidationModeDetector

A B C D E F G H I J K L M N O P Q R S T U V W X