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

使用Nullable的程序包

程序包	说明
cn.taketoday.aot.generate	Support classes for components that contribute generated code equivalent to a runtime behavior.
cn.taketoday.aot.hint	Support for registering the need for reflection, resources, java serialization and proxies at runtime.
cn.taketoday.aot.hint.predicate	Predicate support for runtime hints.
cn.taketoday.aot.hint.support	Convenience classes for using runtime hints.
cn.taketoday.aot.nativex	Support for generating GraalVM native configuration from runtime hints.
cn.taketoday.bytecode	CGLIB or ASM other byte code library
cn.taketoday.bytecode.commons
cn.taketoday.bytecode.core
cn.taketoday.bytecode.proxy
cn.taketoday.bytecode.tree
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.ssl	Management of trust material that can be used to establish an SSL connection.
cn.taketoday.core.ssl.jks	SSL trust material provider for Java KeyStores.
cn.taketoday.core.ssl.pem	SSL trust material provider for PEM-encoded certificates.
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.logging	Logging System Adapter
cn.taketoday.reflect	Optimised Reflection System
cn.taketoday.util	Miscellaneous utility classes, such as utilities for working with strings, classes, collections, reflection, etc.
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.
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.aot.generate中Nullable的使用

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

修饰符和类型	字段	说明
private final cn.taketoday.javapoet.ClassName	DefaultMethodReference.declaringClass
private final GeneratedClass	GeneratedClass.enclosingClass
private final cn.taketoday.javapoet.ClassName	GeneratedClasses.Owner.target	target 记录组件的字段。

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

修饰符和类型	方法	说明
cn.taketoday.javapoet.CodeBlock	MethodReference.ArgumentCodeGenerator.generateCode(cn.taketoday.javapoet.TypeName argumentType)	Generate the code for the given argument type.
GeneratedClass	GeneratedClass.getEnclosingClass()	Return the enclosing GeneratedClass or null if this instance represents a top-level class.
InputStreamSource	InMemoryGeneratedFiles.getGeneratedFile(GeneratedFiles.Kind kind, String path)	Return the InputStreamSource of specified file.
String	InMemoryGeneratedFiles.getGeneratedFileContent(GeneratedFiles.Kind kind, String path)	Return the content of the specified file.
private static GeneratedTypeReference	GeneratedTypeReference.safeCreate(cn.taketoday.javapoet.ClassName className)
cn.taketoday.javapoet.ClassName	GeneratedClasses.Owner.target()	返回 target 记录组件的值。

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

修饰符和类型	方法	说明
private static String	MethodName.clean(String part)
private GeneratedClass	GeneratedClasses.createAndAddGeneratedClass(String featureName, cn.taketoday.javapoet.ClassName targetComponent, Consumer<cn.taketoday.javapoet.TypeSpec.Builder> type)
boolean	MethodName.equals(Object obj)
cn.taketoday.javapoet.ClassName	ClassNameGenerator.generateClassName(String featureName, cn.taketoday.javapoet.ClassName target)	Generate a unique ClassName based on the specified featureName and target.
private String	ClassNameGenerator.getRootName(String featureName, cn.taketoday.javapoet.ClassName target)
private static GeneratedTypeReference	GeneratedTypeReference.safeCreate(cn.taketoday.javapoet.ClassName className)
cn.taketoday.javapoet.CodeBlock	DefaultMethodReference.toInvokeCodeBlock(MethodReference.ArgumentCodeGenerator argumentCodeGenerator, cn.taketoday.javapoet.ClassName targetClassName)
cn.taketoday.javapoet.CodeBlock	MethodReference.toInvokeCodeBlock(MethodReference.ArgumentCodeGenerator argumentCodeGenerator, cn.taketoday.javapoet.ClassName targetClassName)	Return this method reference as a CodeBlock using the specified MethodReference.ArgumentCodeGenerator.

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

限定符	构造器	说明
	DefaultMethodReference(cn.taketoday.javapoet.MethodSpec method, cn.taketoday.javapoet.ClassName declaringClass)
private	GeneratedClass(GeneratedClass enclosingClass, cn.taketoday.javapoet.ClassName name, Consumer<cn.taketoday.javapoet.TypeSpec.Builder> type)
private	Owner(String featureNamePrefix, String featureName, cn.taketoday.javapoet.ClassName target)	创建 Owner 记录的实例。

cn.taketoday.aot.hint中Nullable的使用

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

修饰符和类型	字段	说明
private String	SimpleTypeReference.canonicalName
private final TypeReference	AbstractTypeReference.enclosingType
private ExecutableMode	ExecutableHint.Builder.mode
private TypeReference	JavaSerializationHint.Builder.reachableType
private final TypeReference	JavaSerializationHint.reachableType
private TypeReference	JdkProxyHint.Builder.reachableType
private final TypeReference	JdkProxyHint.reachableType
private TypeReference	ResourceBundleHint.Builder.reachableType
private final TypeReference	ResourceBundleHint.reachableType
private final TypeReference	ResourcePatternHint.reachableType
private TypeReference	TypeHint.Builder.reachableType
private final TypeReference	TypeHint.reachableType

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

修饰符和类型	方法	说明
private static TypeReference	ReflectionTypeReference.getEnclosingClass(Class<?> type)
TypeReference	AbstractTypeReference.getEnclosingType()
TypeReference	TypeReference.getEnclosingType()	Return the enclosing type reference, or null if this type reference does not have an enclosing type.
TypeReference	ConditionalHint.getReachableType()	Return the type that should be reachable for this hint to apply, or null if this hint should always been applied.
TypeReference	JavaSerializationHint.getReachableType()
TypeReference	JdkProxyHint.getReachableType()
TypeReference	ResourceBundleHint.getReachableType()
TypeReference	ResourcePatternHint.getReachableType()
TypeReference	TypeHint.getReachableType()
TypeHint	ReflectionHints.getTypeHint(TypeReference type)	Return the reflection hints for the type defined by the specified TypeReference.
TypeHint	ReflectionHints.getTypeHint(Class<?> type)	Return the reflection hints for the specified type.

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

修饰符和类型	方法	说明
private static void	SimpleTypeReference.buildName(TypeReference type, StringBuilder sb)
boolean	AbstractTypeReference.equals(Object other)
boolean	JavaSerializationHint.equals(Object o)
boolean	JdkProxyHint.equals(Object o)
boolean	ResourceBundleHint.equals(Object o)
boolean	ResourcePatternHint.equals(Object o)
boolean	TypeHint.ExecutableKey.equals(Object o)
(专用程序包) boolean	ExecutableMode.includes(ExecutableMode other)	Specify if this mode already includes the specified other mode.
ResourcePatternHints.Builder	ResourcePatternHints.Builder.includes(TypeReference reachableType, String... includes)	Include resources matching the specified patterns.
void	RuntimeHintsRegistrar.registerHints(RuntimeHints hints, ClassLoader classLoader)	Contribute hints to the given RuntimeHints instance.
ResourceHints	ResourceHints.registerPattern(Consumer<ResourcePatternHints.Builder> resourceHint)	Register that the resources matching the specified pattern should be made available at runtime.
ResourceHints	ResourceHints.registerPatternIfPresent(ClassLoader classLoader, String location, Consumer<ResourcePatternHints.Builder> resourceHint)	Register a pattern if the given location is available on the classpath.
private void	BindingReflectionHintsRegistrar.registerPropertyHints(ReflectionHints hints, Set<Type> seen, Method method, int parameterIndex)
ResourceHints	ResourceHints.registerResourceBundle(String baseName, Consumer<ResourceBundleHint.Builder> resourceHint)	Register that the resource bundle with the specified base name should be made available at runtime.
SerializationHints	SerializationHints.registerType(TypeReference type, Consumer<JavaSerializationHint.Builder> serializationHint)	Register that the type defined by the specified TypeReference need to be serialized using java serialization.
SerializationHints	SerializationHints.registerType(Class<? extends Serializable> type, Consumer<JavaSerializationHint.Builder> serializationHint)	Register that the specified type need to be serialized using java serialization.
ReflectionHints	ReflectionHints.registerTypeIfPresent(ClassLoader classLoader, String typeName, MemberCategory... memberCategories)	Register or customize reflection hints for the specified type if it is available using the specified ClassLoader.
ReflectionHints	ReflectionHints.registerTypeIfPresent(ClassLoader classLoader, String typeName, Consumer<TypeHint.Builder> typeHint)	Register or customize reflection hints for the specified type if it is available using the specified ClassLoader.

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

限定符	构造器	说明
protected	AbstractTypeReference(String packageName, String simpleName, TypeReference enclosingType)
(专用程序包)	ResourcePatternHint(String pattern, TypeReference reachableType)
(专用程序包)	SimpleTypeReference(String packageName, String simpleName, TypeReference enclosingType)

cn.taketoday.aot.hint.predicate中Nullable的使用

注释类型为Nullable的cn.taketoday.aot.hint.predicate中的方法

修饰符和类型	方法	说明
private TypeHint	ReflectionHintsPredicates.TypeHintPredicate.getTypeHint(RuntimeHints hints)

cn.taketoday.aot.hint.support中Nullable的使用

注释类型为Nullable的cn.taketoday.aot.hint.support中的方法

修饰符和类型	方法	说明
private Class<?>	TodayStrategiesRuntimeHints.resolveClassName(ClassLoader classLoader, String factoryClassName)

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

修饰符和类型	方法	说明
void	FilePatternResourceHintsRegistrar.Builder.registerHints(ResourceHints hints, ClassLoader classLoader)	Register resource hints for the current state of this builder.
void	FilePatternResourceHintsRegistrar.registerHints(ResourceHints hints, ClassLoader classLoader)
void	ObjectToObjectConverterRuntimeHints.registerHints(RuntimeHints hints, ClassLoader classLoader)

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

限定符	构造器	说明
(专用程序包)	ExtendedTodayStrategies(ClassLoader classLoader, Map<String,List<String>> factories)

cn.taketoday.aot.nativex中Nullable的使用

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

修饰符和类型	字段	说明
private final String	FileNativeConfigurationWriter.artifactId
private final String	FileNativeConfigurationWriter.groupId

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

修饰符和类型	方法	说明
private static void	ReflectionHintsWriter.addIfNotEmpty(Map<String,Object> attributes, String name, Object value)
private static void	ResourceHintsWriter.addIfNotEmpty(Map<String,Object> attributes, String name, Object value)

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

限定符	构造器	说明
	FileNativeConfigurationWriter(Path basePath, String groupId, String artifactId)
	FileNativeConfigurationWriter(Path basePath, String groupId, String artifactId)

cn.taketoday.bytecode中Nullable的使用

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

修饰符和类型	字段	说明
private final ClassLoader	ClassWriter.classLoader	the ClassLoader to be used by the default implementation of ClassWriter.getCommonSuperClass(String, String), that of this ClassWriter's runtime type by default.

注释类型为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)
	ChildClassLoader(ClassLoader classLoader)
	ClassWriter(int flags, ClassLoader classLoader)	Constructs a new ClassWriter object.
	ClassWriter(ClassReader classReader, int flags, ClassLoader classLoader)	Constructs a new ClassWriter object and enables optimizations for "mostly add" bytecode transformations.

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中的字段

修饰符和类型	字段	说明
private ArrayList<CodeFlow.ClinitAdder>	CodeFlow.clinitAdders	As SpEL ast nodes are called to generate code for the main evaluation method they can register to add code to a static initializer in the class.
private DefineClassStrategy	AbstractClassGenerator.defineClassStrategy
private ArrayList<CodeFlow.FieldAdder>	CodeFlow.fieldAdders	As SpEL ast nodes are called to generate code for the main evaluation method they can register to add a field to this class.

注释类型为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)
AbstractClassGenerator	AbstractClassGenerator.setNamingPolicy(NamingPolicy namingPolicy)	Override the default naming policy.
static String	CodeFlow.toDescriptorFromObject(Object value)	Determine the descriptor for an object instance (or null).

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

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

修饰符和类型	字段	说明
private final WeakCacheKey<CallbackFilter>	Enhancer.EnhancerKey.filter	filter 记录组件的字段。
private final List<String>	Enhancer.EnhancerKey.interfaces	interfaces 记录组件的字段。
private Class<?>[]	Enhancer.interfaces
private MethodSignature	MethodProxy.sig1
private MethodSignature	MethodProxy.sig2
private final String	Enhancer.EnhancerKey.type	type 记录组件的字段。

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

修饰符和类型	方法	说明
WeakCacheKey<CallbackFilter>	Enhancer.EnhancerKey.filter()	返回 filter 记录组件的值。
Object	MethodInterceptor.intercept(Object obj, Method method, Object[] args, MethodProxy proxy)	All generated proxied methods call this method instead of the original method.
List<String>	Enhancer.EnhancerKey.interfaces()	返回 interfaces 记录组件的值。
Object	Dispatcher.loadObject()	Return the object which the original method invocation should be dispatched.
String	Enhancer.EnhancerKey.type()	返回 type 记录组件的值。

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

修饰符和类型	方法	说明
private static void	Enhancer.getMethods(Class<?> superclass, Class<?>[] interfaces, List<Method> methods, List<Method> interfaceMethods)
private static void	Enhancer.getMethods(Class<?> superclass, Class<?>[] interfaces, List<Method> methods, List<Method> interfaceMethods)
void	Enhancer.setInterfaces(Class<?>... interfaces)	Set the interfaces to implement.
void	Enhancer.setSerialVersionUID(Long sUID)	Insert a static serialVersionUID field into the generated class.

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

限定符	构造器	说明
private	EnhancerKey(String type, List<String> interfaces, WeakCacheKey<CallbackFilter> filter, List<Type> callbackTypes, boolean useFactory, boolean interceptDuringConstruction, Long serialVersionUID)	创建 EnhancerKey 记录的实例。
private	EnhancerKey(String type, List<String> interfaces, WeakCacheKey<CallbackFilter> filter, List<Type> callbackTypes, boolean useFactory, boolean interceptDuringConstruction, Long serialVersionUID)	创建 EnhancerKey 记录的实例。
private	EnhancerKey(String type, List<String> interfaces, WeakCacheKey<CallbackFilter> filter, List<Type> callbackTypes, boolean useFactory, boolean interceptDuringConstruction, Long serialVersionUID)	创建 EnhancerKey 记录的实例。

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

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

修饰符和类型	方法	说明
private static void	TryCatchBlockNode.doAccept(MethodVisitor methodVisitor, List<TypeAnnotationNode> typeAnnotations, boolean visible)

cn.taketoday.core中Nullable的使用

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

修饰符和类型	字段	说明
private final AnnotatedElement	TypeDescriptor.AnnotatedElementAdapter.annotated
private Annotation[]	TypeDescriptor.AnnotatedElementAdapter.annotations
protected Map<String,Object>	AttributeAccessorSupport.attributes	Map with String keys and Object values.
private Boolean	AntPathMatcher.cachePatterns
private final ClassLoader	ConfigurableObjectInputStream.classLoader
private Annotation[]	MethodParameter.FieldAwareConstructorParameter.combinedAnnotations
private final ResolvableType	ResolvableType.componentType	The component type for an array or null if the type should be deduced.
private Class<?>	MethodParameter.containingClass	The containing class.
private final Supplier<?>	ReactiveTypeDescriptor.emptySupplier
final A	Pair.first
final A	Triple.first
private Type	MethodParameter.genericParameterType
private ResolvableType[]	ResolvableType.generics
private final Integer	ResolvableType.hash
private static final String	NativeDetector.imageCode
private ResolvableType[]	ResolvableType.interfaces
private final String	SerializableTypeWrapper.MethodParameterTypeProvider.methodName
private final String	SerializableTypeWrapper.ParameterTypeProvider.methodName
private MethodParameter	MethodParameter.nestedMethodParameter
protected Integer	OrderedSupport.order
private final ClassLoader	OverridingClassLoader.overrideDelegate
private Parameter	MethodParameter.parameter
private Annotation[]	MethodParameter.parameterAnnotations
(专用程序包) String	MethodParameter.parameterName
private ParameterNameDiscoverer	MethodParameter.parameterNameDiscoverer
private Class<?>	MethodParameter.parameterType
private final Class<?>[]	ConstructorNotFoundException.parameterTypes
private Path	ApplicationTemp.path
private final String	ApplicationPid.pid
private Class<?>	ResolvableType.resolved
private Object	SerializableTypeWrapper.MethodInvokeTypeProvider.result
final B	Pair.second
final B	Triple.second
private static ReactiveAdapterRegistry	ReactiveAdapterRegistry.sharedInstance
private final Class<?>	ApplicationTemp.sourceClass
private ResolvableType	ResolvableType.superType
final C	Triple.third
(专用程序包) Map<Integer,Integer>	MethodParameter.typeIndexesPerLevel	Map from Integer level to Integer type index.
private final SerializableTypeWrapper.TypeProvider	ResolvableType.typeProvider	Optional provider for the type.
private Boolean	ResolvableType.unresolvableGenerics
private final ResolvableType.VariableResolver	ResolvableType.variableResolver	The VariableResolver to use or null if no resolver is available.

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

