## 类的使用
org.springframework.lang.Nullable

- 使用Nullable的程序包
  程序包 | 说明
  --- | ---
  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 | Core support package for annotations, meta-annotations, and composed annotations with attribute overrides.
  org.springframework.core.codec | `Encoder` and `Decoder` abstractions to convert between a reactive stream of bytes and Java objects.
  org.springframework.core.convert | Type conversion system API.
  org.springframework.core.convert.converter | SPI to implement Converters for the type conversion system.
  org.springframework.core.convert.support | Default implementation of the type conversion system.
  org.springframework.core.env | Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
  org.springframework.core.io | Generic abstraction for (file-based) resources, used throughout the framework.
  org.springframework.core.io.buffer | Generic abstraction for working with byte buffer implementations.
  org.springframework.core.io.support | Support classes for Spring's resource abstraction.
  org.springframework.core.serializer | Root package for Spring's serializer interfaces and implementations.
  org.springframework.core.style | Support for styling values as Strings, with ToStringCreator as central class.
  org.springframework.core.task | This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
  org.springframework.core.task.support | Support classes for Spring's TaskExecutor abstraction.
  org.springframework.core.type | Core support package for type introspection.
  org.springframework.core.type.classreading | Support classes for reading annotation and class-level metadata.
  org.springframework.core.type.filter | Core support package for type filtering (e.g. for classpath scanning).
  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.comparator | Useful generic `java.util.Comparator` implementations, such as an invertible comparator and a compound comparator.
  org.springframework.util.concurrent | Useful generic `java.util.concurrent.Future` extension.
  org.springframework.util.xml | Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.

