Annotation Interface的使用
cn.taketoday.lang.Nullable

使用Nullable的程序包

程序包	说明
cn.taketoday.bytecode	CGLIB or ASM other byte code library
cn.taketoday.bytecode.commons	Provides some useful class and method adapters.
cn.taketoday.bytecode.core
cn.taketoday.core	Provides core helpers that are not specific to any part of the framework.
cn.taketoday.core.annotation	Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
cn.taketoday.core.codec	Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
cn.taketoday.core.conversion	Type Conversion System
cn.taketoday.core.conversion.support	Default implementation of the type conversion system.
cn.taketoday.core.env	environment abstraction consisting of bean definition profile and hierarchical property source support.
cn.taketoday.core.i18n	Abstraction for determining the current Locale, plus global holder that exposes a thread-bound Locale.
cn.taketoday.core.io
cn.taketoday.core.io.buffer	Generic abstraction for working with byte buffer implementations.
cn.taketoday.core.serializer	Root package for Framework's serializer interfaces and implementations.
cn.taketoday.core.style	Support for styling values as Strings, with ToStringBuilder as central class.
cn.taketoday.core.task	This package defines core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
cn.taketoday.core.task.support	Support classes for TaskExecutor abstraction.
cn.taketoday.core.type	Core support package for type introspection.
cn.taketoday.core.type.classreading	Support classes for reading annotation and class-level metadata.
cn.taketoday.core.type.filter	Core support package for type filtering (e.g. for classpath scanning).
cn.taketoday.expression	Core abstractions behind the Spring Expression Language.
cn.taketoday.expression.common	Common utility classes behind the Spring Expression Language.
cn.taketoday.expression.spel	SpEL's central implementation package.
cn.taketoday.expression.spel.ast	SpEL's abstract syntax tree.
cn.taketoday.expression.spel.standard	SpEL's standard parser implementation.
cn.taketoday.expression.spel.support	SpEL's default implementations for various core abstractions.
cn.taketoday.lang	Framework global classes
cn.taketoday.reflect	Optimised Reflection System
cn.taketoday.util	Useful Tools
cn.taketoday.util.comparator	Useful generic java.util.Comparator implementations, such as an invertible comparator and a compound comparator.
cn.taketoday.util.concurrent	Useful generic java.util.concurrent.Future extensions. from Spring
cn.taketoday.util.function	Useful generic java.util.function helper classes.
cn.taketoday.util.xml	Miscellaneous utility classes for XML parsing and transformation, such as error handlers that log warnings via Logging.

cn.taketoday.bytecode中Nullable的使用

注释类型为Nullable的cn.taketoday.bytecode中的方法

修饰符和类型	方法	说明
static String	Type.resolvePrimitiveTypeDescriptor(String type)

注释类型为Nullable的cn.taketoday.bytecode中的方法参数

修饰符和类型	方法	说明
static BytecodeCompiler	BytecodeCompiler.getCompiler(ClassLoader classLoader)	Factory method for compiler instances.
static Type[]	Type.getTypes(Class<?>... items)

注释类型为Nullable的cn.taketoday.bytecode中的构造器参数

限定符	构造器	说明
protected	BytecodeCompiler(ClassLoader classloader)

cn.taketoday.bytecode.commons中Nullable的使用

注释类型为Nullable的cn.taketoday.bytecode.commons中的方法

修饰符和类型	方法	说明
protected AnnotationVisitor	FieldRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected AnnotationVisitor	MethodRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected AnnotationVisitor	RecordComponentRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected RecordComponentVisitor	ClassRemapper.createRecordComponentRemapper(RecordComponentVisitor recordComponentVisitor)	Constructs a new remapper for record components.

注释类型为Nullable的cn.taketoday.bytecode.commons中的方法参数

修饰符和类型	方法	说明
protected AnnotationVisitor	FieldRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected AnnotationVisitor	MethodRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected AnnotationVisitor	RecordComponentRemapper.createAnnotationRemapper(String descriptor, AnnotationVisitor annotationVisitor)	Constructs a new remapper for annotations.
protected RecordComponentVisitor	ClassRemapper.createRecordComponentRemapper(RecordComponentVisitor recordComponentVisitor)	Constructs a new remapper for record components.

cn.taketoday.bytecode.core中Nullable的使用

注释类型为Nullable的cn.taketoday.bytecode.core中的方法

修饰符和类型	方法	说明
DefineClassStrategy	AbstractClassGenerator.getDefineClassStrategy()
static String[]	CglibReflectUtils.getNames(Class[] classes)
String	CodeFlow.lastDescriptor()	Return the descriptor for the item currently on top of the stack (in the current scope).

注释类型为Nullable的cn.taketoday.bytecode.core中的方法参数

