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	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.
ResolvableType	AbstractBeanDefinition.getResolvableType() Return a resolvable type for this bean definition.
protected ResolvableType	GenericTypeAwareAutowireCandidateResolver.getReturnTypeForFactoryMethod(RootBeanDefinition rbd, DependencyDescriptor descriptor)
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.
protected ResolvableType	AbstractBeanFactory.getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit) Determine the bean type for the given FactoryBean definition, as far as possible.

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	StaticListableBeanFactory.isTypeMatch(String name, ResolvableType typeToMatch)
boolean	AbstractBeanFactory.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	SimpleApplicationEventMulticaster.multicastEvent(ApplicationEvent event, ResolvableType eventType)
void	ApplicationEventMulticaster.multicastEvent(ApplicationEvent event, ResolvableType eventType) Multicast the given application event to appropriate listeners.
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	SourceFilteringListener.supportsEventType(ResolvableType eventType)
boolean	GenericApplicationListener.supportsEventType(ResolvableType eventType) Determine whether this listener actually supports the given event type.
boolean	GenericApplicationListenerAdapter.supportsEventType(ResolvableType eventType)
boolean	ApplicationListenerMethodAdapter.supportsEventType(ResolvableType eventType)

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	ByteArrayDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	StringDecoder.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	NettyByteBufDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	CharSequenceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	NettyByteBufEncoder.canEncode(ResolvableType type, MimeType mimeType)
boolean	ByteBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceRegionEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	DataBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceEncoder.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.
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)
DataBuffer	DataBufferDecoder.decode(DataBuffer buffer, 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.
io.netty.buffer.ByteBuf	NettyByteBufDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
ByteBuffer	ByteBufferDecoder.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<T>	AbstractDataBufferDecoder.decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<String>	StringDecoder.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)
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<Resource>	ResourceDecoder.decode(Publisher<DataBuffer> inputStream, 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>	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.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>	AbstractSingleValueEncoder.encode(Publisher<? extends T> 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.
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	DecoderHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	HttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType) Whether the given object type is supported by this reader.
boolean	ServerSentEventHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	FormHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	ServerSentEventHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	FormHttpMessageWriter.canWrite(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.
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.
List<MediaType>	DecoderHttpMessageReader.getReadableMediaTypes(ResolvableType elementType)
default List<MediaType>	HttpMessageReader.getReadableMediaTypes(ResolvableType elementType) Return the list of media types supported by this Reader for the given type of element.
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 elementType, ReactiveHttpInputMessage message)
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.
protected Map<String,Object>	ResourceHttpMessageReader.getReadHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)
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<T>	DecoderHttpMessageReader.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<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>	DecoderHttpMessageReader.read(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, 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.Mono<T>	DecoderHttpMessageReader.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<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>	DecoderHttpMessageReader.readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, 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<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	KotlinSerializationJsonDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractJackson2Decoder.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>	KotlinSerializationJsonDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, 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.Mono<Object>	KotlinSerializationJsonDecoder.decodeToMono(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.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>	Jackson2JsonDecoder.processInput(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
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 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	DefaultPartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	SynchronossPartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	MultipartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	MultipartWriterSupport.canWrite(ResolvableType elementType, MediaType mediaType)
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.Flux<MultiValueMap<String,Part>>	MultipartHttpMessageReader.read(ResolvableType elementType, ReactiveHttpInputMessage message, 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<MultiValueMap<String,Part>>	MultipartHttpMessageReader.readMono(ResolvableType elementType, ReactiveHttpInputMessage inputMessage, 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.