Uses of Class
org.springframework.lang.Nullable

Packages that use Nullable

Package	Description
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.log	Useful delegates for Spring's logging conventions.
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.
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 extensions.
org.springframework.util.function	Useful generic java.util.function helper classes.
org.springframework.util.unit	Useful unit data types.
org.springframework.util.xml	Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Commons Logging.

Uses of Nullable in org.springframework.core

Methods in org.springframework.core with annotations of type Nullable

Modifier and Type	Method and Description
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	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.
String	NestedCheckedException.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.
<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[]	PrioritizedParameterNameDiscoverer.getParameterNames(Constructor<?> ctor)
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[]	StandardReflectionParameterNameDiscoverer.getParameterNames(Constructor<?> ctor)
String[]	PrioritizedParameterNameDiscoverer.getParameterNames(Method method)
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[]	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	NestedRuntimeException.getRootCause() Retrieve the innermost cause of this exception, if any.
Throwable	NestedCheckedException.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.

Method parameters in org.springframework.core with annotations of type Nullable

Modifier and Type	Method and Description
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	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.
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.
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.
static boolean	CollectionFactory.isApproximableMapType(Class<?> mapType) Determine whether the given map type is an approximable type, i.e.
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.

Constructor parameters in org.springframework.core with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.core.annotation

Methods in org.springframework.core.annotation with annotations of type Nullable

Modifier and Type	Method and Description
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.
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.

Method parameters in org.springframework.core.annotation with annotations of type Nullable

Modifier and Type	Method and Description
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.
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.

Constructor parameters in org.springframework.core.annotation with annotations of type Nullable

Constructor and Description
AnnotationAttributes(String annotationType, ClassLoader classLoader) Create a new, empty AnnotationAttributes instance for the specified annotationType.

Uses of Nullable in org.springframework.core.codec

Method parameters in org.springframework.core.codec with annotations of type Nullable

Modifier and Type	Method and Description
boolean	DataBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	StringDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceDecoder.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	ByteArrayDecoder.canDecode(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	CharSequenceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceRegionEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
reactor.core.publisher.Flux<DataBuffer>	DataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	DataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<String>	StringDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<String>	StringDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, 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<Resource>	ResourceDecoder.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> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	AbstractDataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, 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.
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 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 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)
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 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)
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>	AbstractDataBufferDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	AbstractDataBufferDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input, 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> input, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ResourceRegionEncoder.encode(org.reactivestreams.Publisher<? extends ResourceRegion> input, 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.
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)
protected reactor.core.publisher.Flux<DataBuffer>	ResourceEncoder.encode(Resource resource, DataBufferFactory bufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)
protected reactor.core.publisher.Flux<DataBuffer>	ResourceEncoder.encode(Resource resource, DataBufferFactory bufferFactory, 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.
static String	Hints.getLogPrefix(Map<String,Object> hints) Obtain the hint Hints.LOG_PREFIX_HINT, if present, or an empty String.
static <T> T	Hints.getRequiredHint(Map<String,Object> hints, String hintName) Obtain the value for a required hint.
static boolean	Hints.isLoggingSuppressed(Map<String,Object> hints) Whether to suppress logging based on the hint Hints.SUPPRESS_LOGGING_HINT.

Constructor parameters in org.springframework.core.codec with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.core.convert

Methods in org.springframework.core.convert with annotations of type Nullable

Modifier and Type	Method and Description
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	ConverterNotFoundException.getSourceType() Return the source type that was requested to convert from.
TypeDescriptor	ConversionFailedException.getSourceType() Return the source type we tried to convert the value 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.

Method parameters in org.springframework.core.convert with annotations of type Nullable

Modifier and Type	Method and Description
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.

Constructor parameters in org.springframework.core.convert with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.core.convert.converter

Methods in org.springframework.core.convert.converter with annotations of type Nullable

Modifier and Type	Method and Description
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.

Method parameters in org.springframework.core.convert.converter with annotations of type Nullable

Modifier and Type	Method and Description
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)

Uses of Nullable in org.springframework.core.convert.support

Methods in org.springframework.core.convert.support with annotations of type Nullable

Modifier and Type	Method and Description
<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.

Method parameters in org.springframework.core.convert.support with annotations of type Nullable

Modifier and Type	Method and Description
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)

Uses of Nullable in org.springframework.core.env

Methods in org.springframework.core.env with annotations of type Nullable