修饰符和类型	方法	说明
void	ClassEmitter.beginClass(int version, int access, String className, Type superType, Type[] interfaces, String source)
void	ClassEmitter.beginClass(int version, int access, String className, Type superType, Type[] interfaces, String source)
Class<?>	DefineClassStrategy.defineClass(String className, ClassLoader classLoader, ProtectionDomain domain, Class<?> neighbor, byte[] classFile)	define a class file to class
Class<?>	DefineClassStrategy.defineClass(String className, ClassLoader classLoader, ProtectionDomain domain, Class<?> neighbor, byte[] classFile)	define a class file to class
static void	CodeFlow.insertBoxIfNecessary(MethodVisitor mv, String descriptor)	Determine the appropriate boxing instruction for a specific type (if it needs boxing) and insert the instruction into the supplied visitor.
static void	CodeFlow.insertCheckCast(MethodVisitor mv, String descriptor)	Insert the appropriate CHECKCAST instruction for the supplied descriptor.
static void	CodeFlow.insertNumericUnboxOrPrimitiveTypeCoercion(MethodVisitor mv, String stackDescriptor, char targetDescriptor)	For use in mathematical operators, handles converting from a (possibly boxed) number on the stack to a primitive numeric type.
static void	CodeFlow.insertUnboxInsns(MethodVisitor mv, char ch, String stackDescriptor)	Insert any necessary cast and value call to convert from a boxed type to a primitive value.
static void	CodeFlow.insertUnboxNumberInsns(MethodVisitor mv, char targetDescriptor, String stackDescriptor)	For numbers, use the appropriate method on the number to convert it to the primitive type requested.
static boolean	CodeFlow.isBooleanCompatible(String descriptor)	Determine whether the descriptor is for a boolean primitive or boolean reference type.
static boolean	CodeFlow.isPrimitive(String descriptor)	Determine whether the descriptor is for a primitive type.
static boolean	CodeFlow.isPrimitiveArray(String descriptor)	Determine whether the descriptor is for a primitive array (e.g.
static boolean	CodeFlow.isPrimitiveOrUnboxableSupportedNumber(String descriptor)	Determine if the supplied descriptor is for a supported number.
static boolean	CodeFlow.isPrimitiveOrUnboxableSupportedNumberOrBoolean(String descriptor)	Determine if the supplied descriptor is for a supported number type or boolean.
void	CodeFlow.pushDescriptor(String descriptor)	Record the descriptor for the most recently evaluated expression element.
void	AbstractClassGenerator.setDefineClassStrategy(DefineClassStrategy defineClassStrategy)
static String	CodeFlow.toDescriptorFromObject(Object value)	Determine the descriptor for an object instance (or null).

cn.taketoday.core中Nullable的使用

注释类型为Nullable的cn.taketoday.core中的字段

修饰符和类型	字段	说明
protected Map<String,Object>	AttributeAccessorSupport.attributes	Map with String keys and Object values.

注释类型为Nullable的cn.taketoday.core中的方法

修饰符和类型	方法	说明
protected String[]	ParameterNameDiscoverer.doGet(Executable executable)
TypeDescriptor	TypeDescriptor.elementDescriptor(Object element)	If this type is a Collection or an array, creates a element TypeDescriptor from the provided collection or array element.
String[]	AntPathMatcher.AntPathStringMatcher.extractVariables(String str)
protected Integer	OrderComparator.findOrder(Object obj)	Find an order value indicated by the given object.
static TypeDescriptor	TypeDescriptor.fromObject(Object source)	Create a new type descriptor for an object.
List<V>	DefaultMultiValueMap.get(Object key)
List<V>	MultiValueMapAdapter.get(Object key)
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.
<T extends Annotation> T	TypeDescriptor.getAnnotation(Class<T> annotationType)	Obtain the annotation of the specified annotationType that is on this type descriptor.
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.
TypeDescriptor	TypeDescriptor.getElementDescriptor()	If this type is an array, returns the array's component type.
protected ClassLoader	ConfigurableObjectInputStream.getFallbackClassLoader()	Return the fallback ClassLoader to use when no ClassLoader was specified and ObjectInputStream's own default class loader failed.
V	MultiValueMap.getFirst(K key)	Return the first value for the given key.
V	MultiValueMapAdapter.getFirst(K key)
TypeDescriptor	TypeDescriptor.getMapKeyDescriptor()	If this type is a Map and its key type is parameterized, returns the map's key type.
TypeDescriptor	TypeDescriptor.getMapKeyDescriptor(Object mapKey)	If this type is a Map, creates a mapKey TypeDescriptor from the provided map key.
TypeDescriptor	TypeDescriptor.getMapValueDescriptor()	If this type is a Map and its value type is parameterized, returns the map's value type.
TypeDescriptor	TypeDescriptor.getMapValueDescriptor(Object mapValue)	If this type is a Map, creates a mapValue TypeDescriptor from the provided map value.
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	OrderSourceProvider.getOrderSource(Object obj)	Return an order source for the specified object, i.e. an object that should be checked for an order value as a replacement to the given object.
<A extends Annotation> A	MethodParameter.getParameterAnnotation(Class<A> annotationType)	Return the parameter annotation of the given type, if available.
String	MethodParameter.getParameterName()	Return the name of the method/constructor parameter.
String[]	CompositeParameterNameDiscoverer.getParameterNames(Executable executable)
String[]	ParameterNameDiscoverer.getParameterNames(Executable executable)	Return parameter names for an Executable(method or constructor), or null if they cannot be determined.
Class<?>[]	ConstructorNotFoundException.getParameterTypes()
Integer	OrderComparator.getPriority(Object obj)	Determine a priority value for the given object, if any.
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.
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.
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.
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(TypeDescriptor typeDescriptor, int nestingLevel)
protected InputStream	OverridingClassLoader.openStreamForClass(String name)	Open an InputStream for the specified class.
List<V>	DefaultMultiValueMap.put(K key, List<V> value)
List<V>	MultiValueMapAdapter.put(K key, List<V> value)
List<V>	DefaultMultiValueMap.remove(Object key)
List<V>	MultiValueMapAdapter.remove(Object key)
Object	AttributeAccessor.removeAttribute(String name)	Remove the attribute identified by name and return its value.
M	MetadataResolver.resolve(C context)	Resolve the given String value, for example parsing placeholders.
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.
String	StringValueResolver.resolveStringValue(String strVal)	Resolve the given String value, for example parsing placeholders.
static <T> Class<T>	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.
ResolvableType	ResolvableType.VariableResolver.resolveVariable(TypeVariable<?> variable)	Resolve the specified variable.
TypeDescriptor	TypeDescriptor.upcast(Class<?> superType)	Cast this TypeDescriptor to a superclass or implemented interface preserving annotations and nested type context.

注释类型为Nullable的cn.taketoday.core中的方法参数

修饰符和类型	方法	说明
void	DefaultMultiValueMap.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.
void	MultiValueMapAdapter.add(K key, V value)
void	DefaultMultiValueMap.addAll(K key, Collection<? extends V> values)
void	DefaultMultiValueMap.addAll(K key, Enumeration<? extends V> values)
void	DefaultMultiValueMap.addAll(K key, List<? extends V> values)
default void	MultiValueMap.addAll(Map<K,List<V>> values)	Add all the values of the given MultiValueMap to the current values.
default void	MultiValueMap.addAll(K key, Collection<? extends V> values)	Add all the values of the given list to the current list of values for the given key.
default void	MultiValueMap.addAll(K key, Enumeration<? extends V> values)	Add all the values of the given enumeration to the current enumeration of values for the given key.
default void	MultiValueMap.addAll(K key, List<? extends V> values)	Add all the values of the given list to the current list of values for the given key.
void	CompositeParameterNameDiscoverer.addDiscoverer(ParameterNameDiscoverer... discoverer)	add ParameterNameDiscoverer
default void	MultiValueMap.addIfAbsent(K key, V value)	Add the given value, only when the map does not contain the given key.
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.
protected boolean	AntPathMatcher.doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)	Actually match the given path against the given pattern.
boolean	MethodParameter.equals(Object other)
boolean	MultiValueMapAdapter.equals(Object other)
boolean	ReactiveTypeDescriptor.equals(Object other)
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.forMethodParameter(MethodParameter methodParameter, Type targetType, int nestingLevel)	Return a ResolvableType for the specified MethodParameter at a specific nesting level, overriding the target type to resolve with a specific given type.
static ResolvableType	ResolvableType.forParameter(Executable executable, int parameterIndex, Class<?> implementationClass)	Return a ResolvableType for the specified Method parameter with a given implementation.
static ResolvableType	ResolvableType.forReturnType(Method method, Class<?> implementationClass)	Return a ResolvableType for the specified Method return type.
static ResolvableType	ResolvableType.fromField(Field field, ResolvableType implementationType)	Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	ResolvableType.fromInstance(Object instance)	Return a ResolvableType for the specified instance.
static TypeDescriptor	TypeDescriptor.fromObject(Object source)	Create a new type descriptor for an object.
static ResolvableType	ResolvableType.fromParameter(Parameter parameter, ResolvableType implementationType)	Return a ResolvableType for the specified Parameter with a given implementation type.
static ResolvableType	ResolvableType.fromParameter(Parameter parameter, Type targetType)	Return a ResolvableType for the specified Parameter, overriding the target type to resolve with a specific given type.
static ResolvableType	ResolvableType.fromRawClass(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.fromType(Type type)	Return a ResolvableType for the specified Type.
static ResolvableType	ResolvableType.fromType(Type type, ResolvableType owner)	Return a ResolvableType for the specified Type backed by the given owner type.
static ResolvableType	ResolvableType.fromType(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.
int	OrderComparator.getOrder(Object obj)	Determine the order value for the given object.
String[]	ParameterNameDiscoverer.getParameterNames(Executable executable)	Return parameter names for an Executable(method or constructor), or null if they cannot be determined.
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.
boolean	ResolvableType.isInstance(Object obj)	Determine whether the given object is an instance of this ResolvableType.
boolean	AntPathMatcher.AntPathStringMatcher.matchStrings(String str, Map<String,String> uriTemplateVariables)	Main entry point.
MethodParameter	MethodParameter.nested(Integer typeIndex)	Return a variant of this MethodParameter which points to the same parameter but one nesting level deeper.
default Class<?>	SmartClassLoader.publicDefineClass(String name, byte[] b, ProtectionDomain protectionDomain)	Define a custom class (typically a CGLIB proxy class) in this class loader.
void	CompositeStrategies.set(List<T> resolver)	set or clear resolvers
void	DefaultMultiValueMap.set(K key, V value)
void	MultiValueMap.set(K key, V value)	Set the given single value under the given key.
void	MultiValueMapAdapter.set(K key, V value)
default void	MultiValueMap.setAll(Map<K,V> values)	Set the given values under.
void	AttributeAccessor.setAttribute(String name, Object value)	Set the attribute defined by name to the supplied value.
void	AttributeAccessorSupport.setAttribute(String name, Object value)
String	Constants.toCode(Object value, String namePrefix)	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.
static ResolvableType	ResolvableType.valueOf(Type type, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.valueOf(Type type, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.valueOf(Type type, cn.taketoday.core.SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.valueOf(Type type, cn.taketoday.core.SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.valueOf(Type type, cn.taketoday.core.SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
MethodParameter	MethodParameter.withContainingClass(Class<?> containingClass)	Return a variant of this MethodParameter which refers to the given containing class.

注释类型为Nullable的cn.taketoday.core中的构造器参数

限定符	构造器	说明
	ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader)	Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
	ConfigurableObjectInputStream(InputStream in, ClassLoader classLoader, boolean acceptProxyClasses)	Create a new ConfigurableObjectInputStream for the given InputStream and ClassLoader.
	ConstructorNotFoundException(Class<?> type, String msg, Class<?>[] parameterTypes, Throwable e)
	ConstructorNotFoundException(Class<?> type, String msg, Class<?>[] parameterTypes, Throwable e)
	DecoratingClassLoader(ClassLoader parent)	Create a new DecoratingClassLoader using the given parent ClassLoader for delegation.
	NestedRuntimeException(String msg)	Construct a NestedRuntimeException with the specified detail message.
	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.
	NestedRuntimeException(Throwable cause)	Construct a NestedRuntimeException with the specified nested exception.
	NoStackTraceRuntimeException(String msg)	Construct a NestedRuntimeException with the specified detail message.
	NoStackTraceRuntimeException(String msg, Throwable cause)	Construct a NestedRuntimeException with the specified detail message and nested exception.
	NoStackTraceRuntimeException(String msg, Throwable cause)	Construct a NestedRuntimeException with the specified detail message and nested exception.
	NoStackTraceRuntimeException(Throwable cause)	Construct a NestedRuntimeException with the specified 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.
	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.
	TypeDescriptor(ResolvableType resolvableType, Class<?> type, AnnotatedElement annotated)	Create a new type descriptor from a ResolvableType.

cn.taketoday.core.annotation中Nullable的使用

注释类型为Nullable的cn.taketoday.core.annotation中的方法

修饰符和类型	方法	说明
Class<? extends Annotation>	AnnotationAttributes.annotationType()	Get the type of annotation represented by this AnnotationAttributes.
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(AnnotatedElement annotatedElement, Class<A> annotationType)	Find a single Annotation of annotationType on the supplied AnnotatedElement.
static <A extends Annotation> A	AnnotationUtils.findAnnotation(Method method, Class<A> annotationType)	Find a single Annotation of annotationType on the supplied Method, traversing its super methods (i.e. from superclasses and interfaces) if the annotation is not directly present on the given method itself.
static Class<?>	AnnotationUtils.findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)	Find the first Class in the inheritance hierarchy of the specified clazz (including the specified clazz itself) on which an annotation of the specified annotationType is directly present.
static Class<?>	AnnotationUtils.findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)	Find the first Class in the inheritance hierarchy of the specified clazz (including the specified clazz itself) on which at least one of the specified annotationTypes is directly present.
static <A extends Annotation> A	AnnotatedElementUtils.findMergedAnnotation(AnnotatedElement element, Class<A> annotationType)	Find the first annotation of the specified annotationType within the annotation hierarchy above the supplied element, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy, and synthesize the result back into an annotation of the specified annotationType.
static AnnotationAttributes	AnnotatedElementUtils.findMergedAnnotationAttributes(AnnotatedElement element, Class<? extends Annotation> annotationType, boolean classValuesAsString, boolean nestedAnnotationsAsMap)	Find the first annotation of the specified annotationType within the annotation hierarchy above the supplied element and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
static AnnotationAttributes	AnnotatedElementUtils.findMergedAnnotationAttributes(AnnotatedElement element, String annotationName, boolean classValuesAsString, boolean nestedAnnotationsAsMap)	Find the first annotation of the specified annotationName within the annotation hierarchy above the supplied element and merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy.
protected Integer	AnnotationAwareOrderComparator.findOrder(Object obj)	This implementation checks for @Order or @Priority on various kinds of elements, in addition to the Ordered check in the superclass.
static AnnotationAttributes	AnnotationAttributes.fromMap(Map<String,Object> map)	Return an AnnotationAttributes instance based on the given map.
static AnnotationAttributes	AnnotationAttributes.fromMetadata(AnnotatedTypeMetadata metadata, Class<?> annotationClass)
static AnnotationAttributes	AnnotationAttributes.fromMetadata(AnnotatedTypeMetadata metadata, String annotationClassName)
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(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(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(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.
MergedAnnotation<?>	MergedAnnotation.getMetaSource()	Get the source of the meta-annotation, or null if the annotation is not meta-present.
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.getOrder(AnnotatedElement element)	Return the order declared on the specified element.
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 Integer	OrderUtils.getPriority(Class<?> type)	Return the value of the jakarta.annotation.Priority annotation declared on the specified type, or null if none.
Object	MergedAnnotation.getSource()	Get the source that ultimately declared the root annotation, or null if the source is not known.
static Object	AnnotationUtils.getValue(Annotation annotation)	Retrieve the value of the value attribute of a single-element Annotation, given an annotation instance.
static Object	AnnotationUtils.getValue(Annotation annotation, String attributeName)	Retrieve the value of a named attribute, given an annotation instance.

注释类型为Nullable的cn.taketoday.core.annotation中的方法参数

修饰符和类型	方法	说明
boolean	RepeatableContainers.equals(Object other)
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(AnnotatedElement annotatedElement, Class<A> annotationType)	Find a single Annotation of annotationType on the supplied AnnotatedElement.
static <A extends Annotation> A	AnnotationUtils.findAnnotation(Method method, Class<A> annotationType)	Find a single Annotation of annotationType on the supplied Method, traversing its super methods (i.e. from superclasses and interfaces) if the annotation is not directly present on the given method itself.
static Class<?>	AnnotationUtils.findAnnotationDeclaringClass(Class<? extends Annotation> annotationType, Class<?> clazz)	Find the first Class in the inheritance hierarchy of the specified clazz (including the specified clazz itself) on which an annotation of the specified annotationType is directly present.
static Class<?>	AnnotationUtils.findAnnotationDeclaringClassForTypes(List<Class<? extends Annotation>> annotationTypes, Class<?> clazz)	Find the first Class in the inheritance hierarchy of the specified clazz (including the specified clazz itself) on which at least one of the specified annotationTypes is directly present.
static <A extends Annotation> Set<A>	AnnotatedElementUtils.findMergedRepeatableAnnotations(AnnotatedElement element, Class<A> annotationType, Class<? extends Annotation> containerType)	Find all repeatable annotations of the specified annotationType within the annotation hierarchy above the supplied element; and for each annotation found, merge that annotation's attributes with matching attributes from annotations in lower levels of the annotation hierarchy and synthesize the results back into an annotation of the specified annotationType.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.from(Object source, A annotation)	Create a new MergedAnnotation instance from the specified annotation.
static AnnotationAttributes	AnnotationAttributes.fromMap(Map<String,Object> map)	Return an AnnotationAttributes instance based on the given map.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate)	Get the nearest matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)	Get a matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)	Get a matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate)	Get the nearest matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)	Get a matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)	Get a matching annotation or meta-annotation of the specified type, or MergedAnnotation.missing() if none is present.
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 <A extends Annotation> boolean	AnnotationUtils.isPresent(AnnotatedElement element, Class<A> annType)	Whether a Annotation present on AnnotatedElement
static <A extends Annotation> boolean	AnnotationUtils.isPresent(AnnotatedElement element, Class<A> annType)	Whether a Annotation present on AnnotatedElement
static boolean	AnnotationUtils.isSynthesizedAnnotation(Annotation annotation)	Determine if the supplied Annotation has been synthesized by Spring (i.e. wrapped in a dynamic proxy) with additional functionality such as attribute alias handling.
static void	AnnotationUtils.postProcessAnnotationAttributes(Object annotatedElement, AnnotationAttributes attributes, boolean classValuesAsString)	Post-process the supplied AnnotationAttributes, preserving nested annotations as Annotation instances.
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.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(AnnotatedElement source, Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.valueOf(AnnotatedElement source, Class<A> annotationType, Map<String,?> attributes)	Create a new MergedAnnotation instance of the specified annotation type with attribute values supplied by a map.
static MergedAnnotations	MergedAnnotations.valueOf(Collection<MergedAnnotation<?>> annotations)	Create a new MergedAnnotations instance from the specified collection of directly present annotations.
static RepeatableContainers	RepeatableContainers.valueOf(Class<? extends Annotation> repeatable, Class<? extends Annotation> container)	Create a RepeatableContainers instance that uses a defined container and repeatable type.

注释类型为Nullable的cn.taketoday.core.annotation中的构造器参数

限定符	构造器	说明
	AnnotationAttributes(String annotationType, ClassLoader classLoader)	Create a new, empty AnnotationAttributes instance for the specified annotationType.

cn.taketoday.core.codec中Nullable的使用

注释类型为Nullable的cn.taketoday.core.codec中的方法

修饰符和类型	方法	说明
default T	Decoder.decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)	Decode a data buffer to an Object of type T.

注释类型为Nullable的cn.taketoday.core.codec中的方法参数

修饰符和类型	方法	说明
boolean	AbstractDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	DataBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	Decoder.canDecode(ResolvableType elementType, MimeType mimeType)	Whether the decoder supports the given target element type and the MIME type of the source stream.
boolean	Netty5BufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	NettyByteBufDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	StringDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	CharSequenceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	DataBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	Encoder.canEncode(ResolvableType elementType, MimeType mimeType)	Whether the encoder supports the given source element type and the MIME type for the output stream.
boolean	Netty5BufferEncoder.canEncode(ResolvableType type, MimeType mimeType)
boolean	NettyByteBufEncoder.canEncode(ResolvableType type, MimeType mimeType)
boolean	ResourceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceRegionEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
reactor.core.publisher.Flux<T>	AbstractDataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> 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)
byte[]	ByteArrayDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
byte[]	ByteArrayDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
ByteBuffer	ByteBufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
ByteBuffer	ByteBufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferDecoder.decode(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferDecoder.decode(DataBuffer buffer, 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<DataBuffer>	DataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
default T	Decoder.decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)	Decode a data buffer to an Object of type T.
default T	Decoder.decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)	Decode a data buffer to an Object of type T.
reactor.core.publisher.Flux<T>	Decoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Decode a DataBuffer input stream into a Flux of T.
reactor.core.publisher.Flux<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.
io.netty5.buffer.api.Buffer	Netty5BufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
io.netty5.buffer.api.Buffer	Netty5BufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
io.netty.buffer.ByteBuf	NettyByteBufDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
io.netty.buffer.ByteBuf	NettyByteBufDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
Resource	ResourceDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
Resource	ResourceDecoder.decode(DataBuffer dataBuffer, 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)
String	StringDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
String	StringDecoder.decode(DataBuffer dataBuffer, 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.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>	AbstractDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	AbstractDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Decode a DataBuffer input stream into a Mono of T.
reactor.core.publisher.Mono<T>	Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Decode a DataBuffer input stream into a Mono of T.
final reactor.core.publisher.Flux<DataBuffer>	AbstractSingleValueEncoder.encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
final reactor.core.publisher.Flux<DataBuffer>	AbstractSingleValueEncoder.encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, 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.
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>	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>	Netty5BufferEncoder.encode(org.reactivestreams.Publisher<? extends io.netty5.buffer.api.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	Netty5BufferEncoder.encode(org.reactivestreams.Publisher<? extends io.netty5.buffer.api.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	NettyByteBufEncoder.encode(org.reactivestreams.Publisher<? extends io.netty.buffer.ByteBuf> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	NettyByteBufEncoder.encode(org.reactivestreams.Publisher<? extends io.netty.buffer.ByteBuf> 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)
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)
DataBuffer	ByteArrayEncoder.encodeValue(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	ByteArrayEncoder.encodeValue(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	ByteBufferEncoder.encodeValue(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	ByteBufferEncoder.encodeValue(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	CharSequenceEncoder.encodeValue(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	CharSequenceEncoder.encodeValue(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferEncoder.encodeValue(DataBuffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferEncoder.encodeValue(DataBuffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
default DataBuffer	Encoder.encodeValue(T value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)	Encode an Object of type T to a data buffer.
default DataBuffer	Encoder.encodeValue(T value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)	Encode an Object of type T to a data buffer.
DataBuffer	Netty5BufferEncoder.encodeValue(io.netty5.buffer.api.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	Netty5BufferEncoder.encodeValue(io.netty5.buffer.api.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	NettyByteBufEncoder.encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	NettyByteBufEncoder.encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
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.
static Map<String,Object>	Hints.merge(Map<String,Object> hints, String hintName, Object hintValue)	Merge a single hint into a map of hints, possibly creating and copying all hints into a new map, or otherwise if the map of hints is empty, creating a new single entry map.
static Map<String,Object>	Hints.merge(Map<String,Object> hints1, Map<String,Object> hints2)	Merge two maps of hints, creating and copying into a new map if both have values, or returning the non-empty map, or an empty map if both are empty.
static Map<String,Object>	Hints.merge(Map<String,Object> hints1, Map<String,Object> hints2)	Merge two maps of hints, creating and copying into a new map if both have values, or returning the non-empty map, or an empty map if both are empty.
static void	Hints.touchDataBuffer(DataBuffer buffer, Map<String,Object> hints, Logger logger)	If the hints contain a Hints.LOG_PREFIX_HINT and the given logger has DEBUG level enabled, apply the log prefix as a hint to the given buffer via DataBufferUtils.touch(DataBuffer, Object).

注释类型为Nullable的cn.taketoday.core.codec中的构造器参数

限定符	构造器	说明
	CodecException(String msg, Throwable cause)	Create a new CodecException.
	DecodingException(String msg, Throwable cause)	Create a new DecodingException.
	EncodingException(String msg, Throwable cause)	Create a new EncodingException.

cn.taketoday.core.conversion中Nullable的使用

注释类型为Nullable的cn.taketoday.core.conversion中的方法

修饰符和类型	方法	说明
<T> T	ConversionService.convert(Object source, 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.
<T> T	ConversionService.convert(Object source, Class<T> targetType)	Convert the given source to the specified targetType.
T	Converter.convert(S source)	Convert the source object of type S to target type T.
Object	GenericConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)	Convert the source object to the targetType described by the TypeDescriptor.
GenericConverter	ConversionService.getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
default GenericConverter	ConversionService.getConverter(Class<?> sourceType, TypeDescriptor targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
default GenericConverter	ConversionService.getConverter(Class<?> sourceType, Class<?> targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
default GenericConverter	ConversionService.getConverter(Object sourceObject, TypeDescriptor targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
default GenericConverter	ConversionService.getConverter(Object sourceObject, Class<?> targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
Set<GenericConverter.ConvertiblePair>	GenericConverter.getConvertibleTypes()	Return the source and target types that this converter can convert between.
TypeDescriptor	ConversionFailedException.getSourceType()	Return the source type we tried to convert the value from.
TypeDescriptor	ConverterNotFoundException.getSourceType()	Return the source type that was requested to convert from.
Object	ConversionFailedException.getValue()	Return the offending value.

注释类型为Nullable的cn.taketoday.core.conversion中的方法参数

修饰符和类型	方法	说明
boolean	ConversionService.canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)	Return true if objects of sourceType can be converted to the targetType.
boolean	ConversionService.canConvert(Class<?> sourceType, Class<?> targetType)	Return true if objects of sourceType can be converted to the targetType.
<T> T	ConversionService.convert(Object source, 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.
Object	ConversionService.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)	Convert the given source to the specified targetType.
<T> T	ConversionService.convert(Object source, Class<T> targetType)	Convert the given source to the specified targetType.
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)	指示某个其他对象是否“等于”此对象。
static void	ConverterRegistry.registerConverters(Set<?> converters, ConverterRegistry registry)	Register the given Converter objects with the given target ConverterRegistry.

注释类型为Nullable的cn.taketoday.core.conversion中的构造器参数

限定符	构造器	说明
	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.

cn.taketoday.core.conversion.support中Nullable的使用

注释类型为Nullable的cn.taketoday.core.conversion.support中的方法

修饰符和类型	方法	说明
<T> T	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)
<T> T	GenericConversionService.convert(Object source, Class<T> targetType)
protected Object	GenericConversionService.convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)	Template method to convert a null source.
String	ConvertingPropertyEditorAdapter.getAsText()
GenericConverter	GenericConversionService.getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
protected GenericConverter	GenericConversionService.getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType)	Return the default converter if no converter is found for the given sourceType/targetType pair.

注释类型为Nullable的cn.taketoday.core.conversion.support中的方法参数

修饰符和类型	方法	说明
boolean	GenericConversionService.canBypassConvert(TypeDescriptor sourceType, TypeDescriptor targetType)	Return whether conversion between the source type and the target type can be bypassed.
boolean	GenericConversionService.canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)
boolean	GenericConversionService.canConvert(Class<?> sourceType, Class<?> targetType)
<T> T	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)
<T> T	GenericConversionService.convert(Object source, Class<T> targetType)
protected Object	GenericConversionService.convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)	Template method to convert a null source.
void	ConvertingPropertyEditorAdapter.setAsText(String text)

cn.taketoday.core.env中Nullable的使用

注释类型为Nullable的cn.taketoday.core.env中的方法

修饰符和类型	方法	说明
protected <T> T	AbstractPropertyResolver.convertValueIfNecessary(Object value, Class<T> targetType)	Convert the given value to the specified target type, if necessary.
protected String	AbstractEnvironment.doGetActiveProfilesProperty()	Return the property value for the active profiles.
protected String	AbstractEnvironment.doGetDefaultProfilesProperty()	Return the property value for the default profiles.
PropertySource<?>	PropertySources.get(String name)	Return the property source with the given name, null if not found.
protected abstract List<String>	CommandLinePropertySource.getOptionValues(String name)	Return the collection of values associated with the command line option having the given name.
List<String>	JOptCommandLinePropertySource.getOptionValues(String name)
protected List<String>	SimpleCommandLinePropertySource.getOptionValues(String name)
String	AbstractEnvironment.getProperty(String key)
<T> T	AbstractEnvironment.getProperty(String key, Class<T> targetType)
String	AbstractPropertyResolver.getProperty(String key)
final String	CommandLinePropertySource.getProperty(String name)	This implementation first checks to see if the name specified is the special "non-option arguments" property, and if so delegates to the abstract CommandLinePropertySource.getNonOptionArgs() method.
Object	CompositePropertySource.getProperty(String name)
<T> T	MapPropertyResolver.getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders)
Object	MapPropertySource.getProperty(String name)
String	PropertyResolver.getProperty(String key)	Return the property value associated with the given key, or null if the key cannot be resolved.
<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.
String	PropertyResolverComposite.getProperty(String key)
<T> T	PropertyResolverComposite.getProperty(String key, Class<T> targetType)
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.
<T> T	PropertySourcesPropertyResolver.getProperty(String key, Class<T> targetValueType, boolean resolveNestedPlaceholders)
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.
String	TypedPropertyResolver.getProperty(String key)
<T> T	TypedPropertyResolver.getProperty(String key, Class<T> targetValueType)
protected abstract String	AbstractPropertyResolver.getPropertyAsRawString(String key)	Retrieve the specified property as a raw String, i.e. without resolution of nested placeholders.
protected String	TypedPropertyResolver.getPropertyAsRawString(String key)
PropertySource<?>	PropertySources.remove(String name)	Remove and return the property source with the given name, null if not found.
String	AbstractPropertyResolver.resolvePlaceholder(String placeholderName)

注释类型为Nullable的cn.taketoday.core.env中的方法参数

修饰符和类型	方法	说明
protected <T> T	AbstractPropertyResolver.convertValueIfNecessary(Object value, Class<T> targetType)	Convert the given value to the specified target type, if necessary.
boolean	PropertySource.equals(Object other)	This PropertySource object is equal to the given object if: they are the same instance the name properties for both objects are equal
void	AbstractEnvironment.setValueSeparator(String valueSeparator)
void	AbstractPropertyResolver.setValueSeparator(String valueSeparator)	Specify the separating character between the placeholders replaced by this resolver and their associated default value, or null if no such special character should be processed as a value separator.
void	ConfigurablePropertyResolver.setValueSeparator(String valueSeparator)	Specify the separating character between the placeholders replaced by this resolver and their associated default value, or null if no such special character should be processed as a value separator.

注释类型为Nullable的cn.taketoday.core.env中的构造器参数

限定符	构造器	说明
	MapPropertyResolver(Map keyValues)	Create a new resolver against the given Map.
	PropertiesPropertyResolver(Properties keyValues)	Create a new resolver against the given Properties.
	PropertySourcesPropertyResolver(PropertySources propertySources)	Create a new resolver against the given property sources.

cn.taketoday.core.i18n中Nullable的使用

注释类型为Nullable的cn.taketoday.core.i18n中的方法

修饰符和类型	方法	说明
Locale	LocaleContext.getLocale()	Return the current Locale, which can be fixed or determined dynamically, depending on the implementation strategy.
Locale	SimpleLocaleContext.getLocale()
static LocaleContext	LocaleContextHolder.getLocaleContext()	Return the LocaleContext associated with the current thread, if any.
TimeZone	SimpleTimeZoneAwareLocaleContext.getTimeZone()
TimeZone	TimeZoneAwareLocaleContext.getTimeZone()	Return the current TimeZone, which can be fixed or determined dynamically, depending on the implementation strategy.

注释类型为Nullable的cn.taketoday.core.i18n中的方法参数

修饰符和类型	方法	说明
static Locale	LocaleContextHolder.getLocale(LocaleContext localeContext)	Return the Locale associated with the given user context, if any, or the system default Locale otherwise.
static TimeZone	LocaleContextHolder.getTimeZone(LocaleContext localeContext)	Return the TimeZone associated with the given user context, if any, or the system default TimeZone otherwise.
static void	LocaleContextHolder.setDefaultLocale(Locale locale)	Set a shared default locale at the framework level, as an alternative to the JVM-wide default locale.
static void	LocaleContextHolder.setDefaultTimeZone(TimeZone timeZone)	Set a shared default time zone at the framework level, as an alternative to the JVM-wide default time zone.
static void	LocaleContextHolder.setLocale(Locale locale)	Associate the given Locale with the current thread, preserving any TimeZone that may have been set already.
static void	LocaleContextHolder.setLocale(Locale locale, boolean inheritable)	Associate the given Locale with the current thread, preserving any TimeZone that may have been set already.
static void	LocaleContextHolder.setLocaleContext(LocaleContext localeContext)	Associate the given LocaleContext with the current thread, not exposing it as inheritable for child threads.
static void	LocaleContextHolder.setLocaleContext(LocaleContext localeContext, boolean inheritable)	Associate the given LocaleContext with the current thread.
static void	LocaleContextHolder.setTimeZone(TimeZone timeZone)	Associate the given TimeZone with the current thread, preserving any Locale that may have been set already.
static void	LocaleContextHolder.setTimeZone(TimeZone timeZone, boolean inheritable)	Associate the given TimeZone with the current thread, preserving any Locale that may have been set already.

注释类型为Nullable的cn.taketoday.core.i18n中的构造器参数

限定符	构造器	说明
	SimpleLocaleContext(Locale locale)	Create a new SimpleLocaleContext that exposes the specified Locale.
	SimpleTimeZoneAwareLocaleContext(Locale locale, TimeZone timeZone)	Create a new SimpleTimeZoneAwareLocaleContext that exposes the specified Locale and TimeZone.
	SimpleTimeZoneAwareLocaleContext(Locale locale, TimeZone timeZone)	Create a new SimpleTimeZoneAwareLocaleContext that exposes the specified Locale and TimeZone.

cn.taketoday.core.io中Nullable的使用

注释类型为Nullable的cn.taketoday.core.io中的字段

修饰符和类型	字段	说明
protected Properties[]	PropertiesLoaderSupport.localProperties

注释类型为Nullable的cn.taketoday.core.io中的方法

修饰符和类型	方法	说明
String	ResourceEditor.getAsText()
final ClassLoader	ClassPathResource.getClassLoader()	Return the ClassLoader that this resource will be obtained from.
ClassLoader	DefaultResourceLoader.getClassLoader()	Return the ClassLoader to load class path resources with.
ClassLoader	ResourceLoader.getClassLoader()	Expose the ClassLoader used by this ResourceLoader.
String	AbstractResource.getName()	Determine the filename for this resource — typically the last part of the path — for example, "myfile.txt".
String	Resource.getName()	Determine a name for this resource, i.e. typically the last part of the path: for example, "myfile.txt".
Collection<ProtocolResolver>	DefaultResourceLoader.getProtocolResolvers()	Return the collection of currently registered protocol resolvers, allowing for introspection as well as modification.
Resource	ProtocolResolver.resolve(String location, ResourceLoader resourceLoader)	Resolve the given location against the given resource loader if this implementation's protocol matches.
protected URL	ClassPathResource.resolveURL()	Resolves a URL for the underlying class path resource.

注释类型为Nullable的cn.taketoday.core.io中的方法参数

修饰符和类型	方法	说明
protected void	PathMatchingPatternResourceLoader.addAllClassLoaderJarRoots(ClassLoader classLoader, ResourceConsumer consumer)	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.
boolean	ClassPathResource.equals(Object obj)	This implementation compares the underlying class path locations and associated class loaders.
boolean	PathResource.equals(Object other)	This implementation compares the underlying Path references.
boolean	UrlResource.equals(Object other)	This implementation compares the underlying URL references.
static PatternResourceLoader	PatternResourceLoader.fromResourceLoader(ResourceLoader resourceLoader)	Return a default PatternResourceLoader for the given ResourceLoader.
static boolean	PatternResourceLoader.isUrl(String resourceLocation)	Return whether the given resource location is a URL: either a special "classpath" or "classpath*" pseudo URL or a standard URL.
Resource[]	Resource.list(ResourceFilter filter)	list Resource under the directory
Resource[]	ResourceDecorator.list(ResourceFilter filter)
static Properties	PropertiesUtils.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 Properties	PropertiesUtils.parse(String text)	Convert String into Properties, considering it as properties content.
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.
void	PropertiesLoaderSupport.setPropertiesPersister(PropertiesPersister propertiesPersister)	Set the PropertiesPersister to use for parsing properties files.

注释类型为Nullable的cn.taketoday.core.io中的构造器参数

限定符	构造器	说明
	ClassPathContextResource(String path, ClassLoader classLoader)
	DefaultResourceLoader(ClassLoader classLoader)	Create a new DefaultResourceLoader.
	PathMatchingPatternResourceLoader(ClassLoader classLoader)	Create a new PathMatchingResourcePatternResolver with a DefaultResourceLoader.
	ResourceArrayPropertyEditor(PatternResourceLoader resourcePatternResolver, PropertyResolver propertyResolver)	Create a new ResourceArrayPropertyEditor with the given PatternResourceLoader and PropertyResolver (typically an Environment).
	ResourceArrayPropertyEditor(PatternResourceLoader resourcePatternResolver, PropertyResolver propertyResolver, boolean ignoreUnresolvablePlaceholders)	Create a new ResourceArrayPropertyEditor with the given PatternResourceLoader and PropertyResolver (typically an Environment).
	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 UrlBasedResource based on a URI specification.

cn.taketoday.core.io.buffer中Nullable的使用

注释类型为Nullable的cn.taketoday.core.io.buffer中的方法参数

修饰符和类型	方法	说明
boolean	DefaultDataBuffer.equals(Object other)
boolean	Netty5DataBuffer.equals(Object other)
boolean	NettyDataBuffer.equals(Object other)
static boolean	DataBufferUtils.release(DataBuffer dataBuffer)	Release the given data buffer.

cn.taketoday.core.serializer中Nullable的使用

注释类型为Nullable的cn.taketoday.core.serializer中的构造器参数

限定符	构造器	说明
	DefaultDeserializer(ClassLoader classLoader)	Create a DefaultDeserializer for using an ObjectInputStream with the given ClassLoader.

cn.taketoday.core.style中Nullable的使用

注释类型为Nullable的cn.taketoday.core.style中的方法参数

修饰符和类型	方法	说明
ToStringBuilder	ToStringBuilder.append(String fieldName, Object value)	Append a field value.
String	DefaultValueStyler.style(Object value)
String	ValueStyler.style(Object value)	Style the given value, returning a String representation.
void	DefaultToStringStyler.styleField(StringBuilder buffer, String fieldName, Object value)
void	ToStringStyler.styleField(StringBuilder buffer, String fieldName, Object value)	Style a field value as a string.
void	DefaultToStringStyler.styleValue(StringBuilder buffer, Object value)

注释类型为Nullable的cn.taketoday.core.style中的构造器参数

限定符	构造器	说明
	ToStringBuilder(Object obj, ToStringStyler styler)	Create a ToStringBuilder for the given object, using the provided style.
	ToStringBuilder(Object obj, ValueStyler styler)	Create a ToStringBuilder for the given object, using the provided style.

cn.taketoday.core.task中Nullable的使用

注释类型为Nullable的cn.taketoday.core.task中的方法

修饰符和类型	方法	说明
final ThreadFactory	SimpleAsyncTaskExecutor.getThreadFactory()	Return the external factory to use for creating new Threads, if any.

注释类型为Nullable的cn.taketoday.core.task中的方法参数

修饰符和类型	方法	说明
final void	SimpleAsyncTaskExecutor.setTaskDecorator(TaskDecorator taskDecorator)	Specify a custom TaskDecorator to be applied to any Runnable about to be executed.
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.

注释类型为Nullable的cn.taketoday.core.task中的构造器参数

限定符	构造器	说明
	SimpleAsyncTaskExecutor(ThreadFactory threadFactory)	Create a new SimpleAsyncTaskExecutor with the given external thread factory.

cn.taketoday.core.task.support中Nullable的使用

注释类型为Nullable的cn.taketoday.core.task.support中的方法参数

修饰符和类型	方法	说明
protected void	TaskExecutorAdapter.doExecute(Executor concurrentExecutor, TaskDecorator taskDecorator, Runnable runnable)	Actually execute the given Runnable (which may be a user-supplied task or a wrapper around a user-supplied task) with the given executor.
final void	TaskExecutorAdapter.setTaskDecorator(TaskDecorator taskDecorator)	Specify a custom TaskDecorator to be applied to any Runnable about to be executed.

cn.taketoday.core.type中Nullable的使用

注释类型为Nullable的cn.taketoday.core.type中的方法

修饰符和类型	方法	说明
default MultiValueMap<String,Object>	AnnotatedTypeMetadata.getAllAnnotationAttributes(String annotationName)	Retrieve all attributes of all annotations of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation).
default MultiValueMap<String,Object>	AnnotatedTypeMetadata.getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)	Retrieve all attributes of all annotations of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation).
MultiValueMap<String,Object>	StandardAnnotationMetadata.getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)
MultiValueMap<String,Object>	StandardMethodMetadata.getAllAnnotationAttributes(String annotationName, boolean classValuesAsString)
default Map<String,Object>	AnnotatedTypeMetadata.getAnnotationAttributes(String annotationName)	Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation), also taking attribute overrides on composed annotations into account.
default Map<String,Object>	AnnotatedTypeMetadata.getAnnotationAttributes(String annotationName, boolean classValuesAsString)	Retrieve the attributes of the annotation of the given type, if any (i.e. if defined on the underlying element, as direct annotation or meta-annotation), also taking attribute overrides on composed annotations into account.
Map<String,Object>	StandardAnnotationMetadata.getAnnotationAttributes(String annotationName, boolean classValuesAsString)
Map<String,Object>	StandardMethodMetadata.getAnnotationAttributes(String annotationName, boolean classValuesAsString)
String	ClassMetadata.getEnclosingClassName()	Return the name of the enclosing class of the underlying class, or null if the underlying class is a top-level class.
String	StandardClassMetadata.getEnclosingClassName()
String	ClassMetadata.getSuperClassName()	Return the name of the super class of the underlying class, or null if there is no super class defined.
String	StandardClassMetadata.getSuperClassName()

注释类型为Nullable的cn.taketoday.core.type中的方法参数

修饰符和类型	方法	说明
boolean	StandardClassMetadata.equals(Object obj)
boolean	StandardMethodMetadata.equals(Object obj)

cn.taketoday.core.type.classreading中Nullable的使用

注释类型为Nullable的cn.taketoday.core.type.classreading中的构造器参数

限定符	构造器	说明
	CachingMetadataReaderFactory(ResourceLoader resourceLoader)	Create a new CachingMetadataReaderFactory for the given ResourceLoader, using a shared resource cache if supported or a local resource cache otherwise.
	CachingMetadataReaderFactory(ClassLoader classLoader)	Create a new CachingMetadataReaderFactory for the given ClassLoader, using a local resource cache.
	SimpleMetadataReaderFactory(ResourceLoader resourceLoader)	Create a new SimpleMetadataReaderFactory for the given resource loader.
	SimpleMetadataReaderFactory(ClassLoader classLoader)	Create a new SimpleMetadataReaderFactory for the given class loader.

cn.taketoday.core.type.filter中Nullable的使用

注释类型为Nullable的cn.taketoday.core.type.filter中的方法

修饰符和类型	方法	说明
protected Boolean	AnnotationTypeFilter.hasAnnotation(String typeName)
protected Boolean	AbstractTypeHierarchyTraversingFilter.matchInterface(String interfaceName)	Override this to match on interface type name.
protected Boolean	AnnotationTypeFilter.matchInterface(String interfaceName)
protected Boolean	AssignableTypeFilter.matchInterface(String interfaceName)
protected Boolean	AbstractTypeHierarchyTraversingFilter.matchSuperClass(String superClassName)	Override this to match on super type name.
protected Boolean	AnnotationTypeFilter.matchSuperClass(String superClassName)
protected Boolean	AssignableTypeFilter.matchSuperClass(String superClassName)
protected Boolean	AssignableTypeFilter.matchTargetType(String typeName)

注释类型为Nullable的cn.taketoday.core.type.filter中的构造器参数

限定符	构造器	说明
	AspectJTypeFilter(String typePatternExpression, ClassLoader classLoader)

cn.taketoday.expression中Nullable的使用

注释类型为Nullable的cn.taketoday.expression中的字段

修饰符和类型	字段	说明
protected final String	ExpressionException.expressionString

注释类型为Nullable的cn.taketoday.expression中的方法

修饰符和类型	方法	说明
Object	TypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)	Convert (or coerce) a value from one type to another, for example from a boolean to a String.
BeanResolver	EvaluationContext.getBeanResolver()	Return a bean resolver that can look up beans by name.
final String	ExpressionException.getExpressionString()	Return the expression string.
Class<?>[]	PropertyAccessor.getSpecificTargetClasses()	Return an array of classes for which this resolver should be called.
TypeDescriptor	TypedValue.getTypeDescriptor()
Object	Expression.getValue()	Evaluate this expression in the default standard context.
Object	Expression.getValue(EvaluationContext context)	Evaluate this expression in the provided context and return the result of evaluation.
<T> T	Expression.getValue(EvaluationContext context, Class<T> desiredResultType)	Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.
Object	Expression.getValue(EvaluationContext context, Object rootObject)	Evaluate this expression in the provided context and return the result of evaluation, but use the supplied root context as an override for any default root object specified in the context.
<T> T	Expression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)	Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.
<T> T	Expression.getValue(Class<T> desiredResultType)	Evaluate the expression in the default context.
Object	Expression.getValue(Object rootObject)	Evaluate this expression against the specified root object.
<T> T	Expression.getValue(Object rootObject, Class<T> desiredResultType)	Evaluate the expression in the default context against the specified root object.
Object	TypedValue.getValue()
Class<?>	Expression.getValueType()	Return the most general type that can be passed to a Expression.setValue(java.lang.Object, java.lang.Object) method using the default context.
Class<?>	Expression.getValueType(EvaluationContext context)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object) method for the given context.
Class<?>	Expression.getValueType(EvaluationContext context, Object rootObject)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object, Object) method for the given context.
Class<?>	Expression.getValueType(Object rootObject)	Return the most general type that can be passed to the Expression.setValue(Object, Object) method using the default context.
TypeDescriptor	Expression.getValueTypeDescriptor()	Return the most general type that can be passed to a Expression.setValue(java.lang.Object, java.lang.Object) method using the default context.
TypeDescriptor	Expression.getValueTypeDescriptor(EvaluationContext context)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object) method for the given context.
TypeDescriptor	Expression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object, Object) method for the given context.
TypeDescriptor	Expression.getValueTypeDescriptor(Object rootObject)	Return the most general type that can be passed to the Expression.setValue(Object, Object) method using the default context.
Object	EvaluationContext.lookupVariable(String name)	Look up a named variable within this evaluation context.
ConstructorExecutor	ConstructorResolver.resolve(EvaluationContext context, String typeName, List<TypeDescriptor> argumentTypes)	Within the supplied context determine a suitable constructor on the supplied type that can handle the specified arguments.
MethodExecutor	MethodResolver.resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes)	Within the supplied context determine a suitable method on the supplied object that can handle the specified arguments.

