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.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.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.
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.
<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.
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.

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).
protected ResolvableType	GenericTypeAwareAutowireCandidateResolver.getReturnTypeForFactoryMethod(RootBeanDefinition rbd, DependencyDescriptor descriptor)

Methods in org.springframework.beans.factory.support with parameters of type ResolvableType

Modifier and Type	Method and Description
String[]	DefaultListableBeanFactory.getBeanNamesForType(ResolvableType type)
String[]	StaticListableBeanFactory.getBeanNamesForType(ResolvableType type)
<T> ObjectProvider<T>	DefaultListableBeanFactory.getBeanProvider(ResolvableType requiredType)
<T> ObjectProvider<T>	StaticListableBeanFactory.getBeanProvider(ResolvableType requiredType)
boolean	AbstractBeanFactory.isTypeMatch(String name, ResolvableType typeToMatch)
boolean	StaticListableBeanFactory.isTypeMatch(String name, ResolvableType typeToMatch)
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	ApplicationListenerMethodAdapter.supportsEventType(ResolvableType eventType)
boolean	SourceFilteringListener.supportsEventType(ResolvableType eventType)
boolean	GenericApplicationListenerAdapter.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)
<T> ObjectProvider<T>	AbstractApplicationContext.getBeanProvider(ResolvableType requiredType)
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 a 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 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 a 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	DataBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	StringDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
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	DataBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	Encoder.canEncode(ResolvableType elementType, MimeType mimeType) Whether the encoder supports the given source element type and the MIME type for the output stream.
boolean	CharSequenceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceRegionEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
reactor.core.publisher.Flux<DataBuffer>	DataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<String>	StringDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<Resource>	ResourceDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	AbstractDataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	Decoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints) Decode a DataBuffer input stream into a Flux of T.
protected DataBuffer	DataBufferDecoder.decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected ByteBuffer	ByteBufferDecoder.decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected String	StringDecoder.decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected Resource	ResourceDecoder.decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected abstract T	AbstractDataBufferDecoder.decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints) How to decode a DataBuffer to the target element type.
protected byte[]	ByteArrayDecoder.decodeDataBuffer(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	AbstractDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	AbstractDataBufferDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints) Decode a DataBuffer input stream into a Mono of T.
reactor.core.publisher.Flux<DataBuffer>	ByteArrayEncoder.encode(org.reactivestreams.Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ByteBufferEncoder.encode(org.reactivestreams.Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	CharSequenceEncoder.encode(org.reactivestreams.Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	DataBufferEncoder.encode(org.reactivestreams.Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ResourceRegionEncoder.encode(org.reactivestreams.Publisher<? extends ResourceRegion> input, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	Encoder.encode(org.reactivestreams.Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints) Encode a stream of Objects of type T into a DataBuffer output stream.
reactor.core.publisher.Flux<DataBuffer>	AbstractSingleValueEncoder.encode(org.reactivestreams.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.

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	HttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType) Whether the given object type is supported by this reader.
boolean	FormHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	DecoderHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	ResourceHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	ServerSentEventHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	FormHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	HttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType) Whether the given object type is supported by this writer.
boolean	EncoderHttpMessageWriter.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.
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>	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<T>	HttpMessageReader.read(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints) Read from the input message and encode to a stream of objects.
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 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<T>	HttpMessageReader.readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints) Read from the input message and encode to a single object.
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 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(org.reactivestreams.Publisher<?> input, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	ServerSentEventHttpMessageWriter.write(org.reactivestreams.Publisher<?> input, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	FormHttpMessageWriter.write(org.reactivestreams.Publisher<? extends MultiValueMap<String,String>> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	ResourceHttpMessageWriter.write(org.reactivestreams.Publisher<? extends Resource> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	ResourceHttpMessageWriter.write(org.reactivestreams.Publisher<? extends Resource> inputStream, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	HttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints) Write an given stream of object to the output message.
reactor.core.publisher.Mono<Void>	EncoderHttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)
default reactor.core.publisher.Mono<Void>	HttpMessageWriter.write(org.reactivestreams.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.
reactor.core.publisher.Mono<Void>	EncoderHttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream, ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response, 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	AbstractJackson2Encoder.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)
reactor.core.publisher.Flux<Object>	AbstractJackson2Decoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<Object>	AbstractJackson2Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	AbstractJackson2Encoder.encode(org.reactivestreams.Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
Map<String,Object>	AbstractJackson2Decoder.getDecodeHints(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response)
Map<String,Object>	AbstractJackson2Encoder.getEncodeHints(ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response)
protected Map<String,Object>	Jackson2CodecSupport.getHints(ResolvableType resolvableType)
protected MethodParameter	Jackson2CodecSupport.getParameter(ResolvableType type)

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	SynchronossPartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	MultipartHttpMessageWriter.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>	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>	SynchronossPartHttpMessageReader.readMono(ResolvableType elementType, ReactiveHttpInputMessage message, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	MultipartHttpMessageWriter.write(org.reactivestreams.Publisher<? extends MultiValueMap<String,?>> inputStream, 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)
reactor.core.publisher.Flux<com.google.protobuf.Message>	ProtobufDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<com.google.protobuf.Message>	ProtobufDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ProtobufEncoder.encode(org.reactivestreams.Publisher<? extends com.google.protobuf.Message> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<Void>	ProtobufHttpMessageWriter.write(org.reactivestreams.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)
reactor.core.publisher.Flux<XMLEvent>	XmlEventDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<Object>	Jaxb2XmlDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<Object>	Jaxb2XmlDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected reactor.core.publisher.Flux<DataBuffer>	Jaxb2XmlEncoder.encode(Object value, DataBufferFactory bufferFactory, ResolvableType type, 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.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.