修饰符和类型	方法	说明
static TypeDescriptor	TypeDescriptor.array(TypeDescriptor elementDescriptor)	Create a new type descriptor as an array of the specified type.
(专用程序包) ResolvableType.VariableResolver	ResolvableType.asVariableResolver()	Adapts this ResolvableType to a ResolvableType.VariableResolver.
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)
private static Method	BridgeMethodResolver.findGenericDeclaration(Method bridgeMethod)	Searches for the generic Method declaration whose erased signature matches that of the supplied bridge method.
protected Integer	OrderComparator.findOrder(Object obj)	Find an order value indicated by the given object.
static String[]	ParameterNameDiscoverer.findParameterNames(Executable executable)	Return parameter names for an Executable(method or constructor), or null if they cannot be determined.
private File	ApplicationHome.findSource(Class<?> sourceClass)
static Type	SerializableTypeWrapper.forField(Field field)	Return a Serializable variant of Field.getGenericType().
static Type	SerializableTypeWrapper.forMethodParameter(MethodParameter methodParameter)	Return a Serializable variant of MethodParameter.getGenericParameterType().
static TypeDescriptor	TypeDescriptor.forObject(Object source)	Create a new type descriptor for an object.
(专用程序包) static Type	SerializableTypeWrapper.forTypeProvider(SerializableTypeWrapper.TypeProvider provider)	Return a Serializable Type backed by a SerializableTypeWrapper.TypeProvider .
static ResolvableType.WildcardBounds	ResolvableType.WildcardBounds.get(ResolvableType type)	Get a ResolvableType.WildcardBounds instance for the specified type, returning null if the specified type cannot be resolved to a WildcardType.
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	MethodParameter.getAnnotation(Class<T> annotationClass)
<T extends Annotation> T	TypeDescriptor.AnnotatedElementAdapter.getAnnotation(Class<T> annotationClass)
<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.
final A	Pair.getFirst()
static <T> T	Pair.getFirst(Pair<T,?> pair)
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.
Type	ResolvableType.SyntheticParameterizedType.getOwnerType()
<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()
private String	ApplicationPid.getPid()
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.
private static TypeDescriptor	TypeDescriptor.getRelatedIfResolvable(TypeDescriptor source, ResolvableType type)
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.
final B	Pair.getSecond()
static <T> T	Pair.getSecond(Pair<?,T> pair)
private static <T> Class<T>	GenericTypeResolver.getSingleGeneric(ResolvableType resolvableType)
File	ApplicationHome.getSource()	Returns the underlying source used to find the home directory.
default Object	SerializableTypeWrapper.TypeProvider.getSource()	Return the source of the type, or null if not known.
private Class<?>	ApplicationHome.getStartClass()
private Class<?>	ApplicationHome.getStartClass(Enumeration<URL> manifestResources)
Type	SerializableTypeWrapper.TypeProvider.getType()	Return the (possibly non Serializable) Type.
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.
Object	SerializableTypeWrapper.TypeProxyInvocationHandler.invoke(Object proxy, Method method, Object[] args)
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.
private TypeDescriptor	TypeDescriptor.narrow(Object value, TypeDescriptor typeDescriptor)
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)
static TypeDescriptor	TypeDescriptor.nested(Field field, int nestingLevel)	Create a type descriptor for a nested type declared within the field.
protected InputStream	OverridingClassLoader.openStreamForClass(String name)	Open an InputStream for the specified class.
Object	AttributeAccessor.removeAttribute(String name)	Remove the attribute identified by name and return its value.
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.
private Type	ResolvableType.resolveBounds(Type[] bounds)
private Class<?>	ResolvableType.resolveClass()
Class<?>	ResolvableType.resolveGeneric(int... indexes)	Convenience method that will get and resolve a specific generic parameters.
static Class<?>	GenericTypeResolver.resolveReturnTypeArgument(Method method, Class<?> genericIfc)	Resolve the single type argument of the given generic interface against the given target method which is assumed to return the given interface or an implementation of it.
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.DefaultVariableResolver.resolveVariable(TypeVariable<?> variable)
private ResolvableType	ResolvableType.resolveVariable(TypeVariable<?> variable)
ResolvableType	ResolvableType.VariableResolver.resolveVariable(TypeVariable<?> variable)	Resolve the specified variable.
private static Method	BridgeMethodResolver.searchCandidates(ArrayList<Method> candidateMethods, Method bridgeMethod)	Searches for the bridged method in the given candidates.
private static Method	BridgeMethodResolver.searchForMatch(Class<?> type, Method bridgeMethod)	If the supplied Class has a declared Method whose signature matches that of the supplied Method, then this matching Method is returned, otherwise null is returned.
private static Method	BridgeMethodResolver.searchInterfaces(Class<?>[] interfaces, Method bridgeMethod)
TypeDescriptor	TypeDescriptor.upcast(Class<?> superType)	Cast this TypeDescriptor to a superclass or implemented interface preserving annotations and nested type context.
MethodVisitor	LocalVariableTableParameterNameDiscoverer.ParameterNameDiscoveringVisitor.visitMethod(int access, String name, String desc, String signature, String[] exceptions)

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

修饰符和类型	方法	说明
void	CompositeParameterNameDiscoverer.addDiscoverer(ParameterNameDiscoverer... discoverer)	add ParameterNameDiscoverer
static TypeDescriptor	TypeDescriptor.array(TypeDescriptor elementDescriptor)	Create a new type descriptor as an array of the specified type.
private void	YamlProcessor.buildFlattenedMap(Map<String,Object> result, Map<String,Object> source, String path)
static TypeDescriptor	TypeDescriptor.collection(Class<?> collectionType, TypeDescriptor elementDescriptor)	Create a new type descriptor from a Collection type.
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.
Path	ApplicationTemp.createFile(String subDir, String prefix)	Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
Path	ApplicationTemp.createFile(String subDir, String prefix, String suffix)	Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
Path	ApplicationTemp.createFile(String subDir, String prefix, String suffix)	Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
Path	ApplicationTemp.createFile(String subDir, String prefix, String suffix)	Creates a new empty file in the specified directory, using the given prefix and suffix strings to generate its name.
private int	OrderComparator.doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)
private int	OrderComparator.doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)
private int	OrderComparator.doCompare(Object o1, Object o2, OrderSourceProvider sourceProvider)
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	ReactiveTypeDescriptor.equals(Object other)
boolean	TypeDescriptor.AnnotatedElementAdapter.equals(Object obj)
protected Integer	OrderComparator.findOrder(Object obj)	Find an order value indicated by the given object.
static String[]	ParameterNameDiscoverer.findParameterNames(Executable executable)	Return parameter names for an Executable(method or constructor), or null if they cannot be determined.
private File	ApplicationHome.findSource(Class<?> sourceClass)
static ResolvableType	ResolvableType.forClass(Class<?> clazz)	Return a ResolvableType for the specified Class, using the full generic type information for assignability checks.
static ResolvableType	ResolvableType.forField(Field field, int nestingLevel, Class<?> implementationClass)	Return a ResolvableType for the specified Field with a given implementation and the given nesting level.
static ResolvableType	ResolvableType.forField(Field field, ResolvableType implementationType)	Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	ResolvableType.forInstance(Object instance)	Return a ResolvableType for the specified instance.
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 TypeDescriptor	TypeDescriptor.forObject(Object source)	Create a new type descriptor for an object.
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.forParameter(Parameter parameter, ResolvableType implementationType)	Return a ResolvableType for the specified Parameter with a given implementation type.
static ResolvableType	ResolvableType.forParameter(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.forRawClass(Class<?> clazz)	Return a ResolvableType for the specified Class, doing assignability checks against the raw class only (analogous to Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for.
static ResolvableType	ResolvableType.forReturnType(Method method, Class<?> implementationClass)	Return a ResolvableType for the specified Method return type.
static ResolvableType	ResolvableType.forType(Type type)	Return a ResolvableType for the specified Type.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType owner)	Return a ResolvableType for the specified Type backed by the given owner type.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType owner)	Return a ResolvableType for the specified Type backed by the given owner type.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.forType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.forType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
static ResolvableType	ResolvableType.forType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Return a ResolvableType for the specified Type backed by a given ResolvableType.VariableResolver.
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.
Path	ApplicationTemp.getDir(String subDir)	Return a sub-directory of the application temp.
static <T> T	Pair.getFirst(Pair<T,?> pair)
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.
private int	OrderComparator.getOrder(Object obj, OrderSourceProvider sourceProvider)	Determine the order value for the given object.
private int	OrderComparator.getOrder(Object obj, OrderSourceProvider sourceProvider)	Determine the order value for the given object.
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.
private static String	Constants.getPrefixToUse(String namePrefix)
static <T> T	Pair.getSecond(Pair<?,T> pair)
private static String	ApplicationTemp.getTempSubDir(Class<?> sourceClass)
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.
private boolean	ResolvableType.isAssignableFrom(ResolvableType other, Map<Type,Type> matchedBefore)
boolean	ResolvableType.isInstance(Object obj)	Determine whether the given object is an instance of this ResolvableType.
private boolean	TypeDescriptor.isNestedAssignable(TypeDescriptor nestedTypeDescriptor, TypeDescriptor otherNestedTypeDescriptor)
private boolean	TypeDescriptor.isNestedAssignable(TypeDescriptor nestedTypeDescriptor, TypeDescriptor otherNestedTypeDescriptor)
static TypeDescriptor	TypeDescriptor.map(Class<?> mapType, TypeDescriptor keyDescriptor, TypeDescriptor valueDescriptor)	Create a new type descriptor from a Map type.
static TypeDescriptor	TypeDescriptor.map(Class<?> mapType, TypeDescriptor keyDescriptor, TypeDescriptor valueDescriptor)	Create a new type descriptor from a Map type.
boolean	AntPathMatcher.AntPathStringMatcher.matchStrings(String str, Map<String,String> uriTemplateVariables)	Main entry point.
private boolean	AntPathMatcher.matchStrings(String pattern, String str, Map<String,String> uriTemplateVariables)	Test whether or not a string matches against a pattern.
TypeDescriptor	TypeDescriptor.narrow(Object value)	Narrows this TypeDescriptor by setting its type to the class of the provided value.
private TypeDescriptor	TypeDescriptor.narrow(Object value, TypeDescriptor typeDescriptor)
private TypeDescriptor	TypeDescriptor.narrow(Object value, TypeDescriptor typeDescriptor)
private MethodParameter	MethodParameter.nested(int nestingLevel, Integer typeIndex)
MethodParameter	MethodParameter.nested(Integer typeIndex)	Return a variant of this MethodParameter which points to the same parameter but one nesting level deeper.
static <A, B> Pair<A,B>	Pair.of(A first, B second)
static <A, B> Pair<A,B>	Pair.of(A first, B second)
static <A, B, C> Triple<A,B,C>	Triple.of(A first, B second, C third)
static <A, B, C> Triple<A,B,C>	Triple.of(A first, B second, C third)
static <A, B, C> Triple<A,B,C>	Triple.of(A first, B second, C third)
default Class<?>	SmartClassLoader.publicDefineClass(String name, byte[] b, ProtectionDomain protectionDomain)	Define a custom class (typically a CGLIB proxy class) in this class loader.
static Type	GenericTypeResolver.resolveType(Type genericType, Class<?> contextClass)	Resolve the given generic type against the given context class, substituting type variables as far as possible.
void	AttributeAccessor.setAttribute(String name, Object value)	Set the attribute defined by name to the supplied value.
void	AttributeAccessorSupport.setAttribute(String name, Object value)
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.
<T> org.reactivestreams.Publisher<T>	ReactiveAdapterRegistry.ReactorAdapter.toPublisher(Object source)
TypeDescriptor	TypeDescriptor.upcast(Class<?> superType)	Cast this TypeDescriptor to a superclass or implemented interface preserving annotations and nested type context.
static TypeDescriptor	TypeDescriptor.valueOf(Class<?> type)	Create a new type descriptor from the given type.
MethodParameter	MethodParameter.withContainingClass(Class<?> containingClass)	Return a variant of this MethodParameter which refers to the given containing class.
Pair<A,B>	Pair.withFirst(A first)
Triple<A,B,C>	Triple.withFirst(A first)
Pair<A,B>	Pair.withSecond(B second)
Triple<A,B,C>	Triple.withSecond(B second)
Triple<A,B,C>	Triple.withThird(C third)

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

限定符	构造器	说明
	AnnotatedElementAdapter(Annotation[] annotations, AnnotatedElement annotated)
	AnnotatedElementAdapter(Annotation[] annotations, AnnotatedElement annotated)
	ApplicationHome(Class<?> sourceClass)	Create a new ApplicationHome instance for the specified source class.
	ApplicationTemp(Class<?> sourceClass)	Create a new ApplicationTemp instance for the specified source class.
	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.
(专用程序包)	MethodParameter(Executable executable, int parameterIndex, Class<?> containingClass)	Internal constructor used to create a MethodParameter with a containing class already set.
	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.
	Pair(A first, B second)
	Pair(A first, B second)
private	ReactiveTypeDescriptor(Class<?> reactiveType, boolean multiValue, boolean noValue, Supplier<?> emptySupplier)
private	ReactiveTypeDescriptor(Class<?> reactiveType, boolean multiValue, boolean noValue, Supplier<?> emptySupplier, boolean deferred)
private	ResolvableType(Class<?> clazz)	Private constructor used to create a new ResolvableType on a Class basis.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Private constructor used to create a new ResolvableType for cache key purposes, with no upfront resolution.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver)	Private constructor used to create a new ResolvableType for cache key purposes, with no upfront resolution.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, ResolvableType componentType)	Private constructor used to create a new ResolvableType for uncached purposes, with upfront resolution but lazily calculated hash.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, ResolvableType componentType)	Private constructor used to create a new ResolvableType for uncached purposes, with upfront resolution but lazily calculated hash.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, ResolvableType componentType)	Private constructor used to create a new ResolvableType for uncached purposes, with upfront resolution but lazily calculated hash.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, Integer hash)	Private constructor used to create a new ResolvableType for cache value purposes, with upfront resolution and a pre-calculated hash.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, Integer hash)	Private constructor used to create a new ResolvableType for cache value purposes, with upfront resolution and a pre-calculated hash.
private	ResolvableType(Type type, SerializableTypeWrapper.TypeProvider typeProvider, ResolvableType.VariableResolver variableResolver, Integer hash)	Private constructor used to create a new ResolvableType for cache value purposes, with upfront resolution and a pre-calculated hash.
	Triple(A first, B second, C third)
	Triple(A first, B second, C third)
	Triple(A first, B second, C third)
	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.
	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中的字段