注释类型为Nullable的cn.taketoday.expression中的方法参数

修饰符和类型	方法	说明
boolean	TypeComparator.canCompare(Object firstObject, Object secondObject)	Return true if the comparator can compare these two objects.
boolean	TypeComparator.canCompare(Object firstObject, Object secondObject)	Return true if the comparator can compare these two objects.
boolean	TypeConverter.canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)	Return true if the type converter can convert the specified type to the desired target type.
boolean	PropertyAccessor.canRead(EvaluationContext context, Object target, String name)	Called to determine if a resolver instance is able to access a specified property on a specified target object.
boolean	PropertyAccessor.canWrite(EvaluationContext context, Object target, String name)	Called to determine if a resolver instance is able to write to a specified property on a specified target object.
int	TypeComparator.compare(Object firstObject, Object secondObject)	Compare two given objects.
int	TypeComparator.compare(Object firstObject, Object secondObject)	Compare two given objects.
Object	TypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)	Convert (or coerce) a value from one type to another, for example from a boolean to a String.
Object	TypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)	Convert (or coerce) a value from one type to another, for example from a boolean to a String.
boolean	TypedValue.equals(Object other)
<T> T	Expression.getValue(EvaluationContext context, Class<T> desiredResultType)	Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.
Object	Expression.getValue(EvaluationContext context, Object rootObject)	Evaluate this expression in the provided context and return the result of evaluation, but use the supplied root context as an override for any default root object specified in the context.
<T> T	Expression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)	Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.
<T> T	Expression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)	Evaluate the expression in a specified context which can resolve references to properties, methods, types, etc.
<T> T	Expression.getValue(Class<T> desiredResultType)	Evaluate the expression in the default context.
Object	Expression.getValue(Object rootObject)	Evaluate this expression against the specified root object.
<T> T	Expression.getValue(Object rootObject, Class<T> desiredResultType)	Evaluate the expression in the default context against the specified root object.
<T> T	Expression.getValue(Object rootObject, Class<T> desiredResultType)	Evaluate the expression in the default context against the specified root object.
Class<?>	Expression.getValueType(EvaluationContext context, Object rootObject)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object, Object) method for the given context.
Class<?>	Expression.getValueType(Object rootObject)	Return the most general type that can be passed to the Expression.setValue(Object, Object) method using the default context.
TypeDescriptor	Expression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)	Return the most general type that can be passed to the Expression.setValue(EvaluationContext, Object, Object) method for the given context.
TypeDescriptor	Expression.getValueTypeDescriptor(Object rootObject)	Return the most general type that can be passed to the Expression.setValue(Object, Object) method using the default context.
boolean	Expression.isWritable(EvaluationContext context, Object rootObject)	Determine if an expression can be written to, i.e. setValue() can be called.
boolean	Expression.isWritable(Object rootObject)	Determine if an expression can be written to, i.e. setValue() can be called.
Object	OperatorOverloader.operate(Operation operation, Object leftOperand, Object rightOperand)	Execute the specified operation on two operands, returning a result.
Object	OperatorOverloader.operate(Operation operation, Object leftOperand, Object rightOperand)	Execute the specified operation on two operands, returning a result.
boolean	OperatorOverloader.overridesOperation(Operation operation, Object leftOperand, Object rightOperand)	Return true if the operator overloader supports the specified operation between the two operands and so should be invoked to handle it.
boolean	OperatorOverloader.overridesOperation(Operation operation, Object leftOperand, Object rightOperand)	Return true if the operator overloader supports the specified operation between the two operands and so should be invoked to handle it.
TypedValue	PropertyAccessor.read(EvaluationContext context, Object target, String name)	Called to read a property from a specified target object.
void	Expression.setValue(EvaluationContext context, Object value)	Set this expression in the provided context to the value provided.
void	Expression.setValue(EvaluationContext context, Object rootObject, Object value)	Set this expression in the provided context to the value provided.
void	Expression.setValue(EvaluationContext context, Object rootObject, Object value)	Set this expression in the provided context to the value provided.
void	Expression.setValue(Object rootObject, Object value)	Set this expression in the provided context to the value provided.
void	Expression.setValue(Object rootObject, Object value)	Set this expression in the provided context to the value provided.
void	EvaluationContext.setVariable(String name, Object value)	Set a named variable within this evaluation context to a specified value.
void	PropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)	Called to write to a property on a specified target object.
void	PropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)	Called to write to a property on a specified target object.

