索引 (spring-core 5.0.15.BUILD-SNAPSHOT API)

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 ListenableFutures.
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 Strings 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 ByteBuffers.
ByteBufferDecoder() - 类的构造器org.springframework.core.codec.ByteBufferDecoder
ByteBufferEncoder - org.springframework.core.codec中的类: Encoder for ByteBuffers.
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.References.
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 Nodes.
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 DataBuffers.
DataBufferDecoder() - 类的构造器org.springframework.core.codec.DataBufferDecoder
DataBufferEncoder - org.springframework.core.codec中的类: Simple pass-through encoder for DataBuffers.
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 DataBuffers.
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 ResolvableTypes 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 DataBuffers.
read(Resource, long, DataBufferFactory, int) - 类中的静态方法org.springframework.core.io.buffer.DataBufferUtils: Read the given Resource into a Flux of DataBuffers 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 DataBuffers.
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 DataBuffers, 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 DataBuffers.
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 DataBuffers.
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 Resources.
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 Resources.
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 ResourceRegions.
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 DataBuffers 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 DataBuffers to the given OutputStream.
write(Publisher<DataBuffer>, WritableByteChannel) - 类中的静态方法org.springframework.core.io.buffer.DataBufferUtils: Write the given stream of DataBuffers to the given WritableByteChannel.
write(Publisher<DataBuffer>, AsynchronousFileChannel) - 类中的静态方法org.springframework.core.io.buffer.DataBufferUtils: Write the given stream of DataBuffers 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 ByteBufs 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