修饰符和类型	字段	说明
private List<TypeMappedAnnotations.Aggregate>	TypeMappedAnnotations.aggregates
final Annotation	AnnotationTypeMapping.annotation	Get the source annotation for this mapping.
private final Annotation[]	TypeMappedAnnotations.annotations
private final Class<? extends Annotation>	AnnotationAttributes.annotationType
private final Class<? extends Annotation>	AttributeMethods.annotationType
private final Predicate<String>	TypeMappedAnnotation.attributeFilter
private final ClassLoader	TypeMappedAnnotation.classLoader
private final AnnotatedElement	TypeMappedAnnotations.element
private Integer	SynthesizedMergedAnnotationInvocationHandler.hash
private Object	MergedAnnotationPredicates.FirstRunOfPredicate.lastValue
private static Logger	IntrospectionFailureLogger.logger
private int[]	TypeMappedAnnotations.AggregatesSpliterator.mappingCursors
private final RepeatableContainers	RepeatableContainers.parent
private final Predicate<? super MergedAnnotation<A>>	TypeMappedAnnotations.MergedAnnotationFinder.predicate
private final Object	MergedAnnotationsCollection.AnnotationsSpliterator.requiredType
private final Object	TypeMappedAnnotations.AggregatesSpliterator.requiredType
private MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.result
private final Object	TypeMappedAnnotation.rootAttributes
private final MergedAnnotations.SearchStrategy	TypeMappedAnnotations.searchStrategy
final AnnotationTypeMapping	AnnotationTypeMapping.source	Get the source of the mapping or null.
private final Object	TypeMappedAnnotation.source
private final Object	TypeMappedAnnotations.Aggregate.source
private final Object	TypeMappedAnnotations.source
private String	SynthesizedMergedAnnotationInvocationHandler.string
private A	AbstractMergedAnnotation.synthesizedAnnotation

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

修饰符和类型	方法	说明
private <T> T	TypeMappedAnnotation.adapt(Method attribute, Object value, Class<T> type)
private static Object	AnnotationUtils.adaptValue(Object annotatedElement, Object value, boolean classValuesAsString)
Class<? extends Annotation>	AnnotationAttributes.annotationType()	Get the type of annotation represented by this AnnotationAttributes.
(专用程序包) static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, MergedAnnotation<?> annotation, IntrospectionFailureLogger logger)
(专用程序包) static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, Object source, Annotation annotation, int aggregateIndex, IntrospectionFailureLogger logger)
private static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, Object source, Object rootAttribute, ValueExtractor valueExtractor, int aggregateIndex, IntrospectionFailureLogger logger)
private MergedAnnotation<A>	MergedAnnotationsCollection.AnnotationsSpliterator.createMergedAnnotationIfPossible(int annotationIndex, int mappingIndex)
(专用程序包) <A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.Aggregate.createMergedAnnotationIfPossible(int annotationIndex, int mappingIndex, IntrospectionFailureLogger logger)
default R	AnnotationsProcessor.doWithAggregate(C context, int aggregateIndex)	Called when an aggregate is about to be processed.
MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.doWithAggregate(Object context, int aggregateIndex)
R	AnnotationsProcessor.doWithAnnotations(C context, int aggregateIndex, Object source, Annotation[] annotations)	Called when an array of annotations can be processed.
List<TypeMappedAnnotations.Aggregate>	TypeMappedAnnotations.AggregatesCollector.doWithAnnotations(Object criteria, int aggregateIndex, Object source, Annotation[] annotations)
Boolean	TypeMappedAnnotations.IsPresent.doWithAnnotations(Object requiredType, int aggregateIndex, Object source, Annotation[] annotations)
MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.doWithAnnotations(Object type, int aggregateIndex, Object source, Annotation[] annotations)
Object	ValueExtractor.extract(Method attribute, Object object)	Extract the annotation attribute represented by the supplied Method from the supplied source Object.
(专用程序包) static Object	TypeMappedAnnotation.extractFromMap(Method attribute, Object map)
private <A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.find(Object requiredType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
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.
private static Integer	OrderUtils.findOrder(MergedAnnotations annotations)
private Integer	AnnotationAwareOrderComparator.findOrderFromAnnotation(Object obj)
(专用程序包) Annotation[]	RepeatableContainers.ExplicitRepeatableContainer.findRepeatedAnnotations(Annotation annotation)
(专用程序包) Annotation[]	RepeatableContainers.findRepeatedAnnotations(Annotation annotation)
(专用程序包) Annotation[]	RepeatableContainers.StandardRepeatableContainers.findRepeatedAnnotations(Annotation annotation)
default R	AnnotationsProcessor.finish(R result)	Get the final result to be returned.
MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.finish(MergedAnnotation<A> result)
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)
(专用程序包) Method	AttributeMethods.get(String name)	Get the attribute with the specified name or null if no matching attribute exists.
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.
<T extends Annotation> T	AnnotatedElementUtils.AnnotatedElementForAnnotations.getAnnotation(Class<T> annotationClass)
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.
private static AnnotationAttributes	AnnotatedElementUtils.getAnnotationAttributes(MergedAnnotation<?> annotation, boolean classValuesAsString, boolean nestedAnnotationsAsMap)
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.
private static Class<? extends Annotation>	AnnotationAttributes.getAnnotationType(String annotationType, ClassLoader classLoader)
(专用程序包) AnnotationTypeMapping.MirrorSets.MirrorSet	AnnotationTypeMapping.MirrorSets.getAssigned(int attributeIndex)
protected abstract <T> T	AbstractMergedAnnotation.getAttributeValue(String attributeName, Class<T> type)	Get the underlying attribute value.
protected <T> T	TypeMappedAnnotation.getAttributeValue(String attributeName, Class<T> type)
private ClassLoader	TypeMappedAnnotation.getClassLoader()
(专用程序包) static <A extends Annotation> A	AnnotationsScanner.getDeclaredAnnotation(AnnotatedElement source, Class<A> annotationType)
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.
(专用程序包) Object	AnnotationTypeMapping.getMappedAnnotationValue(int attributeIndex, boolean metaAnnotationsOnly)	Get a mapped attribute value from the most suitable meta-annotation.
private AnnotationTypeMapping	MergedAnnotationsCollection.AnnotationsSpliterator.getMapping(int annotationIndex, int mappingIndex)
(专用程序包) AnnotationTypeMapping	TypeMappedAnnotations.Aggregate.getMapping(int annotationIndex, int mappingIndex)
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.
MergedAnnotation<?>	MissingMergedAnnotation.getMetaSource()
MergedAnnotation<?>	TypeMappedAnnotation.getMetaSource()
private AnnotationTypeMapping	MergedAnnotationsCollection.AnnotationsSpliterator.getNextSuitableMapping(int annotationIndex)
private AnnotationTypeMapping	TypeMappedAnnotations.AggregatesSpliterator.getNextSuitableMapping(TypeMappedAnnotations.Aggregate aggregate, int annotationIndex)
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.
(专用程序包) static Integer	OrderUtils.getOrderFromAnnotations(AnnotatedElement element, MergedAnnotations annotations)	Return the order from the specified annotation collection.
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.
private Method	RepeatableContainers.StandardRepeatableContainers.getRepeatedAnnotationsMethod(Class<? extends Annotation> annotationType)
Object	MergedAnnotation.getSource()	Get the source that ultimately declared the root annotation, or null if the source is not known.
Object	MissingMergedAnnotation.getSource()
Object	TypeMappedAnnotation.getSource()
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.
private Object	TypeMappedAnnotation.getValue(int attributeIndex, boolean useConventionMapping, boolean forMirrorResolution)
private <T> T	TypeMappedAnnotation.getValue(int attributeIndex, Class<T> type)
private Object	TypeMappedAnnotation.getValueForMirrorResolution(Method attribute, Object annotation)
private Object	TypeMappedAnnotation.getValueFromMetaAnnotation(int attributeIndex, boolean forMirrorResolution)
private static MultiValueMap<String,Object>	AnnotatedElementUtils.nullIfEmpty(MultiValueMap<String,Object> map)
private static <C, R> R	AnnotationsScanner.process(C context, AnnotatedElement source, MergedAnnotations.SearchStrategy searchStrategy, Predicate<Class<?>> searchEnclosingClass, AnnotationsProcessor<C,R> processor)
private MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.process(Object type, int aggregateIndex, Object source, Annotation annotation)
private static <C, R> R	AnnotationsScanner.processClass(C context, Class<?> source, MergedAnnotations.SearchStrategy searchStrategy, Predicate<Class<?>> searchEnclosingClass, AnnotationsProcessor<C,R> processor)
private static <C, R> R	AnnotationsScanner.processClassHierarchy(C context, int[] aggregateIndex, Class<?> source, AnnotationsProcessor<C,R> processor, boolean includeInterfaces, Predicate<Class<?>> searchEnclosingClass)
private static <C, R> R	AnnotationsScanner.processClassHierarchy(C context, Class<?> source, AnnotationsProcessor<C,R> processor, boolean includeInterfaces, Predicate<Class<?>> searchEnclosingClass)
private static <C, R> R	AnnotationsScanner.processClassInheritedAnnotations(C context, Class<?> source, MergedAnnotations.SearchStrategy searchStrategy, AnnotationsProcessor<C,R> processor)
private static <C, R> R	AnnotationsScanner.processElement(C context, AnnotatedElement source, AnnotationsProcessor<C,R> processor)
private static <C, R> R	AnnotationsScanner.processMethod(C context, Method source, MergedAnnotations.SearchStrategy searchStrategy, AnnotationsProcessor<C,R> processor)
private static <C, R> R	AnnotationsScanner.processMethodAnnotations(C context, int aggregateIndex, Method source, AnnotationsProcessor<C,R> processor)
private static <C, R> R	AnnotationsScanner.processMethodHierarchy(C context, int[] aggregateIndex, Class<?> sourceClass, AnnotationsProcessor<C,R> processor, Method rootMethod, boolean includeInterfaces)
private static <C, R> R	AnnotationsScanner.processMethodInheritedAnnotations(C context, Method source, AnnotationsProcessor<C,R> processor)
(专用程序包) static <C, R> R	AnnotationsScanner.scan(C context, AnnotatedElement source, MergedAnnotations.SearchStrategy searchStrategy, Predicate<Class<?>> searchEnclosingClass, AnnotationsProcessor<C,R> processor)	Scan the hierarchy of the specified element for relevant annotations and call the processor as required.
private <C, R> R	TypeMappedAnnotations.scan(C criteria, AnnotationsProcessor<C,R> processor)
Spliterator<MergedAnnotation<A>>	MergedAnnotationsCollection.AnnotationsSpliterator.trySplit()
Spliterator<MergedAnnotation<A>>	TypeMappedAnnotations.AggregatesSpliterator.trySplit()

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

修饰符和类型	方法	说明
private <T> T	TypeMappedAnnotation.adapt(Method attribute, Object value, Class<T> type)
private static Object	AnnotationUtils.adaptValue(Object annotatedElement, Object value, boolean classValuesAsString)
private static Object	AnnotationUtils.adaptValue(Object annotatedElement, Object value, boolean classValuesAsString)
private void	AnnotationTypeMappings.addIfPossible(Deque<AnnotationTypeMapping> queue, AnnotationTypeMapping source, Class<? extends Annotation> annotationType, Annotation ann, Set<Class<? extends Annotation>> visitedAnnotationTypes)
private void	AnnotationTypeMappings.addIfPossible(Deque<AnnotationTypeMapping> queue, AnnotationTypeMapping source, Class<? extends Annotation> annotationType, Annotation ann, Set<Class<? extends Annotation>> visitedAnnotationTypes)
private static boolean	AnnotationTypeMapping.areEquivalent(Annotation annotation, Object extractedValue, ValueExtractor valueExtractor)
private static boolean	AnnotationTypeMapping.areEquivalent(Object value, Object extractedValue, ValueExtractor valueExtractor)
private static boolean	AnnotationTypeMapping.areEquivalent(Object value, Object extractedValue, ValueExtractor valueExtractor)
private TypeMappedAnnotations.Aggregate	TypeMappedAnnotations.AggregatesCollector.createAggregate(int aggregateIndex, Object source, Annotation[] annotations)
(专用程序包) static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, Object source, Annotation annotation, int aggregateIndex, IntrospectionFailureLogger logger)
private static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, Object source, Object rootAttribute, ValueExtractor valueExtractor, int aggregateIndex, IntrospectionFailureLogger logger)
private static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.createIfPossible(AnnotationTypeMapping mapping, Object source, Object rootAttribute, ValueExtractor valueExtractor, int aggregateIndex, IntrospectionFailureLogger logger)
(专用程序包) static String	AttributeMethods.describe(Class<?> annotationType, String attributeName)	Create a description for the given attribute method suitable to use in exception messages and logs.
(专用程序包) static String	AttributeMethods.describe(Class<?> annotationType, String attributeName)	Create a description for the given attribute method suitable to use in exception messages and logs.
(专用程序包) static String	AttributeMethods.describe(Method attribute)	Create a description for the given attribute method suitable to use in exception messages and logs.
R	AnnotationsProcessor.doWithAnnotations(C context, int aggregateIndex, Object source, Annotation[] annotations)	Called when an array of annotations can be processed.
List<TypeMappedAnnotations.Aggregate>	TypeMappedAnnotations.AggregatesCollector.doWithAnnotations(Object criteria, int aggregateIndex, Object source, Annotation[] annotations)
Boolean	TypeMappedAnnotations.IsPresent.doWithAnnotations(Object requiredType, int aggregateIndex, Object source, Annotation[] annotations)
MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.doWithAnnotations(Object type, int aggregateIndex, Object source, Annotation[] annotations)
boolean	PackagesAnnotationFilter.equals(Object other)
boolean	RepeatableContainers.equals(Object other)
boolean	RepeatableContainers.ExplicitRepeatableContainer.equals(Object other)
Object	ValueExtractor.extract(Method attribute, Object object)	Extract the annotation attribute represented by the supplied Method from the supplied source Object.
(专用程序包) static Object	TypeMappedAnnotation.extractFromMap(Method attribute, Object map)
private <A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.find(Object requiredType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
private <A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.find(Object requiredType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
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.
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.
private static MergedAnnotations	AnnotatedElementUtils.findRepeatableAnnotations(AnnotatedElement element, Class<? extends Annotation> containerType, Class<? extends Annotation> annotationType)
default R	AnnotationsProcessor.finish(R result)	Get the final result to be returned.
List<TypeMappedAnnotations.Aggregate>	TypeMappedAnnotations.AggregatesCollector.finish(List<TypeMappedAnnotations.Aggregate> processResult)
MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.finish(MergedAnnotation<A> result)
(专用程序包) static AttributeMethods	AttributeMethods.forAnnotationType(Class<? extends Annotation> annotationType)	Get the attribute methods for the given annotation type.
static <A extends Annotation> MergedAnnotation<A>	MergedAnnotation.from(Object source, A annotation)	Create a new MergedAnnotation instance from the specified annotation.
(专用程序包) static <A extends Annotation> TypeMappedAnnotation<A>	TypeMappedAnnotation.from(Object source, A annotation)
(专用程序包) static MergedAnnotations	TypeMappedAnnotations.from(Object source, Annotation[] annotations, RepeatableContainers repeatableContainers, AnnotationFilter filter)
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.
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate)
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate)
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	MergedAnnotationsCollection.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(Class<A> annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
<A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotations.get(String annotationType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
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.
private static Class<? extends Annotation>	AnnotationAttributes.getAnnotationType(String annotationType, ClassLoader classLoader)
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.
<T> Optional<T>	MissingMergedAnnotation.getDefaultValue(String attributeName, Class<T> 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.
private static Set<String>	AnnotatedElementUtils.getMetaAnnotationTypes(Annotation annotation)
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.
private static MergedAnnotations	AnnotatedElementUtils.getRepeatableAnnotations(AnnotatedElement element, Class<? extends Annotation> containerType, Class<? extends Annotation> annotationType)
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 void	AnnotationUtils.handleIntrospectionFailure(AnnotatedElement element, Throwable ex)	Handle the supplied annotation introspection exception.
(专用程序包) static boolean	AnnotationsScanner.hasPlainJavaAnnotationsOnly(Object annotatedElement)
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.isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType)	Determine whether the given class is a candidate for carrying the specified annotation (at type, method or field level).
static boolean	AnnotationUtils.isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType1, Class<? extends Annotation> annotationType2)	Determine whether the given class is a candidate for carrying the specified annotation (at type, method or field level).
static boolean	AnnotationUtils.isCandidateClass(Class<?> clazz, Class<? extends Annotation> annotationType1, Class<? extends Annotation> annotationType2)	Determine whether the given class is a candidate for carrying the specified annotation (at type, method or field level).
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.
private static boolean	MergedAnnotationsCollection.isMappingForType(AnnotationTypeMapping mapping, Object requiredType)
private static boolean	TypeMappedAnnotations.isMappingForType(AnnotationTypeMapping mapping, AnnotationFilter filter, Object requiredType)
private boolean	AnnotationTypeMappings.isNotMappable(AnnotationTypeMapping source, Annotation metaAnnotation)
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 Infra (i.e. wrapped in a dynamic proxy) with additional functionality such as attribute alias handling.
(专用程序包) void	IntrospectionFailureLogger.log(String message, Object source, Exception ex)
private static <T> List<T>	AnnotationTypeMapping.merge(List<T> existing, T element)
(专用程序包) static <A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotation.of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)
(专用程序包) static <A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotation.of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)
(专用程序包) static <A extends Annotation> MergedAnnotation<A>	TypeMappedAnnotation.of(ClassLoader classLoader, Object source, Class<A> annotationType, Map<String,?> attributes)
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.
private MergedAnnotation<A>	TypeMappedAnnotations.MergedAnnotationFinder.process(Object type, int aggregateIndex, Object source, Annotation annotation)
(专用程序包) <A> int	AnnotationTypeMapping.MirrorSets.MirrorSet.resolve(Object source, A annotation, ValueExtractor valueExtractor)
(专用程序包) <A> int	AnnotationTypeMapping.MirrorSets.MirrorSet.resolve(Object source, A annotation, ValueExtractor valueExtractor)
(专用程序包) int[]	AnnotationTypeMapping.MirrorSets.resolve(Object source, Object annotation, ValueExtractor valueExtractor)
(专用程序包) int[]	AnnotationTypeMapping.MirrorSets.resolve(Object source, Object annotation, ValueExtractor valueExtractor)
static void	AnnotationAwareOrderComparator.sortIfNecessary(Object value)	Sort the given array or List with a default AnnotationAwareOrderComparator, if necessary.
private <A extends Annotation> Spliterator<MergedAnnotation<A>>	MergedAnnotationsCollection.spliterator(Object annotationType)
private <A extends Annotation> Spliterator<MergedAnnotation<A>>	TypeMappedAnnotations.spliterator(Object annotationType)
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.
boolean	MergedAnnotationPredicates.FirstRunOfPredicate.test(MergedAnnotation<A> annotation)
boolean	MergedAnnotationPredicates.UniquePredicate.test(MergedAnnotation<A> annotation)
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 MergedAnnotations	MergedAnnotationsCollection.valueOf(Collection<MergedAnnotation<?>> annotations)
static RepeatableContainers	RepeatableContainers.valueOf(Class<? extends Annotation> repeatable, Class<? extends Annotation> container)	Create a RepeatableContainers instance that uses predefined repeatable and container types.

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