注释类型为Nullable的cn.taketoday.expression中的构造器参数

限定符	构造器	说明
	ExpressionException(String expressionString, int position, String message)	Construct a new expression exception.
	ExpressionException(String expressionString, String message)	Construct a new expression exception.
	ParseException(String expressionString, int position, String message)	Create a new expression parsing exception.
	TypedValue(Object value)	Create a TypedValue for a simple object.
	TypedValue(Object value, TypeDescriptor typeDescriptor)	Create a TypedValue for a particular value with a particular TypeDescriptor which may contain additional generic declarations.
	TypedValue(Object value, TypeDescriptor typeDescriptor)	Create a TypedValue for a particular value with a particular TypeDescriptor which may contain additional generic declarations.

cn.taketoday.expression.common中Nullable的使用

注释类型为Nullable的cn.taketoday.expression.common中的方法

修饰符和类型	方法	说明
static <T> T	ExpressionUtils.convertTypedValue(EvaluationContext context, TypedValue typedValue, Class<T> targetType)	Determines if there is a type converter available in the specified context and attempts to use it to convert the supplied value to the specified type.
<T> T	CompositeStringExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
<T> T	CompositeStringExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	CompositeStringExpression.getValue(Class<T> expectedResultType)
<T> T	CompositeStringExpression.getValue(Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
<T> T	LiteralExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(Class<T> expectedResultType)
<T> T	LiteralExpression.getValue(Object rootObject, Class<T> desiredResultType)

注释类型为Nullable的cn.taketoday.expression.common中的方法参数

修饰符和类型	方法	说明
static <T> T	ExpressionUtils.convertTypedValue(EvaluationContext context, TypedValue typedValue, Class<T> targetType)	Determines if there is a type converter available in the specified context and attempts to use it to convert the supplied value to the specified type.
static <T> T	ExpressionUtils.convertTypedValue(EvaluationContext context, TypedValue typedValue, Class<T> targetType)	Determines if there is a type converter available in the specified context and attempts to use it to convert the supplied value to the specified type.
protected abstract Expression	TemplateAwareExpressionParser.doParseExpression(String expressionString, ParserContext context)	Actually parse the expression string and return an Expression object.
<T> T	CompositeStringExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
String	CompositeStringExpression.getValue(EvaluationContext context, Object rootObject)
<T> T	CompositeStringExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	CompositeStringExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	CompositeStringExpression.getValue(Class<T> expectedResultType)
String	CompositeStringExpression.getValue(Object rootObject)
<T> T	CompositeStringExpression.getValue(Object rootObject, Class<T> desiredResultType)
<T> T	CompositeStringExpression.getValue(Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
String	LiteralExpression.getValue(EvaluationContext context, Object rootObject)
<T> T	LiteralExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(EvaluationContext context, Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(Class<T> expectedResultType)
String	LiteralExpression.getValue(Object rootObject)
<T> T	LiteralExpression.getValue(Object rootObject, Class<T> desiredResultType)
<T> T	LiteralExpression.getValue(Object rootObject, Class<T> desiredResultType)
Class<?>	CompositeStringExpression.getValueType(EvaluationContext context, Object rootObject)
Class<?>	CompositeStringExpression.getValueType(Object rootObject)
Class<?>	LiteralExpression.getValueType(EvaluationContext context, Object rootObject)
Class<?>	LiteralExpression.getValueType(Object rootObject)
TypeDescriptor	CompositeStringExpression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)
TypeDescriptor	CompositeStringExpression.getValueTypeDescriptor(Object rootObject)
TypeDescriptor	LiteralExpression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)
TypeDescriptor	LiteralExpression.getValueTypeDescriptor(Object rootObject)
boolean	CompositeStringExpression.isWritable(EvaluationContext context, Object rootObject)
boolean	CompositeStringExpression.isWritable(Object rootObject)
boolean	LiteralExpression.isWritable(EvaluationContext context, Object rootObject)
boolean	LiteralExpression.isWritable(Object rootObject)
Expression	TemplateAwareExpressionParser.parseExpression(String expressionString, ParserContext context)
void	CompositeStringExpression.setValue(EvaluationContext context, Object value)
void	CompositeStringExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	CompositeStringExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	CompositeStringExpression.setValue(Object rootObject, Object value)
void	CompositeStringExpression.setValue(Object rootObject, Object value)
void	LiteralExpression.setValue(EvaluationContext context, Object value)
void	LiteralExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	LiteralExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	LiteralExpression.setValue(Object rootObject, Object value)
void	LiteralExpression.setValue(Object rootObject, Object value)

cn.taketoday.expression.spel中Nullable的使用

注释类型为Nullable的cn.taketoday.expression.spel中的方法

修饰符和类型	方法	说明
Object	ExpressionState.convertValue(TypedValue value, TypeDescriptor targetTypeDescriptor)
ClassLoader	SpelParserConfiguration.getCompilerClassLoader()	Return the ClassLoader to use as the basis for expression compilation.
Class<?>	SpelNode.getObjectClass(Object obj)	Determine the class of the object passed in, unless it is already a class object.
Object	SpelNode.getValue(ExpressionState expressionState)	Evaluate the expression node in the context of the supplied expression state and return the value.
Object	ExpressionState.lookupLocalVariable(String name)

注释类型为Nullable的cn.taketoday.expression.spel中的方法参数

修饰符和类型	方法	说明
Class<?>	SpelNode.getObjectClass(Object obj)	Determine the class of the object passed in, unless it is already a class object.
abstract Object	CompiledExpression.getValue(Object target, EvaluationContext context)	Subclasses of CompiledExpression generated by SpelCompiler will provide an implementation of this method.
abstract Object	CompiledExpression.getValue(Object target, EvaluationContext context)	Subclasses of CompiledExpression generated by SpelCompiler will provide an implementation of this method.
TypedValue	ExpressionState.operate(Operation op, Object left, Object right)
TypedValue	ExpressionState.operate(Operation op, Object left, Object right)
void	SpelNode.setValue(ExpressionState expressionState, Object newValue)	Evaluate the expression to a node and then set the new value on that node.
void	ExpressionState.setVariable(String name, Object value)

注释类型为Nullable的cn.taketoday.expression.spel中的构造器参数

限定符	构造器	说明
	SpelParseException(String expressionString, int position, SpelMessage message, Object... inserts)
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader)	Create a new SpelParserConfiguration instance.
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader)	Create a new SpelParserConfiguration instance.
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader, boolean autoGrowNullReferences, boolean autoGrowCollections, int maximumAutoGrowSize)	Create a new SpelParserConfiguration instance.
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader, boolean autoGrowNullReferences, boolean autoGrowCollections, int maximumAutoGrowSize)	Create a new SpelParserConfiguration instance.