- - ### org.springframework.core中Nullable的使用

    注释类型为Nullable的org.springframework.core中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `static String` | NestedExceptionUtils.`buildMessage(String message, Throwable cause)` Build a message for the given base message and root cause.
    `protected Integer` | OrderComparator.`findOrder(Object obj)` Find an order value indicated by the given object.
    `ReactiveAdapter` | ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType)` Get the adapter for the given reactive type.
    `ReactiveAdapter` | ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)` Get the adapter for the given reactive type.
    `Object` | AttributeAccessor.`getAttribute(String name)` Get the value of the attribute identified by `name`.
    `Object` | AttributeAccessorSupport.`getAttribute(String name)`
    `Constructor<?>` | MethodParameter.`getConstructor()` Return the wrapped Constructor, if any.
    `protected ClassLoader` | ConfigurableObjectInputStream.`getFallbackClassLoader()` Return the fallback ClassLoader to use when no ClassLoader was specified and ObjectInputStream's own default class loader failed.
    `String` | NestedCheckedException.`getMessage()` Return the detail message, including the message from the nested exception if there is one.
    `String` | NestedIOException.`getMessage()` Return the detail message, including the message from the nested exception if there is one.
    `String` | NestedRuntimeException.`getMessage()` Return the detail message, including the message from the nested exception if there is one.
    `Method` | MethodParameter.`getMethod()` Return the wrapped Method, if any.
    `<A extends Annotation> A` | MethodParameter.`getMethodAnnotation(Class<A> annotationType)` Return the method/constructor annotation of the given type, if available.
    `Object` | OrderComparator.OrderSourceProvider.`getOrderSource(Object obj)` 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.
    `<A extends Annotation> A` | MethodParameter.`getParameterAnnotation(Class<A> annotationType)` Return the parameter annotation of the given type, if available.
    `String` | MethodParameter.`getParameterName()` Return the name of the method/constructor parameter.
    `String[]` | KotlinReflectionParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
    `String[]` | LocalVariableTableParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
    `String[]` | ParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)` Return parameter names for a constructor, or `null` if they cannot be determined.
    `String[]` | PrioritizedParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
    `String[]` | StandardReflectionParameterNameDiscoverer.`getParameterNames(Constructor<?> ctor)`
    `String[]` | KotlinReflectionParameterNameDiscoverer.`getParameterNames(Method method)`
    `String[]` | LocalVariableTableParameterNameDiscoverer.`getParameterNames(Method method)`
    `String[]` | ParameterNameDiscoverer.`getParameterNames(Method method)` Return parameter names for a method, or `null` if they cannot be determined.
    `String[]` | PrioritizedParameterNameDiscoverer.`getParameterNames(Method method)`
    `String[]` | StandardReflectionParameterNameDiscoverer.`getParameterNames(Method method)`
    `Integer` | OrderComparator.`getPriority(Object obj)` Determine a priority value for the given object, if any.
    `static String` | SpringProperties.`getProperty(String key)` Retrieve the property value for the given key, checking local Spring properties first and falling back to JVM-level system properties.
    `Class<?>` | ResolvableType.`getRawClass()` Return the underlying Java `Class` being managed, if available; otherwise `null`.
    `ResolvableType` | ResolvableTypeProvider.`getResolvableType()` Return the `ResolvableType` describing this instance (or `null` if some sort of default should be applied instead).
    `Throwable` | NestedCheckedException.`getRootCause()` Retrieve the innermost cause of this exception, if any.
    `Throwable` | NestedRuntimeException.`getRootCause()` Retrieve the innermost cause of this exception, if any.
    `static Throwable` | NestedExceptionUtils.`getRootCause(Throwable original)` Retrieve the innermost cause of the given exception, if any.
    `Integer` | MethodParameter.`getTypeIndexForCurrentLevel()` Return the type index for the current nesting level.
    `Integer` | MethodParameter.`getTypeIndexForLevel(int nestingLevel)` Return the type index for the specified nesting level.
    `static String` | SpringVersion.`getVersion()` Return the full version string of the present Spring codebase, or `null` if it cannot be determined.
    `T` | MethodIntrospector.MetadataLookup.`inspect(Method method)` Perform a lookup on the given method and return associated metadata, if any.
    `protected byte[]` | OverridingClassLoader.`loadBytesForClass(String name)` Load the defining bytes for the given class, to be turned into a Class object through a `ClassLoader.defineClass(byte[], int, int)` call.
    `protected Class<?>` | OverridingClassLoader.`loadClassForOverriding(String name)` Load the specified class for overriding purposes in this ClassLoader.
    `protected InputStream` | OverridingClassLoader.`openStreamForClass(String name)` Open an InputStream for the specified class.
    `Object` | AttributeAccessor.`removeAttribute(String name)` Remove the attribute identified by `name` and return its value.
    `Object` | AttributeAccessorSupport.`removeAttribute(String name)`
    `Class<?>` | ResolvableType.`resolve()` Resolve this type to a `Class`, returning `null` if the type cannot be resolved.
    `Class<?>` | ResolvableType.`resolveGeneric(int... indexes)` Convenience method that will `get` and `resolve` a specific generic parameters.
    `static Class<?>` | GenericTypeResolver.`resolveReturnTypeArgument(Method method, Class<?> genericIfc)` 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.
    `static Class<?>` | GenericTypeResolver.`resolveTypeArgument(Class<?> clazz, Class<?> genericIfc)` 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.
    `static Class<?>[]` | GenericTypeResolver.`resolveTypeArguments(Class<?> clazz, Class<?> genericIfc)` 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.

    注释类型为Nullable的org.springframework.core中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `static String` | NestedExceptionUtils.`buildMessage(String message, Throwable cause)` Build a message for the given base message and root cause.
    `static String` | NestedExceptionUtils.`buildMessage(String message, Throwable cause)` Build a message for the given base message and root cause.
    `int` | OrderComparator.`compare(Object o1, Object o2)`
    `int` | OrderComparator.`compare(Object o1, Object o2)`
    `boolean` | NestedCheckedException.`contains(Class<?> exType)` 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.
    `boolean` | NestedRuntimeException.`contains(Class<?> exType)` 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.
    `static <E> Collection<E>` | CollectionFactory.`createApproximateCollection(Object collection, int capacity)` Create the most approximate collection for the given collection.
    `static <K,V> Map<K,V>` | CollectionFactory.`createApproximateMap(Object map, int capacity)` Create the most approximate map for the given map.
    `static <E> Collection<E>` | CollectionFactory.`createCollection(Class<?> collectionType, Class<?> elementType, int capacity)` Create the most appropriate collection for the given collection type.
    `static <K,V> Map<K,V>` | CollectionFactory.`createMap(Class<?> mapType, Class<?> keyType, int capacity)` Create the most appropriate map for the given map type.
    `boolean` | ReactiveTypeDescriptor.`equals(Object other)`
    `static ResolvableType` | ResolvableType.`forClass(Class<?> clazz)` Return a `ResolvableType` for the specified `Class`, using the full generic type information for assignability checks.
    `static ResolvableType` | ResolvableType.`forField(Field field, int nestingLevel, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Field` with a given implementation and the given nesting level.
    `static ResolvableType` | ResolvableType.`forField(Field field, ResolvableType implementationType)` Return a `ResolvableType` for the specified `Field` with a given implementation.
    `static ResolvableType` | ResolvableType.`forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)` Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
    `static ResolvableType` | ResolvableType.`forMethodParameter(MethodParameter methodParameter, Type targetType)` Return a `ResolvableType` for the specified `MethodParameter`, overriding the target type to resolve with a specific given type.
    `static ResolvableType` | ResolvableType.`forRawClass(Class<?> clazz)` 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.
    `static ResolvableType` | ResolvableType.`forType(Type type)` Return a `ResolvableType` for the specified `Type`.
    `static ResolvableType` | ResolvableType.`forType(Type type, ResolvableType owner)` Return a `ResolvableType` for the specified `Type` backed by the given owner type.
    `static ResolvableType` | ResolvableType.`forType(Type type, ResolvableType owner)` Return a `ResolvableType` for the specified `Type` backed by the given owner type.
    `ReactiveAdapter` | ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)` Get the adapter for the given reactive type.
    `ReactiveAdapter` | ReactiveAdapterRegistry.`getAdapter(Class<?> reactiveType, Object source)` Get the adapter for the given reactive type.
    `ResolvableType` | ResolvableType.`getGeneric(int... indexes)` Return a `ResolvableType` representing the generic parameter for the given indexes.
    `Set<String>` | Constants.`getNames(String namePrefix)` Return all names of the given group of constants.
    `Set<String>` | Constants.`getNamesForSuffix(String nameSuffix)` Return all names of the given group of constants.
    `ResolvableType` | ResolvableType.`getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)` Return a `ResolvableType` for the specified nesting level.
    `protected int` | OrderComparator.`getOrder(Object obj)` Determine the order value for the given object.
    `static Throwable` | NestedExceptionUtils.`getRootCause(Throwable original)` Retrieve the innermost cause of the given exception, if any.
    `Set<Object>` | Constants.`getValues(String namePrefix)` Return all values of the given group of constants.
    `Set<Object>` | Constants.`getValuesForSuffix(String nameSuffix)` Return all values of the given group of constants.
    `static String` | Conventions.`getVariableNameForReturnType(Method method, Class<?> resolvedType, Object value)` 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.
    `static String` | Conventions.`getVariableNameForReturnType(Method method, Object value)` 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.
    `void` | MethodParameter.`initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer)` Initialize parameter name discovery for this method parameter.
    `static boolean` | CollectionFactory.`isApproximableCollectionType(Class<?> collectionType)` Determine whether the given collection type is an approximable type, i.e. a type that `CollectionFactory.createApproximateCollection(java.lang.Object, int)` can approximate.
    `static boolean` | CollectionFactory.`isApproximableMapType(Class<?> mapType)` Determine whether the given map type is an approximable type, i.e. a type that `CollectionFactory.createApproximateMap(java.lang.Object, int)` can approximate.
    `boolean` | ResolvableType.`isInstance(Object obj)` Determine whether the given object is an instance of this `ResolvableType`.
    `static Type` | GenericTypeResolver.`resolveType(Type genericType, Class<?> contextClass)` Resolve the given generic type against the given context class, substituting type variables as far as possible.
    `void` | AttributeAccessor.`setAttribute(String name, Object value)` Set the attribute defined by `name` to the supplied `value`.
    `void` | AttributeAccessorSupport.`setAttribute(String name, Object value)`
    `static void` | SpringProperties.`setProperty(String key, String value)` Programmatically set a local property, overriding an entry in the `spring.properties` file (if any).
    `String` | Constants.`toCode(Object value, String namePrefix)` Look up the given value within the given group of constants.
    `String` | Constants.`toCodeForSuffix(Object value, String nameSuffix)` Look up the given value within the given group of constants.
    `<T> org.reactivestreams.Publisher<T>` | ReactiveAdapter.`toPublisher(Object source)` Adapt the given instance to a Reactive Streams `Publisher`.

    注释类型为Nullable的org.springframework.core中的构造器参数
    构造器和说明
    `ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader)` Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
    `ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader, boolean acceptProxyClasses)` Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
    `DecoratingClassLoader(ClassLoader parent)` Create a new DecoratingClassLoader using the given parent ClassLoader for delegation.
    `MethodClassKey(Method method, Class<?> targetClass)` Create a key object for the given method and target class.
    `NestedCheckedException(String msg, Throwable cause)` Construct a `NestedCheckedException` with the specified detail message and nested exception.
    `NestedCheckedException(String msg, Throwable cause)` Construct a `NestedCheckedException` with the specified detail message and nested exception.
    `NestedIOException(String msg, Throwable cause)` Construct a `NestedIOException` with the specified detail message and nested exception.
    `NestedIOException(String msg, Throwable cause)` Construct a `NestedIOException` with the specified detail message and nested exception.
    `NestedRuntimeException(String msg, Throwable cause)` Construct a `NestedRuntimeException` with the specified detail message and nested exception.
    `NestedRuntimeException(String msg, Throwable cause)` Construct a `NestedRuntimeException` with the specified detail message and nested exception.
    `OverridingClassLoader(ClassLoader parent)` Create a new OverridingClassLoader for the given ClassLoader.
    `OverridingClassLoader(ClassLoader parent, ClassLoader overrideDelegate)` Create a new OverridingClassLoader for the given ClassLoader.
    `OverridingClassLoader(ClassLoader parent, ClassLoader overrideDelegate)` Create a new OverridingClassLoader for the given ClassLoader.

  - ### org.springframework.core.annotation中Nullable的使用

    注释类型为Nullable的org.springframework.core.annotation中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `Class<? extends Annotation>` | AnnotationAttributes.`annotationType()` Get the type of annotation represented by this `AnnotationAttributes`.
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)` Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(Class<?> clazz, Class<A> annotationType)` 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.
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(Method method, Class<A> annotationType)` 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.
    `static Class<?>` | AnnotationUtils.`findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)` 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.
    `static Class<?>` | AnnotationUtils.`findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)` 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.
    `static <A extends Annotation> A` | AnnotatedElementUtils.`findMergedAnnotation(AnnotatedElement element, Class<A> annotationType)` 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`.
    `static AnnotationAttributes` | AnnotatedElementUtils.`findMergedAnnotationAttributes(AnnotatedElement element, Class<? extends Annotation> annotationType, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` 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.
    `static AnnotationAttributes` | AnnotatedElementUtils.`findMergedAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` 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.
    `protected Integer` | AnnotationAwareOrderComparator.`findOrder(Object obj)` This implementation checks for `@Order` or `@Priority` on various kinds of elements, in addition to the `Ordered` check in the superclass.
    `static AnnotationAttributes` | AnnotationAttributes.`fromMap(Map<String,Object> map)` Return an `AnnotationAttributes` instance based on the given map.
    `static MultiValueMap<String,Object>` | AnnotatedElementUtils.`getAllAnnotationAttributes(AnnotatedElement element, String annotationName)` 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`.
    `static MultiValueMap<String,Object>` | AnnotatedElementUtils.`getAllAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` 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`.
    `static <A extends Annotation> A` | AnnotationUtils.`getAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied `AnnotatedElement`, where the annotation is either present or meta-present on the `AnnotatedElement`.
    `static <A extends Annotation> A` | AnnotationUtils.`getAnnotation(Annotation annotation, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied annotation: either the given annotation itself or a direct meta-annotation thereof.
    `static <A extends Annotation> A` | AnnotationUtils.`getAnnotation(Method method, Class<A> annotationType)` Get a single `Annotation` of `annotationType` from the supplied `Method`, where the annotation is either present or meta-present on the method.
    `static Annotation[]` | AnnotationUtils.`getAnnotations(AnnotatedElement annotatedElement)` Get all `Annotations` that are present on the supplied `AnnotatedElement`.
    `static Annotation[]` | AnnotationUtils.`getAnnotations(Method method)` Get all `Annotations` that are present on the supplied `Method`.
    `static Object` | AnnotationUtils.`getDefaultValue(Annotation annotation)` Retrieve the default value of the `value` attribute of a single-element Annotation, given an annotation instance.
    `static Object` | AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)` Retrieve the default value of a named attribute, given an annotation instance.
    `static Object` | AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType)` Retrieve the default value of the `value` attribute of a single-element Annotation, given the `annotation type`.
    `static Object` | AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)` Retrieve the default value of a named attribute, given the `annotation type`.
    `static <A extends Annotation> A` | AnnotatedElementUtils.`getMergedAnnotation(AnnotatedElement element, Class<A> annotationType)` 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`.
    `static AnnotationAttributes` | AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, Class<? extends Annotation> annotationType)` 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.
    `static AnnotationAttributes` | AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, String annotationName)` 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.
    `static AnnotationAttributes` | AnnotatedElementUtils.`getMergedAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` 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.
    `static Integer` | OrderUtils.`getOrder(Class<?> type)` Return the order on the specified `type`.
    `static Integer` | OrderUtils.`getOrder(Class<?> type, Integer defaultOrder)` Return the order on the specified `type`, or the specified default value if none can be found.
    `static Integer` | OrderUtils.`getPriority(Class<?> type)` Return the value of the `javax.annotation.Priority` annotation declared on the specified type, or `null` if none.
    `Integer` | AnnotationAwareOrderComparator.`getPriority(Object obj)` 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.
    `static Object` | AnnotationUtils.`getValue(Annotation annotation)` Retrieve the value of the `value` attribute of a single-element Annotation, given an annotation instance.
    `static Object` | AnnotationUtils.`getValue(Annotation annotation, String attributeName)` Retrieve the value of a named attribute, given an annotation instance.

    注释类型为Nullable的org.springframework.core.annotation中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(AnnotatedElement annotatedElement, Class<A> annotationType)` Find a single `Annotation` of `annotationType` on the supplied `AnnotatedElement`.
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(Class<?> clazz, Class<A> annotationType)` 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.
    `static <A extends Annotation> A` | AnnotationUtils.`findAnnotation(Method method, Class<A> annotationType)` 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.
    `static Class<?>` | AnnotationUtils.`findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)` 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.
    `static Class<?>` | AnnotationUtils.`findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)` 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.
    `static <A extends Annotation> Set<A>` | AnnotatedElementUtils.`findMergedRepeatableAnnotations(AnnotatedElement element, Class<A> annotationType, Class<? extends Annotation> containerType)` 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`.
    `static AnnotationAttributes` | AnnotationAttributes.`fromMap(Map<String,Object> map)` Return an `AnnotationAttributes` instance based on the given map.
    `static AnnotationAttributes` | AnnotationUtils.`getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation)` Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
    `static AnnotationAttributes` | AnnotationUtils.`getAnnotationAttributes(AnnotatedElement annotatedElement, Annotation annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap)` Retrieve the given annotation's attributes as an `AnnotationAttributes` map.
    `static <A extends Annotation> Set<A>` | AnnotationUtils.`getDeclaredRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)` 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.
    `static Object` | AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)` Retrieve the default value of a named attribute, given an annotation instance.
    `static Object` | AnnotationUtils.`getDefaultValue(Annotation annotation, String attributeName)` Retrieve the default value of a named attribute, given an annotation instance.
    `static Object` | AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)` Retrieve the default value of a named attribute, given the `annotation type`.
    `static Object` | AnnotationUtils.`getDefaultValue(Class<? extends Annotation> annotationType, String attributeName)` Retrieve the default value of a named attribute, given the `annotation type`.
    `static <A extends Annotation> Set<A>` | AnnotatedElementUtils.`getMergedRepeatableAnnotations(AnnotatedElement element, Class<A> annotationType, Class<? extends Annotation> containerType)` 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`.
    `static Integer` | OrderUtils.`getOrder(Class<?> type, Integer defaultOrder)` Return the order on the specified `type`, or the specified default value if none can be found.
    `static <A extends Annotation> Set<A>` | AnnotationUtils.`getRepeatableAnnotations(AnnotatedElement annotatedElement, Class<A> annotationType, Class<? extends Annotation> containerAnnotationType)` Get the repeatable annotations of `annotationType` from the supplied `AnnotatedElement`, where such annotations are either present, indirectly present, or meta-present on the element.
    `static Object` | AnnotationUtils.`getValue(Annotation annotation, String attributeName)` Retrieve the value of a named attribute, given an annotation instance.
    `static Object` | AnnotationUtils.`getValue(Annotation annotation, String attributeName)` Retrieve the value of a named attribute, given an annotation instance.
    `static boolean` | AnnotationUtils.`isAnnotationMetaPresent(Class<? extends Annotation> annotationType, Class<? extends Annotation> metaAnnotationType)` Determine if an annotation of type `metaAnnotationType` is meta-present on the supplied `annotationType`.
    `static boolean` | AnnotationUtils.`isInJavaLangAnnotationPackage(Annotation annotation)` Determine if the supplied `Annotation` is defined in the core JDK `java.lang.annotation` package.
    `static boolean` | AnnotationUtils.`isInJavaLangAnnotationPackage(String annotationType)` Determine if the `Annotation` with the supplied name is defined in the core JDK `java.lang.annotation` package.
    `static void` | AnnotationUtils.`postProcessAnnotationAttributes(Object annotatedElement, AnnotationAttributes attributes, boolean classValuesAsString)` Post-process the supplied `AnnotationAttributes`, preserving nested annotations as `Annotation` instances.
    `static <A extends Annotation> A` | AnnotationUtils.`synthesizeAnnotation(A annotation, AnnotatedElement annotatedElement)` 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`.
    `static <A extends Annotation> A` | AnnotationUtils.`synthesizeAnnotation(Map<String,Object> attributes, Class<A> annotationType, AnnotatedElement annotatedElement)` 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`.

    注释类型为Nullable的org.springframework.core.annotation中的构造器参数
    构造器和说明
    `AnnotationAttributes(String annotationType, ClassLoader classLoader)` Create a new, empty `AnnotationAttributes` instance for the specified `annotationType`.

  - ### org.springframework.core.codec中Nullable的使用

    注释类型为Nullable的org.springframework.core.codec中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `default Long` | Encoder.`getContentLength(T t, MimeType mimeType)` 已过时。 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.

    注释类型为Nullable的org.springframework.core.codec中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `boolean` | AbstractDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteArrayDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | DataBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | Decoder.`canDecode(ResolvableType elementType, MimeType mimeType)` Whether the decoder supports the given target element type and the MIME type of the source stream.
    `boolean` | ResourceDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | StringDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | AbstractEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteArrayEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | CharSequenceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | DataBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | Encoder.`canEncode(ResolvableType elementType, MimeType mimeType)` Whether the encoder supports the given source element type and the MIME type for the output stream.
    `boolean` | ResourceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ResourceRegionEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `reactor.core.publisher.Flux<T>` | AbstractDataBufferDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<T>` | AbstractDataBufferDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | DataBufferDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | DataBufferDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<T>` | Decoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Decode a `DataBuffer` input stream into a Flux of `T`.
    `reactor.core.publisher.Flux<T>` | Decoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Decode a `DataBuffer` input stream into a Flux of `T`.
    `reactor.core.publisher.Flux<Resource>` | ResourceDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Resource>` | ResourceDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<String>` | StringDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<String>` | StringDecoder.`decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected abstract T` | AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` How to decode a `DataBuffer` to the target element type.
    `protected abstract T` | AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` How to decode a `DataBuffer` to the target element type.
    `protected byte[]` | ByteArrayDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected byte[]` | ByteArrayDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected ByteBuffer` | ByteBufferDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected ByteBuffer` | ByteBufferDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected DataBuffer` | DataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected DataBuffer` | DataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected Resource` | ResourceDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected Resource` | ResourceDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected String` | StringDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected String` | StringDecoder.`decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | AbstractDataBufferDecoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | AbstractDataBufferDecoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | AbstractDecoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | AbstractDecoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | Decoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Decode a `DataBuffer` input stream into a Mono of `T`.
    `reactor.core.publisher.Mono<T>` | Decoder.`decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Decode a `DataBuffer` input stream into a Mono of `T`.
    `reactor.core.publisher.Flux<DataBuffer>` | ByteArrayEncoder.`encode(org.reactivestreams.Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ByteArrayEncoder.`encode(org.reactivestreams.Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ByteBufferEncoder.`encode(org.reactivestreams.Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ByteBufferEncoder.`encode(org.reactivestreams.Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | CharSequenceEncoder.`encode(org.reactivestreams.Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | CharSequenceEncoder.`encode(org.reactivestreams.Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | DataBufferEncoder.`encode(org.reactivestreams.Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | DataBufferEncoder.`encode(org.reactivestreams.Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ResourceRegionEncoder.`encode(org.reactivestreams.Publisher<? extends ResourceRegion> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ResourceRegionEncoder.`encode(org.reactivestreams.Publisher<? extends ResourceRegion> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | AbstractSingleValueEncoder.`encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | AbstractSingleValueEncoder.`encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | Encoder.`encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
    `reactor.core.publisher.Flux<DataBuffer>` | Encoder.`encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
    `protected reactor.core.publisher.Flux<DataBuffer>` | ResourceEncoder.`encode(Resource resource, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
    `protected reactor.core.publisher.Flux<DataBuffer>` | ResourceEncoder.`encode(Resource resource, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
    `protected abstract reactor.core.publisher.Flux<DataBuffer>` | AbstractSingleValueEncoder.`encode(T t, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)` Encode `T` to an output `DataBuffer` stream.
    `protected abstract reactor.core.publisher.Flux<DataBuffer>` | AbstractSingleValueEncoder.`encode(T t, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)` Encode `T` to an output `DataBuffer` stream.
    `default Long` | Encoder.`getContentLength(T t, MimeType mimeType)` 已过时。 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.

    注释类型为Nullable的org.springframework.core.codec中的构造器参数
    构造器和说明
    `CodecException(String msg, Throwable cause)` Create a new CodecException.
    `DecodingException(String msg, Throwable cause)` Create a new DecodingException.
    `EncodingException(String msg, Throwable cause)` Create a new EncodingException.

  - ### org.springframework.core.convert中Nullable的使用

    注释类型为Nullable的org.springframework.core.convert中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `static TypeDescriptor` | TypeDescriptor.`array(TypeDescriptor elementTypeDescriptor)` Create a new type descriptor as an array of the specified type.
    `<T> T` | ConversionService.`convert(Object source, Class<T> targetType)` Convert the given `source` to the specified `targetType`.
    `Object` | ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)` Convert the given `source` to the specified `targetType`.
    `TypeDescriptor` | TypeDescriptor.`elementTypeDescriptor(Object element)` If this type is a `Collection` or an array, creates a element TypeDescriptor from the provided collection or array element.
    `static TypeDescriptor` | TypeDescriptor.`forObject(Object source)` Create a new type descriptor for an object.
    `<T extends Annotation> T` | TypeDescriptor.`getAnnotation(Class<T> annotationType)` Obtain the annotation of the specified `annotationType` that is on this type descriptor.
    `TypeDescriptor` | TypeDescriptor.`getElementTypeDescriptor()` If this type is an array, returns the array's component type.
    `TypeDescriptor` | TypeDescriptor.`getMapKeyTypeDescriptor()` If this type is a `Map` and its key type is parameterized, returns the map's key type.
    `TypeDescriptor` | TypeDescriptor.`getMapKeyTypeDescriptor(Object mapKey)` If this type is a `Map`, creates a mapKey `TypeDescriptor` from the provided map key.
    `TypeDescriptor` | TypeDescriptor.`getMapValueTypeDescriptor()` If this type is a `Map` and its value type is parameterized, returns the map's value type.
    `TypeDescriptor` | TypeDescriptor.`getMapValueTypeDescriptor(Object mapValue)` If this type is a `Map`, creates a mapValue `TypeDescriptor` from the provided map value.
    `Method` | Property.`getReadMethod()` The property getter method: e.g.
    `TypeDescriptor` | ConversionFailedException.`getSourceType()` Return the source type we tried to convert the value from.
    `TypeDescriptor` | ConverterNotFoundException.`getSourceType()` Return the source type that was requested to convert from.
    `Object` | ConversionFailedException.`getValue()` Return the offending value.
    `Method` | Property.`getWriteMethod()` The property setter method: e.g.
    `static TypeDescriptor` | TypeDescriptor.`nested(Field field, int nestingLevel)` Create a type descriptor for a nested type declared within the field.
    `static TypeDescriptor` | TypeDescriptor.`nested(MethodParameter methodParameter, int nestingLevel)` Create a type descriptor for a nested type declared within the method parameter.
    `static TypeDescriptor` | TypeDescriptor.`nested(Property property, int nestingLevel)` Create a type descriptor for a nested type declared within the property.
    `TypeDescriptor` | TypeDescriptor.`upcast(Class<?> superType)` Cast this `TypeDescriptor` to a superclass or implemented interface preserving annotations and nested type context.

    注释类型为Nullable的org.springframework.core.convert中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `static TypeDescriptor` | TypeDescriptor.`array(TypeDescriptor elementTypeDescriptor)` Create a new type descriptor as an array of the specified type.
    `boolean` | ConversionService.`canConvert(Class<?> sourceType, Class<?> targetType)` Return `true` if objects of `sourceType` can be converted to the `targetType`.
    `boolean` | ConversionService.`canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)` Return `true` if objects of `sourceType` can be converted to the `targetType`.
    `static TypeDescriptor` | TypeDescriptor.`collection(Class<?> collectionType, TypeDescriptor elementTypeDescriptor)` Create a new type descriptor from a `Collection` type.
    `<T> T` | ConversionService.`convert(Object source, Class<T> targetType)` Convert the given `source` to the specified `targetType`.
    `Object` | ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)` Convert the given `source` to the specified `targetType`.
    `Object` | ConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)` Convert the given `source` to the specified `targetType`.
    `static TypeDescriptor` | TypeDescriptor.`forObject(Object source)` Create a new type descriptor for an object.
    `static TypeDescriptor` | TypeDescriptor.`map(Class<?> mapType, TypeDescriptor keyTypeDescriptor, TypeDescriptor valueTypeDescriptor)` Create a new type descriptor from a `Map` type.
    `static TypeDescriptor` | TypeDescriptor.`map(Class<?> mapType, TypeDescriptor keyTypeDescriptor, TypeDescriptor valueTypeDescriptor)` Create a new type descriptor from a `Map` type.
    `TypeDescriptor` | TypeDescriptor.`narrow(Object value)` Narrows this `TypeDescriptor` by setting its type to the class of the provided value.
    `TypeDescriptor` | TypeDescriptor.`upcast(Class<?> superType)` Cast this `TypeDescriptor` to a superclass or implemented interface preserving annotations and nested type context.
    `static TypeDescriptor` | TypeDescriptor.`valueOf(Class<?> type)` Create a new type descriptor from the given type.

    注释类型为Nullable的org.springframework.core.convert中的构造器参数
    构造器和说明
    `ConversionFailedException(TypeDescriptor sourceType, TypeDescriptor targetType, Object value, Throwable cause)` Create a new conversion exception.
    `ConversionFailedException(TypeDescriptor sourceType, TypeDescriptor targetType, Object value, Throwable cause)` Create a new conversion exception.
    `ConverterNotFoundException(TypeDescriptor sourceType, TypeDescriptor targetType)` Create a new conversion executor not found exception.
    `Property(Class<?> objectType, Method readMethod, Method writeMethod)`
    `Property(Class<?> objectType, Method readMethod, Method writeMethod)`
    `Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
    `Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
    `Property(Class<?> objectType, Method readMethod, Method writeMethod, String name)`
    `TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)` Create a new type descriptor from a `ResolvableType`.
    `TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)` Create a new type descriptor from a `ResolvableType`.

  - ### org.springframework.core.convert.converter中Nullable的使用

    注释类型为Nullable的org.springframework.core.convert.converter中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `Object` | GenericConverter.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)` Convert the source object to the targetType described by the `TypeDescriptor`.
    `T` | Converter.`convert(S source)` Convert the source object of type `S` to target type `T`.
    `Set<GenericConverter.ConvertiblePair>` | GenericConverter.`getConvertibleTypes()` Return the source and target types that this converter can convert between.

    注释类型为Nullable的org.springframework.core.convert.converter中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `Object` | GenericConverter.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)` Convert the source object to the targetType described by the `TypeDescriptor`.
    `boolean` | GenericConverter.ConvertiblePair.`equals(Object other)`

  - ### org.springframework.core.convert.support中Nullable的使用

    注释类型为Nullable的org.springframework.core.convert.support中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `<T> T` | GenericConversionService.`convert(Object source, Class<T> targetType)`
    `Object` | GenericConversionService.`convert(Object source, TypeDescriptor targetType)` Convenience operation for converting a source object to the specified targetType, where the target type is a descriptor that provides additional conversion context.
    `Object` | GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
    `protected Object` | GenericConversionService.`convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)` Template method to convert a `null` source.
    `String` | ConvertingPropertyEditorAdapter.`getAsText()`
    `protected GenericConverter` | GenericConversionService.`getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)` Hook method to lookup the converter for a given sourceType/targetType pair.
    `protected GenericConverter` | GenericConversionService.`getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType)` Return the default converter if no converter is found for the given sourceType/targetType pair.

    注释类型为Nullable的org.springframework.core.convert.support中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `boolean` | GenericConversionService.`canBypassConvert(TypeDescriptor sourceType, TypeDescriptor targetType)` Return whether conversion between the source type and the target type can be bypassed.
    `boolean` | GenericConversionService.`canConvert(Class<?> sourceType, Class<?> targetType)`
    `boolean` | GenericConversionService.`canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)`
    `<T> T` | GenericConversionService.`convert(Object source, Class<T> targetType)`
    `Object` | GenericConversionService.`convert(Object source, TypeDescriptor targetType)` Convenience operation for converting a source object to the specified targetType, where the target type is a descriptor that provides additional conversion context.
    `Object` | GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
    `Object` | GenericConversionService.`convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)`
    `protected Object` | GenericConversionService.`convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)` Template method to convert a `null` source.
    `static void` | ConversionServiceFactory.`registerConverters(Set<?> converters, ConverterRegistry registry)` Register the given Converter objects with the given target ConverterRegistry.
    `void` | ConvertingPropertyEditorAdapter.`setAsText(String text)`

  - ### org.springframework.core.env中Nullable的使用

    注释类型为Nullable的org.springframework.core.env中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected <T> T` | AbstractPropertyResolver.`convertValueIfNecessary(Object value, Class<T> targetType)` Convert the given value to the specified target type, if necessary.
    `PropertySource<?>` | MutablePropertySources.`get(String name)`
    `PropertySource<?>` | PropertySources.`get(String name)` Return the property source with the given name, `null` if not found.
    `protected abstract List<String>` | CommandLinePropertySource.`getOptionValues(String name)` Return the collection of values associated with the command line option having the given name.
    `List<String>` | JOptCommandLinePropertySource.`getOptionValues(String name)`
    `protected List<String>` | SimpleCommandLinePropertySource.`getOptionValues(String name)`
    `String` | AbstractEnvironment.`getProperty(String key)`
    `String` | AbstractPropertyResolver.`getProperty(String key)`
    `String` | CommandLinePropertySource.`getProperty(String name)` 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.
    `Object` | CompositePropertySource.`getProperty(String name)`
    `Object` | MapPropertySource.`getProperty(String name)`
    `String` | PropertyResolver.`getProperty(String key)` Return the property value associated with the given key, or `null` if the key cannot be resolved.
    `abstract Object` | PropertySource.`getProperty(String name)` Return the value associated with the given name, or `null` if not found.
    `String` | PropertySource.StubPropertySource.`getProperty(String name)` Always returns `null`.
    `String` | PropertySourcesPropertyResolver.`getProperty(String key)`
    `Object` | SystemEnvironmentPropertySource.`getProperty(String name)` This implementation returns `true` if a property with the given name or any underscore/uppercase variant thereof exists in this property source.
    `<T> T` | AbstractEnvironment.`getProperty(String key, Class<T> targetType)`
    `<T> T` | PropertyResolver.`getProperty(String key, Class<T> targetType)` Return the property value associated with the given key, or `null` if the key cannot be resolved.
    `<T> T` | PropertySourcesPropertyResolver.`getProperty(String key, Class<T> targetValueType)`
    `protected <T> T` | PropertySourcesPropertyResolver.`getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders)`
    `protected abstract String` | AbstractPropertyResolver.`getPropertyAsRawString(String key)` Retrieve the specified property as a raw String, i.e. without resolution of nested placeholders.
    `protected String` | PropertySourcesPropertyResolver.`getPropertyAsRawString(String key)`
    `PropertySource<?>` | MutablePropertySources.`remove(String name)` Remove and return the property source with the given name, `null` if not found.

    注释类型为Nullable的org.springframework.core.env中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `protected <T> T` | AbstractPropertyResolver.`convertValueIfNecessary(Object value, Class<T> targetType)` Convert the given value to the specified target type, if necessary.
    `void` | AbstractEnvironment.`setValueSeparator(String valueSeparator)`
    `void` | AbstractPropertyResolver.`setValueSeparator(String valueSeparator)` 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.
    `void` | ConfigurablePropertyResolver.`setValueSeparator(String valueSeparator)` 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.

    注释类型为Nullable的org.springframework.core.env中的构造器参数
    构造器和说明
    `PropertySourcesPropertyResolver(PropertySources propertySources)` Create a new resolver against the given property sources.

  - ### org.springframework.core.io中Nullable的使用

    注释类型为Nullable的org.springframework.core.io中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected static String` | VfsUtils.`doGetPath(Object resource)`
    `protected static Object` | VfsUtils.`doGetVisitorAttributes()`
    `String` | ResourceEditor.`getAsText()`
    `ClassLoader` | ClassPathResource.`getClassLoader()` Return the ClassLoader that this resource will be obtained from.
    `ClassLoader` | DefaultResourceLoader.`getClassLoader()` Return the ClassLoader to load class path resources with.
    `ClassLoader` | ResourceLoader.`getClassLoader()` Expose the ClassLoader used by this ResourceLoader.
    `String` | AbstractResource.`getFilename()` This implementation always returns `null`, assuming that this resource type does not have a filename.
    `String` | ClassPathResource.`getFilename()` This implementation returns the name of the file that this class path resource refers to.
    `String` | Resource.`getFilename()` Determine a filename for this resource, i.e. typically the last part of the path: for example, "myfile.txt".
    `Resource` | ProtocolResolver.`resolve(String location, ResourceLoader resourceLoader)` Resolve the given location against the given resource loader if this implementation's protocol matches.
    `protected URL` | ClassPathResource.`resolveURL()` Resolves a URL for the underlying class path resource.

    注释类型为Nullable的org.springframework.core.io中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `protected static Object` | VfsUtils.`invokeVfsMethod(Method method, Object target, Object... args)`
    `void` | DefaultResourceLoader.`setClassLoader(ClassLoader classLoader)` 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.

    注释类型为Nullable的org.springframework.core.io中的构造器参数
    构造器和说明
    `ByteArrayResource(byte[] byteArray, String description)` Create a new `ByteArrayResource` with a description.
    `ClassPathContextResource(String path, ClassLoader classLoader)`
    `ClassPathResource(String path, Class<?> clazz)` Create a new `ClassPathResource` for `Class` usage.
    `ClassPathResource(String path, ClassLoader classLoader)` Create a new `ClassPathResource` for `ClassLoader` usage.
    `ClassPathResource(String path, ClassLoader classLoader, Class<?> clazz)` 已过时。 as of 4.3.13, in favor of selective use of `ClassPathResource.ClassPathResource(String, ClassLoader)` vs `ClassPathResource.ClassPathResource(String, Class)`
    `ClassPathResource(String path, ClassLoader classLoader, Class<?> clazz)` 已过时。 as of 4.3.13, in favor of selective use of `ClassPathResource.ClassPathResource(String, ClassLoader)` vs `ClassPathResource.ClassPathResource(String, Class)`
    `DefaultResourceLoader(ClassLoader classLoader)` Create a new DefaultResourceLoader.
    `DescriptiveResource(String description)` Create a new DescriptiveResource.
    `InputStreamResource(InputStream inputStream, String description)` Create a new InputStreamResource.
    `ResourceEditor(ResourceLoader resourceLoader, PropertyResolver propertyResolver)` Create a new instance of the `ResourceEditor` class using the given `ResourceLoader` and `PropertyResolver`.
    `ResourceEditor(ResourceLoader resourceLoader, PropertyResolver propertyResolver, boolean ignoreUnresolvablePlaceholders)` Create a new instance of the `ResourceEditor` class using the given `ResourceLoader`.
    `UrlResource(String protocol, String location, String fragment)` Create a new `UrlResource` based on a URI specification.

  - ### org.springframework.core.io.buffer中Nullable的使用

    注释类型为Nullable的org.springframework.core.io.buffer中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `static boolean` | DataBufferUtils.`release(DataBuffer dataBuffer)` Release the given data buffer, if it is a `PooledDataBuffer`.

  - ### org.springframework.core.io.support中Nullable的使用

    注释类型为Nullable的org.springframework.core.io.support中的字段
    限定符和类型 | 字段和说明
    --- | ---
    `protected Properties[]` | PropertiesLoaderSupport.`localProperties`

    注释类型为Nullable的org.springframework.core.io.support中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `Charset` | EncodedResource.`getCharset()` Return the `Charset` to use for reading from the resource, or `null` if none specified.
    `ClassLoader` | PathMatchingResourcePatternResolver.`getClassLoader()`
    `String` | EncodedResource.`getEncoding()` Return the encoding to use for reading from the resource, or `null` if none specified.

    注释类型为Nullable的org.springframework.core.io.support中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `protected void` | PathMatchingResourcePatternResolver.`addAllClassLoaderJarRoots(ClassLoader classLoader, Set<Resource> result)` 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.
    `PropertySource<?>` | DefaultPropertySourceFactory.`createPropertySource(String name, EncodedResource resource)`
    `PropertySource<?>` | PropertySourceFactory.`createPropertySource(String name, EncodedResource resource)` Create a `PropertySource` that wraps the given resource.
    `Resource` | LocalizedResourceHelper.`findLocalizedResource(String name, String extension, Locale locale)` 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.
    `static ResourcePatternResolver` | ResourcePatternUtils.`getResourcePatternResolver(ResourceLoader resourceLoader)` Return a default `ResourcePatternResolver` for the given `ResourceLoader`.
    `static boolean` | ResourcePatternUtils.`isUrl(String resourceLocation)` Return whether the given resource location is a URL: either a special "classpath" or "classpath*" pseudo URL or a standard URL.
    `static Properties` | PropertiesLoaderUtils.`loadAllProperties(String resourceName, ClassLoader classLoader)` Load all properties from the specified class path resource (in ISO-8859-1 encoding), using the given class loader.
    `static <T> List<T>` | SpringFactoriesLoader.`loadFactories(Class<T> factoryClass, ClassLoader classLoader)` Load and instantiate the factory implementations of the given type from "META-INF/spring.factories", using the given class loader.
    `static List<String>` | SpringFactoriesLoader.`loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader)` Load the fully qualified class names of factory implementations of the given type from "META-INF/spring.factories", using the given class loader.
    `void` | PropertiesLoaderSupport.`setPropertiesPersister(PropertiesPersister propertiesPersister)` Set the PropertiesPersister to use for parsing properties files.
    `void` | LocalizedResourceHelper.`setSeparator(String separator)` Set the separator to use in-between file name parts.

    注释类型为Nullable的org.springframework.core.io.support中的构造器参数
    构造器和说明
    `EncodedResource(Resource resource, Charset charset)` Create a new `EncodedResource` for the given `Resource`, using the specified `Charset`.
    `EncodedResource(Resource resource, String encoding)` Create a new `EncodedResource` for the given `Resource`, using the specified `encoding`.
    `PathMatchingResourcePatternResolver(ClassLoader classLoader)` Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
    `ResourceArrayPropertyEditor(ResourcePatternResolver resourcePatternResolver, PropertyResolver propertyResolver)` Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).
    `ResourceArrayPropertyEditor(ResourcePatternResolver resourcePatternResolver, PropertyResolver propertyResolver, boolean ignoreUnresolvablePlaceholders)` Create a new ResourceArrayPropertyEditor with the given `ResourcePatternResolver` and `PropertyResolver` (typically an `Environment`).

  - ### org.springframework.core.serializer中Nullable的使用

    注释类型为Nullable的org.springframework.core.serializer中的构造器参数
    构造器和说明
    `DefaultDeserializer(ClassLoader classLoader)` Create a `DefaultDeserializer` for using an `ObjectInputStream` with the given `ClassLoader`.

  - ### org.springframework.core.style中Nullable的使用

    注释类型为Nullable的org.springframework.core.style中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `ToStringCreator` | ToStringCreator.`append(String fieldName, Object value)` Append a field value.
    `String` | DefaultValueStyler.`style(Object value)`
    `String` | ValueStyler.`style(Object value)` Style the given value, returning a String representation.
    `void` | DefaultToStringStyler.`styleField(StringBuilder buffer, String fieldName, Object value)`
    `void` | ToStringStyler.`styleField(StringBuilder buffer, String fieldName, Object value)` Style a field value as a string.
    `void` | DefaultToStringStyler.`styleValue(StringBuilder buffer, Object value)`

    注释类型为Nullable的org.springframework.core.style中的构造器参数
    构造器和说明
    `ToStringCreator(Object obj, ToStringStyler styler)` Create a ToStringCreator for the given object, using the provided style.
    `ToStringCreator(Object obj, ValueStyler styler)` Create a ToStringCreator for the given object, using the provided style.

  - ### org.springframework.core.task中Nullable的使用

    注释类型为Nullable的org.springframework.core.task中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `ThreadFactory` | SimpleAsyncTaskExecutor.`getThreadFactory()` Return the external factory to use for creating new Threads, if any.

    注释类型为Nullable的org.springframework.core.task中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `void` | SimpleAsyncTaskExecutor.`setThreadFactory(ThreadFactory threadFactory)` Specify an external factory to use for creating new Threads, instead of relying on the local properties of this executor.

  - ### org.springframework.core.task.support中Nullable的使用

    注释类型为Nullable的org.springframework.core.task.support中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `protected void` | TaskExecutorAdapter.`doExecute(Executor concurrentExecutor, TaskDecorator taskDecorator, Runnable runnable)` Actually execute the given `Runnable` (which may be a user-supplied task or a wrapper around a user-supplied task) with the given executor.

  - ### org.springframework.core.type中Nullable的使用

    注释类型为Nullable的org.springframework.core.type中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `MultiValueMap<String,Object>` | AnnotatedTypeMetadata.`getAllAnnotationAttributes(String annotationName)` 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).
    `MultiValueMap<String,Object>` | StandardAnnotationMetadata.`getAllAnnotationAttributes(String annotationName)`
    `MultiValueMap<String,Object>` | StandardMethodMetadata.`getAllAnnotationAttributes(String annotationName)`
    `MultiValueMap<String,Object>` | AnnotatedTypeMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)` 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).
    `MultiValueMap<String,Object>` | StandardAnnotationMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `MultiValueMap<String,Object>` | StandardMethodMetadata.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `Map<String,Object>` | AnnotatedTypeMetadata.`getAnnotationAttributes(String annotationName)` 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.
    `Map<String,Object>` | StandardMethodMetadata.`getAnnotationAttributes(String annotationName)`
    `Map<String,Object>` | AnnotatedTypeMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)` 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.
    `Map<String,Object>` | StandardAnnotationMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `Map<String,Object>` | StandardMethodMetadata.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `String` | ClassMetadata.`getEnclosingClassName()` Return the name of the enclosing class of the underlying class, or `null` if the underlying class is a top-level class.
    `String` | StandardClassMetadata.`getEnclosingClassName()`
    `String` | ClassMetadata.`getSuperClassName()` Return the name of the super class of the underlying class, or `null` if there is no super class defined.
    `String` | StandardClassMetadata.`getSuperClassName()`

  - ### org.springframework.core.type.classreading中Nullable的使用

    注释类型为Nullable的org.springframework.core.type.classreading中的字段
    限定符和类型 | 字段和说明
    --- | ---
    `protected ClassLoader` | AnnotationMetadataReadingVisitor.`classLoader`
    `protected ClassLoader` | MethodMetadataReadingVisitor.`classLoader`

    注释类型为Nullable的org.springframework.core.type.classreading中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `MultiValueMap<String,Object>` | AnnotationMetadataReadingVisitor.`getAllAnnotationAttributes(String annotationName)`
    `MultiValueMap<String,Object>` | MethodMetadataReadingVisitor.`getAllAnnotationAttributes(String annotationName)`
    `MultiValueMap<String,Object>` | AnnotationMetadataReadingVisitor.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `MultiValueMap<String,Object>` | MethodMetadataReadingVisitor.`getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `AnnotationAttributes` | AnnotationMetadataReadingVisitor.`getAnnotationAttributes(String annotationName)`
    `AnnotationAttributes` | MethodMetadataReadingVisitor.`getAnnotationAttributes(String annotationName)`
    `AnnotationAttributes` | AnnotationMetadataReadingVisitor.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`
    `AnnotationAttributes` | MethodMetadataReadingVisitor.`getAnnotationAttributes(String annotationName, boolean classValuesAsString)`

    注释类型为Nullable的org.springframework.core.type.classreading中的构造器参数
    构造器和说明
    `AnnotationMetadataReadingVisitor(ClassLoader classLoader)`
    `CachingMetadataReaderFactory(ClassLoader classLoader)` Create a new CachingMetadataReaderFactory for the given `ClassLoader`, using a local resource cache.
    `CachingMetadataReaderFactory(ResourceLoader resourceLoader)` Create a new CachingMetadataReaderFactory for the given `ResourceLoader`, using a shared resource cache if supported or a local resource cache otherwise.
    `MethodMetadataReadingVisitor(String methodName, int access, String declaringClassName, String returnTypeName, ClassLoader classLoader, Set<MethodMetadata> methodMetadataSet)`
    `SimpleMetadataReaderFactory(ClassLoader classLoader)` Create a new SimpleMetadataReaderFactory for the given class loader.
    `SimpleMetadataReaderFactory(ResourceLoader resourceLoader)` Create a new SimpleMetadataReaderFactory for the given resource loader.

  - ### org.springframework.core.type.filter中Nullable的使用

    注释类型为Nullable的org.springframework.core.type.filter中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected Boolean` | AnnotationTypeFilter.`hasAnnotation(String typeName)`
    `protected Boolean` | AbstractTypeHierarchyTraversingFilter.`matchInterface(String interfaceName)` Override this to match on interface type name.
    `protected Boolean` | AnnotationTypeFilter.`matchInterface(String interfaceName)`
    `protected Boolean` | AssignableTypeFilter.`matchInterface(String interfaceName)`
    `protected Boolean` | AbstractTypeHierarchyTraversingFilter.`matchSuperClass(String superClassName)` Override this to match on super type name.
    `protected Boolean` | AnnotationTypeFilter.`matchSuperClass(String superClassName)`
    `protected Boolean` | AssignableTypeFilter.`matchSuperClass(String superClassName)`
    `protected Boolean` | AssignableTypeFilter.`matchTargetType(String typeName)`

    注释类型为Nullable的org.springframework.core.type.filter中的构造器参数
    构造器和说明
    `AspectJTypeFilter(String typePatternExpression, ClassLoader classLoader)`

  - ### org.springframework.util中Nullable的使用

    注释类型为Nullable的org.springframework.util中的字段
    限定符和类型 | 字段和说明
    --- | ---
    `protected Class<?>` | MethodInvoker.`targetClass`

    注释类型为Nullable的org.springframework.util中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `static String[]` | StringUtils.`concatenateStringArrays(String[] array1, String[] array2)` Concatenate the given `String` arrays into one, with overlapping array elements included twice.
    `String` | StopWatch.`currentTaskName()` Return the name of the currently running task, if any.
    `static Object` | SerializationUtils.`deserialize(byte[] bytes)` Deserialize the byte array into an object.
    `static Class<?>` | ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)` Determine the common ancestor of the given classes, if any.
    `<T> T` | ConcurrentReferenceHashMap.Segment.`doTask(int hash, Object key, org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)` Apply an update operation to this segment.
    `static Class<?>` | CollectionUtils.`findCommonElementType(Collection<?> collection)` Find the common element type of the given Collection, if any.
    `static Field` | ReflectionUtils.`findField(Class<?> clazz, String name)` Attempt to find a `field` on the supplied `Class` with the supplied `name`.
    `static Field` | ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)` Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
    `static <E> E` | CollectionUtils.`findFirstMatch(Collection<?> source, Collection<E> candidates)` Return the first element in '`candidates`' that is contained in '`source`'.
    `protected Method` | MethodInvoker.`findMatchingMethod()` Find a matching method with the specified name for the specified arguments.
    `static Method` | ReflectionUtils.`findMethod(Class<?> clazz, String name)` Attempt to find a `Method` on the supplied class with the supplied name and no parameters.
    `static Method` | ReflectionUtils.`findMethod(Class<?> clazz, String name, Class<?>... paramTypes)` Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
    `static Object` | CollectionUtils.`findValueOfType(Collection<?> collection, Class<?>[] types)` 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.
    `static <T> T` | CollectionUtils.`findValueOfType(Collection<?> collection, Class<T> type)` Find a single value of the given type in the given Collection.
    `ConcurrentReferenceHashMap.Entry<K,V>` | ConcurrentReferenceHashMap.Reference.`get()` Return the referenced entry, or `null` if the entry is no longer available.
    `V` | ConcurrentReferenceHashMap.`get(Object key)`
    `V` | LinkedCaseInsensitiveMap.`get(Object key)`
    `List<V>` | LinkedMultiValueMap.`get(Object key)`
    `Charset` | MimeType.`getCharset()` Return the character set, as indicated by a `charset` parameter, if any.
    `static <T> Constructor<T>` | ClassUtils.`getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)` Determine whether the given class has a public constructor with the given signature, and return it if available (else return `null`).
    `static ClassLoader` | ClassUtils.`getDefaultClassLoader()` 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.
    `static String` | ClassUtils.`getDescriptiveType(Object value)` 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.
    `static Object` | ReflectionUtils.`getField(Field field, Object target)` Get the field represented by the supplied `field object` on the specified `target object`.
    `static String` | StringUtils.`getFilename(String path)` Extract the filename from the given Java resource path, e.g.
    `static String` | StringUtils.`getFilenameExtension(String path)` Extract the filename extension from the given Java resource path, e.g.
    `V` | LinkedMultiValueMap.`getFirst(K key)`
    `V` | MultiValueMap.`getFirst(K key)` Return the first value for the given key.
    `K` | ConcurrentReferenceHashMap.Entry.`getKey()`
    `static Method` | ClassUtils.`getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
    `ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.Reference.`getNext()` Return the next reference in the chain, or `null` if none.
    `V` | ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
    `V` | LinkedCaseInsensitiveMap.`getOrDefault(Object key, V defaultValue)`
    `String` | MimeType.`getParameter(String name)` Return a generic parameter value, given a parameter name.
    `protected ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.`getReference(Object key, ConcurrentReferenceHashMap.Restructure restructure)` Return a `ConcurrentReferenceHashMap.Reference` to the `ConcurrentReferenceHashMap.Entry` for the specified `key`, or `null` if not found.
    `ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.Segment.`getReference(Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)`
    `static Method` | ClassUtils.`getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)` Return a public static method of a class.
    `Class<?>` | MethodInvoker.`getTargetClass()` Return the target class on which to call the target method.
    `String` | MethodInvoker.`getTargetMethod()` Return the name of the method to be invoked.
    `Object` | MethodInvoker.`getTargetObject()` Return the target object on which to call the target method.
    `ThreadGroup` | CustomizableThreadCreator.`getThreadGroup()` Return the thread group that threads should be created in (or `null` for the default group).
    `V` | ConcurrentReferenceHashMap.Entry.`getValue()`
    `Object` | MethodInvoker.`invoke()` Invoke the specified method.
    `static Object` | ReflectionUtils.`invokeJdbcMethod(Method method, Object target)` 已过时。 as of 5.0.11, in favor of custom SQLException handling
    `static Object` | ReflectionUtils.`invokeJdbcMethod(Method method, Object target, Object... args)` 已过时。 as of 5.0.11, in favor of custom SQLException handling
    `static Object` | ReflectionUtils.`invokeMethod(Method method, Object target)` Invoke the specified `Method` against the supplied target object with no arguments.
    `static Object` | ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)` Invoke the specified `Method` against the supplied target object with the supplied arguments.
    `static <T> T` | CollectionUtils.`lastElement(List<T> list)` Retrieve the last element of the given List, accessing the highest index.
    `static <T> T` | CollectionUtils.`lastElement(Set<T> set)` Retrieve the last element of the given Set, using `SortedSet.last()` or otherwise iterating over all elements (assuming a linked set).
    `static String[]` | StringUtils.`mergeStringArrays(String[] array1, String[] array2)` 已过时。 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)
    `static ClassLoader` | ClassUtils.`overrideThreadContextClassLoader(ClassLoader classLoaderToUse)` 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.
    `static Locale` | StringUtils.`parseLocale(String localeValue)` Parse the given `String` value into a `Locale`, accepting the `Locale.toString()` format as well as BCP 47 language tags.
    `static Locale` | StringUtils.`parseLocaleString(String localeString)` Parse the given `String` representation into a `Locale`.
    `ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.ReferenceManager.`pollForPurge()` Return any reference that has been garbage collected and can be purged from the underlying structure or `null` if no references need purging.
    `List<V>` | LinkedMultiValueMap.`put(K key, List<V> value)`
    `V` | ConcurrentReferenceHashMap.`put(K key, V value)`
    `V` | LinkedCaseInsensitiveMap.`put(String key, V value)`
    `V` | ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
    `static String` | StringUtils.`quote(String str)` Quote the given `String` with single quotes.
    `static Object` | StringUtils.`quoteIfString(Object obj)` Turn the given Object into a `String` with single quotes if it is a `String`; keeping the Object as-is else.
    `V` | ConcurrentReferenceHashMap.`remove(Object key)`
    `V` | LinkedCaseInsensitiveMap.`remove(Object key)`
    `List<V>` | LinkedMultiValueMap.`remove(Object key)`
    `V` | ConcurrentReferenceHashMap.`replace(K key, V value)`
    `String` | PropertyPlaceholderHelper.PlaceholderResolver.`resolvePlaceholder(String placeholderName)` Resolve the supplied placeholder name to the replacement value.
    `static Class<?>` | ClassUtils.`resolvePrimitiveClassName(String name)` Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
    `String` | StringValueResolver.`resolveStringValue(String strVal)` Resolve the given String value, for example parsing placeholders.
    `static byte[]` | SerializationUtils.`serialize(Object object)` Serialize the given object to a byte array.
    `V` | ConcurrentReferenceHashMap.Entry.`setValue(V value)`
    `static String[]` | StringUtils.`split(String toSplit, String delimiter)` Split a `String` at the first occurrence of the delimiter.
    `static Properties` | StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter)` Take an array of strings and split each element based on the given delimiter.
    `static Properties` | StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter, String charsToDelete)` Take an array of strings and split each element based on the given delimiter.
    `static Object` | ObjectUtils.`unwrapOptional(Object obj)` Unwrap the given object which is potentially a `Optional`.

    注释类型为Nullable的org.springframework.util中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `void` | LinkedMultiValueMap.`add(K key, V value)`
    `void` | MultiValueMap.`add(K key, V value)` Add the given single value to the current list of values for the given key.
    `static <A,O extends A> A[]` | ObjectUtils.`addObjectToArray(A[] array, O obj)` Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
    `static <A,O extends A> A[]` | ObjectUtils.`addObjectToArray(A[] array, O obj)` Append the given object to the given array, returning a new array consisting of the input array contents plus the given object.
    `static String[]` | StringUtils.`addStringToArray(String[] array, String str)` Append the given `String` to the given `String` array, returning a new array consisting of the input array contents plus the given `String`.
    `static String` | StringUtils.`arrayToCommaDelimitedString(Object[] arr)` Convert a `String` array into a comma delimited `String` (i.e., CSV).
    `static String` | StringUtils.`arrayToDelimitedString(Object[] arr, String delim)` Convert a `String` array into a delimited `String` (e.g.
    `static List` | CollectionUtils.`arrayToList(Object source)` Convert the supplied array into a List.
    `static String` | ClassUtils.`classNamesToString(Collection<Class<?>> classes)` Build a String that consists of the names of the classes/interfaces in the given collection.
    `static String` | ClassUtils.`classPackageAsResourcePath(Class<?> clazz)` 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 ('/').
    `static String` | StringUtils.`collectionToCommaDelimitedString(Collection<?> coll)` Convert a `Collection` into a delimited `String` (e.g., CSV).
    `static String` | StringUtils.`collectionToDelimitedString(Collection<?> coll, String delim)` Convert a `Collection` into a delimited `String` (e.g.
    `static String` | StringUtils.`collectionToDelimitedString(Collection<?> coll, String delim, String prefix, String suffix)` Convert a `Collection` to a delimited `String` (e.g.
    `static Set<String>` | StringUtils.`commaDelimitedListToSet(String str)` Convert a comma delimited list (e.g., a row from a CSV file) into a set.
    `static String[]` | StringUtils.`commaDelimitedListToStringArray(String str)` Convert a comma delimited list (e.g., a row from a CSV file) into an array of strings.
    `static String[]` | StringUtils.`concatenateStringArrays(String[] array1, String[] array2)` Concatenate the given `String` arrays into one, with overlapping array elements included twice.
    `static String[]` | StringUtils.`concatenateStringArrays(String[] array1, String[] array2)` Concatenate the given `String` arrays into one, with overlapping array elements included twice.
    `static boolean` | CollectionUtils.`contains(Enumeration<?> enumeration, Object element)` Check whether the given Enumeration contains the given element.
    `static boolean` | CollectionUtils.`contains(Iterator<?> iterator, Object element)` Check whether the given Iterator contains the given element.
    `static boolean` | ObjectUtils.`containsElement(Object[] array, Object element)` Check whether the given array contains the given element.
    `static boolean` | CollectionUtils.`containsInstance(Collection<?> collection, Object element)` Check whether the given Collection contains the given element instance.
    `boolean` | ConcurrentReferenceHashMap.`containsKey(Object key)`
    `static boolean` | StringUtils.`containsWhitespace(CharSequence str)` Check whether the given `CharSequence` contains any whitespace characters.
    `static boolean` | StringUtils.`containsWhitespace(String str)` Check whether the given `String` contains any whitespace characters.
    `static byte[]` | FileCopyUtils.`copyToByteArray(InputStream in)` Copy the contents of the given InputStream into a new byte array.
    `static byte[]` | StreamUtils.`copyToByteArray(InputStream in)` Copy the contents of the given InputStream into a new byte array.
    `static String` | StreamUtils.`copyToString(InputStream in, Charset charset)` Copy the contents of the given InputStream into a String.
    `static String` | FileCopyUtils.`copyToString(Reader in)` Copy the contents of the given Reader into a String.
    `static Class<?>` | ClassUtils.`createCompositeInterface(Class<?>[] interfaces, ClassLoader classLoader)` Create a composite interface Class for the given interfaces, implementing the given interfaces in one single Class.
    `ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.ReferenceManager.`createReference(ConcurrentReferenceHashMap.Entry<K,V> entry, int hash, ConcurrentReferenceHashMap.Reference<K,V> next)` Factory method used to create a new `ConcurrentReferenceHashMap.Reference`.
    `static String` | StringUtils.`deleteAny(String inString, String charsToDelete)` Delete any character in a given `String`.
    `static boolean` | FileSystemUtils.`deleteRecursively(File root)` Delete the supplied `File` - for directories, recursively delete any nested directories or files as well.
    `static boolean` | FileSystemUtils.`deleteRecursively(Path root)` Delete the supplied `File` - for directories, recursively delete any nested directories or files as well.
    `static String[]` | StringUtils.`delimitedListToStringArray(String str, String delimiter)` Take a `String` that is a delimited list and convert it into a `String` array.
    `static String[]` | StringUtils.`delimitedListToStringArray(String str, String delimiter)` Take a `String` that is a delimited list and convert it into a `String` array.
    `static String[]` | StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)` Take a `String` that is a delimited list and convert it into a `String` array.
    `static String[]` | StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)` Take a `String` that is a delimited list and convert it into a `String` array.
    `static String[]` | StringUtils.`delimitedListToStringArray(String str, String delimiter, String charsToDelete)` Take a `String` that is a delimited list and convert it into a `String` array.
    `static Object` | SerializationUtils.`deserialize(byte[] bytes)` Deserialize the byte array into an object.
    `static Class<?>` | ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)` Determine the common ancestor of the given classes, if any.
    `static Class<?>` | ClassUtils.`determineCommonAncestor(Class<?> clazz1, Class<?> clazz2)` Determine the common ancestor of the given classes, if any.
    `static void` | Assert.`doesNotContain(String textToSearch, String substring)` 已过时。 as of 4.3.7, in favor of `Assert.doesNotContain(String, String, String)`
    `static void` | Assert.`doesNotContain(String textToSearch, String substring, String message)` Assert that the given text does not contain the given substring.
    `static void` | Assert.`doesNotContain(String textToSearch, String substring, Supplier<String> messageSupplier)` Assert that the given text does not contain the given substring.
    `protected boolean` | AntPathMatcher.`doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)` Actually match the given `path` against the given `pattern`.
    `<T> T` | ConcurrentReferenceHashMap.Segment.`doTask(int hash, Object key, org.springframework.util.ConcurrentReferenceHashMap.Task<T> task)` Apply an update operation to this segment.
    `static void` | ReflectionUtils.`doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc, ReflectionUtils.FieldFilter ff)` Invoke the given callback on all fields in the target class, going up the class hierarchy to get all declared fields.
    `static void` | ReflectionUtils.`doWithMethods(Class<?> clazz, ReflectionUtils.MethodCallback mc, ReflectionUtils.MethodFilter mf)` Perform the given callback operation on all matching methods of the given class and superclasses (or given interface and super-interfaces).
    `static boolean` | StringUtils.`endsWithIgnoreCase(String str, String suffix)` Test if the given `String` ends with the specified suffix, ignoring upper/lower case.
    `static boolean` | StringUtils.`endsWithIgnoreCase(String str, String suffix)` Test if the given `String` ends with the specified suffix, ignoring upper/lower case.
    `static Field` | ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)` Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
    `static Field` | ReflectionUtils.`findField(Class<?> clazz, String name, Class<?> type)` Attempt to find a `field` on the supplied `Class` with the supplied `name` and/or `type`.
    `static Method` | ReflectionUtils.`findMethod(Class<?> clazz, String name, Class<?>... paramTypes)` Attempt to find a `Method` on the supplied class with the supplied name and parameter types.
    `static <T> T` | CollectionUtils.`findValueOfType(Collection<?> collection, Class<T> type)` Find a single value of the given type in the given Collection.
    `static Class<?>` | ClassUtils.`forName(String name, ClassLoader classLoader)` Replacement for `Class.forName()` that also returns Class instances for primitives (e.g.
    `V` | ConcurrentReferenceHashMap.`get(Object key)`
    `static Class<?>[]` | ClassUtils.`getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)` Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
    `static Set<Class<?>>` | ClassUtils.`getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader)` Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
    `static String` | ClassUtils.`getDescriptiveType(Object value)` 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.
    `static String` | ObjectUtils.`getDisplayString(Object obj)` Return a content-based String representation if `obj` is not `null`; otherwise returns an empty String.
    `static Object` | ReflectionUtils.`getField(Field field, Object target)` Get the field represented by the supplied `field object` on the specified `target object`.
    `static String` | StringUtils.`getFilename(String path)` Extract the filename from the given Java resource path, e.g.
    `static String` | StringUtils.`getFilenameExtension(String path)` Extract the filename extension from the given Java resource path, e.g.
    `protected int` | ConcurrentReferenceHashMap.`getHash(Object o)` Get the hash for a given object, apply an additional hash function to reduce collisions.
    `static Method` | ClassUtils.`getMethod(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature, and return it if available (else throws an `IllegalStateException`).
    `static Method` | ClassUtils.`getMethodIfAvailable(Class<?> clazz, String methodName, Class<?>... paramTypes)` Determine whether the given class has a public method with the given signature, and return it if available (else return `null`).
    `static Method` | ClassUtils.`getMostSpecificMethod(Method method, Class<?> targetClass)` 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.
    `V` | ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
    `V` | ConcurrentReferenceHashMap.`getOrDefault(Object key, V defaultValue)`
    `static String` | ClassUtils.`getQualifiedMethodName(Method method, Class<?> clazz)` Return the qualified name of the given method, consisting of fully qualified interface/class name + "." + method name.
    `protected ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.`getReference(Object key, ConcurrentReferenceHashMap.Restructure restructure)` Return a `ConcurrentReferenceHashMap.Reference` to the `ConcurrentReferenceHashMap.Entry` for the specified `key`, or `null` if not found.
    `ConcurrentReferenceHashMap.Reference<K,V>` | ConcurrentReferenceHashMap.Segment.`getReference(Object key, int hash, ConcurrentReferenceHashMap.Restructure restructure)`
    `static boolean` | StringUtils.`hasLength(CharSequence str)` Check that the given `CharSequence` is neither `null` nor of length 0.
    `static void` | Assert.`hasLength(String text)` 已过时。 as of 4.3.7, in favor of `Assert.hasLength(String, String)`
    `static boolean` | StringUtils.`hasLength(String str)` Check that the given `String` is neither `null` nor of length 0.
    `static void` | Assert.`hasLength(String text, String message)` Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
    `static void` | Assert.`hasLength(String text, Supplier<String> messageSupplier)` Assert that the given String is not empty; that is, it must not be `null` and not the empty String.
    `static boolean` | StringUtils.`hasText(CharSequence str)` Check whether the given `CharSequence` contains actual text.
    `static void` | Assert.`hasText(String text)` 已过时。 as of 4.3.7, in favor of `Assert.hasText(String, String)`
    `static boolean` | StringUtils.`hasText(String str)` Check whether the given `String` contains actual text.
    `static void` | Assert.`hasText(String text, String message)` 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.
    `static void` | Assert.`hasText(String text, Supplier<String> messageSupplier)` 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.
    `static String` | ObjectUtils.`identityToString(Object obj)` Return a String representation of an object's overall identity.
    `boolean` | MimeType.`includes(MimeType other)` Indicate whether this MIME Type includes the given MIME Type.
    `static Object` | ReflectionUtils.`invokeJdbcMethod(Method method, Object target)` 已过时。 as of 5.0.11, in favor of custom SQLException handling
    `static Object` | ReflectionUtils.`invokeJdbcMethod(Method method, Object target, Object... args)` 已过时。 as of 5.0.11, in favor of custom SQLException handling
    `static Object` | ReflectionUtils.`invokeJdbcMethod(Method method, Object target, Object... args)` 已过时。 as of 5.0.11, in favor of custom SQLException handling
    `static Object` | ReflectionUtils.`invokeMethod(Method method, Object target)` Invoke the specified `Method` against the supplied target object with no arguments.
    `static Object` | ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)` Invoke the specified `Method` against the supplied target object with the supplied arguments.
    `static Object` | ReflectionUtils.`invokeMethod(Method method, Object target, Object... args)` Invoke the specified `Method` against the supplied target object with the supplied arguments.
    `static boolean` | ObjectUtils.`isArray(Object obj)` Determine whether the given object is an array: either an Object array or a primitive array.
    `static void` | Assert.`isAssignable(Class<?> superType, Class<?> subType, String message)` Assert that `superType.isAssignableFrom(subType)` is `true`.
    `static void` | Assert.`isAssignable(Class<?> superType, Class<?> subType, Supplier<String> messageSupplier)` Assert that `superType.isAssignableFrom(subType)` is `true`.
    `static boolean` | TypeUtils.`isAssignableBound(Type lhsType, Type rhsType)`
    `static boolean` | TypeUtils.`isAssignableBound(Type lhsType, Type rhsType)`
    `static boolean` | ClassUtils.`isAssignableValue(Class<?> type, Object value)` Determine if the given type is assignable from the given value, assuming setting by reflection.
    `static boolean` | ClassUtils.`isCacheSafe(Class<?> clazz, ClassLoader classLoader)` 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.
    `static boolean` | ClassUtils.`isCglibProxyClass(Class<?> clazz)` Check whether the specified class is a CGLIB-generated class.
    `static boolean` | ClassUtils.`isCglibProxyClassName(String className)` Check whether the specified class name is a CGLIB-generated class.
    `boolean` | MimeType.`isCompatibleWith(MimeType other)` Indicate whether this MIME Type is compatible with the given MIME Type.
    `static boolean` | ObjectUtils.`isCompatibleWithThrowsClause(Throwable ex, Class<?>... declaredExceptions)` Check whether the given exception is compatible with the specified exception types, as declared in a throws clause.
    `static boolean` | CollectionUtils.`isEmpty(Collection<?> collection)` Return `true` if the supplied Collection is `null` or empty.
    `static boolean` | CollectionUtils.`isEmpty(Map<?,?> map)` Return `true` if the supplied Map is `null` or empty.
    `static boolean` | ObjectUtils.`isEmpty(Object obj)` Determine whether the given object is empty.
    `static boolean` | StringUtils.`isEmpty(Object str)` Check whether the given object (possibly a `String`) is empty.
    `static boolean` | ObjectUtils.`isEmpty(Object[] array)` Determine whether the given array is empty: i.e.
    `static boolean` | ReflectionUtils.`isEqualsMethod(Method method)` Determine whether the given method is an "equals" method.
    `static boolean` | ReflectionUtils.`isHashCodeMethod(Method method)` Determine whether the given method is a "hashCode" method.
    `static void` | Assert.`isInstanceOf(Class<?> type, Object obj)` Assert that the provided object is an instance of the provided class.
    `static void` | Assert.`isInstanceOf(Class<?> type, Object obj, String message)` Assert that the provided object is an instance of the provided class.
    `static void` | Assert.`isInstanceOf(Class<?> type, Object obj, Supplier<String> messageSupplier)` Assert that the provided object is an instance of the provided class.
    `static void` | Assert.`isNull(Object object)` 已过时。 as of 4.3.7, in favor of `Assert.isNull(Object, String)`
    `static void` | Assert.`isNull(Object object, String message)` Assert that an object is `null`.
    `static void` | Assert.`isNull(Object object, Supplier<String> messageSupplier)` Assert that an object is `null`.
    `static boolean` | ReflectionUtils.`isObjectMethod(Method method)` Determine whether the given method is originally declared by `Object`.
    `static boolean` | ClassUtils.`isPresent(String className, ClassLoader classLoader)` Determine whether the `Class` identified by the supplied name is present and can be loaded.
    `static boolean` | ReflectionUtils.`isToStringMethod(Method method)` Determine whether the given method is a "toString" method.
    `static boolean` | ResourceUtils.`isUrl(String resourceLocation)` Return whether the given resource location is a URL: either a special "classpath" pseudo URL or a standard URL.
    `static boolean` | ClassUtils.`isVisible(Class<?> clazz, ClassLoader classLoader)` Check whether the given class is visible in the given ClassLoader.
    `static <T> T` | CollectionUtils.`lastElement(List<T> list)` Retrieve the last element of the given List, accessing the highest index.
    `static <T> T` | CollectionUtils.`lastElement(Set<T> set)` Retrieve the last element of the given Set, using `SortedSet.last()` or otherwise iterating over all elements (assuming a linked set).
    `static boolean` | ClassUtils.`matchesTypeName(Class<?> clazz, String typeName)` Check whether the given class matches the user-specified type name.
    `boolean` | AntPathMatcher.AntPathStringMatcher.`matchStrings(String str, Map<String,String> uriTemplateVariables)` Main entry point.
    `static <E> void` | CollectionUtils.`mergeArrayIntoCollection(Object array, Collection<E> collection)` Merge the given array into the given Collection.
    `static <K,V> void` | CollectionUtils.`mergePropertiesIntoMap(Properties props, Map<K,V> map)` Merge the given Properties instance into the given Map, copying all properties (key-value pairs) over.
    `static String[]` | StringUtils.`mergeStringArrays(String[] array1, String[] array2)` 已过时。 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)
    `static String[]` | StringUtils.`mergeStringArrays(String[] array1, String[] array2)` 已过时。 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)
    `static void` | Assert.`noNullElements(Object[] array)` 已过时。 as of 4.3.7, in favor of `Assert.noNullElements(Object[], String)`
    `static void` | Assert.`noNullElements(Object[] array, String message)` Assert that an array contains no `null` elements.
    `static void` | Assert.`noNullElements(Object[] array, Supplier<String> messageSupplier)` Assert that an array contains no `null` elements.
    `static void` | Assert.`notEmpty(Collection<?> collection)` 已过时。 as of 4.3.7, in favor of `Assert.notEmpty(Collection, String)`
    `static void` | Assert.`notEmpty(Collection<?> collection, String message)` Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
    `static void` | Assert.`notEmpty(Collection<?> collection, Supplier<String> messageSupplier)` Assert that a collection contains elements; that is, it must not be `null` and must contain at least one element.
    `static void` | Assert.`notEmpty(Map<?,?> map)` 已过时。 as of 4.3.7, in favor of `Assert.notEmpty(Map, String)`
    `static void` | Assert.`notEmpty(Map<?,?> map, String message)` Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
    `static void` | Assert.`notEmpty(Map<?,?> map, Supplier<String> messageSupplier)` Assert that a Map contains entries; that is, it must not be `null` and must contain at least one entry.
    `static void` | Assert.`notEmpty(Object[] array)` 已过时。 as of 4.3.7, in favor of `Assert.notEmpty(Object[], String)`
    `static void` | Assert.`notEmpty(Object[] array, String message)` Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
    `static void` | Assert.`notEmpty(Object[] array, Supplier<String> messageSupplier)` Assert that an array contains elements; that is, it must not be `null` and must contain at least one element.
    `static void` | Assert.`notNull(Object object)` 已过时。 as of 4.3.7, in favor of `Assert.notNull(Object, String)`
    `static void` | Assert.`notNull(Object object, String message)` Assert that an object is not `null`.
    `static void` | Assert.`notNull(Object object, Supplier<String> messageSupplier)` Assert that an object is not `null`.
    `static String` | ObjectUtils.`nullSafeClassName(Object obj)` Determine the class name for the given object.
    `static boolean` | ObjectUtils.`nullSafeEquals(Object o1, Object o2)` Determine if the given objects are equal, returning `true` if both are `null` or `false` if only one is `null`.
    `static boolean` | ObjectUtils.`nullSafeEquals(Object o1, Object o2)` Determine if the given objects are equal, returning `true` if both are `null` or `false` if only one is `null`.
    `static int` | ObjectUtils.`nullSafeHashCode(boolean[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(byte[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(char[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(double[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(float[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(int[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(long[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(Object obj)` Return as hash code for the given object; typically the value of `Object#hashCode()`}.
    `static int` | ObjectUtils.`nullSafeHashCode(Object[] array)` Return a hash code based on the contents of the specified array.
    `static int` | ObjectUtils.`nullSafeHashCode(short[] array)` Return a hash code based on the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(boolean[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(byte[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(char[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(double[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(float[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(int[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(long[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(Object obj)` Return a String representation of the specified Object.
    `static String` | ObjectUtils.`nullSafeToString(Object[] array)` Return a String representation of the contents of the specified array.
    `static String` | ObjectUtils.`nullSafeToString(short[] array)` Return a String representation of the contents of the specified array.
    `static ClassLoader` | ClassUtils.`overrideThreadContextClassLoader(ClassLoader classLoaderToUse)` 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.
    `static <T extends Number> T` | NumberUtils.`parseNumber(String text, Class<T> targetClass, NumberFormat numberFormat)` Parse the given `text` into a `Number` instance of the given target class, using the supplied `NumberFormat`.
    `V` | ConcurrentReferenceHashMap.`put(K key, V value)`
    `V` | ConcurrentReferenceHashMap.`put(K key, V value)`
    `V` | LinkedCaseInsensitiveMap.`put(String key, V value)`
    `V` | ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
    `V` | ConcurrentReferenceHashMap.`putIfAbsent(K key, V value)`
    `static String` | StringUtils.`quote(String str)` Quote the given `String` with single quotes.
    `static Object` | StringUtils.`quoteIfString(Object obj)` Turn the given Object into a `String` with single quotes if it is a `String`; keeping the Object as-is else.
    `static String` | StringUtils.`replace(String inString, String oldPattern, String newPattern)` Replace all occurrences of a substring within a string with another string.
    `static Class<?>` | ClassUtils.`resolveClassName(String className, ClassLoader classLoader)` Resolve the given class name into a Class instance.
    `static Class<?>` | ClassUtils.`resolvePrimitiveClassName(String name)` Resolve the given class name as primitive class, if appropriate, according to the JVM's naming rules for primitive classes.
    `static byte[]` | SerializationUtils.`serialize(Object object)` Serialize the given object to a byte array.
    `void` | LinkedMultiValueMap.`set(K key, V value)`
    `void` | MultiValueMap.`set(K key, V value)` Set the given single value under the given key.
    `static void` | ReflectionUtils.`setField(Field field, Object target, Object value)` Set the field represented by the supplied `field object` on the specified `target object` to the specified `value`.
    `static void` | ReflectionUtils.`setField(Field field, Object target, Object value)` Set the field represented by the supplied `field object` on the specified `target object` to the specified `value`.
    `void` | AntPathMatcher.`setPathSeparator(String pathSeparator)` Set the path separator to use for pattern parsing.
    `void` | MethodInvoker.`setTargetClass(Class<?> targetClass)` Set the target class on which to call the target method.
    `void` | MethodInvoker.`setTargetMethod(String targetMethod)` Set the name of the method to be invoked.
    `void` | MethodInvoker.`setTargetObject(Object targetObject)` Set the target object on which to call the target method.
    `void` | CustomizableThreadCreator.`setThreadGroup(ThreadGroup threadGroup)` Specify the thread group that threads should be created in.
    `void` | CustomizableThreadCreator.`setThreadNamePrefix(String threadNamePrefix)` Specify the prefix to use for the names of newly created threads.
    `V` | ConcurrentReferenceHashMap.Entry.`setValue(V value)`
    `static boolean` | PatternMatchUtils.`simpleMatch(String[] patterns, String str)` 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.
    `static boolean` | PatternMatchUtils.`simpleMatch(String pattern, String str)` 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.
    `static boolean` | PatternMatchUtils.`simpleMatch(String pattern, String str)` 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.
    `static String[]` | StringUtils.`split(String toSplit, String delimiter)` Split a `String` at the first occurrence of the delimiter.
    `static String[]` | StringUtils.`split(String toSplit, String delimiter)` Split a `String` at the first occurrence of the delimiter.
    `static Properties` | StringUtils.`splitArrayElementsIntoProperties(String[] array, String delimiter, String charsToDelete)` Take an array of strings and split each element based on the given delimiter.
    `static boolean` | StringUtils.`startsWithIgnoreCase(String str, String prefix)` Test if the given `String` starts with the specified prefix, ignoring upper/lower case.
    `static boolean` | StringUtils.`startsWithIgnoreCase(String str, String prefix)` Test if the given `String` starts with the specified prefix, ignoring upper/lower case.
    `static <E> Iterator<E>` | CollectionUtils.`toIterator(Enumeration<E> enumeration)` Adapt an `Enumeration` to an `Iterator`.
    `static String[]` | StringUtils.`tokenizeToStringArray(String str, String delimiters)` Tokenize the given `String` into a `String` array via a `StringTokenizer`.
    `static String[]` | StringUtils.`tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens)` Tokenize the given `String` into a `String` array via a `StringTokenizer`.
    `static Object[]` | ObjectUtils.`toObjectArray(Object source)` Convert the given array (which may be a primitive array) to an object array (if necessary of primitive wrapper objects).
    `static String[]` | StringUtils.`toStringArray(Collection<String> collection)` Copy the given `Collection` into a `String` array.
    `static String[]` | StringUtils.`toStringArray(Enumeration<String> enumeration)` Copy the given `Enumeration` into a `String` array.
    `static String[]` | StringUtils.`trimArrayElements(String[] array)` Trim the elements of the given `String` array, calling `String.trim()` on each of them.
    `static Object` | ObjectUtils.`unwrapOptional(Object obj)` Unwrap the given object which is potentially a `Optional`.

    注释类型为Nullable的org.springframework.util中的构造器参数
    构造器和说明
    `CustomizableThreadCreator(String threadNamePrefix)` Create a new CustomizableThreadCreator with the given thread name prefix.
    `Entry(K key, V value)`
    `Entry(K key, V value)`
    `InstanceFilter(Collection<? extends T> includes, Collection<? extends T> excludes, boolean matchIfEmpty)` Create a new instance based on includes/excludes collections.
    `InstanceFilter(Collection<? extends T> includes, Collection<? extends T> excludes, boolean matchIfEmpty)` Create a new instance based on includes/excludes collections.
    `LinkedCaseInsensitiveMap(int initialCapacity, Locale locale)` 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).
    `LinkedCaseInsensitiveMap(Locale locale)` Create a new LinkedCaseInsensitiveMap that stores case-insensitive keys according to the given Locale (by default in lower case).
    `MimeType(MimeType other, Map<String,String> parameters)` Copy-constructor that copies the type and subtype of the given `MimeType`, and allows for different parameter.
    `MimeType(String type, String subtype, Map<String,String> parameters)` Create a new `MimeType` for the given type, subtype, and parameters.
    `PropertyPlaceholderHelper(String placeholderPrefix, String placeholderSuffix, String valueSeparator, boolean ignoreUnresolvablePlaceholders)` Creates a new `PropertyPlaceholderHelper` that uses the supplied prefix and suffix.

  - ### org.springframework.util.comparator中Nullable的使用

    注释类型为Nullable的org.springframework.util.comparator中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `int` | NullSafeComparator.`compare(T o1, T o2)`
    `int` | NullSafeComparator.`compare(T o1, T o2)`

  - ### org.springframework.util.concurrent中Nullable的使用

    注释类型为Nullable的org.springframework.util.concurrent中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected abstract T` | FutureAdapter.`adapt(S adapteeResult)` Adapts the given adaptee's result into T.
    `T` | FutureAdapter.`get()`
    `T` | FutureAdapter.`get(long timeout, TimeUnit unit)`

    注释类型为Nullable的org.springframework.util.concurrent中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `void` | SuccessCallback.`onSuccess(T result)` Called when the `ListenableFuture` completes with success.
    `boolean` | SettableListenableFuture.`set(T value)` Set the value of this future.
    `void` | ListenableFutureCallbackRegistry.`success(T result)` Trigger a `SuccessCallback.onSuccess(Object)` call on all added callbacks with the given result.

    注释类型为Nullable的org.springframework.util.concurrent中的构造器参数
    构造器和说明
    `ListenableFutureTask(Runnable runnable, T result)` Create a `ListenableFutureTask` that will, upon running, execute the given `Runnable`, and arrange that `FutureTask.get()` will return the given result on successful completion.

  - ### org.springframework.util.xml中Nullable的使用

    注释类型为Nullable的org.springframework.util.xml中的方法
    限定符和类型 | 方法和说明
    --- | ---
    `static Element` | DomUtils.`getChildElementByTagName(Element ele, String childEleName)` Utility method that returns the first child element identified by its name.
    `static String` | DomUtils.`getChildElementValueByTagName(Element ele, String childEleName)` Utility method that returns the first child element value identified by its name.
    `String` | SimpleNamespaceContext.`getPrefix(String namespaceUri)`
    `static XMLEventReader` | StaxUtils.`getXMLEventReader(Source source)` Return the `XMLEventReader` for the given StAX Source.
    `static XMLEventWriter` | StaxUtils.`getXMLEventWriter(Result result)` Return the `XMLEventWriter` for the given StAX Result.
    `static XMLStreamReader` | StaxUtils.`getXMLStreamReader(Source source)` Return the `XMLStreamReader` for the given StAX Source.
    `static XMLStreamWriter` | StaxUtils.`getXMLStreamWriter(Result result)` Return the `XMLStreamWriter` for the given StAX Result.

    注释类型为Nullable的org.springframework.util.xml中的方法参数
    限定符和类型 | 方法和说明
    --- | ---
    `void` | SimpleNamespaceContext.`removeBinding(String prefix)` Remove the given prefix from this context.