限定符	构造器	说明
(专用程序包)	Aggregate(int aggregateIndex, Object source, ArrayList<Annotation> annotations)
(专用程序包)	AggregatesSpliterator(Object requiredType, List<TypeMappedAnnotations.Aggregate> aggregates)
	AnnotationAttributes(String annotationType, ClassLoader classLoader)	Create a new, empty AnnotationAttributes instance for the specified annotationType.
	AnnotationsSpliterator(Object requiredType)
(专用程序包)	AnnotationTypeMapping(AnnotationTypeMapping source, Class<? extends Annotation> annotationType, Annotation annotation, Set<Class<? extends Annotation>> visitedAnnotationTypes)
(专用程序包)	AnnotationTypeMapping(AnnotationTypeMapping source, Class<? extends Annotation> annotationType, Annotation annotation, Set<Class<? extends Annotation>> visitedAnnotationTypes)
private	AttributeMethods(Class<? extends Annotation> annotationType, Method[] attributes)
(专用程序包)	ExplicitRepeatableContainer(RepeatableContainers parent, Class<? extends Annotation> repeatable, Class<? extends Annotation> container)
(专用程序包)	ExplicitRepeatableContainer(RepeatableContainers parent, Class<? extends Annotation> repeatable, Class<? extends Annotation> container)
(专用程序包)	MergedAnnotationFinder(Object requiredType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
(专用程序包)	MergedAnnotationFinder(Object requiredType, Predicate<? super MergedAnnotation<A>> predicate, MergedAnnotationSelector<A> selector)
private	RepeatableContainers(RepeatableContainers parent)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAnnotation, ValueExtractor valueExtractor, int aggregateIndex, boolean useMergedValues, Predicate<String> attributeFilter, int[] resolvedRootMirrors, int[] resolvedMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAnnotation, ValueExtractor valueExtractor, int aggregateIndex, boolean useMergedValues, Predicate<String> attributeFilter, int[] resolvedRootMirrors, int[] resolvedMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAnnotation, ValueExtractor valueExtractor, int aggregateIndex, boolean useMergedValues, Predicate<String> attributeFilter, int[] resolvedRootMirrors, int[] resolvedMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAnnotation, ValueExtractor valueExtractor, int aggregateIndex, boolean useMergedValues, Predicate<String> attributeFilter, int[] resolvedRootMirrors, int[] resolvedMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex, int[] resolvedRootMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex, int[] resolvedRootMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex, int[] resolvedRootMirrors)
private	TypeMappedAnnotation(AnnotationTypeMapping mapping, ClassLoader classLoader, Object source, Object rootAttributes, ValueExtractor valueExtractor, int aggregateIndex, int[] resolvedRootMirrors)
private	TypeMappedAnnotations(Object source, Annotation[] annotations, RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)
private	TypeMappedAnnotations(Object source, Annotation[] annotations, RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)
private	TypeMappedAnnotations(AnnotatedElement element, MergedAnnotations.SearchStrategy searchStrategy, Predicate<Class<?>> searchEnclosingClass, RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)
private	TypeMappedAnnotations(AnnotatedElement element, MergedAnnotations.SearchStrategy searchStrategy, Predicate<Class<?>> searchEnclosingClass, RepeatableContainers repeatableContainers, AnnotationFilter annotationFilter)

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	CharBufferDecoder.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)
final T	AbstractCharSequenceDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
final T	AbstractCharSequenceDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
final reactor.core.publisher.Flux<T>	AbstractCharSequenceDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
final reactor.core.publisher.Flux<T>	AbstractCharSequenceDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	AbstractDataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	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.Buffer	Netty5BufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
io.netty5.buffer.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)
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.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.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.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	Netty5BufferEncoder.encodeValue(io.netty5.buffer.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)
private Charset	AbstractCharSequenceDecoder.getCharset(MimeType mimeType)
private Charset	CharSequenceEncoder.getCharset(MimeType mimeType)
private byte[][]	AbstractCharSequenceDecoder.getDelimiterBytes(MimeType mimeType)
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.
private void	DataBufferEncoder.logValue(DataBuffer buffer, Map<String,Object> hints)
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).
private reactor.core.publisher.Flux<DataBuffer>	ResourceRegionEncoder.writeResourceRegion(ResourceRegion region, DataBufferFactory bufferFactory, Map<String,Object> hints)

注释类型为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中的字段

修饰符和类型	字段	说明
private final TypeDescriptor	ConversionFailedException.sourceType
private final TypeDescriptor	ConverterNotFoundException.sourceType
private final Object	ConversionFailedException.value

注释类型为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.
T	ConvertingComparator.ConversionServiceConverter.convert(S source)
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中的字段

修饰符和类型	字段	说明
private final Object	MapToMapConverter.MapEntry.key	key 记录组件的字段。
private static DefaultConversionService	DefaultConversionService.sharedInstance
private final Object	MapToMapConverter.MapEntry.value	value 记录组件的字段。

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

修饰符和类型	方法	说明
Object	ArrayToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ByteBufferConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	FallbackObjectToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor 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)
<T> T	GenericConversionService.convert(Object source, Class<T> targetType)
Object	GenericConversionService.ConverterAdapter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	GenericConversionService.ConverterFactoryAdapter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	GenericConversionService.NoOpConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	IdToEntityConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	MapToMapConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StreamConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StringToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Boolean	StringToBooleanConverter.convert(String source)
Character	StringToCharacterConverter.convert(String source)
Object	StringToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
T	StringToEnumConverterFactory.StringToEnum.convert(String source)
Locale	StringToLocaleConverter.convert(String source)
T	StringToNumberConverterFactory.StringToNumber.convert(String source)
UUID	StringToUUIDConverter.convert(String source)
private Object	ByteBufferConverter.convertFromByteBuffer(ByteBuffer source, TypeDescriptor targetType)
private Object	StreamConverter.convertFromStream(Stream<?> source, TypeDescriptor streamType, TypeDescriptor targetType)
private Object	MapToMapConverter.convertKey(Object sourceKey, TypeDescriptor sourceType, TypeDescriptor targetType)
protected Object	GenericConversionService.convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)	Template method to convert a null source.
private Object	MapToMapConverter.convertValue(Object sourceValue, TypeDescriptor sourceType, TypeDescriptor targetType)
private static Constructor<?>	ObjectToObjectConverter.determineFactoryConstructor(Class<?> targetClass, Class<?> sourceClass)
private static Method	ObjectToObjectConverter.determineFactoryMethod(Class<?> targetClass, Class<?> sourceClass)
private static Method	ObjectToObjectConverter.determineToMethod(Class<?> targetClass, Class<?> sourceClass)
GenericConverter	GenericConversionService.Converters.find(TypeDescriptor sourceType, TypeDescriptor targetType)	Find a GenericConverter given a source and target type.
String	ConvertingPropertyEditorAdapter.getAsText()
GenericConverter	GenericConversionService.ConvertersForPair.getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)
GenericConverter	GenericConversionService.getConverter(TypeDescriptor sourceType, TypeDescriptor targetType)	Hook method to lookup the converter for a given sourceType/targetType pair.
Set<GenericConverter.ConvertiblePair>	GenericConversionService.NoOpConverter.getConvertibleTypes()
protected GenericConverter	GenericConversionService.getDefaultConverter(TypeDescriptor sourceType, TypeDescriptor targetType)	Return the default converter if no converter is found for the given sourceType/targetType pair.
private Method	IdToEntityConverter.getFinder(Class<?> entityClass)
private GenericConverter	GenericConversionService.Converters.getRegisteredConverter(TypeDescriptor sourceType, TypeDescriptor targetType, GenericConverter.ConvertiblePair convertiblePair)
private ResolvableType[]	GenericConversionService.getRequiredTypeInfo(Class<?> converterClass, Class<?> genericIfc)
private static Executable	ObjectToObjectConverter.getValidatedExecutable(Class<?> targetClass, Class<?> sourceClass)
private Object	GenericConversionService.handleConverterNotFound(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
private Object	GenericConversionService.handleResult(TypeDescriptor sourceType, TypeDescriptor targetType, Object result)
static Object	ConversionUtils.invokeConverter(GenericConverter converter, Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	MapToMapConverter.MapEntry.key()	返回 key 记录组件的值。
Object	MapToMapConverter.MapEntry.value()	返回 value 记录组件的值。

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

修饰符和类型	方法	说明
private void	GenericConversionService.assertNotPrimitiveTargetType(TypeDescriptor sourceType, TypeDescriptor targetType)
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)
static boolean	ConversionUtils.canConvertElements(TypeDescriptor sourceElementType, TypeDescriptor targetElementType, ConversionService conversionService)
static boolean	ConversionUtils.canConvertElements(TypeDescriptor sourceElementType, TypeDescriptor targetElementType, ConversionService conversionService)
Object	ArrayToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ArrayToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ByteBufferConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	CollectionToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	FallbackObjectToStringConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor 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)
Object	GenericConversionService.ConverterAdapter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	GenericConversionService.ConverterFactoryAdapter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	GenericConversionService.NoOpConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	IdToEntityConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	MapToMapConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToObjectConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	ObjectToOptionalConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StreamConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StringToArrayConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
Object	StringToCollectionConverter.convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
private Object	StreamConverter.convertFromStream(Stream<?> source, TypeDescriptor streamType, TypeDescriptor targetType)
private Object	MapToMapConverter.convertKey(Object sourceKey, TypeDescriptor sourceType, TypeDescriptor targetType)
protected Object	GenericConversionService.convertNullSource(TypeDescriptor sourceType, TypeDescriptor targetType)	Template method to convert a null source.
private Object	ByteBufferConverter.convertToByteBuffer(Object source, TypeDescriptor sourceType)
private Object	StreamConverter.convertToStream(Object source, TypeDescriptor sourceType, TypeDescriptor streamType)
private Object	MapToMapConverter.convertValue(Object sourceValue, TypeDescriptor sourceType, TypeDescriptor targetType)
private Collection<Object>	ArrayToCollectionConverter.createCollection(Class<?> targetType, Class<?> elementType, int length)
boolean	GenericConversionService.ConverterCacheKey.equals(Object other)	指示某个其他对象是否“等于”此对象。
private Object	GenericConversionService.handleConverterNotFound(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
private Object	GenericConversionService.handleConverterNotFound(Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
private Object	GenericConversionService.handleResult(TypeDescriptor sourceType, TypeDescriptor targetType, Object result)
private Object	GenericConversionService.handleResult(TypeDescriptor sourceType, TypeDescriptor targetType, Object result)
static Object	ConversionUtils.invokeConverter(GenericConverter converter, Object source, TypeDescriptor sourceType, TypeDescriptor targetType)
boolean	StreamConverter.matchesFromStream(TypeDescriptor elementType, TypeDescriptor targetType)	Validate that a Collection of the elements held within the stream can be converted to the specified targetType.
boolean	StreamConverter.matchesToStream(TypeDescriptor elementType, TypeDescriptor sourceType)	Validate that the specified sourceType can be converted to a Collection of the type of the stream elements.
void	ConvertingPropertyEditorAdapter.setAsText(String text)

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

限定符	构造器	说明
private	MapEntry(Object key, Object value)	创建 MapEntry 记录的实例。
private	MapEntry(Object key, Object value)	创建 MapEntry 记录的实例。

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

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

修饰符和类型	字段	说明
private ConfigurableConversionService	AbstractPropertyResolver.conversionService
private final Map<String,Object>	MapPropertyResolver.keyValues
private PropertyPlaceholderHandler	AbstractPropertyResolver.nonStrictHelper
private final PropertySources	PropertySourcesPropertyResolver.propertySources
private LinkedHashSet<String>	AbstractPropertyResolver.requiredProperties
private PropertyPlaceholderHandler	AbstractPropertyResolver.strictHelper
private String	AbstractPropertyResolver.valueSeparator

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

修饰符和类型	方法	说明
private String	SystemEnvironmentPropertySource.checkPropertyName(String name)
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.
List<String>	CommandLineArgs.getOptionValues(String optionName)	Return the list of values associated with the given option.
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	PropertySource.ComparisonPropertySource.getProperty(String name)
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中的方法参数

修饰符和类型	方法	说明
void	CommandLineArgs.addOptionArg(String optionName, String optionValue)	Add an option argument for the given option name and add the given value to the list of values associated with this option (of which there may be zero or more).
protected <T> T	AbstractPropertyResolver.convertValueIfNecessary(Object value, Class<T> targetType)	Convert the given value to the specified target type, if necessary.
boolean	ProfilesParser.ParsedProfiles.equals(Object obj)
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
private static Profiles	ProfilesParser.merge(String expression, List<Profiles> elements, ProfilesParser.Operator operator)
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中的字段

修饰符和类型	字段	说明
private static Locale	LocaleContextHolder.defaultLocale
private static TimeZone	LocaleContextHolder.defaultTimeZone
private final Locale	SimpleLocaleContext.locale
private final TimeZone	SimpleTimeZoneAwareLocaleContext.timeZone

注释类型为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中的字段

修饰符和类型	字段	说明
private ClassLoader	DefaultResourceLoader.classLoader
private String	UrlResource.cleanedUrl	Cleaned URL String (with normalized path), used for comparisons.
private final String	PropertySourceDescriptor.encoding	encoding 记录组件的字段。
private final File	FileSystemResource.file
private File	FileUrlResource.file
private String	PropertiesLoaderSupport.fileEncoding
protected Properties[]	PropertiesLoaderSupport.localProperties
private Resource[]	PropertiesLoaderSupport.locations
private final String	PropertySourceDescriptor.name	name 记录组件的字段。
private PropertyResolver	ResourceArrayPropertyEditor.propertyResolver
private PropertyResolver	ResourceEditor.propertyResolver
private final Class<? extends PropertySourceFactory>	PropertySourceDescriptor.propertySourceFactory	propertySourceFactory 记录组件的字段。
private LinkedHashSet<ProtocolResolver>	DefaultResourceLoader.protocolResolvers
private final String	ResourcePropertySource.resourceName	The original resource name, if different from the given name.
private final URI	UrlResource.uri	Original URI, if available; used for URI and File access.

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

修饰符和类型	方法	说明
String	PropertySourceDescriptor.encoding()	返回 encoding 记录组件的值。
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	ModuleResource.getName()
String	Resource.getName()	Determine a name for this resource, i.e. typically the last part of the path: for example, "myfile.txt".
String	UrlResource.getName()	This implementation returns the URL-decoded name of the file that this URL refers to.
Collection<ProtocolResolver>	DefaultResourceLoader.getProtocolResolvers()	Return the collection of currently registered protocol resolvers, allowing for introspection as well as modification.
String	PropertySourceDescriptor.name()	返回 name 记录组件的值。
Class<? extends PropertySourceFactory>	PropertySourceDescriptor.propertySourceFactory()	返回 propertySourceFactory 记录组件的值。
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	ModuleResource.equals(Object obj)
boolean	PathResource.equals(Object obj)	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.
private static boolean	PropertySourceProcessor.isIgnorableException(Throwable ex)	Determine if the supplied exception can be ignored according to ignoreResourceNotFound semantics.
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.
	PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)	创建 PropertySourceDescriptor 记录的实例。
	PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)	创建 PropertySourceDescriptor 记录的实例。
	PropertySourceDescriptor(List<String> locations, boolean ignoreResourceNotFound, String name, Class<? extends PropertySourceFactory> propertySourceFactory, String encoding)	创建 PropertySourceDescriptor 记录的实例。
	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.