cn.taketoday.expression.spel.ast中Nullable的使用

注释类型为Nullable的cn.taketoday.expression.spel.ast中的字段

修饰符和类型	字段	说明
protected String	SpelNodeImpl.exitTypeDescriptor	Indicates the type descriptor for the result of this expression node.
protected String	Operator.leftActualDescriptor
protected String	Operator.rightActualDescriptor

注释类型为Nullable的cn.taketoday.expression.spel.ast中的方法

修饰符和类型	方法	说明
List<Object>	InlineList.getConstantValue()
Map<Object,Object>	InlineMap.getConstantValue()
String	SpelNodeImpl.getExitDescriptor()
Class<?>	SpelNodeImpl.getObjectClass(Object obj)
final String	Literal.getOriginalValue()
final Object	SpelNodeImpl.getValue(ExpressionState expressionState)
protected final <T> T	SpelNodeImpl.getValue(ExpressionState state, Class<T> desiredReturnType)

注释类型为Nullable的cn.taketoday.expression.spel.ast中的方法参数

修饰符和类型	方法	说明
static Operator.DescriptorComparison	Operator.DescriptorComparison.checkNumericCompatibility(String leftDeclaredDescriptor, String rightDeclaredDescriptor, String leftActualDescriptor, String rightActualDescriptor)	Return an object that indicates whether the input descriptors are compatible.
static Operator.DescriptorComparison	Operator.DescriptorComparison.checkNumericCompatibility(String leftDeclaredDescriptor, String rightDeclaredDescriptor, String leftActualDescriptor, String rightActualDescriptor)	Return an object that indicates whether the input descriptors are compatible.
static Operator.DescriptorComparison	Operator.DescriptorComparison.checkNumericCompatibility(String leftDeclaredDescriptor, String rightDeclaredDescriptor, String leftActualDescriptor, String rightActualDescriptor)	Return an object that indicates whether the input descriptors are compatible.
static Operator.DescriptorComparison	Operator.DescriptorComparison.checkNumericCompatibility(String leftDeclaredDescriptor, String rightDeclaredDescriptor, String leftActualDescriptor, String rightActualDescriptor)	Return an object that indicates whether the input descriptors are compatible.
static boolean	Operator.equalityCheck(EvaluationContext context, Object left, Object right)	Perform an equality check for the given operand values.
static boolean	Operator.equalityCheck(EvaluationContext context, Object left, Object right)	Perform an equality check for the given operand values.
Class<?>	SpelNodeImpl.getObjectClass(Object obj)
static List<PropertyAccessor>	AstUtils.getPropertyAccessorsToTry(Class<?> targetType, List<PropertyAccessor> propertyAccessors)	Determines the set of property resolvers that should be used to try and access a property on the specified target type.
void	CompoundExpression.setValue(ExpressionState state, Object value)
void	Indexer.setValue(ExpressionState state, Object newValue)
void	PropertyOrFieldReference.setValue(ExpressionState state, Object newValue)
void	SpelNodeImpl.setValue(ExpressionState expressionState, Object newValue)
void	ValueRef.NullValueRef.setValue(Object newValue)
void	ValueRef.setValue(Object newValue)	Sets the value this ValueRef points to, it should not require expression component re-evaluation.
void	ValueRef.TypedValueHolderValueRef.setValue(Object newValue)
void	VariableReference.setValue(ExpressionState state, Object value)

