## Uses of Class
org.springframework.core.ResolvableType

- Packages that use ResolvableType
  Package | Description
  --- | ---
  org.springframework.beans | This package contains interfaces and classes for manipulating Java beans.
  org.springframework.beans.factory | The core package implementing Spring's lightweight Inversion of Control (IoC) container.
  org.springframework.beans.factory.config | SPI interfaces and configuration-related convenience classes for bean factories.
  org.springframework.beans.factory.support | Classes supporting the `org.springframework.beans.factory` package.
  org.springframework.context | This package builds on the beans package to add support for message sources and for the Observer design pattern, and the ability for application objects to obtain resources using a consistent API.
  org.springframework.context.event | Support classes for application events, like standard context events.
  org.springframework.context.support | Classes supporting the org.springframework.context package, such as abstract base classes for ApplicationContext implementations and a MessageSource implementation.
  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.
  org.springframework.http.codec | Provides implementations of `Encoder` and `Decoder` for web use.
  org.springframework.http.codec.cbor |
  org.springframework.http.codec.json | JSON encoder and decoder support.
  org.springframework.http.codec.multipart | Multipart support.
  org.springframework.http.codec.protobuf | Provides an encoder and a decoder for Google Protocol Buffers.
  org.springframework.http.codec.xml | XML encoder and decoder support.
  org.springframework.jndi.support | Support classes for JNDI usage, including a JNDI-based BeanFactory implementation.
  org.springframework.messaging.rsocket | Support for the RSocket protocol.
  org.springframework.web.reactive | Top-level package for the `spring-webflux` module that contains `DispatcherHandler`, the main entry point for WebFlux server endpoint processing including key contracts used to map requests to handlers, invoke them, and process the result.
  org.springframework.web.reactive.function | Provides a foundation for both the reactive client and server subpackages.
  org.springframework.web.server | Core interfaces and classes for Spring's generic, reactive web support.