private	ResourcePropertySource(String name, String resourceName, Map<String,Object> source)
	UrlResource(String protocol, String location, String fragment)	Create a new UrlResource based on a URI specification.

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

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

修饰符和类型	字段	说明
private T	Netty5DataBuffer.BufferComponentIterator.next

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

修饰符和类型	方法	说明
(专用程序包) static void	DataBufferUtils.closeChannel(Channel channel)
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中的字段

修饰符和类型	字段	说明
private final ClassLoader	DefaultDeserializer.classLoader

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

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

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

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

修饰符和类型	方法	说明
static Set<String>	SslOptions.asSet(String[] array)	Helper method that provides a null-safe way to convert a String[] to a Collection for client libraries to use.
String	SslBundleKey.getAlias()	Return the alias of the key or null if the key has no alias.
String[]	SslOptions.getCiphers()	Return the ciphers that can be used or an empty set.
String[]	SslOptions.getEnabledProtocols()	Return the protocols that should be enabled or an empty set.
KeyStore	SslStoreBundle.getKeyStore()	Return a key store generated from the trust material or null.
String	SslStoreBundle.getKeyStorePassword()	Return the password for the key in the key store or null.
String	SslBundleKey.getPassword()	Return the password that should be used to access the key or null if no password is required.
KeyStore	SslStoreBundle.getTrustStore()	Return a trust store generated from the trust material or null.
private static String[]	SslOptions.toArray(Collection<String> collection)

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

修饰符和类型	方法	说明
default void	SslBundleKey.assertContainsAlias(KeyStore keyStore)	Assert that the alias is contained in the given keystore.
static Set<String>	SslOptions.asSet(String[] array)	Helper method that provides a null-safe way to convert a String[] to a Collection for client libraries to use.
static SslManagerBundle	SslManagerBundle.from(SslStoreBundle storeBundle, SslBundleKey key)	Factory method to create a new SslManagerBundle backed by the given SslBundle and SslBundleKey.
static SslManagerBundle	SslManagerBundle.from(SslStoreBundle storeBundle, SslBundleKey key)	Factory method to create a new SslManagerBundle backed by the given SslBundle and SslBundleKey.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol, SslManagerBundle managers)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol, SslManagerBundle managers)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol, SslManagerBundle managers)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol, SslManagerBundle managers)	Factory method to create a new SslBundle instance.
static SslBundle	SslBundle.of(SslStoreBundle stores, SslBundleKey key, SslOptions options, String protocol, SslManagerBundle managers)	Factory method to create a new SslBundle instance.
static SslBundleKey	SslBundleKey.of(String password, String alias)	Factory method to create a new SslBundleKey instance.
static SslBundleKey	SslBundleKey.of(String password, String alias)	Factory method to create a new SslBundleKey instance.
static SslOptions	SslOptions.of(String[] ciphers, String[] enabledProtocols)	Factory method to create a new SslOptions instance.
static SslOptions	SslOptions.of(String[] ciphers, String[] enabledProtocols)	Factory method to create a new SslOptions instance.
static SslOptions	SslOptions.of(Set<String> ciphers, Set<String> enabledProtocols)	Factory method to create a new SslOptions instance.
static SslOptions	SslOptions.of(Set<String> ciphers, Set<String> enabledProtocols)	Factory method to create a new SslOptions instance.
static SslStoreBundle	SslStoreBundle.of(KeyStore keyStore, String keyStorePassword, KeyStore trustStore)	Factory method to create a new SslStoreBundle instance.
static SslStoreBundle	SslStoreBundle.of(KeyStore keyStore, String keyStorePassword, KeyStore trustStore)	Factory method to create a new SslStoreBundle instance.
static SslStoreBundle	SslStoreBundle.of(KeyStore keyStore, String keyStorePassword, KeyStore trustStore)	Factory method to create a new SslStoreBundle instance.
private static String[]	SslOptions.toArray(Collection<String> collection)

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

限定符	构造器	说明
(专用程序包)	DefaultSslManagerBundle(SslStoreBundle storeBundle, SslBundleKey key)
(专用程序包)	DefaultSslManagerBundle(SslStoreBundle storeBundle, SslBundleKey key)
	NoSuchSslBundleException(String bundleName, String message, Throwable cause)	Create a new SslBundleNotFoundException instance.

cn.taketoday.core.ssl.jks中Nullable的使用

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

修饰符和类型	字段	说明
private final KeyStore	JksSslStoreBundle.keyStore
private final JksSslStoreDetails	JksSslStoreBundle.keyStoreDetails
private final String	JksSslStoreDetails.location	location 记录组件的字段。
private final String	JksSslStoreDetails.password	password 记录组件的字段。
private final String	JksSslStoreDetails.provider	provider 记录组件的字段。
private final KeyStore	JksSslStoreBundle.trustStore
private final String	JksSslStoreDetails.type	type 记录组件的字段。

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

修饰符和类型	方法	说明
private KeyStore	JksSslStoreBundle.createKeyStore(String name, JksSslStoreDetails details)
KeyStore	JksSslStoreBundle.getKeyStore()
String	JksSslStoreBundle.getKeyStorePassword()
KeyStore	JksSslStoreBundle.getTrustStore()
String	JksSslStoreDetails.location()	返回 location 记录组件的值。
String	JksSslStoreDetails.password()	返回 password 记录组件的值。
String	JksSslStoreDetails.provider()	返回 provider 记录组件的值。
String	JksSslStoreDetails.type()	返回 type 记录组件的值。

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

修饰符和类型	方法	说明
private KeyStore	JksSslStoreBundle.createKeyStore(String name, JksSslStoreDetails details)
private KeyStore	JksSslStoreBundle.getKeyStoreInstance(String type, String provider)
private boolean	JksSslStoreDetails.isEmpty(String value)
private void	JksSslStoreBundle.loadHardwareKeyStore(KeyStore store, String location, char[] password)
private void	JksSslStoreBundle.loadHardwareKeyStore(KeyStore store, String location, char[] password)
private void	JksSslStoreBundle.loadKeyStore(KeyStore store, String location, char[] password)
private void	JksSslStoreBundle.loadKeyStore(KeyStore store, String location, char[] password)

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

限定符	构造器	说明
	JksSslStoreBundle(JksSslStoreDetails keyStoreDetails, JksSslStoreDetails trustStoreDetails)	Create a new JksSslStoreBundle instance.
	JksSslStoreDetails(String type, String provider, String location, String password)	创建 JksSslStoreDetails 记录的实例。
	JksSslStoreDetails(String type, String provider, String location, String password)	创建 JksSslStoreDetails 记录的实例。
	JksSslStoreDetails(String type, String provider, String location, String password)	创建 JksSslStoreDetails 记录的实例。
	JksSslStoreDetails(String type, String provider, String location, String password)	创建 JksSslStoreDetails 记录的实例。

cn.taketoday.core.ssl.pem中Nullable的使用

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

修饰符和类型	字段	说明
private final String	PemSslStoreDetails.certificate	certificate 记录组件的字段。
private final KeyStore	PemSslStoreBundle.keyStore
private final String	PemSslStoreDetails.privateKey	privateKey 记录组件的字段。
private final String	PemSslStoreDetails.privateKeyPassword	privateKeyPassword 记录组件的字段。
private final KeyStore	PemSslStoreBundle.trustStore
private final String	PemSslStoreDetails.type	type 记录组件的字段。

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

修饰符和类型	方法	说明
private static byte[]	PemPrivateKeyParser.DerEncoder.bytes(int... elements)
String	PemSslStoreDetails.certificate()	返回 certificate 记录组件的值。
private KeyStore	PemSslStoreBundle.createKeyStore(String name, PemSslStoreDetails details, String alias, String keyPassword)
KeyStore	PemSslStoreBundle.getKeyStore()
String	PemSslStoreBundle.getKeyStorePassword()
KeyStore	PemSslStoreBundle.getTrustStore()
(专用程序包) static String	PemContent.load(String content)
(专用程序包) static PemPrivateKeyParser.DerElement	PemPrivateKeyParser.DerElement.of(byte[] bytes)
(专用程序包) static PemPrivateKeyParser.DerElement	PemPrivateKeyParser.DerElement.of(ByteBuffer bytes)
(专用程序包) static X509Certificate[]	PemCertificateParser.parse(String certificates)	Parse certificates from the specified string.
(专用程序包) static PrivateKey	PemPrivateKeyParser.parse(String key, String password)	Parse a private key from the specified string, using the provided password for decryption if necessary.
private PrivateKey	PemPrivateKeyParser.PemParser.parse(byte[] bytes, String password)
(专用程序包) PrivateKey	PemPrivateKeyParser.PemParser.parse(String text, String password)
String	PemSslStoreDetails.privateKey()	返回 privateKey 记录组件的值。
String	PemSslStoreDetails.privateKeyPassword()	返回 privateKeyPassword 记录组件的值。
String	PemSslStoreDetails.type()	返回 type 记录组件的值。

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

修饰符和类型	方法	说明
private void	PemSslStoreBundle.addCertificates(KeyStore keyStore, X509Certificate[] certificates, PrivateKey privateKey, String alias, String keyPassword)
private void	PemSslStoreBundle.addCertificates(KeyStore keyStore, X509Certificate[] certificates, PrivateKey privateKey, String alias, String keyPassword)
private void	PemSslStoreBundle.addCertificates(KeyStore keyStore, X509Certificate[] certificates, PrivateKey privateKey, String alias, String keyPassword)
private static byte[]	PemPrivateKeyParser.DerEncoder.bytes(int... elements)
private static PKCS8EncodedKeySpec	PemPrivateKeyParser.createKeySpecForAlgorithm(byte[] bytes, int[] algorithm, int[] parameters)
private KeyStore	PemSslStoreBundle.createKeyStore(String name, PemSslStoreDetails details, String alias, String keyPassword)
private KeyStore	PemSslStoreBundle.createKeyStore(String name, PemSslStoreDetails details, String alias, String keyPassword)
private KeyStore	PemSslStoreBundle.createKeyStore(String name, PemSslStoreDetails details, String alias, String keyPassword)
static PemSslStoreDetails	PemSslStoreDetails.forCertificate(String certificate)	Factory method to create a new PemSslStoreDetails instance for the given certificate.
private static int[]	PemPrivateKeyParser.getEcParameters(PemPrivateKeyParser.DerElement parameters)
private boolean	PemSslStoreDetails.isEmpty(String value)
private static boolean	PemContent.isPemContent(String content)
(专用程序包) static String	PemContent.load(String content)
(专用程序包) void	PemPrivateKeyParser.DerEncoder.objectIdentifier(int... encodedObjectIdentifier)
(专用程序包) static X509Certificate[]	PemCertificateParser.parse(String certificates)	Parse certificates from the specified string.
(专用程序包) static PrivateKey	PemPrivateKeyParser.parse(String key, String password)	Parse a private key from the specified string, using the provided password for decryption if necessary.
(专用程序包) static PrivateKey	PemPrivateKeyParser.parse(String key, String password)	Parse a private key from the specified string, using the provided password for decryption if necessary.

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

限定符	构造器	说明
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias, String keyPassword)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias, String keyPassword)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias, String keyPassword)	Create a new PemSslStoreBundle instance.
	PemSslStoreBundle(PemSslStoreDetails keyStoreDetails, PemSslStoreDetails trustStoreDetails, String keyAlias, String keyPassword)	Create a new PemSslStoreBundle instance.
	PemSslStoreDetails(String type, String certificate, String privateKey)
	PemSslStoreDetails(String type, String certificate, String privateKey)
	PemSslStoreDetails(String type, String certificate, String privateKey)
	PemSslStoreDetails(String type, String certificate, String privateKey, String privateKeyPassword)	创建 PemSslStoreDetails 记录的实例。
	PemSslStoreDetails(String type, String certificate, String privateKey, String privateKeyPassword)	创建 PemSslStoreDetails 记录的实例。
	PemSslStoreDetails(String type, String certificate, String privateKey, String privateKeyPassword)	创建 PemSslStoreDetails 记录的实例。
	PemSslStoreDetails(String type, String certificate, String privateKey, String privateKeyPassword)	创建 PemSslStoreDetails 记录的实例。

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中的字段

修饰符和类型	字段	说明
private Set<Thread>	SimpleAsyncTaskExecutor.activeThreads
private TaskDecorator	SimpleAsyncTaskExecutor.taskDecorator
private ThreadFactory	SimpleAsyncTaskExecutor.threadFactory
private VirtualThreadDelegate	SimpleAsyncTaskExecutor.virtualThreadDelegate

注释类型为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中的字段

修饰符和类型	字段	说明
private TaskDecorator	TaskExecutorAdapter.taskDecorator

注释类型为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中的字段

修饰符和类型	字段	说明
private Set<String>	StandardAnnotationMetadata.annotationTypes

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

修饰符和类型	方法	说明
default MultiValueMap<String,Object>	AnnotatedTypeMetadata.getAllAnnotationAttributes(Class<? extends Annotation> annotationType)	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(Class<? extends Annotation> annotationType, 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).
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(Class<? extends Annotation> annotationType)	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).
default Map<String,Object>	AnnotatedTypeMetadata.getAnnotationAttributes(Class<? extends Annotation> annotationType, 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).
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).
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).
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中的字段

修饰符和类型	字段	说明
private ArrayList<MergedAnnotation<?>>	SimpleAnnotationMetadataReadingVisitor.annotations
private ArrayList<MergedAnnotation<?>>	SimpleMethodMetadataReadingVisitor.annotations
private Set<String>	SimpleAnnotationMetadata.annotationTypes
private final ClassLoader	MergedAnnotationReadingVisitor.classLoader
private final ClassLoader	SimpleAnnotationMetadataReadingVisitor.classLoader
private final ClassLoader	SimpleMethodMetadata.classLoader
private final ClassLoader	SimpleMethodMetadataReadingVisitor.classLoader
private final Set<MethodMetadata>	SimpleAnnotationMetadata.declaredMethods
private LinkedHashSet<MethodMetadata>	SimpleAnnotationMetadataReadingVisitor.declaredMethods
private final String	SimpleAnnotationMetadata.enclosingClassName
private String	SimpleAnnotationMetadataReadingVisitor.enclosingClassName
private final Set<String>	SimpleAnnotationMetadata.interfaceNames
private LinkedHashSet<String>	SimpleAnnotationMetadataReadingVisitor.interfaceNames
private final Set<String>	SimpleAnnotationMetadata.memberClassNames
private LinkedHashSet<String>	SimpleAnnotationMetadataReadingVisitor.memberClassNames
private SimpleAnnotationMetadata	SimpleAnnotationMetadataReadingVisitor.metadata
private Map<Resource,MetadataReader>	CachingMetadataReaderFactory.metadataReaderCache	MetadataReader cache: either local or shared at the ResourceLoader level.
private String	SimpleMethodMetadata.returnTypeName
private final Object	MergedAnnotationReadingVisitor.source
private SimpleAnnotationMetadataReadingVisitor.Source	SimpleAnnotationMetadataReadingVisitor.source
private SimpleMethodMetadataReadingVisitor.Source	SimpleMethodMetadataReadingVisitor.source
private final String	SimpleAnnotationMetadata.superClassName
private String	SimpleAnnotationMetadataReadingVisitor.superClassName
private String	SimpleMethodMetadataReadingVisitor.Source.toStringValue

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