注释类型为Nullable的cn.taketoday.expression.spel.ast中的构造器参数

限定符	构造器	说明
	Literal(String originalValue, int startPos, int endPos)

cn.taketoday.expression.spel.standard中Nullable的使用

注释类型为Nullable的cn.taketoday.expression.spel.standard中的方法

修饰符和类型	方法	说明
CompiledExpression	SpelCompiler.compile(SpelNodeImpl expression)	Attempt compilation of the supplied expression.
Object	SpelExpression.getValue()
Object	SpelExpression.getValue(EvaluationContext context)
<T> T	SpelExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
Object	SpelExpression.getValue(EvaluationContext context, Object rootObject)
<T> T	SpelExpression.getValue(EvaluationContext context, Object rootObject, Class<T> expectedResultType)
<T> T	SpelExpression.getValue(Class<T> expectedResultType)
Object	SpelExpression.getValue(Object rootObject)
<T> T	SpelExpression.getValue(Object rootObject, Class<T> expectedResultType)
Class<?>	SpelExpression.getValueType()
Class<?>	SpelExpression.getValueType(EvaluationContext context)
Class<?>	SpelExpression.getValueType(EvaluationContext context, Object rootObject)
Class<?>	SpelExpression.getValueType(Object rootObject)
TypeDescriptor	SpelExpression.getValueTypeDescriptor()
TypeDescriptor	SpelExpression.getValueTypeDescriptor(EvaluationContext context)
TypeDescriptor	SpelExpression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)
TypeDescriptor	SpelExpression.getValueTypeDescriptor(Object rootObject)

注释类型为Nullable的cn.taketoday.expression.spel.standard中的方法参数

修饰符和类型	方法	说明
protected SpelExpression	SpelExpressionParser.doParseExpression(String expressionString, ParserContext context)
static SpelCompiler	SpelCompiler.getCompiler(ClassLoader classLoader)	Factory method for compiler instances.
<T> T	SpelExpression.getValue(EvaluationContext context, Class<T> expectedResultType)
Object	SpelExpression.getValue(EvaluationContext context, Object rootObject)
<T> T	SpelExpression.getValue(EvaluationContext context, Object rootObject, Class<T> expectedResultType)
<T> T	SpelExpression.getValue(EvaluationContext context, Object rootObject, Class<T> expectedResultType)
<T> T	SpelExpression.getValue(Class<T> expectedResultType)
Object	SpelExpression.getValue(Object rootObject)
<T> T	SpelExpression.getValue(Object rootObject, Class<T> expectedResultType)
<T> T	SpelExpression.getValue(Object rootObject, Class<T> expectedResultType)
Class<?>	SpelExpression.getValueType(EvaluationContext context, Object rootObject)
Class<?>	SpelExpression.getValueType(Object rootObject)
TypeDescriptor	SpelExpression.getValueTypeDescriptor(EvaluationContext context, Object rootObject)
TypeDescriptor	SpelExpression.getValueTypeDescriptor(Object rootObject)
boolean	SpelExpression.isWritable(EvaluationContext context, Object rootObject)
boolean	SpelExpression.isWritable(Object rootObject)
void	SpelExpression.setValue(EvaluationContext context, Object value)
void	SpelExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	SpelExpression.setValue(EvaluationContext context, Object rootObject, Object value)
void	SpelExpression.setValue(Object rootObject, Object value)
void	SpelExpression.setValue(Object rootObject, Object value)

cn.taketoday.expression.spel.support中Nullable的使用

注释类型为Nullable的cn.taketoday.expression.spel.support中的方法

修饰符和类型	方法	说明
Object	StandardTypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)
protected Field	ReflectivePropertyAccessor.findField(String name, Class<?> clazz, boolean mustBeStatic)	Find a field of a certain name on a specified class.
protected Method	ReflectivePropertyAccessor.findGetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)	Find a getter method for the specified property.
protected Method	ReflectivePropertyAccessor.findSetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)	Find a setter method for the specified property.
BeanResolver	SimpleEvaluationContext.getBeanResolver()	SimpleEvaluationContext does not support the use of bean references.
BeanResolver	StandardEvaluationContext.getBeanResolver()
Class<?>	StandardTypeLocator.getClassFor(String className)
Class<?>	ReflectiveMethodExecutor.getPublicDeclaringClass()	Find the first public class in the methods declaring class hierarchy that declares this method.
Class<?>[]	ReflectivePropertyAccessor.getSpecificTargetClasses()	Returns null which means this is a general purpose accessor.
Class<?>[]	ReflectivePropertyAccessor.OptimalPropertyAccessor.getSpecificTargetClasses()
Object	SimpleEvaluationContext.lookupVariable(String name)
Object	StandardEvaluationContext.lookupVariable(String name)
MethodExecutor	DataBindingMethodResolver.resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes)
ConstructorExecutor	ReflectiveConstructorResolver.resolve(EvaluationContext context, String typeName, List<TypeDescriptor> argumentTypes)	Locate a constructor on the type.
MethodExecutor	ReflectiveMethodResolver.resolve(EvaluationContext context, Object targetObject, String name, List<TypeDescriptor> argumentTypes)	Locate a method on a type.

注释类型为Nullable的cn.taketoday.expression.spel.support中的方法参数

修饰符和类型	方法	说明
boolean	StandardTypeComparator.canCompare(Object left, Object right)
boolean	StandardTypeComparator.canCompare(Object left, Object right)
boolean	StandardTypeConverter.canConvert(TypeDescriptor sourceType, TypeDescriptor targetType)
boolean	ReflectivePropertyAccessor.canRead(EvaluationContext context, Object target, String name)
boolean	ReflectivePropertyAccessor.OptimalPropertyAccessor.canRead(EvaluationContext context, Object target, String name)
boolean	ReflectivePropertyAccessor.canWrite(EvaluationContext context, Object target, String name)
boolean	ReflectivePropertyAccessor.OptimalPropertyAccessor.canWrite(EvaluationContext context, Object target, String name)
int	StandardTypeComparator.compare(Object left, Object right)
int	StandardTypeComparator.compare(Object left, Object right)
Object	StandardTypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StandardTypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)
PropertyAccessor	ReflectivePropertyAccessor.createOptimalAccessor(EvaluationContext context, Object target, String name)	Attempt to create an optimized property accessor tailored for a property of a particular name on a particular class.
Object	StandardOperatorOverloader.operate(Operation operation, Object leftOperand, Object rightOperand)
Object	StandardOperatorOverloader.operate(Operation operation, Object leftOperand, Object rightOperand)
boolean	StandardOperatorOverloader.overridesOperation(Operation operation, Object leftOperand, Object rightOperand)
boolean	StandardOperatorOverloader.overridesOperation(Operation operation, Object leftOperand, Object rightOperand)
TypedValue	ReflectivePropertyAccessor.OptimalPropertyAccessor.read(EvaluationContext context, Object target, String name)
TypedValue	ReflectivePropertyAccessor.read(EvaluationContext context, Object target, String name)
void	ReflectiveMethodResolver.registerMethodFilter(Class<?> type, MethodFilter filter)	Register a filter for methods on the given type.
void	StandardEvaluationContext.setRootObject(Object rootObject)
void	StandardEvaluationContext.setRootObject(Object rootObject, TypeDescriptor typeDescriptor)
void	SimpleEvaluationContext.setVariable(String name, Object value)
void	StandardEvaluationContext.setVariable(String name, Object value)
void	StandardEvaluationContext.setVariable(String name, Object value)
void	ReflectivePropertyAccessor.OptimalPropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)
void	ReflectivePropertyAccessor.OptimalPropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)
void	ReflectivePropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)
void	ReflectivePropertyAccessor.write(EvaluationContext context, Object target, String name, Object newValue)

注释类型为Nullable的cn.taketoday.expression.spel.support中的构造器参数

限定符	构造器	说明
	ReflectiveMethodExecutor(Method method, Class<?> targetClass)	Create a new executor for the given method.
	StandardEvaluationContext(Object rootObject)	Create a StandardEvaluationContext with the given root object.
	StandardTypeLocator(ClassLoader classLoader)	Create a StandardTypeLocator for the given ClassLoader.

cn.taketoday.lang中Nullable的使用

注释类型为Nullable的cn.taketoday.lang中的方法

修饰符和类型	方法	说明
String	Version.extension()	返回 extension 记录组件的值。
static String	TodayStrategies.getFirst(String strategyKey)	get first strategy
static Integer	TodayStrategies.getInteger(String key)	Determines the integer value of the property with the specified name.
static Integer	TodayStrategies.getInteger(String key, Integer val)	Returns the integer value of the property with the specified name.
static String	TodayStrategies.getProperty(String key)	Retrieve the property value for the given key, checking local properties first and falling back to JVM-level system properties.
static <T extends Enumerable<V>, V> V	Enumerable.getValue(Class<T> enumerable, String name)	Get the value corresponding to the name
protected <T> T	TodayStrategies.instantiateStrategy(String implementationName, Class<T> type, TodayStrategies.Instantiator instantiator, TodayStrategies.FailureHandler failureHandler)
static <T extends Enumerable<V>, V> T	Enumerable.of(Class<T> enumerable, V value)	Returns Enumerable by enum value
<T> T	TodayStrategies.ArgumentResolver.resolve(Class<T> type)	Resolve the given argument if possible.

注释类型为Nullable的cn.taketoday.lang中的方法参数

修饰符和类型	方法	说明
static <T> List<T>	TodayStrategies.find(Class<T> strategyType, ClassLoader classLoader)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the given class loader.
static <T> List<T>	TodayStrategies.find(Class<T> strategyType, ClassLoader classLoader, TodayStrategies.Instantiator instantiator)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the given class loader.
static List<String>	TodayStrategies.findNames(Class<?> strategyType, ClassLoader classLoader)	Load the fully qualified class names of strategy implementations of the given type from "META-INF/today-strategies.properties", using the given class loader.
static List<String>	TodayStrategies.findNames(String strategyKey, ClassLoader classLoader)	Load the fully qualified class names of strategy implementations of the given type from "META-INF/today-strategies.properties", using the given class loader.
static TodayStrategies	TodayStrategies.forDefaultResourceLocation(ClassLoader classLoader)	Create a TodayStrategies instance that will load and instantiate the strategy implementations from "META-INF/today-strategies.properties", using the given class loader.
static TodayStrategies	TodayStrategies.forLocation(String resourceLocation, ClassLoader classLoader)	Create a TodayStrategies instance that will load and instantiate the strategy implementations from the given location, using the given class loader.
static <T> T	TodayStrategies.getFirst(Class<T> strategyClass, Supplier<T> defaultValue)	get first strategy
static Integer	TodayStrategies.getInteger(String key, Integer val)	Returns the integer value of the property with the specified name.
<T> List<T>	TodayStrategies.load(Class<T> strategyType, TodayStrategies.ArgumentResolver argumentResolver)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the configured class loader and the given argument resolver.
<T> List<T>	TodayStrategies.load(Class<T> strategyType, TodayStrategies.ArgumentResolver argumentResolver, TodayStrategies.FailureHandler failureHandler)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the configured class loader, the given argument resolver, and custom failure handling provided by the given failure handler.
<T> List<T>	TodayStrategies.load(Class<T> strategyType, TodayStrategies.ArgumentResolver argumentResolver, TodayStrategies.FailureHandler failureHandler)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the configured class loader, the given argument resolver, and custom failure handling provided by the given failure handler.
<T> List<T>	TodayStrategies.load(Class<T> strategyType, TodayStrategies.FailureHandler failureHandler)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the configured class loader with custom failure handling provided by the given failure handler.
<T> List<T>	TodayStrategies.load(Class<T> strategyType, TodayStrategies.Instantiator instantiator, TodayStrategies.FailureHandler failureHandler)	Load and instantiate the strategy implementations of the given type from "META-INF/today-strategies.properties", using the configured class loader, the given argument resolver, and custom failure handling provided by the given failure handler.
static <T extends Enumerable<V>, V> T	Enumerable.of(Class<T> enumerable, V value)	Returns Enumerable by enum value
static void	TodayStrategies.setProperty(String key, String value)	Programmatically set a local property, overriding an entry in the TodayStrategies.PROPERTIES_RESOURCE_LOCATION file (if any).