Modifier and Type	Method and Description
protected <T> T	AbstractPropertyResolver.convertValueIfNecessary(Object value, Class<T> targetType) Convert the given value to the specified target type, if necessary.
PropertySource<?>	PropertySources.get(String name) Return the property source with the given name, null if not found.
PropertySource<?>	MutablePropertySources.get(String name)
protected abstract List<String>	CommandLinePropertySource.getOptionValues(String name) Return the collection of values associated with the command line option having the given name.
protected List<String>	SimpleCommandLinePropertySource.getOptionValues(String name)
List<String>	JOptCommandLinePropertySource.getOptionValues(String name)
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.
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)
String	PropertyResolver.getProperty(String key) Return the property value associated with the given key, or null if the key cannot be resolved.
String	AbstractEnvironment.getProperty(String key)
String	AbstractPropertyResolver.getProperty(String key)
Object	MapPropertySource.getProperty(String name)
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.
Object	CompositePropertySource.getProperty(String name)
<T> T	PropertySourcesPropertyResolver.getProperty(String key, Class<T> targetValueType)
<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	AbstractEnvironment.getProperty(String key, Class<T> targetType)
protected <T> T	PropertySourcesPropertyResolver.getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders)
protected String	PropertySourcesPropertyResolver.getPropertyAsRawString(String key)
protected abstract String	AbstractPropertyResolver.getPropertyAsRawString(String key) Retrieve the specified property as a raw String, i.e.
PropertySource<?>	MutablePropertySources.remove(String name) Remove and return the property source with the given name, null if not found.

Method parameters in org.springframework.core.env with annotations of type Nullable

Modifier and Type	Method and Description
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.

Constructor parameters in org.springframework.core.env with annotations of type Nullable

Constructor and Description
PropertySourcesPropertyResolver(PropertySources propertySources) Create a new resolver against the given property sources.

Uses of Nullable in org.springframework.core.io

Methods in org.springframework.core.io with annotations of type Nullable

Modifier and Type	Method and Description
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	ClassPathResource.getFilename() This implementation returns the name of the file that this class path resource refers to.
String	AbstractResource.getFilename() This implementation always returns null, assuming that this resource type does not have a filename.
String	Resource.getFilename() Determine a filename for this resource, i.e.
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.

Method parameters in org.springframework.core.io with annotations of type Nullable

Modifier and Type	Method and Description
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.

Constructor parameters in org.springframework.core.io with annotations of type Nullable

Constructor and Description
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) Deprecated. 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) Deprecated. 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.

Uses of Nullable in org.springframework.core.io.buffer

Method parameters in org.springframework.core.io.buffer with annotations of type Nullable

Modifier and Type	Method and Description
static boolean	DataBufferUtils.release(DataBuffer dataBuffer) Release the given data buffer, if it is a PooledDataBuffer and has been allocated.

Uses of Nullable in org.springframework.core.io.support

Fields in org.springframework.core.io.support with annotations of type Nullable

Modifier and Type	Field and Description
protected Properties[]	PropertiesLoaderSupport.localProperties

Methods in org.springframework.core.io.support with annotations of type Nullable

Modifier and Type	Method and Description
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.

Method parameters in org.springframework.core.io.support with annotations of type Nullable

Modifier and Type	Method and Description
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:
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.

Constructor parameters in org.springframework.core.io.support with annotations of type Nullable

Constructor and Description
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).

Uses of Nullable in org.springframework.core.log

Method parameters in org.springframework.core.log with annotations of type Nullable

Modifier and Type	Method and Description
static String	LogFormatUtils.formatValue(Object value, boolean limitLength) Format the given value via toString(), quoting it if it is a CharSequence, and possibly truncating at 100 if limitLength is set to true.

Uses of Nullable in org.springframework.core.serializer

Constructor parameters in org.springframework.core.serializer with annotations of type Nullable

Constructor and Description
DefaultDeserializer(ClassLoader classLoader) Create a DefaultDeserializer for using an ObjectInputStream with the given ClassLoader.

Uses of Nullable in org.springframework.core.style

Method parameters in org.springframework.core.style with annotations of type Nullable

Modifier and Type	Method and Description
ToStringCreator	ToStringCreator.append(String fieldName, Object value) Append a field value.
String	ValueStyler.style(Object value) Style the given value, returning a String representation.
String	DefaultValueStyler.style(Object value)
void	ToStringStyler.styleField(StringBuilder buffer, String fieldName, Object value) Style a field value as a string.
void	DefaultToStringStyler.styleField(StringBuilder buffer, String fieldName, Object value)
void	DefaultToStringStyler.styleValue(StringBuilder buffer, Object value)

Constructor parameters in org.springframework.core.style with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.core.task

Methods in org.springframework.core.task with annotations of type Nullable

Modifier and Type	Method and Description
ThreadFactory	SimpleAsyncTaskExecutor.getThreadFactory() Return the external factory to use for creating new Threads, if any.