修饰符和类型	方法	说明
(专用程序包) static <A extends Annotation> AnnotationVisitor	MergedAnnotationReadingVisitor.get(ClassLoader classLoader, Object source, String descriptor, boolean visible, Consumer<MergedAnnotation<A>> consumer)
String	SimpleAnnotationMetadata.getEnclosingClassName()
String	SimpleAnnotationMetadata.getSuperClassName()
AnnotationVisitor	MergedAnnotationReadingVisitor.ArrayVisitor.visitAnnotation(String name, String descriptor)
AnnotationVisitor	MergedAnnotationReadingVisitor.visitAnnotation(String name, String descriptor)
private <T extends Annotation> AnnotationVisitor	MergedAnnotationReadingVisitor.visitAnnotation(String descriptor, Consumer<MergedAnnotation<T>> consumer)
AnnotationVisitor	SimpleAnnotationMetadataReadingVisitor.visitAnnotation(String descriptor, boolean visible)
AnnotationVisitor	SimpleMethodMetadataReadingVisitor.visitAnnotation(String descriptor, boolean visible)
MethodVisitor	SimpleAnnotationMetadataReadingVisitor.visitMethod(int access, String name, String descriptor, String signature, String[] exceptions)

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

修饰符和类型	方法	说明
boolean	SimpleAnnotationMetadata.equals(Object obj)
boolean	SimpleAnnotationMetadataReadingVisitor.Source.equals(Object obj)	指示某个其他对象是否“等于”此对象。
boolean	SimpleMethodMetadata.equals(Object obj)
boolean	SimpleMethodMetadataReadingVisitor.Source.equals(Object other)
(专用程序包) static <A extends Annotation> AnnotationVisitor	MergedAnnotationReadingVisitor.get(ClassLoader classLoader, Object source, String descriptor, boolean visible, Consumer<MergedAnnotation<A>> consumer)
(专用程序包) static <A extends Annotation> AnnotationVisitor	MergedAnnotationReadingVisitor.get(ClassLoader classLoader, Object source, String descriptor, boolean visible, Consumer<MergedAnnotation<A>> consumer)
void	SimpleAnnotationMetadataReadingVisitor.visit(int version, int access, String name, String signature, String supername, String[] interfaces)
void	SimpleAnnotationMetadataReadingVisitor.visitInnerClass(String name, String outerName, String innerName, int access)

注释类型为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.
	MergedAnnotationReadingVisitor(ClassLoader classLoader, Object source, Class<A> annotationType, Consumer<MergedAnnotation<A>> consumer)
	MergedAnnotationReadingVisitor(ClassLoader classLoader, Object source, Class<A> annotationType, Consumer<MergedAnnotation<A>> consumer)
(专用程序包)	SimpleAnnotationMetadata(String className, int access, String enclosingClassName, String superClassName, boolean independentInnerClass, Set<String> interfaceNames, Set<String> memberClassNames, Set<MethodMetadata> declaredMethods, MergedAnnotations annotations)
(专用程序包)	SimpleAnnotationMetadata(String className, int access, String enclosingClassName, String superClassName, boolean independentInnerClass, Set<String> interfaceNames, Set<String> memberClassNames, Set<MethodMetadata> declaredMethods, MergedAnnotations annotations)
(专用程序包)	SimpleAnnotationMetadata(String className, int access, String enclosingClassName, String superClassName, boolean independentInnerClass, Set<String> interfaceNames, Set<String> memberClassNames, Set<MethodMetadata> declaredMethods, MergedAnnotations annotations)
(专用程序包)	SimpleAnnotationMetadata(String className, int access, String enclosingClassName, String superClassName, boolean independentInnerClass, Set<String> interfaceNames, Set<String> memberClassNames, Set<MethodMetadata> declaredMethods, MergedAnnotations annotations)
(专用程序包)	SimpleAnnotationMetadata(String className, int access, String enclosingClassName, String superClassName, boolean independentInnerClass, Set<String> interfaceNames, Set<String> memberClassNames, Set<MethodMetadata> declaredMethods, MergedAnnotations annotations)
(专用程序包)	SimpleAnnotationMetadataReadingVisitor(ClassLoader classLoader)
(专用程序包)	SimpleMetadataReader(Resource resource, ClassLoader classLoader)
	SimpleMetadataReaderFactory(ResourceLoader resourceLoader)	Create a new SimpleMetadataReaderFactory for the given resource loader.
	SimpleMetadataReaderFactory(ClassLoader classLoader)	Create a new SimpleMetadataReaderFactory for the given class loader.
(专用程序包)	SimpleMethodMetadata(int access, String declaringClassName, Object source, MergedAnnotations annotations, MethodSignature methodSignature, ClassLoader classLoader)
(专用程序包)	SimpleMethodMetadataReadingVisitor(ClassLoader classLoader, String declaringClassName, int access, String methodName, String descriptor, Consumer<SimpleMethodMetadata> consumer)

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
private TypeDescriptor	TypedValue.typeDescriptor
private final Object	TypedValue.value

注释类型为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中的字段

修饰符和类型	字段	说明
private final ClassLoader	SpelParserConfiguration.compilerClassLoader
private Deque<TypedValue>	ExpressionState.contextObjects
private ArrayDeque<TypedValue>	ExpressionState.scopeRootObjects
private Deque<ExpressionState.VariableScope>	ExpressionState.variableScopes

注释类型为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)	Set a named variable in the evaluation context to a specified 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.
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader, boolean autoGrowNullReferences, boolean autoGrowCollections, int maximumAutoGrowSize, int maximumExpressionLength)	Create a new SpelParserConfiguration instance.
	SpelParserConfiguration(SpelCompilerMode compilerMode, ClassLoader compilerClassLoader, boolean autoGrowNullReferences, boolean autoGrowCollections, int maximumAutoGrowSize, int maximumExpressionLength)	Create a new SpelParserConfiguration instance.
	VariableScope(Map<String,Object> arguments)

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

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

修饰符和类型	字段	说明
private ConstructorExecutor	ConstructorReference.cachedExecutor	The cached executor that may be reused on subsequent evaluations.
private MethodReference.CachedMethodExecutor	MethodReference.cachedExecutor
private PropertyAccessor	Indexer.cachedReadAccessor
private PropertyAccessor	PropertyOrFieldReference.cachedReadAccessor
private String	Indexer.cachedReadName
private Class<?>	Indexer.cachedReadTargetType
private PropertyAccessor	Indexer.cachedWriteAccessor
private PropertyAccessor	PropertyOrFieldReference.cachedWriteAccessor
private String	Indexer.cachedWriteName
private Class<?>	Indexer.cachedWriteTargetType
private final TypedValue	InlineList.constant
private final TypedValue	InlineMap.constant
private final SpelNodeImpl[]	ConstructorReference.dimensions
protected String	SpelNodeImpl.exitTypeDescriptor	Indicates the type descriptor for the result of this expression node.
private Indexer.IndexedType	Indexer.indexedType
private final Object	Indexer.MapIndexingValueRef.key
protected String	Operator.leftActualDescriptor
private Method	FunctionReference.method
private String	MethodReference.originalPrimitiveExitTypeDescriptor
private String	PropertyOrFieldReference.originalPrimitiveExitTypeDescriptor
private final String	Literal.originalValue
private SpelNodeImpl	SpelNodeImpl.parent
protected String	Operator.rightActualDescriptor
private final Class<?>	MethodReference.CachedMethodExecutor.staticClass	staticClass 记录组件的字段。
private final TypeDescriptor	MethodReference.CachedMethodExecutor.target	target 记录组件的字段。
private final TypeDescriptor	MethodReference.MethodValueRef.targetType
private Class<?>	OperatorInstanceof.type
private Class<?>	TypeReference.type
private final Object	MethodReference.MethodValueRef.value
private TypedValue	QualifiedIdentifier.value

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

修饰符和类型	方法	说明
private TypedValue	InlineList.computeConstant()	If all the components of the list are constants, or lists that themselves contain constants, then a constant list can be built to represent this node.
private TypedValue	InlineMap.computeConstantValue()	If all the components of the map are constants, or lists/maps that themselves contain constants, then a constant list can be built to represent this node.
private MethodExecutor	MethodReference.getCachedExecutor(EvaluationContext evaluationContext, Object value, TypeDescriptor target, List<TypeDescriptor> argumentTypes)
List<Object>	InlineList.getConstantValue()
Map<Object,Object>	InlineMap.getConstantValue()
private Constructor<?>	Indexer.CollectionIndexingValueRef.getDefaultConstructor(Class<?> type)
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)
Class<?>	MethodReference.CachedMethodExecutor.staticClass()	返回 staticClass 记录组件的值。
TypeDescriptor	MethodReference.CachedMethodExecutor.target()	返回 target 记录组件的值。

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

修饰符和类型	方法	说明
private void	OpAnd.assertValueNotNull(Boolean value)
private void	OpOr.assertValueNotNull(Boolean value)
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.
private <T> T	Indexer.convertValue(TypeConverter converter, Object value, Class<T> targetType)
private Class<?>	Projection.determineCommonType(Class<?> oldType, Class<?> newType)
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.
static String	FormatHelper.formatClassNameForMessage(Class<?> clazz)	Determine a readable name for a given Class object.
private MethodExecutor	MethodReference.getCachedExecutor(EvaluationContext evaluationContext, Object value, TypeDescriptor target, List<TypeDescriptor> argumentTypes)
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.
private List<PropertyAccessor>	PropertyOrFieldReference.getPropertyAccessorsToTry(Object contextObject, List<PropertyAccessor> propertyAccessors)	Determines the set of property resolvers that should be used to try and access a property on the specified target type.
private TypedValue	MethodReference.getValueInternal(EvaluationContext evaluationContext, Object value, TypeDescriptor targetType, Object[] arguments)
private TypedValue	MethodReference.getValueInternal(EvaluationContext evaluationContext, Object value, TypeDescriptor targetType, Object[] arguments)
boolean	MethodReference.CachedMethodExecutor.isSuitable(Object value, TypeDescriptor target, List<TypeDescriptor> argumentTypes)
private void	Indexer.setArrayElement(TypeConverter converter, Object ctx, int idx, Object newValue, Class<?> arrayComponentType)
void	Indexer.ArrayIndexingValueRef.setValue(Object newValue)
void	Indexer.CollectionIndexingValueRef.setValue(Object newValue)
void	Indexer.MapIndexingValueRef.setValue(Object newValue)
void	Indexer.PropertyIndexingValueRef.setValue(Object newValue)
void	Indexer.setValue(ExpressionState state, Object newValue)
void	Indexer.StringIndexingLValue.setValue(Object newValue)
void	MethodReference.MethodValueRef.setValue(Object newValue)
void	PropertyOrFieldReference.AccessorLValue.setValue(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.VariableRef.setValue(Object newValue)
private void	OpPlus.walk(MethodVisitor mv, CodeFlow cf, SpelNodeImpl operand)	Walk through a possible tree of nodes that combine strings and append them all to the same (on stack) StringBuilder.
private void	PropertyOrFieldReference.writeProperty(TypedValue contextObject, EvaluationContext evalContext, String name, Object newValue)

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

限定符	构造器	说明
private	CachedMethodExecutor(MethodExecutor methodExecutor, Class<?> staticClass, TypeDescriptor target, List<TypeDescriptor> argumentTypes)	创建 CachedMethodExecutor 记录的实例。
private	CachedMethodExecutor(MethodExecutor methodExecutor, Class<?> staticClass, TypeDescriptor target, List<TypeDescriptor> argumentTypes)	创建 CachedMethodExecutor 记录的实例。
	Literal(String originalValue, int startPos, int endPos)
	MapIndexingValueRef(TypeConverter typeConverter, Map map, Object key, TypeDescriptor mapEntryDescriptor)

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

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

修饰符和类型	字段	说明
private CompiledExpression	SpelExpression.compiledAst
String	Token.data
private EvaluationContext	SpelExpression.evaluationContext

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

修饰符和类型	方法	说明
CompiledExpression	SpelCompiler.compile(SpelNodeImpl expression)	Attempt compilation of the supplied expression.
private Class<? extends CompiledExpression>	SpelCompiler.createExpressionClass(SpelNodeImpl expressionToCompile)	Generate the class that encapsulates the compiled expression and define it.
private SpelNodeImpl	InternalSpelExpressionParser.eatExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatLogicalAndExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatLogicalOrExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatNode()
private SpelNodeImpl	InternalSpelExpressionParser.eatNonDottedNode()
private SpelNodeImpl	InternalSpelExpressionParser.eatPowerIncDecExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatPrimaryExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatProductExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatRelationalExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatStartNode()
private SpelNodeImpl	InternalSpelExpressionParser.eatSumExpression()
private SpelNodeImpl	InternalSpelExpressionParser.eatUnaryExpression()
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)
private SpelNodeImpl[]	InternalSpelExpressionParser.maybeEatMethodArgs()
private Token	InternalSpelExpressionParser.maybeEatRelationalOperator()
private Token	InternalSpelExpressionParser.nextToken()
private Token	InternalSpelExpressionParser.peekToken()

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

修饰符和类型	方法	说明
private void	InternalSpelExpressionParser.checkLeftOperand(Token token, SpelNodeImpl operandExpression)
private void	InternalSpelExpressionParser.checkOperands(Token token, SpelNodeImpl left, SpelNodeImpl right)
private void	InternalSpelExpressionParser.checkOperands(Token token, SpelNodeImpl left, SpelNodeImpl right)
private void	InternalSpelExpressionParser.checkRightOperand(Token token, SpelNodeImpl operandExpression)
protected SpelExpression	InternalSpelExpressionParser.doParseExpression(String expressionString, ParserContext context)
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)
private boolean	InternalSpelExpressionParser.isValidQualifiedId(Token node)
boolean	SpelExpression.isWritable(EvaluationContext context, Object rootObject)
boolean	SpelExpression.isWritable(Object rootObject)
private int	InternalSpelExpressionParser.positionOf(Token t)
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)
String	InternalSpelExpressionParser.toString(Token t)
private TypedValue	SpelExpression.toTypedValue(Object object)

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

限定符	构造器	说明
private	SpelCompiler(ClassLoader classloader)

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

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

修饰符和类型	字段	说明
private BeanResolver	StandardEvaluationContext.beanResolver
private final ClassLoader	StandardTypeLocator.classLoader
private List<ConstructorResolver>	StandardEvaluationContext.constructorResolvers
private Map<Class<?>,MethodFilter>	ReflectiveMethodResolver.filters
private List<MethodResolver>	StandardEvaluationContext.methodResolvers
private List<PropertyAccessor>	StandardEvaluationContext.propertyAccessors
private Class<?>	ReflectiveMethodExecutor.publicDeclaringClass
private ReflectiveMethodResolver	StandardEvaluationContext.reflectiveMethodResolver
private TypedValue	SimpleEvaluationContext.Builder.rootObject
private TypeConverter	SimpleEvaluationContext.Builder.typeConverter
private TypeConverter	StandardEvaluationContext.typeConverter
private TypeLocator	StandardEvaluationContext.typeLocator
private final Integer	ReflectiveConstructorExecutor.varargsPosition
private final Integer	ReflectiveMethodExecutor.varargsPosition

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