注释类型为Nullable的cn.taketoday.lang中的构造器参数

限定符	构造器	说明
protected	TodayStrategies(ClassLoader classLoader, Map<String,List<String>> strategies)	Create a new TodayStrategies instance.
	Version(int major, int minor, int micro, String type, int step, String extension, String implementationVersion)	创建 Version 记录的实例。

cn.taketoday.reflect中Nullable的使用

注释类型为Nullable的cn.taketoday.reflect中的字段

修饰符和类型	字段	说明
protected final Method	Property.readMethod
protected final Method	Property.writeMethod

注释类型为Nullable的cn.taketoday.reflect中的方法

修饰符和类型	方法	说明
<T extends Annotation> T	Property.getAnnotation(Class<T> annotationClass)
Field	Property.getField()	get or find a Field
MethodParameter	Property.getMethodParameter()	If method based bean-property
default Method	GetterMethod.getReadMethod()
Method	Property.getReadMethod()
Method	Property.getWriteMethod()
default Method	SetterMethod.getWriteMethod()
MethodParameter	Property.getWriteMethodParameter()

注释类型为Nullable的cn.taketoday.reflect中的方法参数

修饰符和类型	方法	说明
static PropertyAccessor	PropertyAccessor.fromField(Field field, Method readMethod, Method writeMethod)
static PropertyAccessor	PropertyAccessor.fromField(Field field, Method readMethod, Method writeMethod)
static PropertyAccessor	PropertyAccessor.fromMethod(GetterMethod readMethod, SetterMethod writeMethod)	use GetterMethod and SetterMethod tech to access property
static PropertyAccessor	PropertyAccessor.fromMethod(Method readMethod, Method writeMethod)	getter setter is exists in a bean or pojo, use fast invoke tech MethodInvoker
static PropertyAccessor	PropertyAccessor.fromMethod(Method readMethod, Method writeMethod)	getter setter is exists in a bean or pojo, use fast invoke tech MethodInvoker
static PropertyAccessor	PropertyAccessor.fromReflective(Field field, Method readMethod, Method writeMethod)	use java reflect Field tech
static PropertyAccessor	PropertyAccessor.fromReflective(Field field, Method readMethod, Method writeMethod)	use java reflect Field tech
static PropertyAccessor	PropertyAccessor.fromReflective(Field field, Method readMethod, Method writeMethod)	use java reflect Field tech

注释类型为Nullable的cn.taketoday.reflect中的构造器参数