- - ### Uses of ResolvableType in org.springframework.beans

    Methods in org.springframework.beans that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `abstract ResolvableType` | AbstractNestablePropertyAccessor.PropertyHandler.`getResolvableType()`

  - ### Uses of ResolvableType in org.springframework.beans.factory

    Methods in org.springframework.beans.factory that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | NoSuchBeanDefinitionException.`getResolvableType()` Return the required `ResolvableType` of the missing bean, if it was a lookup by type that failed.

    Methods in org.springframework.beans.factory with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `static String[]` | BeanFactoryUtils.`beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, ResolvableType type)` Get all bean names for the given type, including those defined in ancestor factories.
    `static String[]` | BeanFactoryUtils.`beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf, ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)` Get all bean names for the given type, including those defined in ancestor factories.
    `String[]` | ListableBeanFactory.`getBeanNamesForType(ResolvableType type)` Return the names of beans matching the given type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
    `String[]` | ListableBeanFactory.`getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)` Return the names of beans matching the given type (including subclasses), judging from either bean definitions or the value of `getObjectType` in the case of FactoryBeans.
    `<T> ObjectProvider<T>` | BeanFactory.`getBeanProvider(ResolvableType requiredType)` Return a provider for the specified bean, allowing for lazy on-demand retrieval of instances, including availability and uniqueness options.
    `<T> ObjectProvider<T>` | ListableBeanFactory.`getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)` Return a provider for the specified bean, allowing for lazy on-demand retrieval of instances, including availability and uniqueness options.
    `boolean` | BeanFactory.`isTypeMatch(String name, ResolvableType typeToMatch)` Check whether the bean with the given name matches the specified type.

    Constructors in org.springframework.beans.factory with parameters of type ResolvableType
    Constructor and Description
    `NoSuchBeanDefinitionException(ResolvableType type)` Create a new `NoSuchBeanDefinitionException`.
    `NoSuchBeanDefinitionException(ResolvableType type, String message)` Create a new `NoSuchBeanDefinitionException`.
    `NoUniqueBeanDefinitionException(ResolvableType type, Collection<String> beanNamesFound)` Create a new `NoUniqueBeanDefinitionException`.
    `NoUniqueBeanDefinitionException(ResolvableType type, String... beanNamesFound)` Create a new `NoUniqueBeanDefinitionException`.

  - ### Uses of ResolvableType in org.springframework.beans.factory.config

    Methods in org.springframework.beans.factory.config that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | DependencyDescriptor.`getResolvableType()` Build a `ResolvableType` object for the wrapped parameter/field.
    `ResolvableType` | BeanDefinition.`getResolvableType()` Return a resolvable type for this bean definition, based on the bean class or other specific metadata.

    Methods in org.springframework.beans.factory.config with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `Object` | DependencyDescriptor.`resolveNotUnique(ResolvableType type, Map<String,Object> matchingBeans)` Resolve the specified not-unique scenario: by default, throwing a `NoUniqueBeanDefinitionException`.

  - ### Uses of ResolvableType in org.springframework.beans.factory.support

    Methods in org.springframework.beans.factory.support that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | AbstractBeanDefinition.`getResolvableType()` Return a resolvable type for this bean definition.
    `ResolvableType` | RootBeanDefinition.`getResolvableType()` Return a `ResolvableType` for this bean definition, either from runtime-cached type information or from configuration-time `RootBeanDefinition.setTargetType(ResolvableType)` or `AbstractBeanDefinition.setBeanClass(Class)`, also considering resolved factory method definitions.
    `protected ResolvableType` | GenericTypeAwareAutowireCandidateResolver.`getReturnTypeForFactoryMethod(RootBeanDefinition rbd, DependencyDescriptor descriptor)`
    `protected ResolvableType` | AbstractBeanFactory.`getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit)` Determine the bean type for the given FactoryBean definition, as far as possible.
    `protected ResolvableType` | AbstractAutowireCapableBeanFactory.`getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit)` This implementation attempts to query the FactoryBean's generic parameter metadata if present to determine the object type.

    Methods in org.springframework.beans.factory.support with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `String[]` | StaticListableBeanFactory.`getBeanNamesForType(ResolvableType type)`
    `String[]` | DefaultListableBeanFactory.`getBeanNamesForType(ResolvableType type)`
    `String[]` | StaticListableBeanFactory.`getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)`
    `String[]` | DefaultListableBeanFactory.`getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)`
    `<T> ObjectProvider<T>` | StaticListableBeanFactory.`getBeanProvider(ResolvableType requiredType)`
    `<T> ObjectProvider<T>` | DefaultListableBeanFactory.`getBeanProvider(ResolvableType requiredType)`
    `<T> ObjectProvider<T>` | StaticListableBeanFactory.`getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)`
    `<T> ObjectProvider<T>` | DefaultListableBeanFactory.`getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)`
    `boolean` | AbstractBeanFactory.`isTypeMatch(String name, ResolvableType typeToMatch)`
    `boolean` | StaticListableBeanFactory.`isTypeMatch(String name, ResolvableType typeToMatch)`
    `protected boolean` | AbstractBeanFactory.`isTypeMatch(String name, ResolvableType typeToMatch, boolean allowFactoryBeanInit)` Internal extended variant of `AbstractBeanFactory.isTypeMatch(String, ResolvableType)` to check whether the bean with the given name matches the specified type.
    `static <T> BeanDefinitionBuilder` | BeanDefinitionBuilder.`rootBeanDefinition(ResolvableType beanType, Supplier<T> instanceSupplier)` Create a new `BeanDefinitionBuilder` used to construct a `RootBeanDefinition`.
    `void` | RootBeanDefinition.`setTargetType(ResolvableType targetType)` Specify a generics-containing target type of this bean definition, if known in advance.

  - ### Uses of ResolvableType in org.springframework.context

    Methods in org.springframework.context that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | PayloadApplicationEvent.`getResolvableType()`

  - ### Uses of ResolvableType in org.springframework.context.event

    Methods in org.springframework.context.event with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `protected Collection<ApplicationListener<?>>` | AbstractApplicationEventMulticaster.`getApplicationListeners(ApplicationEvent event, ResolvableType eventType)` Return a Collection of ApplicationListeners matching the given event type.
    `void` | ApplicationEventMulticaster.`multicastEvent(ApplicationEvent event, ResolvableType eventType)` Multicast the given application event to appropriate listeners.
    `void` | SimpleApplicationEventMulticaster.`multicastEvent(ApplicationEvent event, ResolvableType eventType)`
    `protected boolean` | AbstractApplicationEventMulticaster.`supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, Class<?> sourceType)` Determine whether the given listener supports the given event.
    `protected boolean` | AbstractApplicationEventMulticaster.`supportsEvent(Class<?> listenerType, ResolvableType eventType)` Filter a listener early through checking its generically declared event type before trying to instantiate it.
    `boolean` | GenericApplicationListenerAdapter.`supportsEventType(ResolvableType eventType)`
    `boolean` | ApplicationListenerMethodAdapter.`supportsEventType(ResolvableType eventType)`
    `boolean` | SourceFilteringListener.`supportsEventType(ResolvableType eventType)`
    `boolean` | GenericApplicationListener.`supportsEventType(ResolvableType eventType)` Determine whether this listener actually supports the given event type.

  - ### Uses of ResolvableType in org.springframework.context.support

    Methods in org.springframework.context.support with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `String[]` | AbstractApplicationContext.`getBeanNamesForType(ResolvableType type)`
    `String[]` | AbstractApplicationContext.`getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)`
    `<T> ObjectProvider<T>` | AbstractApplicationContext.`getBeanProvider(ResolvableType requiredType)`
    `<T> ObjectProvider<T>` | AbstractApplicationContext.`getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)`
    `boolean` | AbstractApplicationContext.`isTypeMatch(String name, ResolvableType typeToMatch)`
    `protected void` | AbstractApplicationContext.`publishEvent(Object event, ResolvableType eventType)` Publish the given event to all listeners.

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

    Fields in org.springframework.core declared as ResolvableType
    Modifier and Type | Field and Description
    --- | ---
    `static ResolvableType` | ResolvableType.`NONE` `ResolvableType` returned when no value is available.

    Methods in org.springframework.core that return ResolvableType
    Modifier and Type | Method and 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, Class<?> implementationClass)` Return a `ResolvableType` for the specified `Field` with a given implementation.
    `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, 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, 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.`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(ParameterizedTypeReference<?> typeReference)` Return a `ResolvableType` for the specified `ParameterizedTypeReference`.
    `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.
    `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 and Description
    --- | ---
    `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.

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

    Methods in org.springframework.core.codec with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | ResourceDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | Decoder.`canDecode(ResolvableType elementType, MimeType mimeType)` Whether the decoder supports the given target element type and the MIME type of the source stream.
    `boolean` | ByteArrayDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | StringDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | AbstractDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | NettyByteBufDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | DataBufferDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | CharSequenceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | NettyByteBufEncoder.`canEncode(ResolvableType type, MimeType mimeType)`
    `boolean` | DataBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | AbstractEncoder.`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` | ByteArrayEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ResourceRegionEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ResourceEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ByteBufferEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `Resource` | ResourceDecoder.`decode(DataBuffer dataBuffer, 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.
    `byte[]` | ByteArrayDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `String` | StringDecoder.`decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `ByteBuffer` | ByteBufferDecoder.`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)`
    `DataBuffer` | DataBufferDecoder.`decode(DataBuffer buffer, 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)`
    `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`.
    `reactor.core.publisher.Flux<String>` | StringDecoder.`decode(Publisher<DataBuffer> input, 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)`
    `reactor.core.publisher.Flux<DataBuffer>` | DataBufferDecoder.`decode(Publisher<DataBuffer> input, 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>` | Decoder.`decodeToMono(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>` | AbstractDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | AbstractDataBufferDecoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `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>` | NettyByteBufEncoder.`encode(Publisher<? extends io.netty.buffer.ByteBuf> 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>` | ResourceRegionEncoder.`encode(Publisher<? extends ResourceRegion> input, 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>` | AbstractSingleValueEncoder.`encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected reactor.core.publisher.Flux<DataBuffer>` | ResourceEncoder.`encode(Resource resource, DataBufferFactory bufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)`
    `protected 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.
    `DataBuffer` | ByteArrayEncoder.`encodeValue(byte[] bytes, 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` | 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.
    `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 and Description
    --- | ---
    `ResolvableType` | TypeDescriptor.`getResolvableType()` Return the underlying `ResolvableType`.

    Constructors in org.springframework.core.convert with parameters of type ResolvableType
    Constructor and Description
    `TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)` Create a new type descriptor from a `ResolvableType`.

  - ### Uses of ResolvableType in org.springframework.http.codec

    Methods in org.springframework.http.codec with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | ServerSentEventHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | FormHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | HttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)` Whether the given object type is supported by this reader.
    `boolean` | DecoderHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | EncoderHttpMessageWriter.`canWrite(ResolvableType elementType, MediaType mediaType)`
    `boolean` | ResourceHttpMessageWriter.`canWrite(ResolvableType elementType, MediaType mediaType)`
    `boolean` | HttpMessageWriter.`canWrite(ResolvableType elementType, MediaType mediaType)` Whether the given object type is supported by this writer.
    `boolean` | FormHttpMessageWriter.`canWrite(ResolvableType elementType, MediaType mediaType)`
    `boolean` | ServerSentEventHttpMessageWriter.`canWrite(ResolvableType elementType, MediaType mediaType)`
    `Map<String,Object>` | HttpMessageDecoder.`getDecodeHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)` Get decoding hints based on the server request or annotations on the target controller method parameter.
    `default Map<String,Object>` | HttpMessageEncoder.`getEncodeHints(ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)` Get decoding hints based on the server request or annotations on the target controller method parameter.
    `default List<MediaType>` | HttpMessageReader.`getReadableMediaTypes(ResolvableType elementType)` Return the list of media types supported by this Reader for the given type of element.
    `List<MediaType>` | DecoderHttpMessageReader.`getReadableMediaTypes(ResolvableType elementType)`
    `protected Map<String,Object>` | ResourceHttpMessageReader.`getReadHints(ResolvableType elementType, ReactiveHttpInputMessage message)`
    `protected Map<String,Object>` | DecoderHttpMessageReader.`getReadHints(ResolvableType elementType, ReactiveHttpInputMessage message)` Get additional hints for decoding based on the input HTTP message.
    `protected Map<String,Object>` | ResourceHttpMessageReader.`getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)`
    `protected Map<String,Object>` | DecoderHttpMessageReader.`getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)` Get additional hints for decoding for example based on the server request or annotations from controller method parameters.
    `List<MediaType>` | EncoderHttpMessageWriter.`getWritableMediaTypes(ResolvableType elementType)`
    `default List<MediaType>` | HttpMessageWriter.`getWritableMediaTypes(ResolvableType elementType)` Return the list of media types supported by this Writer for the given type of element.
    `protected Map<String,Object>` | EncoderHttpMessageWriter.`getWriteHints(ResolvableType streamType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)` Get additional hints for encoding for example based on the server request or annotations from controller method parameters.
    `reactor.core.publisher.Flux<Object>` | ServerSentEventHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<MultiValueMap<String,String>>` | FormHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<T>` | HttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)` Read from the input message and decode to a stream of objects.
    `reactor.core.publisher.Flux<T>` | DecoderHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `default reactor.core.publisher.Flux<T>` | HttpMessageReader.`read(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)` Server-side only alternative to `HttpMessageReader.read(ResolvableType, ReactiveHttpInputMessage, Map)` with additional context available.
    `reactor.core.publisher.Flux<T>` | DecoderHttpMessageReader.`read(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Object>` | ServerSentEventHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<MultiValueMap<String,String>>` | FormHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<T>` | HttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)` Read from the input message and decode to a single object.
    `reactor.core.publisher.Mono<T>` | DecoderHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `default reactor.core.publisher.Mono<T>` | HttpMessageReader.`readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)` Server-side only alternative to `HttpMessageReader.readMono(ResolvableType, ReactiveHttpInputMessage, Map)` with additional, context available.
    `reactor.core.publisher.Mono<T>` | DecoderHttpMessageReader.`readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | ServerSentEventHttpMessageWriter.`write(Publisher<?> input, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | ServerSentEventHttpMessageWriter.`write(Publisher<?> input, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | FormHttpMessageWriter.`write(Publisher<? extends MultiValueMap<String,String>> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | ResourceHttpMessageWriter.`write(Publisher<? extends Resource> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | ResourceHttpMessageWriter.`write(Publisher<? extends Resource> inputStream, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | EncoderHttpMessageWriter.`write(Publisher<? extends T> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | HttpMessageWriter.`write(Publisher<? extends T> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)` Write a given stream of object to the output message.
    `reactor.core.publisher.Mono<Void>` | EncoderHttpMessageWriter.`write(Publisher<? extends T> inputStream, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)`
    `default reactor.core.publisher.Mono<Void>` | HttpMessageWriter.`write(Publisher<? extends T> inputStream, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)` Server-side only alternative to `HttpMessageWriter.write(Publisher, ResolvableType, MediaType, ReactiveHttpOutputMessage, Map)` with additional context available.

  - ### Uses of ResolvableType in org.springframework.http.codec.cbor

    Methods in org.springframework.http.codec.cbor with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `reactor.core.publisher.Flux<Object>` | Jackson2CborDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | Jackson2CborEncoder.`encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`

  - ### Uses of ResolvableType in org.springframework.http.codec.json

    Methods in org.springframework.http.codec.json with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | AbstractJackson2Decoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | KotlinSerializationJsonDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | AbstractJackson2Encoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | KotlinSerializationJsonEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `protected ObjectWriter` | AbstractJackson2Encoder.`customizeWriter(ObjectWriter writer, MimeType mimeType, ResolvableType elementType, Map<String,Object> hints)`
    `protected ObjectWriter` | Jackson2JsonEncoder.`customizeWriter(ObjectWriter writer, MimeType mimeType, ResolvableType elementType, Map<String,Object> hints)`
    `Object` | AbstractJackson2Decoder.`decode(DataBuffer dataBuffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Object>` | AbstractJackson2Decoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Object>` | KotlinSerializationJsonDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Object>` | AbstractJackson2Decoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Object>` | KotlinSerializationJsonDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | AbstractJackson2Encoder.`encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | KotlinSerializationJsonEncoder.`encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `DataBuffer` | AbstractJackson2Encoder.`encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
    `DataBuffer` | KotlinSerializationJsonEncoder.`encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
    `List<MimeType>` | AbstractJackson2Decoder.`getDecodableMimeTypes(ResolvableType targetType)`
    `Map<String,Object>` | AbstractJackson2Decoder.`getDecodeHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)`
    `List<MimeType>` | AbstractJackson2Encoder.`getEncodableMimeTypes(ResolvableType elementType)`
    `Map<String,Object>` | AbstractJackson2Encoder.`getEncodeHints(ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)`
    `protected Map<String,Object>` | Jackson2CodecSupport.`getHints(ResolvableType resolvableType)`
    `protected List<MimeType>` | Jackson2CodecSupport.`getMimeTypes(ResolvableType elementType)`
    `protected MethodParameter` | Jackson2CodecSupport.`getParameter(ResolvableType type)`
    `protected reactor.core.publisher.Flux<DataBuffer>` | AbstractJackson2Decoder.`processInput(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Process the input publisher into a flux.
    `protected reactor.core.publisher.Flux<DataBuffer>` | Jackson2JsonDecoder.`processInput(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected ObjectMapper` | Jackson2CodecSupport.`selectObjectMapper(ResolvableType targetType, MimeType targetMimeType)` Select an ObjectMapper to use, either the main ObjectMapper or another if the handling for the given Class has been customized through `Jackson2CodecSupport.registerObjectMappersForType(Class, Consumer)`.

  - ### Uses of ResolvableType in org.springframework.http.codec.multipart

    Methods in org.springframework.http.codec.multipart with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | MultipartHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | DefaultPartHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | SynchronossPartHttpMessageReader.`canRead(ResolvableType elementType, MediaType mediaType)`
    `boolean` | MultipartWriterSupport.`canWrite(ResolvableType elementType, MediaType mediaType)`
    `reactor.core.publisher.Flux<MultiValueMap<String,Part>>` | MultipartHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Part>` | DefaultPartHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Part>` | SynchronossPartHttpMessageReader.`read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<MultiValueMap<String,Part>>` | MultipartHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage inputMessage, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Part>` | DefaultPartHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Part>` | SynchronossPartHttpMessageReader.`readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | MultipartHttpMessageWriter.`write(Publisher<? extends MultiValueMap<String,?>> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage outputMessage, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | PartHttpMessageWriter.`write(Publisher<? extends Part> parts, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage outputMessage, Map<String,Object> hints)`

  - ### Uses of ResolvableType in org.springframework.http.codec.protobuf

    Methods in org.springframework.http.codec.protobuf with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | ProtobufDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | ProtobufEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `com.google.protobuf.Message` | ProtobufDecoder.`decode(DataBuffer dataBuffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<com.google.protobuf.Message>` | ProtobufDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<com.google.protobuf.Message>` | ProtobufDecoder.`decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<DataBuffer>` | ProtobufEncoder.`encode(Publisher<? extends com.google.protobuf.Message> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `DataBuffer` | ProtobufEncoder.`encodeValue(com.google.protobuf.Message message, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Void>` | ProtobufHttpMessageWriter.`write(Publisher<? extends com.google.protobuf.Message> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)`

  - ### Uses of ResolvableType in org.springframework.http.codec.xml

    Methods in org.springframework.http.codec.xml with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | Jaxb2XmlDecoder.`canDecode(ResolvableType elementType, MimeType mimeType)`
    `boolean` | Jaxb2XmlEncoder.`canEncode(ResolvableType elementType, MimeType mimeType)`
    `Object` | Jaxb2XmlDecoder.`decode(DataBuffer dataBuffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<XMLEvent>` | XmlEventDecoder.`decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Flux<Object>` | Jaxb2XmlDecoder.`decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `reactor.core.publisher.Mono<Object>` | Jaxb2XmlDecoder.`decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`
    `protected reactor.core.publisher.Flux<DataBuffer>` | Jaxb2XmlEncoder.`encode(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`
    `DataBuffer` | Jaxb2XmlEncoder.`encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)`

  - ### Uses of ResolvableType in org.springframework.jndi.support

    Methods in org.springframework.jndi.support with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `<T> ObjectProvider<T>` | SimpleJndiBeanFactory.`getBeanProvider(ResolvableType requiredType)`
    `boolean` | SimpleJndiBeanFactory.`isTypeMatch(String name, ResolvableType typeToMatch)`

  - ### Uses of ResolvableType in org.springframework.messaging.rsocket

    Methods in org.springframework.messaging.rsocket with parameters of type ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `default <T> Decoder<T>` | RSocketStrategies.`decoder(ResolvableType elementType, MimeType mimeType)` Find a compatible Decoder for the given element type.
    `default <T> Encoder<T>` | RSocketStrategies.`encoder(ResolvableType elementType, MimeType mimeType)` Find a compatible Encoder for the given element type.

  - ### Uses of ResolvableType in org.springframework.web.reactive

    Methods in org.springframework.web.reactive that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | HandlerResult.`getReturnType()` Return the type of the value returned from the handler -- e.g.

  - ### Uses of ResolvableType in org.springframework.web.reactive.function

    Methods in org.springframework.web.reactive.function that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | UnsupportedMediaTypeException.`getBodyType()` Return the body type in the context of which this exception was generated.

    Constructors in org.springframework.web.reactive.function with parameters of type ResolvableType
    Constructor and Description
    `UnsupportedMediaTypeException(MediaType contentType, List<MediaType> supportedTypes, ResolvableType bodyType)` Constructor for when trying to encode from or decode to a specific Java type.

  - ### Uses of ResolvableType in org.springframework.web.server

    Methods in org.springframework.web.server that return ResolvableType
    Modifier and Type | Method and Description
    --- | ---
    `ResolvableType` | UnsupportedMediaTypeStatusException.`getBodyType()` Return the body type in the context of which this exception was generated.

    Constructors in org.springframework.web.server with parameters of type ResolvableType
    Constructor and Description
    `UnsupportedMediaTypeStatusException(MediaType contentType, List<MediaType> supportedTypes, ResolvableType bodyType)` Constructor for when trying to encode from or decode to a specific Java type.
    `UnsupportedMediaTypeStatusException(MediaType contentType, List<MediaType> supportedTypes, ResolvableType bodyType, HttpMethod method)` Constructor for when trying to encode from or decode to a specific Java type.