Method parameters in org.springframework.core.task with annotations of type Nullable

Modifier and Type	Method and Description
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.

Uses of Nullable in org.springframework.core.task.support

Method parameters in org.springframework.core.task.support with annotations of type Nullable

Modifier and Type	Method and Description
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.

Uses of Nullable in org.springframework.core.type

Methods in org.springframework.core.type with annotations of type Nullable

Modifier and Type	Method and Description
MultiValueMap<String,Object>	AnnotatedTypeMetadata.getAllAnnotationAttributes(String annotationName) Retrieve all attributes of all annotations of the given type, if any (i.e.
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.
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.
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.
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()

Uses of Nullable in org.springframework.core.type.classreading

Fields in org.springframework.core.type.classreading with annotations of type Nullable

Modifier and Type	Field and Description
protected ClassLoader	MethodMetadataReadingVisitor.classLoader
protected ClassLoader	AnnotationMetadataReadingVisitor.classLoader

Methods in org.springframework.core.type.classreading with annotations of type Nullable

Modifier and Type	Method and Description
MultiValueMap<String,Object>	MethodMetadataReadingVisitor.getAllAnnotationAttributes(String annotationName)
MultiValueMap<String,Object>	AnnotationMetadataReadingVisitor.getAllAnnotationAttributes(String annotationName)
MultiValueMap<String,Object>	MethodMetadataReadingVisitor.getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)
MultiValueMap<String,Object>	AnnotationMetadataReadingVisitor.getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)
AnnotationAttributes	MethodMetadataReadingVisitor.getAnnotationAttributes(String annotationName)
AnnotationAttributes	AnnotationMetadataReadingVisitor.getAnnotationAttributes(String annotationName)
AnnotationAttributes	MethodMetadataReadingVisitor.getAnnotationAttributes(String annotationName, boolean classValuesAsString)
AnnotationAttributes	AnnotationMetadataReadingVisitor.getAnnotationAttributes(String annotationName, boolean classValuesAsString)

Constructor parameters in org.springframework.core.type.classreading with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.core.type.filter

Methods in org.springframework.core.type.filter with annotations of type Nullable

Modifier and Type	Method and Description
protected Boolean	AnnotationTypeFilter.hasAnnotation(String typeName)
protected Boolean	AbstractTypeHierarchyTraversingFilter.matchInterface(String interfaceName) Override this to match on interface type name.
protected Boolean	AssignableTypeFilter.matchInterface(String interfaceName)
protected Boolean	AnnotationTypeFilter.matchInterface(String interfaceName)
protected Boolean	AbstractTypeHierarchyTraversingFilter.matchSuperClass(String superClassName) Override this to match on super type name.
protected Boolean	AssignableTypeFilter.matchSuperClass(String superClassName)
protected Boolean	AnnotationTypeFilter.matchSuperClass(String superClassName)
protected Boolean	AssignableTypeFilter.matchTargetType(String typeName)

Constructor parameters in org.springframework.core.type.filter with annotations of type Nullable

Constructor and Description
AspectJTypeFilter(String typePatternExpression, ClassLoader classLoader)

Uses of Nullable in org.springframework.util

Fields in org.springframework.util with annotations of type Nullable

Modifier and Type	Field and Description
protected Class<?>	MethodInvoker.targetClass

Methods in org.springframework.util with annotations of type Nullable

