# Uses of Class
org.springframework.core.ResolvableType

Packages that use ResolvableType
Package
Description
org.springframework.aot.generate
Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.core
Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
org.springframework.core.codec
`Encoder` and `Decoder` abstractions to convert between a reactive stream of bytes and Java objects.
org.springframework.core.convert
Type conversion system API.

## Uses of ResolvableType in org.springframework.aot.generate

Methods in org.springframework.aot.generate with parameters of type ResolvableType
Modifier and Type
Method
Description
`static AccessControl`
AccessControl.`forResolvableType(ResolvableType resolvableType)`
Create an `AccessControl` for the given `ResolvableType`.

## Uses of ResolvableType in org.springframework.core

Fields in org.springframework.core declared as ResolvableType
Modifier and Type
Field
Description
`static final ResolvableType`
ResolvableType.`NONE`
`ResolvableType` returned when no value is available.
Methods in org.springframework.core that return ResolvableType
Modifier and Type
Method
Description
`ResolvableType`
ResolvableType.`as(Class<?> type)`
Return this type as a `ResolvableType` of the specified class.
`ResolvableType`
ResolvableType.`asCollection()`
Convenience method to return this type as a resolvable `Collection` type.
`ResolvableType`
ResolvableType.`asMap()`
Convenience method to return this type as a resolvable `Map` type.
`static ResolvableType`
ResolvableType.`forArrayComponent(ResolvableType componentType)`
Return a `ResolvableType` as an array of the specified `componentType`.
`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.`forClass(Class<?> baseType, Class<?> implementationClass)`
Return a `ResolvableType` for the specified base type (interface or base class) with a given implementation class.
`static ResolvableType`
ResolvableType.`forClassWithGenerics(Class<?> clazz, Class<?>... generics)`
Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`
ResolvableType.`forClassWithGenerics(Class<?> clazz, ResolvableType... generics)`
Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`
ResolvableType.`forConstructorParameter(Constructor<?> constructor, int parameterIndex)`
Return a `ResolvableType` for the specified `Constructor` parameter.
`static ResolvableType`
ResolvableType.`forConstructorParameter(Constructor<?> constructor, int parameterIndex, Class<?> implementationClass)`
Return a `ResolvableType` for the specified `Constructor` parameter with a given implementation.
`static ResolvableType`
ResolvableType.`forField(Field field)`
Return a `ResolvableType` for the specified `Field`.
`static ResolvableType`
ResolvableType.`forField(Field field, int nestingLevel)`
Return a `ResolvableType` for the specified `Field` with the given nesting level.
`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, Class<?> implementationClass)`
Return a `ResolvableType` for the specified `Field` with a given implementation.
`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(Method method, int parameterIndex)`
Return a `ResolvableType` for the specified `Method` parameter.
`static ResolvableType`
ResolvableType.`forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)`
Return a `ResolvableType` for the specified `Method` parameter with a given implementation.
`static ResolvableType`
ResolvableType.`forMethodParameter(MethodParameter methodParameter)`
Return a `ResolvableType` for the specified `MethodParameter`.
`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, ResolvableType implementationType)`
Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
`static ResolvableType`
ResolvableType.`forMethodReturnType(Method method)`
Return a `ResolvableType` for the specified `Method` return type.
`static ResolvableType`
ResolvableType.`forMethodReturnType(Method method, Class<?> implementationClass)`
Return a `ResolvableType` for the specified `Method` return type.
`static ResolvableType`
ResolvableType.`forRawClass(Class<?> clazz)`
Return a `ResolvableType` for the specified `Class`, doing assignability checks against the raw class only (analogous to `Class.isAssignableFrom(java.lang.Class<?>)`, which this serves as a wrapper for).
`static ResolvableType`
ResolvableType.`forType(Type type)`
Return a `ResolvableType` for the specified `Type`.
`static ResolvableType`
ResolvableType.`forType(Type type, ResolvableType owner)`
Return a `ResolvableType` for the specified `Type` backed by the given owner type.
`static ResolvableType`
ResolvableType.`forType(ParameterizedTypeReference<?> typeReference)`
Return a `ResolvableType` for the specified `ParameterizedTypeReference`.
`ResolvableType`
ResolvableType.`getComponentType()`
Return the ResolvableType representing the component type of the array or `NONE` if this type does not represent an array.
`ResolvableType`
ResolvableType.`getGeneric(int... indexes)`
Return a `ResolvableType` representing the generic parameter for the given indexes.
`ResolvableType[]`
ResolvableType.`getGenerics()`
Return an array of `ResolvableType ResolvableTypes` representing the generic parameters of this type.
`ResolvableType[]`
ResolvableType.`getInterfaces()`
Return a `ResolvableType` array representing the direct interfaces implemented by this type.
`ResolvableType`
ResolvableType.`getNested(int nestingLevel)`
Return a `ResolvableType` for the specified nesting level.
`ResolvableType`
ResolvableType.`getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)`
Return a `ResolvableType` for the specified nesting level.
`ResolvableType`
ResolvableTypeProvider.`getResolvableType()`
Return the `ResolvableType` describing this instance (or `null` if some sort of default should be applied instead).
`ResolvableType`
ResolvableType.`getSuperType()`
Return a `ResolvableType` representing the direct supertype of this type.
Methods in org.springframework.core with parameters of type ResolvableType
Modifier and Type
Method
Description
`boolean`
ResolvableType.`equalsType(ResolvableType otherType)`
Check for type-level equality with another `ResolvableType`.
`static ResolvableType`
ResolvableType.`forArrayComponent(ResolvableType componentType)`
Return a `ResolvableType` as an array of the specified `componentType`.
`static ResolvableType`
ResolvableType.`forClassWithGenerics(Class<?> clazz, ResolvableType... generics)`
Return a `ResolvableType` for the specified `Class` with pre-declared generics.
`static ResolvableType`
ResolvableType.`forField(Field field, ResolvableType implementationType)`
Return a `ResolvableType` for the specified `Field` with a given implementation.
`static ResolvableType`
ResolvableType.`forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)`
Return a `ResolvableType` for the specified `MethodParameter` with a given implementation type.
`static ResolvableType`
ResolvableType.`forType(Type type, ResolvableType owner)`
Return a `ResolvableType` for the specified `Type` backed by the given owner type.
`boolean`
ResolvableType.`isAssignableFrom(ResolvableType other)`
Determine whether this `ResolvableType` is assignable from the specified other type.
`boolean`
ResolvableType.`isAssignableFromResolvedPart(ResolvableType other)`
Determine whether this `ResolvableType` is assignable from the specified other type, as far as the other type is actually resolvable.

## Uses of ResolvableType in org.springframework.core.codec

Methods in org.springframework.core.codec with parameters of type ResolvableType
Modifier and Type
Method
Description
`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 reactor.core.publisher.Flux<T>`
AbstractCharSequenceDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`final T`
AbstractCharSequenceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<T>`
AbstractDataBufferDecoder.`decode(Publisher<DataBuffer> input, 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)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferDecoder.`decode(Publisher<DataBuffer> input, 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<T>`
Decoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Decode a `DataBuffer` input stream into a Flux of `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.
`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)`
`reactor.core.publisher.Flux<Resource>`
ResourceDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`Resource`
ResourceDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`protected T`
AbstractDataBufferDecoder.`decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
Deprecated.
as of 5.2, please implement `Decoder.decode(DataBuffer, ResolvableType, MimeType, Map)` instead
`reactor.core.publisher.Mono<T>`
AbstractDataBufferDecoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
AbstractDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Mono<T>`
Decoder.`decodeToMono(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(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.
`reactor.core.publisher.Flux<DataBuffer>`
ByteArrayEncoder.`encode(Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
ByteBufferEncoder.`encode(Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
CharSequenceEncoder.`encode(Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
DataBufferEncoder.`encode(Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
Encoder.`encode(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(Publisher<? extends io.netty5.buffer.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
`reactor.core.publisher.Flux<DataBuffer>`
NettyByteBufEncoder.`encode(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)`
`reactor.core.publisher.Flux<DataBuffer>`
ResourceRegionEncoder.`encode(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`
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`
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.
`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)`
`default List<MimeType>`
Decoder.`getDecodableMimeTypes(ResolvableType targetType)`
Return the list of MIME types supported by this Decoder for the given type of element.
`default List<MimeType>`
Encoder.`getEncodableMimeTypes(ResolvableType elementType)`
Return the list of MIME types supported by this Encoder for the given type of element.

## Uses of ResolvableType in org.springframework.core.convert

Methods in org.springframework.core.convert that return ResolvableType
Modifier and Type
Method
Description
`ResolvableType`
TypeDescriptor.`getResolvableType()`
Return the underlying `ResolvableType`.
Constructors in org.springframework.core.convert with parameters of type ResolvableType
Modifier
Constructor
Description
``
`TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)`
Create a new type descriptor from a `ResolvableType`.