修饰符和类型	方法	说明
(专用程序包) static ReflectionHelper.ArgumentsMatchInfo	ReflectionHelper.compareArguments(List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter)	Compare argument arrays and return information about whether they match.
(专用程序包) static ReflectionHelper.ArgumentsMatchInfo	ReflectionHelper.compareArgumentsVarargs(List<TypeDescriptor> expectedArgTypes, List<TypeDescriptor> suppliedArgTypes, TypeConverter typeConverter)	Compare argument arrays and return information about whether they match.
Object	StandardTypeConverter.convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType)
private Class<?>	ReflectiveMethodExecutor.discoverPublicDeclaringClass(Method method, Class<?> clazz)
protected Field	ReflectivePropertyAccessor.findField(String name, Class<?> clazz, boolean mustBeStatic)	Find a field of a certain name on a specified class.
private Field	ReflectivePropertyAccessor.findField(String name, Class<?> clazz, Object target)
protected Method	ReflectivePropertyAccessor.findGetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)	Find a getter method for the specified property.
private Method	ReflectivePropertyAccessor.findGetterForProperty(String propertyName, Class<?> clazz, Object target)
private Method	ReflectivePropertyAccessor.findMethodForProperty(String[] methodSuffixes, String prefix, Class<?> clazz, boolean mustBeStatic, int numberOfParams, Set<Class<?>> requiredReturnTypes)
protected Method	ReflectivePropertyAccessor.findSetterForProperty(String propertyName, Class<?> clazz, boolean mustBeStatic)	Find a setter method for the specified property.
private Method	ReflectivePropertyAccessor.findSetterForProperty(String propertyName, Class<?> clazz, Object target)
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()
private TypeDescriptor	ReflectivePropertyAccessor.getTypeDescriptor(EvaluationContext context, Object target, String name)
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.
private Class<?>	StandardTypeLocator.resolveClassFor(String className)

注释类型为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)
static boolean	ReflectionHelper.convertAllMethodHandleArguments(TypeConverter converter, Object[] arguments, MethodHandle methodHandle, Integer varargsPosition)	Takes an input set of argument values and converts them to the types specified as the required parameter types.
(专用程序包) static boolean	ReflectionHelper.convertArguments(TypeConverter converter, Object[] arguments, Executable executable, Integer varargsPosition)	Takes an input set of argument values and converts them to the types specified as the required parameter types.
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.
boolean	ReflectivePropertyAccessor.PropertyCacheKey.equals(Object other)
private TypeDescriptor	ReflectivePropertyAccessor.getTypeDescriptor(Method readMethod, Method writeMethod, Class<?> declaringClass)
private TypeDescriptor	ReflectivePropertyAccessor.getTypeDescriptor(Method readMethod, Method writeMethod, Class<?> declaringClass)
private TypeDescriptor	ReflectivePropertyAccessor.getTypeDescriptor(Method readMethod, Method writeMethod, Class<?> declaringClass)
private static boolean	ReflectionHelper.isFirstEntryInArray(Object value, Object possibleArray)	Check if the supplied value is the first entry in the array represented by the possibleArray value.
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.
private	SimpleEvaluationContext(List<PropertyAccessor> accessors, List<MethodResolver> resolvers, TypeConverter converter, TypedValue rootObject)
private	SimpleEvaluationContext(List<PropertyAccessor> accessors, List<MethodResolver> resolvers, TypeConverter converter, TypedValue rootObject)
	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中的字段

修饰符和类型	字段	说明
private final TodayStrategies.ArgumentResolver	TodayStrategies.DefaultInstantiator.argumentResolver
private final String	Version.extension	extension 记录组件的字段。

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

修饰符和类型	方法	说明
String	Version.extension()	返回 extension 记录组件的值。
private static Constructor<?>	TodayStrategies.DefaultInstantiator.findConstructor(Class<?> implementationClass)
private static Constructor<?>	TodayStrategies.DefaultInstantiator.findDeclaredConstructor(Class<?> implementationClass)
private static Constructor<?>	TodayStrategies.DefaultInstantiator.findSingleConstructor(Constructor<?>[] constructors)
static String	VersionExtractor.forClass(Class<?> cls)	Return the version information for the provided Class.
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 Long	TodayStrategies.getLong(String nm)	Determines the long value of the system property with the specified name.
static Long	TodayStrategies.getLong(String nm, Long val)	Returns the long value of the system 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, ClassInstantiator 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", using the given class loader.
static <T> List<T>	TodayStrategies.find(Class<T> strategyType, ClassLoader classLoader, ClassInstantiator instantiator)	Load and instantiate the strategy implementations of the given type from "META-INF/today.strategies", 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", 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", 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", 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, ClassInstantiator instantiator, TodayStrategies.FailureHandler failureHandler)	Load and instantiate the strategy implementations of the given type from "META-INF/today.strategies", 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)	Load and instantiate the strategy implementations of the given type from "META-INF/today.strategies", 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", 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", 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", using the configured class loader with 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中的构造器参数

限定符	构造器	说明
(专用程序包)	DefaultInstantiator(TodayStrategies.ArgumentResolver argumentResolver)
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.logging中Nullable的使用

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

修饰符和类型	字段	说明
private String	LogMessage.result

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

修饰符和类型	方法	说明
protected abstract void	Logger.logInternal(Level level, String msg, Throwable t, Object[] args)

cn.taketoday.reflect中Nullable的使用

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

修饰符和类型	字段	说明
private Annotation[]	Property.annotations
private final Field	ReflectivePropertyAccessor.field
private final Field	ReflectiveReadOnlyPropertyAccessor.field
protected final Method	Property.readMethod
private TypeDescriptor	Property.typeDescriptor
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
default Method	GetterMethod.getReadMethod()
Method	Property.getReadMethod()
Method	Property.getWriteMethod()
default Method	SetterMethod.getWriteMethod()
MethodParameter	Property.getWriteMethodParameter()
private MethodParameter	Property.resolveReadMethodParameter()

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

修饰符和类型	方法	说明
private void	Property.addAnnotationsToMap(Map<Class<? extends Annotation>,Annotation> annotationMap, AnnotatedElement object)
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)
(专用程序包)	ReflectivePropertyAccessor(Field field, Method readMethod, Method writeMethod)
(专用程序包)	ReflectivePropertyAccessor(Field field, Method readMethod, Method writeMethod)
(专用程序包)	ReflectivePropertyAccessor(Field field, Method readMethod, Method writeMethod)
(专用程序包)	ReflectiveReadOnlyPropertyAccessor(Field field, Method readMethod)

cn.taketoday.util中Nullable的使用

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

修饰符和类型	字段	说明
private Object[]	ReflectiveMethodInvoker.arguments
private final IntFunction<E[]>	ArrayHolder.arrayGenerator
private static final Method	DefineClassHelper.classLoaderDefineClassMethod
private byte[]	FastByteArrayOutputStream.FastByteArrayInputStream.currentBuffer
private String	StopWatch.currentTaskName	Name of the current task.
private final Class<E>	ArrayHolder.elementClass
private Set<Map.Entry<K,V>>	ConcurrentReferenceHashMap.entrySet	Late binding entry set.
private Set<Map.Entry<K,List<V>>>	UnmodifiableMultiValueMap.entrySet
(专用程序包) ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.EvictionQueue.first
private static BiConsumer<String,byte[]>	DefineClassHelper.generatedClassHandler
private final K	ConcurrentReferenceHashMap.Entry.key
private Set<K>	UnmodifiableMultiValueMap.keySet
(专用程序包) ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.EvictionQueue.last
private ConcurrentReferenceHashMap.Entry<K,V>	ConcurrentReferenceHashMap.EntryIterator.last
private StopWatch.TaskInfo	StopWatch.lastTaskInfo
private static Consumer<Class<?>>	DefineClassHelper.loadedClassHandler
private final Function<Key,Value>	MapCache.mappingFunction	default mapping function
private Method	ReflectiveMethodInvoker.methodObject	The method we will call.
(专用程序包) ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.Node.next
private ConcurrentReferenceHashMap.Entry<K,V>	ConcurrentReferenceHashMap.EntryIterator.next
private final ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.SoftEntryReference.nextReference
private final ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.WeakEntryReference.nextReference
private final PropertyMapper	PropertyMapper.parent
(专用程序包) ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.Node.prev
private static final ProtectionDomain	DefineClassHelper.PROTECTION_DOMAIN
private static Random	MimeTypeUtils.random
private ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.EntryIterator.reference
private ConcurrentReferenceHashMap.Reference<K,V>[]	ConcurrentReferenceHashMap.EntryIterator.references
private Charset	MimeType.resolvedCharset
private final PropertyMapper.SourceOperator	PropertyMapper.sourceOperator
private String	ReflectiveMethodInvoker.staticMethod
private final Class<?>	MethodClassKey.targetClass
protected Class<?>	ReflectiveMethodInvoker.targetClass
private String	ReflectiveMethodInvoker.targetMethod
private Object	ReflectiveMethodInvoker.targetObject
private ArrayList<StopWatch.TaskInfo>	StopWatch.taskList
private ThreadGroup	CustomizableThreadCreator.threadGroup
private static final Throwable	DefineClassHelper.THROWABLE
private String	MimeType.toStringValue
private V	ConcurrentReferenceHashMap.Entry.value
private V	KeyValueHolder.value
private Collection<List<V>>	UnmodifiableMultiValueMap.values
private final String	PropertyPlaceholderHandler.valueSeparator

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