Modifier and Type	Method and Description
V	LinkedCaseInsensitiveMap.computeIfAbsent(String key, Function<? super String,? extends V> mappingFunction)
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.
List<V>	LinkedMultiValueMap.get(Object key)
V	ConcurrentReferenceHashMap.get(Object key)
V	LinkedCaseInsensitiveMap.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) Deprecated. as of 5.0.11, in favor of custom SQLException handling
static Object	ReflectionUtils.invokeJdbcMethod(Method method, Object target, Object... args) Deprecated. 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) Deprecated. 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.
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)
V	LinkedCaseInsensitiveMap.putIfAbsent(String 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.
List<V>	LinkedMultiValueMap.remove(Object key)
V	ConcurrentReferenceHashMap.remove(Object key)
V	LinkedCaseInsensitiveMap.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.

Method parameters in org.springframework.util with annotations of type Nullable

Modifier and Type	Method and Description
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) Deprecated. 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.
boolean	LinkedCaseInsensitiveMap.equals(Object obj)
boolean	MimeType.equalsTypeAndSubtype(MimeType other) Similar to MimeType.equals(Object) but based on the type and subtype only, i.e.
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 boolean	StringUtils.hasLength(String str) Check that the given String is neither null nor of length 0.
static void	Assert.hasLength(String text) Deprecated. as of 4.3.7, in favor of Assert.hasLength(String, String)
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 boolean	StringUtils.hasText(String str) Check whether the given String contains actual text.
static void	Assert.hasText(String text) Deprecated. as of 4.3.7, in favor of Assert.hasText(String, String)
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) Deprecated. as of 5.0.11, in favor of custom SQLException handling
static Object	ReflectionUtils.invokeJdbcMethod(Method method, Object target, Object... args) Deprecated. as of 5.0.11, in favor of custom SQLException handling
static Object	ReflectionUtils.invokeJdbcMethod(Method method, Object target, Object... args) Deprecated. 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.
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	StringUtils.isEmpty(Object str) Check whether the given object (possibly a String) is empty.
static boolean	ObjectUtils.isEmpty(Object obj) Determine whether the given object 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) Deprecated. 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) Deprecated. 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) Deprecated. 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) Deprecated. 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) Deprecated. 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) Deprecated. 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) Deprecated. 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) Deprecated. 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.
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.
protected String	PropertyPlaceholderHelper.parseStringValue(String value, PropertyPlaceholderHelper.PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders)
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)
V	LinkedCaseInsensitiveMap.putIfAbsent(String 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 Object	ObjectUtils.unwrapOptional(Object obj) Unwrap the given object which is potentially a Optional.

Constructor parameters in org.springframework.util with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.util.comparator

Method parameters in org.springframework.util.comparator with annotations of type Nullable

Modifier and Type	Method and Description
int	NullSafeComparator.compare(T o1, T o2)
int	NullSafeComparator.compare(T o1, T o2)

Uses of Nullable in org.springframework.util.concurrent

Methods in org.springframework.util.concurrent with annotations of type Nullable

Modifier and Type	Method and Description
protected abstract T	FutureAdapter.adapt(S adapteeResult) Adapts the given adaptee's result into T.
T	FutureAdapter.get()
T	MonoToListenableFutureAdapter.get()
T	FutureAdapter.get(long timeout, TimeUnit unit)
T	MonoToListenableFutureAdapter.get(long timeout, TimeUnit unit)

Method parameters in org.springframework.util.concurrent with annotations of type Nullable

Modifier and Type	Method and Description
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.

Constructor parameters in org.springframework.util.concurrent with annotations of type Nullable

Constructor and Description
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.

Uses of Nullable in org.springframework.util.function

Methods in org.springframework.util.function with annotations of type Nullable

Modifier and Type	Method and Description
T	SingletonSupplier.get() Get the shared singleton instance for this supplier.
static <T> SingletonSupplier<T>	SingletonSupplier.ofNullable(Supplier<T> supplier) Build a SingletonSupplier with the given supplier.
static <T> SingletonSupplier<T>	SingletonSupplier.ofNullable(T instance) Build a SingletonSupplier with the given singleton instance.
static <T> T	SupplierUtils.resolve(Supplier<T> supplier) Resolve the given Supplier, getting its result or immediately returning null if the supplier itself was null.

Method parameters in org.springframework.util.function with annotations of type Nullable

Modifier and Type	Method and Description
static <T> SingletonSupplier<T>	SingletonSupplier.ofNullable(Supplier<T> supplier) Build a SingletonSupplier with the given supplier.
static <T> SingletonSupplier<T>	SingletonSupplier.ofNullable(T instance) Build a SingletonSupplier with the given singleton instance.
static <T> T	SupplierUtils.resolve(Supplier<T> supplier) Resolve the given Supplier, getting its result or immediately returning null if the supplier itself was null.

Constructor parameters in org.springframework.util.function with annotations of type Nullable

Constructor and Description
SingletonSupplier(Supplier<? extends T> instanceSupplier, Supplier<? extends T> defaultSupplier) Build a SingletonSupplier with the given instance supplier and a default supplier for the case when the instance is null.
SingletonSupplier(T instance, Supplier<? extends T> defaultSupplier) Build a SingletonSupplier with the given singleton instance and a default supplier for the case when the instance is null.

Uses of Nullable in org.springframework.util.unit

Method parameters in org.springframework.util.unit with annotations of type Nullable

Modifier and Type	Method and Description
static DataSize	DataSize.parse(CharSequence text, DataUnit defaultUnit) Obtain a DataSize from a text string such as 12MB using the specified default DataUnit if no unit is specified.

Uses of Nullable in org.springframework.util.xml

Methods in org.springframework.util.xml with annotations of type Nullable

Modifier and Type	Method and Description
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.

Method parameters in org.springframework.util.xml with annotations of type Nullable

Modifier and Type	Method and Description
void	SimpleNamespaceContext.removeBinding(String prefix) Remove the given prefix from this context.