限定符	构造器	说明
	Property(Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(String name, Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(String name, Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(String name, Method readMethod, Method writeMethod, Class<?> declaringClass)
	Property(String name, Method readMethod, Method writeMethod, Class<?> declaringClass)

cn.taketoday.util中Nullable的使用

注释类型为Nullable的cn.taketoday.util中的字段

修饰符和类型	字段	说明
protected Class<?>	ReflectiveMethodInvoker.targetClass

注释类型为Nullable的cn.taketoday.util中的方法

修饰符和类型	方法	说明
static Object	SerializationUtils.deserialize(byte[] bytes)	已过时。 This utility uses Java Object Serialization, which allows arbitrary code to be run and is known for being the source of many Remote Code Execution (RCE) vulnerabilities.
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, ConcurrentReferenceHashMap<K,V>.cn.taketoday.util.ConcurrentReferenceHashMap.Task<T> task)	Apply an update operation to this segment.
static Method	ReflectionUtils.findDeclaredMethodWithMinimalParameters(Class<?> clazz, String methodName)	Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses.
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	ReflectiveMethodInvoker.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 Method	ReflectionUtils.findMethodWithMinimalParameters(Class<?> clazz, String methodName)	Find a method with the given method name and minimal parameters (best case: none), declared on the given class or one of its superclasses.
static Method	ReflectionUtils.findMethodWithMinimalParameters(Method[] methods, String methodName)	Find a method with the given method name and minimal parameters (best case: none) in the given list of methods.
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.
static <T> T	CollectionUtils.firstElement(Iterable<T> iterable)	Retrieve the first element of the given Iterable, using SortedSet.first() or otherwise using the iterator.
static <T> T	CollectionUtils.firstElement(List<T> list)	Retrieve the first element of the given List, accessing the zero index.
static <T> T	CollectionUtils.firstElement(T[] array)	Retrieve the first element of the given Array, accessing the zero index.
E[]	ArrayHolder.get()
V	ConcurrentReferenceHashMap.get(Object key)
ConcurrentReferenceHashMap.Entry<K,V>	ConcurrentReferenceHashMap.Reference.get()	Return the referenced entry, or null if the entry is no longer available.
<T extends Annotation> T	AnnotationsAnnotatedElementAdapter.getAnnotation(Class<T> annotationClass)
Charset	MimeType.getCharset()	Return the character set, as indicated by a charset parameter, if any.
static <T> Constructor<T>	ReflectionUtils.getConstructorIfAvailable(Class<T> clazz, Class<?>... paramTypes)	Determine whether the given class has a declared 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 <T> T	CollectionUtils.getElement(List<T> list, int index)	Returns the element at the specified position in this list.
static <T> T	CollectionUtils.getElement(T[] array, int index)	Returns the element at the specified position in this list.
static Class<?>[]	ClassUtils.getGenerics(Class<?> type, Class<?> superClass)	Find generics in target class
static Type[]	ClassUtils.getGenericTypes(Field property)
static Type[]	ClassUtils.getGenericTypes(Parameter parameter)
K	ConcurrentReferenceHashMap.Entry.getKey()
static Method	ReflectionUtils.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)
String	MimeType.getParameter(String name)	Return a generic parameter value, given a parameter name.
static String	ReflectionUtils.getPropertyName(Method readMethod, Method writeMethod)	get property name from readMethod or writeMethod
static ProtectionDomain	ReflectionUtils.getProtectionDomain(Class<?> source)
static Method	ReflectionUtils.getReadMethod(Class<?> declaredClass, Class<?> type, String name)	find getter method
static Method	ReflectionUtils.getReadMethod(Field field)	find getter method
protected final 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	ReflectionUtils.getStaticMethod(Class<?> clazz, String methodName, Class<?>... args)	Return a public static method of a class.
String	MimeType.getSubtypeSuffix()	Return the subtype suffix as defined in RFC 6839.
Class<?>	ReflectiveMethodInvoker.getTargetClass()	Return the target class on which to call the target method.
String	ReflectiveMethodInvoker.getTargetMethod()	Return the name of the method to be invoked.
Object	ReflectiveMethodInvoker.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()
static Method	ReflectionUtils.getWriteMethod(Class<?> declaredClass, Class<?> type, String name)	find setter method
static Method	ReflectionUtils.getWriteMethod(Field field)	find setter method
Object	ReflectiveMethodInvoker.invoke()	Invoke the specified method.
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 <T> Class<T>	ClassUtils.load(String name)	Load class
static <T> Class<T>	ClassUtils.load(String name, ClassLoader classLoader)	Load class with given class name and ClassLoader
<U> U	ArrayHolder.map(Function<? super E[],? extends U> mapper)
<U> U	ArrayHolder.map(Function<? super E[],? extends U> mapper, Supplier<U> emptySupplier)
Map<String,String>	RouteMatcher.matchAndExtract(String pattern, RouteMatcher.Route route)	Match the pattern to the route and extract template variables.
Map<String,String>	SimpleRouteMatcher.matchAndExtract(String pattern, RouteMatcher.Route route)
static ClassLoader	ClassUtils.overrideThreadContextClassLoader(ClassLoader classLoaderToUse)	Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.
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.
V	ConcurrentReferenceHashMap.put(K key, V value)
V	ConcurrentReferenceHashMap.putIfAbsent(K key, V value)
static String	StringUtils.quote(String str)	Quote the given String with single quotes.
static Object	StringUtils.quoteIfString(Object obj)	Turn the given Object into a String with single quotes if it is a String; keeping the Object as-is else.
V	ConcurrentReferenceHashMap.remove(Object key)
V	ConcurrentReferenceHashMap.replace(K key, V value)
String	PlaceholderResolver.resolvePlaceholder(String placeholderName)	Resolve the supplied placeholder name to the replacement value.
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 String	ObjectUtils.toString(Object obj)	Return a String from none-null object's toString.
static String	StringUtils.trimAllWhitespace(String str)	Trim all whitespace from the given String: leading, trailing, and in between characters.
static Object	ObjectUtils.unwrapOptional(Object obj)	Unwrap the given object which is potentially a Optional.

注释类型为Nullable的cn.taketoday.util中的方法参数

修饰符和类型	方法	说明
static Object[]	ClassUtils.adaptArgumentsIfNecessary(Method method, Object[] arguments)	Adapt the given arguments to the target signature in the given method, if necessary: in particular, if a given vararg argument array does not match the array type of the declared vararg parameter in the method.
static void	CollectionUtils.addAll(ArrayHolder c, Object[] elements)
static void	CollectionUtils.addAll(ArrayHolder c, Collection elements)
static void	CollectionUtils.addAll(Collection c, Object[] elements)	Adds all of the specified elements to the specified collection.
static void	CollectionUtils.addAll(Collection c, Collection elements)	Adds all of the specified elements to the specified collection.
static void	CollectionUtils.addAll(Collection c, Enumeration values)	Adds all of the specified elements to the specified collection.
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 <A, O extends A> A[]	ObjectUtils.addObjectToArray(A[] array, O obj, int position)	Add the given object to the given array at the specified position, 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, int position)	Add the given object to the given array at the specified position, 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.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 boolean	CollectionUtils.contains(Iterable<?> iterable, Object element)	Check whether the given Iterable contains the given element.
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 byte[]	FileCopyUtils.copyToByteArray(InputStream in)	Copy the contents of the given InputStream into a new byte array.
static byte[]	FileCopyUtils.copyToByteArray(InputStream in, int bufferSize)	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	FileCopyUtils.copyToString(Reader in)	Copy the contents of the given Reader into a String.
static String	FileCopyUtils.copyToString(Reader in, int bufferSize)	Copy the contents of the given Reader into a String.
static String	StreamUtils.copyToString(InputStream in)	Copy the contents of the given InputStream into a String.
static String	StreamUtils.copyToString(InputStream in, Charset charset)	Copy the contents of the given InputStream into a String.
static String	StreamUtils.copyToString(InputStream in, Charset charset, int bufferSize)	Copy the contents of the given InputStream into a String.
static <K, V> Map<K,V>	CollectionUtils.createApproximateMap(Object map)	Create the most approximate map for the given map.
static <K, V> Map<K,V>	CollectionUtils.createApproximateMap(Object map, int capacity)	Create the most approximate map for the given map.
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.
protected Value	MapCache.createValue(Key key, Param param)
static Class<?>	DefineClassHelper.defineClass(String className, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain, byte[] classFile)	Loads a class file by a given class loader.
static Class<?>	DefineClassHelper.defineClass(String className, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain, byte[] classFile)	Loads a class file by a given class loader.
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)	已过时。 This utility uses Java Object Serialization, which allows arbitrary code to be run and is known for being the source of many Remote Code Execution (RCE) vulnerabilities.
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.
<T> T	ConcurrentReferenceHashMap.Segment.doTask(int hash, Object key, ConcurrentReferenceHashMap<K,V>.cn.taketoday.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	AnnotationsAnnotatedElementAdapter.equals(Object other)
final boolean	ConcurrentReferenceHashMap.Entry.equals(Object other)
boolean	DataSize.equals(Object other)
boolean	MethodClassKey.equals(Object other)
boolean	MimeType.equalsTypeAndSubtype(MimeType other)	Similar to MimeType.equals(Object) but based on the type and subtype only, i.e. ignoring parameters.
static <T> T	CollectionUtils.findValueOfType(Collection<?> collection, Class<T> type)	Find a single value of the given type in the given Collection.
static <T> T	CollectionUtils.firstElement(Iterable<T> iterable)	Retrieve the first element of the given Iterable, using SortedSet.first() or otherwise using the iterator.
static <T> T	CollectionUtils.firstElement(List<T> list)	Retrieve the first element of the given List, accessing the zero index.
static <T> T	CollectionUtils.firstElement(T[] array)	Retrieve the first element of the given Array, accessing the zero index.
static <E> ArrayHolder<E>	ArrayHolder.forClass(Class<E> elementClass)
static <E> ArrayHolder<E>	ArrayHolder.forGenerator(IntFunction<E[]> arrayGenerator)
static String	LogFormatUtils.formatValue(Object value, boolean limitLength)	Convenience variant of LogFormatUtils.formatValue(Object, int, boolean) that limits the length of a log message to 100 characters and also replaces newline and control characters if limitLength is set to "true".
static String	LogFormatUtils.formatValue(Object value, int maxLength, boolean replaceNewlinesAndControlCharacters)	Format the given value via toString(), quoting it if it is a CharSequence, truncating at the specified maxLength, and compacting it into a single line when replaceNewLines is set.
static <T> Class<T>	ClassUtils.forName(String name, ClassLoader classLoader)	Replacement for Class.forName() that also returns Class instances for primitives (e.g.
V	ConcurrentReferenceHashMap.get(Object key)
final Value	MapCache.get(Key key, Function<Key,Value> mappingFunction)	If the specified key is not already associated with a value (or is mapped to null), attempts to compute its value using the given mapping function and enters it into this map unless null.
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 <T> T	CollectionUtils.getElement(List<T> list, int index)	Returns the element at the specified position in this list.
static <T> T	CollectionUtils.getElement(T[] array, int index)	Returns the element at the specified position in this list.
protected int	ConcurrentReferenceHashMap.getHash(Object o)	Get the hash for a given object, apply an additional hash function to reduce collisions.
static Method	ReflectionUtils.getInterfaceMethodIfPossible(Method method, Class<?> targetClass)	Determine a corresponding interface method for the given method handle, if possible.
static Method	ReflectionUtils.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	ReflectionUtils.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	ReflectionUtils.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	ReflectionUtils.getPropertyName(Method readMethod, Method writeMethod)	get property name from readMethod or writeMethod
static String	ReflectionUtils.getPropertyName(Method readMethod, Method writeMethod)	get property name from readMethod or writeMethod
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.
static Method	ReflectionUtils.getReadMethod(Class<?> declaredClass, Class<?> type, String name)	find getter method
protected final 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 Resource[]	ResourceUtils.getResources(String pathPattern, ClassLoader classLoader)	Resolve the given location pattern into Resource objects.
static Method[]	ReflectionUtils.getUniqueDeclaredMethods(Class<?> leafClass, ReflectionUtils.MethodFilter mf)	Get the unique set of declared methods on the leaf class and all superclasses.
static Method	ReflectionUtils.getWriteMethod(Class<?> declaredClass, Class<?> type, String name)	find setter method
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 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 <T> int	SmartList.indexOf(T[] src, T obj, int start, int end)
List<T>	Instantiator.instantiate(ClassLoader classLoader, Collection<String> names)	Instantiate the given set of class name, injecting constructor arguments as necessary.
static boolean	CollectionUtils.isApproximableCollectionType(Class<?> collectionType)	Determine whether the given collection type is an approximable type, i.e. a type that CollectionUtils.createApproximateCollection(java.lang.Object, int) can approximate.
static boolean	CollectionUtils.isApproximableMapType(Class<?> mapType)	Determine whether the given map type is an approximable type, i.e. a type that CollectionUtils.createApproximateMap(java.lang.Object) can approximate.
static boolean	ObjectUtils.isArray(Object obj)	Determine whether the given object is an array: either an Object array or a primitive array.
static boolean	ClassUtils.isAssignableValue(Class<?> type, Object value)	Determine if the given type is assignable from the given value, assuming setting by reflection.
static boolean	ClassUtils.isCacheSafe(Class<?> clazz, ClassLoader classLoader)	Check whether the given class is cache-safe in the given context, i.e. whether it is loaded by the given ClassLoader or a parent of it.
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(ArrayHolder<?> holder)	Return true if the supplied Collection is null or empty.
static boolean	CollectionUtils.isEmpty(Collection<?> collection)	Return true if the supplied Collection is null or empty.
static boolean	CollectionUtils.isEmpty(Map<?,?> map)	Return true if the supplied Map is null or empty.
static boolean	ObjectUtils.isEmpty(Object obj)	Determine whether the given object is empty.
static boolean	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.isFinalizeMethod(Method method)	Determine whether the given method is a "finalize" method.
static boolean	ReflectionUtils.isHashCodeMethod(Method method)	Determine whether the given method is a "hashCode" method.
static boolean	TypeUtils.isNotAssignableBound(Type lhsType, Type rhsType)
static boolean	TypeUtils.isNotAssignableBound(Type lhsType, Type rhsType)
static boolean	CollectionUtils.isNotEmpty(ArrayHolder<?> holder)	Return true if the supplied Collection is not null and empty.
static boolean	CollectionUtils.isNotEmpty(Collection<?> collection)
static boolean	CollectionUtils.isNotEmpty(Map<?,?> map)
static boolean	ObjectUtils.isNotEmpty(Object obj)
static boolean	ObjectUtils.isNotEmpty(Object[] array)
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	ClassUtils.isVisible(Class<?> clazz, ClassLoader classLoader)	Check whether the given class is visible in the given ClassLoader.
static <T> void	CollectionUtils.iterate(Enumeration<T> enumeration, Consumer<T> consumer)
static <T> void	CollectionUtils.iterate(Iterator<T> iterator, Consumer<T> consumer)
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 <T> T	CollectionUtils.lastElement(T[] array)	Retrieve the last element of the given array, accessing the highest index.
<U> U	ArrayHolder.map(Function<? super E[],? extends U> mapper, Supplier<U> emptySupplier)
static boolean	StringUtils.matchesCharacter(String str, int idx, char charToMatch)	Test if the given String matches the given index to single character.
static boolean	StringUtils.matchesFirst(String str, char charToMatch)	Test if the first given String matches the given single character.
static boolean	StringUtils.matchesLast(String str, char charToMatch)	Test if the last given String matches the given single character.
static boolean	ClassUtils.matchesTypeName(Class<?> clazz, String typeName)	Check whether the given class matches the user-specified type name.
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 <E> ArrayList<E>	CollectionUtils.newArrayList(E... elements)
static <E> HashSet<E>	CollectionUtils.newHashSet(E... elements)	Create a hash set
static <E> LinkedHashSet<E>	CollectionUtils.newLinkedHashSet(E... elements)	Instantiate a new LinkedHashSet with an initial elements that can accommodate the specified number of elements without any immediate resize/rehash operations to be expected.
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(short[] 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 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(short[] 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 ClassLoader	ClassUtils.overrideThreadContextClassLoader(ClassLoader classLoaderToUse)	Override the thread context ClassLoader with the environment's bean ClassLoader if necessary, i.e. if the bean ClassLoader is not equivalent to the thread context ClassLoader already.
static 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.
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	PropertyPlaceholderHandler.parseStringValue(String value, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders)
V	ConcurrentReferenceHashMap.put(K key, V value)
V	ConcurrentReferenceHashMap.put(K key, V value)
static void	CollectionUtils.putAll(Map target, Map mappings)	Copies all of the mappings from the specified map to target map (optional operation).
V	ConcurrentReferenceHashMap.putIfAbsent(K key, V value)
V	ConcurrentReferenceHashMap.putIfAbsent(K key, V value)
static String	StringUtils.quote(String str)	Quote the given String with single quotes.
static Object	StringUtils.quoteIfString(Object obj)	Turn the given Object into a String with single quotes if it is a String; keeping the Object as-is else.
V	ConcurrentReferenceHashMap.remove(Object key)
boolean	ConcurrentReferenceHashMap.remove(Object key, Object value)
boolean	ConcurrentReferenceHashMap.remove(Object key, Object value)
V	ConcurrentReferenceHashMap.replace(K key, V value)
V	ConcurrentReferenceHashMap.replace(K key, V value)
boolean	ConcurrentReferenceHashMap.replace(K key, V oldValue, V newValue)
boolean	ConcurrentReferenceHashMap.replace(K key, V oldValue, V newValue)
boolean	ConcurrentReferenceHashMap.replace(K key, V oldValue, V newValue)
static String	StringUtils.replace(String inString, String oldPattern, String newPattern)	Replace all occurrences of a substring within a string with another string.
static <T> Class<T>	ClassUtils.resolveClassName(String className, ClassLoader classLoader)	Resolve the given class name into a Class instance.
static byte[]	SerializationUtils.serialize(Object object)	Serialize the given object to a byte array.
final void	ArrayHolder.set(E... array)
void	ArrayHolder.set(Collection<E> list)
void	ReflectiveMethodInvoker.setStaticMethod(String staticMethod)	Set a fully qualified static method name to invoke, e.g.
void	ReflectiveMethodInvoker.setTargetClass(Class<?> targetClass)	Set the target class on which to call the target method.
void	ReflectiveMethodInvoker.setTargetMethod(String targetMethod)	Set the name of the method to be invoked.
void	ReflectiveMethodInvoker.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	StringUtils.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 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 <A, E extends A> A[]	CollectionUtils.toArray(Enumeration<E> enumeration, A[] array)	Marshal the elements from the given enumeration into an array of the given type.
static <A, E extends A> A[]	CollectionUtils.toArray(Iterator<E> iterator, A[] array)	Marshal the elements from the given iterator into an array of the given type.
static String	ObjectUtils.toHexString(Object obj)
static <E> Iterator<E>	CollectionUtils.toIterator(Enumeration<E> enumeration)	Adapt an Enumeration to an Iterator.
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	ObjectUtils.toString(Object obj)	Return a String from none-null object's toString.
static String[]	StringUtils.toStringArray(Collection<String> collection)	Copy the given Collection into a String array.
static String[]	StringUtils.toStringArray(Enumeration<String> enumeration)	Copy the given Enumeration into a String array.
static String	StringUtils.trimAllWhitespace(String str)	Trim all whitespace from the given String: leading, trailing, and in between characters.
static String	StringUtils.trimLeadingWhitespace(String str)	Trim leading whitespace from the given String.
static void	CollectionUtils.trimToSize(Object list)	Trims the capacity of ArrayList instance to be the list's current size.
static String	StringUtils.trimTrailingWhitespace(String str)	Trim trailing whitespace from the given String.
static String	StringUtils.trimWhitespace(String str)	Trim leading and trailing whitespace from the given String.
static Object	ObjectUtils.unwrapOptional(Object obj)	Unwrap the given object which is potentially a Optional.

注释类型为Nullable的cn.taketoday.util中的构造器参数

限定符	构造器	说明
	AnnotationsAnnotatedElementAdapter(Annotation[] annotations)
	ArrayHolder(Class<E> elementClass, IntFunction<E[]> arrayGenerator)
	ArrayHolder(Class<E> elementClass, IntFunction<E[]> arrayGenerator)
	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.
	MapCache(Map<Key,Value> mapping, Function<Key,Value> mappingFunction)
	MethodClassKey(Method method, Class<?> targetClass)	Create a key object for the given method and target class.
	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.
	PropertyPlaceholderHandler(String placeholderPrefix, String placeholderSuffix, String valueSeparator, boolean ignoreUnresolvablePlaceholders)	Creates a new PropertyPlaceholderHandler that uses the supplied prefix and suffix.

cn.taketoday.util.comparator中Nullable的使用

注释类型为Nullable的cn.taketoday.util.comparator中的方法参数

修饰符和类型	方法	说明
int	NullSafeComparator.compare(T o1, T o2)
int	NullSafeComparator.compare(T o1, T o2)
boolean	BooleanComparator.equals(Object other)
boolean	NullSafeComparator.equals(Object other)

cn.taketoday.util.concurrent中Nullable的使用

注释类型为Nullable的cn.taketoday.util.concurrent中的方法

修饰符和类型	方法	说明
protected abstract T	FutureAdapter.adapt(S adapteeResult)	Adapts the given adaptee's result into T.
T	FutureAdapter.get()
T	FutureAdapter.get(long timeout, TimeUnit unit)
T	SettableListenableFuture.get()	Retrieve the value.
T	SettableListenableFuture.get(long timeout, TimeUnit unit)	Retrieve the value.

注释类型为Nullable的cn.taketoday.util.concurrent中的方法参数

修饰符和类型	方法	说明
void	SuccessCallback.onSuccess(T result)	Called when the ListenableFuture completes with success.
boolean	SettableListenableFuture.set(T value)	Set the value of this future.
void	ListenableFutureCallbackRegistry.success(T result)	Trigger a SuccessCallback.onSuccess(Object) call on all added callbacks with the given result.

注释类型为Nullable的cn.taketoday.util.concurrent中的构造器参数

限定符	构造器	说明
	ListenableFutureTask(Runnable runnable, T result)	Create a ListenableFutureTask that will, upon running, execute the given Runnable, and arrange that FutureTask.get() will return the given result on successful completion.

cn.taketoday.util.function中Nullable的使用

注释类型为Nullable的cn.taketoday.util.function中的方法

修饰符和类型	方法	说明
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.

注释类型为Nullable的cn.taketoday.util.function中的方法参数

修饰符和类型	方法	说明
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.

注释类型为Nullable的cn.taketoday.util.function中的构造器参数

限定符	构造器	说明
	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.

cn.taketoday.util.xml中Nullable的使用

注释类型为Nullable的cn.taketoday.util.xml中的方法

修饰符和类型	方法	说明
static Element	DomUtils.getChildElementByTagName(Element ele, String childEleName)	Utility method that returns the first child element identified by its name.
static String	DomUtils.getChildElementValueByTagName(Element ele, String childEleName)	Utility method that returns the first child element value identified by its name.
String	SimpleNamespaceContext.getPrefix(String namespaceUri)
static XMLEventReader	StaxUtils.getXMLEventReader(Source source)	Return the XMLEventReader for the given StAX Source.
static XMLEventWriter	StaxUtils.getXMLEventWriter(Result result)	Return the XMLEventWriter for the given StAX Result.
static XMLStreamReader	StaxUtils.getXMLStreamReader(Source source)	Return the XMLStreamReader for the given StAX Source.
static XMLStreamWriter	StaxUtils.getXMLStreamWriter(Result result)	Return the XMLStreamWriter for the given StAX Result.

注释类型为Nullable的cn.taketoday.util.xml中的方法参数

修饰符和类型	方法	说明
void	SimpleNamespaceContext.removeBinding(String prefix)	Remove the given prefix from this context.