修饰符和类型	方法	说明
String	StopWatch.currentTaskName()	Get the name of the currently running task, if any.
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.
private <T> T	ConcurrentReferenceHashMap.doTask(Object key, ConcurrentReferenceHashMap<K,V>.Task<T> task)
<T> T	ConcurrentReferenceHashMap.Segment.doTask(int hash, Object key, ConcurrentReferenceHashMap<K,V>.Task<T> task)	Apply an update operation to this segment.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry)	Convenience method that can be used for tasks that do not need access to ConcurrentReferenceHashMap.Entries.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry, ConcurrentReferenceHashMap.Entries entries)	Execute the task.
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.
private static List<Method>	ReflectionUtils.findDefaultMethodsOnInterfaces(Class<?> clazz)
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 Field	ReflectionUtils.findFieldIgnoreCase(Class<?> clazz, String name)	Attempt to find a field on the supplied Class with the supplied name.
static <E> E	CollectionUtils.findFirstMatch(Collection<?> source, Collection<E> candidates)	Return the first element in 'candidates' that is contained in 'source'.
private static <K, V> ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.findInChain(ConcurrentReferenceHashMap.Reference<K,V> ref, Object key, int hash)
private static ConcurrentReferenceHashMap.Reference	ConcurrentReferenceHashMap.findInChain(Object key, int hash, ConcurrentReferenceHashMap.Reference[] references)
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.
List<V>	DefaultMultiValueMap.get(Object key)
List<V>	MultiValueMapAdapter.get(Object key)
List<V>	UnmodifiableMultiValueMap.get(Object key)
private Object[]	Instantiator.getArgs(Class<?>[] parameterTypes)
private Function<Class<?>,Object>	Instantiator.getAvailableParameter(Class<?> parameterType)
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 Object	ReflectionUtils.getField(Field field, Object target)	Get the field represented by the supplied field object on the specified target object.
static String	StringUtils.getFilename(String path)	Extract the filename from the given Java resource path, e.g.
static String	StringUtils.getFilenameExtension(String path)	Extract the filename extension from the given Java resource path, e.g.
V	MultiValueMap.getFirst(K key)	Return the first value for the given key.
V	MultiValueMapAdapter.getFirst(K key)
static Class<?>[]	ClassUtils.getGenerics(Class<?> type, Class<?> superClass)	Find generics in target class
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).
(专用程序包) static Method	ReflectionUtils.getMethodOrNull(Class<?> clazz, String methodName, Class<?>[] paramTypes)
ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.Node.getNext()
ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.Reference.getNext()	Return the next reference in the chain, or null if none.
ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.SoftEntryReference.getNext()
ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.WeakEntryReference.getNext()
V	ConcurrentReferenceHashMap.getOrDefault(Object key, V defaultValue)
String	MimeType.getParameter(String name)	Return a generic parameter value, given a parameter name.
ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.Node.getPrevious()
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).
static <T> Class<T>	ClassUtils.getUserClass(String name)	If the class is dynamically generated then the user class will be extracted in a specific format.
V	ConcurrentReferenceHashMap.Entry.getValue()
V	KeyValueHolder.getValue()	Gets the value from this holder.
static Method	ReflectionUtils.getWriteMethod(Class<?> declaredClass, Class<?> type, String name)	find setter method
static Method	ReflectionUtils.getWriteMethod(Field field)	find setter method
private T	Instantiator.instantiate(Instantiator.TypeSupplier typeSupplier)
Object	ReflectiveMethodInvoker.invoke()	Invoke the specified method.
static Object	ReflectionUtils.invokeMethod(Method method, Object target)	Invoke the specified Method against the supplied target object with no arguments.
static Object	ReflectionUtils.invokeMethod(Method method, Object target, Object... args)	Invoke the specified Method against the supplied target object with the supplied arguments.
static <T> T	CollectionUtils.lastElement(List<T> list)	Retrieve the last element of the given List, accessing the highest index.
static <T> T	CollectionUtils.lastElement(Set<T> set)	Retrieve the last element of the given Set, using SortedSet.last() or otherwise iterating over all elements (assuming a linked set).
static <T> T	CollectionUtils.lastElement(T[] array)	Retrieve the last element of the given array, accessing the highest index.
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.
static Locale	StringUtils.parseLocale(String localeValue)	Parse the given String value into a Locale, accepting the Locale.toString() format as well as BCP 47 language tags.
static Locale	StringUtils.parseLocaleString(String localeString)	Parse the given String representation into a Locale.
(专用程序包) ConcurrentLruCache.Node<K,V>	ConcurrentLruCache.EvictionQueue.poll()
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)
private V	ConcurrentReferenceHashMap.put(K key, V value, boolean overwriteExisting)
List<V>	DefaultMultiValueMap.put(K key, List<V> value)
List<V>	MultiValueMapAdapter.put(K key, List<V> value)
List<V>	UnmodifiableMultiValueMap.put(K key, List<V> value)
V	ConcurrentReferenceHashMap.putIfAbsent(K key, V value)
List<V>	MultiValueMapAdapter.putIfAbsent(K key, List<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)
List<V>	DefaultMultiValueMap.remove(Object key)
List<V>	MultiValueMapAdapter.remove(Object key)
V	ConcurrentReferenceHashMap.replace(K key, V value)
String	PlaceholderResolver.resolvePlaceholder(String placeholderName)	Resolve the supplied placeholder name to the replacement value.
String	SystemPropertyUtils.SystemPropertyPlaceholderResolver.resolvePlaceholder(String placeholderName)
static Class<?>	ClassUtils.resolvePrimitiveClassName(String name)
static byte[]	SerializationUtils.serialize(Object object)	Serialize the given object to a byte array.
V	ConcurrentReferenceHashMap.Entry.setValue(V value)
V	KeyValueHolder.setValue(V value)	Replaces the value corresponding to this entry with the specified value (optional operation).
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 String	StringUtils.trimLeadingCharacter(String str, char leadingCharacter)	Trim all occurrences of the supplied leading character from the given String.
static String	StringUtils.trimLeadingWhitespace(String str)	Trim leading whitespace from the given String.
static String	StringUtils.trimTrailingCharacter(String str, char trailingCharacter)	Trim all occurrences of the supplied trailing character from the given String.
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.
Spliterator<Map.Entry<K,List<V>>>	UnmodifiableMultiValueMap.UnmodifiableEntrySet.UnmodifiableEntrySpliterator.trySplit()
Spliterator<List<T>>	UnmodifiableMultiValueMap.UnmodifiableValueCollection.UnmodifiableValueSpliterator.trySplit()
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.
final void	ArrayHolder.add(E... array)
void	ConcurrentReferenceHashMap.Entries.add(V value)	Add a new entry with the specified value.
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	UnmodifiableMultiValueMap.add(K key, V value)
void	ArrayHolder.addAll(Collection<E> list)	add list at end of the array
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.
void	DefaultMultiValueMap.addAll(K key, Collection<? extends V> values)
void	DefaultMultiValueMap.addAll(K key, Enumeration<? 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.
void	MultiValueMapAdapter.addAll(K key, Collection<? extends V> values)
void	UnmodifiableMultiValueMap.addAll(Map<K,List<V>> values)
void	UnmodifiableMultiValueMap.addAll(K key, Collection<? extends V> values)
void	UnmodifiableMultiValueMap.addAll(K key, Enumeration<? extends V> values)
default void	MultiValueMap.addIfAbsent(K key, V value)	Add the given value, only when the map does not contain the given key.
void	UnmodifiableMultiValueMap.addIfAbsent(K key, V value)
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	StringUtils.camelCaseToUnderscore(String name)	Convert a name in camelCase to an underscored name in lower case.
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 ('/').
private static void	FileCopyUtils.close(Closeable closeable)	Attempt to close the supplied Closeable, silently swallowing any exceptions.
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.
boolean	ConcurrentReferenceHashMap.EntrySet.contains(Object o)
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[]	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 <E> Collection<E>	CollectionUtils.createCollection(Class<?> collectionType, Class<?> elementType, int capacity)	Create the most appropriate collection for the given collection type.
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.
static <K, V> Map<K,V>	CollectionUtils.createMap(Class<?> mapType, Class<?> keyType, int capacity)	Create the most appropriate map for the given map type.
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 Path — 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.
private static DataUnit	DataSize.DataSizeUtils.determineDataUnit(String suffix, DataUnit defaultUnit)
private static Class<?>	ClassUtils.doForName(String name, ClassLoader classLoader)
private <T> T	ConcurrentReferenceHashMap.doTask(Object key, ConcurrentReferenceHashMap<K,V>.Task<T> task)
<T> T	ConcurrentReferenceHashMap.Segment.doTask(int hash, Object key, ConcurrentReferenceHashMap<K,V>.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.
final boolean	ConcurrentReferenceHashMap.Entry.equals(Object other)
boolean	DataSize.equals(Object obj)
boolean	LinkedCaseInsensitiveMap.equals(Object other)
boolean	MethodClassKey.equals(Object other)
boolean	MultiValueMapAdapter.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.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry)	Convenience method that can be used for tasks that do not need access to ConcurrentReferenceHashMap.Entries.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry)	Convenience method that can be used for tasks that do not need access to ConcurrentReferenceHashMap.Entries.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry, ConcurrentReferenceHashMap.Entries entries)	Execute the task.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry, ConcurrentReferenceHashMap.Entries entries)	Execute the task.
protected T	ConcurrentReferenceHashMap.Task.execute(ConcurrentReferenceHashMap.Reference<K,V> ref, ConcurrentReferenceHashMap.Entry<K,V> entry, ConcurrentReferenceHashMap.Entries entries)	Execute the task.
static Field	ReflectionUtils.findField(Class<?> clazz, String name, Class<?> type)	Attempt to find a field on the supplied Class with the supplied name and/or type.
static Field	ReflectionUtils.findField(Class<?> clazz, String name, Class<?> type)	Attempt to find a field on the supplied Class with the supplied name and/or type.
private static <K, V> ConcurrentReferenceHashMap.Reference<K,V>	ConcurrentReferenceHashMap.findInChain(ConcurrentReferenceHashMap.Reference<K,V> ref, Object key, int hash)
private static ConcurrentReferenceHashMap.Reference	ConcurrentReferenceHashMap.findInChain(Object key, int hash, ConcurrentReferenceHashMap.Reference[] references)
static Method	ReflectionUtils.findMethod(Class<?> clazz, String name, Class<?>... paramTypes)	Attempt to find a Method on the supplied class with the supplied name and parameter types.
static <T> T	CollectionUtils.findValueOfType(Collection<?> collection, Class<T> type)	Find a single value of the given type in the given Collection.
static <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.
(专用程序包) static Instantiator.TypeSupplier	Instantiator.TypeSupplier.forName(ClassLoader classLoader, String name)
<T> PropertyMapper.Source<T>	PropertyMapper.from(T value)	Return a new PropertyMapper.Source from the specified value that can be used to perform the mapping.
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 Class<?>[]	ClassUtils.getAllInterfacesForClass(Class<?> clazz, ClassLoader classLoader)	Return all interfaces that the given class implements as an array, including ones implemented by superclasses.
static Set<Class<?>>	ClassUtils.getAllInterfacesForClassAsSet(Class<?> clazz, ClassLoader classLoader)	Return all interfaces that the given class implements as a Set, including ones implemented by superclasses.
static String	ClassUtils.getDescriptiveType(Object value)	Return a descriptive name for the given object's type: usually simply the class name, but component type class name + "[]" for arrays, and an appended list of implemented interfaces for JDK proxies.
static String	ObjectUtils.getDisplayString(Object obj)	Return a content-based String representation if obj is not null; otherwise returns an empty String.
static <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 Object	ReflectionUtils.getField(Field field, Object target)	Get the field represented by the supplied field object on the specified target object.
static String	StringUtils.getFilename(String path)	Extract the filename from the given Java resource path, e.g.
static String	StringUtils.getFilenameExtension(String path)	Extract the filename extension from the given Java resource path, e.g.
protected int	ConcurrentReferenceHashMap.getHash(Object o)	Get the hash for a given object, apply an additional hash function to reduce collisions.
static Method	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 ProtectionDomain	ReflectionUtils.getProtectionDomain(Class<?> source)
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 String	ReflectionUtils.getterPropertyName(String name, Class<?> type)	getterPropertyName("isName", boolean.class); -> isName getterPropertyName("isName", String.class); -> getIsName
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 <T> T	ReflectionUtils.invokeConstructor(Constructor<T> constructor, Object[] args)
static Object	ReflectionUtils.invokeMethod(Method method, Object target)	Invoke the specified Method against the supplied target object with no arguments.
static Object	ReflectionUtils.invokeMethod(Method method, Object target, Object... args)	Invoke the specified Method against the supplied target object with the supplied arguments.
static 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	StringUtils.isBlank(CharSequence str)	Check whether the given CharSequence contains actual text.
static boolean	StringUtils.isBlank(String str)	Check whether the given String contains actual text.
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	StringUtils.isEmpty(CharSequence str)
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	StringUtils.isNotEmpty(CharSequence str)
static boolean	ReflectionUtils.isObjectMethod(Method method)	Determine whether the given method is originally declared by Object.
private static boolean	ReflectionUtils.isOverridable(Method method, Class<?> targetClass)	Determine whether the given method is overridable in the given target class.
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.
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, Supplier<U> emptySupplier)
static boolean	StringUtils.matchesCharacter(String str, char singleCharacter)	Test if the given String matches the given single character.
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 <T> T	ReflectionUtils.newInstance(Class<T> type, Class[] parameterTypes, Object[] args)
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 String	ObjectUtils.nullSafeConciseToString(Object obj)	Generate a null-safe, concise string representation of the supplied object as described below.
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.nullSafeHash(Object... elements)	Return a hash code for the given elements, delegating to ObjectUtils.nullSafeHashCode(Object) for each element.
static int	ObjectUtils.nullSafeHashCode(Object obj)	Return a hash code for the given object; typically the value of Object#hashCode()}.
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 Locale	StringUtils.parseLocaleString(String localeString)	Parse the given String representation into a Locale.
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)
static String	StringUtils.prependLeadingSlash(String path)	Check Url, format url like :
V	ConcurrentReferenceHashMap.put(K key, V value)
V	ConcurrentReferenceHashMap.put(K key, V value)
private V	ConcurrentReferenceHashMap.put(K key, V value, boolean overwriteExisting)
private V	ConcurrentReferenceHashMap.put(K key, V value, boolean overwriteExisting)
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 Class<?>	ClassUtils.resolvePrimitiveClassName(String name)
private void	ConcurrentReferenceHashMap.Segment.restructure(boolean allowResize, ConcurrentReferenceHashMap.Reference<K,V> ref)
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	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)
void	UnmodifiableMultiValueMap.set(K key, V value)
default void	MultiValueMap.setAll(Map<K,V> values)	Set the given values under.
static void	ReflectionUtils.setField(Field field, Object target, Object value)	Set the field represented by the supplied field object on the specified target object to the specified value.
static void	DefineClassHelper.setGeneratedClassHandler(BiConsumer<String,byte[]> handler)
static void	DefineClassHelper.setLoadedClassHandler(Consumer<Class<?>> handler)
void	ConcurrentLruCache.Node.setNext(ConcurrentLruCache.Node<K,V> next)
void	ConcurrentLruCache.Node.setPrevious(ConcurrentLruCache.Node<K,V> prev)
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.
(专用程序包) static String	ReflectionUtils.setterPropertyName(String name, Class<?> type)	setterPropertyName("isName", boolean.class); -> setName setterPropertyName("isName", String.class); -> setIsName
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 boolean	StringUtils.simpleMatch(String pattern, String str)	Match a String against the given pattern, supporting the following simple pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy" matches (with an arbitrary number of pattern parts), as well as direct equality.
static boolean	StringUtils.simpleMatch(String pattern, String str)	Match a String against the given pattern, supporting the following simple pattern styles: "xxx*", "*xxx", "*xxx*" and "xxx*yyy" matches (with an arbitrary number of pattern parts), as well as direct equality.
static String[]	StringUtils.split(String source)	Split with Constant.SPLIT_REGEXP
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 List<String>	StringUtils.splitAsList(String source)	Split with Constant.SPLIT_REGEXP
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 String[]	StringUtils.tokenizeToStringArray(String str, String delimiters)	Tokenize the given String into a String array via a StringTokenizer.
static String[]	StringUtils.tokenizeToStringArray(String str, String delimiters, boolean trimTokens, boolean ignoreEmptyTokens)	Tokenize the given String into a String array via a StringTokenizer.
static Object[]	ObjectUtils.toObjectArray(Object source)	Convert the given array (which may be a primitive array) to an object array (if necessary of primitive wrapper objects).
static String	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.trimLeadingCharacter(String str, char leadingCharacter)	Trim all occurrences of the supplied leading character from the given String.
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.trimTrailingCharacter(String str, char trailingCharacter)	Trim all occurrences of the supplied trailing character from the given String.
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中的构造器参数

限定符	构造器	说明
	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.
	KeyValueHolder(K k, V v)
	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.
private	PropertyMapper(PropertyMapper parent, PropertyMapper.SourceOperator sourceOperator)
private	PropertyMapper(PropertyMapper parent, PropertyMapper.SourceOperator sourceOperator)
	PropertyPlaceholderHandler(String placeholderPrefix, String placeholderSuffix, String valueSeparator, boolean ignoreUnresolvablePlaceholders)	Creates a new PropertyPlaceholderHandler that uses the supplied prefix and suffix.
	SoftEntryReference(ConcurrentReferenceHashMap.Entry<K,V> entry, int hash, ConcurrentReferenceHashMap.Reference<K,V> next, ReferenceQueue<ConcurrentReferenceHashMap.Entry<K,V>> queue)
	WeakEntryReference(ConcurrentReferenceHashMap.Entry<K,V> entry, int hash, ConcurrentReferenceHashMap.Reference<K,V> next, ReferenceQueue<ConcurrentReferenceHashMap.Entry<K,V>> queue)

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

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

修饰符和类型	方法	说明
int	NullSafeComparator.compare(T left, T right)
int	NullSafeComparator.compare(T left, T right)
boolean	BooleanComparator.equals(Object other)
boolean	NullSafeComparator.equals(Object other)
private int	InstanceComparator.getOrder(T object)

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

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

修饰符和类型	字段	说明
private Thread	SettableListenableFuture.SettableTask.completingThread
private Object	FutureAdapter.result
private Object	ListenableFutureCallbackRegistry.result

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

修饰符和类型	方法	说明
protected abstract T	FutureAdapter.adapt(S adapteeResult)	Adapts the given adaptee's result into T.
(专用程序包) final T	FutureAdapter.adaptInternal(S adapteeResult)
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.
boolean	SettableListenableFuture.SettableTask.setResultValue(T value)
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中的字段

修饰符和类型	字段	说明
private final Supplier<? extends T>	SingletonSupplier.defaultSupplier
private final Supplier<? extends T>	SingletonSupplier.instanceSupplier
private T	SingletonSupplier.singletonInstance

注释类型为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中的字段

修饰符和类型	字段	说明
private ContentHandler	AbstractXMLReader.contentHandler
private XMLEvent	ListBasedXMLEventReader.currentEvent
private DTDHandler	AbstractXMLReader.dtdHandler
private String	StaxEventXMLReader.encoding
private String	StaxStreamXMLReader.encoding
private EntityResolver	AbstractXMLReader.entityResolver
private ErrorHandler	AbstractXMLReader.errorHandler
private XMLEventReader	StaxSource.eventReader
private XMLEventWriter	StaxResult.eventWriter
private Boolean	AbstractStaxXMLReader.isStandalone
private LexicalHandler	AbstractXMLReader.lexicalHandler
private XMLStreamReader	StaxSource.streamReader
private XMLStreamWriter	StaxResult.streamWriter

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

修饰符和类型	方法	说明
private String	XmlValidationModeDetector.consume(String line)	Consume the next comment token, update the "inComment" flag, and return the remaining content.
String	AbstractXMLStreamReader.getAttributeValue(String namespaceURI, String localName)
String	XMLEventStreamReader.getCharacterEncodingScheme()
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.
ContentHandler	AbstractXMLReader.getContentHandler()
DTDHandler	AbstractXMLReader.getDTDHandler()
String	XMLEventStreamReader.getEncoding()
EntityResolver	AbstractXMLReader.getEntityResolver()
ErrorHandler	AbstractXMLReader.getErrorHandler()
protected LexicalHandler	AbstractXMLReader.getLexicalHandler()
String	SimpleNamespaceContext.getPrefix(String namespaceUri)
Object	AbstractXMLReader.getProperty(String name)	Throws a SAXNotRecognizedException exception when the given property does not signify a lexical handler.
String	XMLEventStreamReader.getVersion()
(专用程序包) XMLEventReader	StaxSource.getXMLEventReader()	Return the XMLEventReader used by this StaxSource.
static XMLEventReader	StaxUtils.getXMLEventReader(Source source)	Return the XMLEventReader for the given StAX Source.
XMLEventWriter	StaxResult.getXMLEventWriter()	Return the XMLEventWriter used by this StaxResult.
static XMLEventWriter	StaxUtils.getXMLEventWriter(Result result)	Return the XMLEventWriter for the given StAX Result.
(专用程序包) XMLStreamReader	StaxSource.getXMLStreamReader()	Return the XMLStreamReader used by this StaxSource.
static XMLStreamReader	StaxUtils.getXMLStreamReader(Source source)	Return the XMLStreamReader for the given StAX Source.
XMLStreamWriter	StaxResult.getXMLStreamWriter()	Return the XMLStreamWriter used by this StaxResult.
static XMLStreamWriter	StaxUtils.getXMLStreamWriter(Result result)	Return the XMLStreamWriter for the given StAX Result.
XMLEvent	ListBasedXMLEventReader.nextTag()
XMLEvent	ListBasedXMLEventReader.peek()

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

修饰符和类型	方法	说明
String	AbstractXMLStreamReader.getAttributeValue(String namespaceURI, String localName)
void	SimpleNamespaceContext.removeBinding(String prefix)	Remove the given prefix from this context.
void	AbstractXMLReader.setContentHandler(ContentHandler contentHandler)
void	StaxEventHandler.setDocumentLocator(Locator locator)
(专用程序包) static void	StaxStreamXMLReader.setDocumentLocator(ContentHandler contentHandler, Location location, String xmlVersion2, String encoding)
(专用程序包) static void	StaxStreamXMLReader.setDocumentLocator(ContentHandler contentHandler, Location location, String xmlVersion2, String encoding)
void	AbstractXMLReader.setDTDHandler(DTDHandler dtdHandler)
void	AbstractXMLReader.setEntityResolver(EntityResolver entityResolver)
void	AbstractXMLReader.setErrorHandler(ErrorHandler errorHandler)
final void	AbstractStaxHandler.startDTD(String name, String publicId, String systemId)
protected void	AbstractStaxXMLReader.startPrefixMapping(String prefix, String namespace)	Start the prefix mapping for the given prefix.