Uses of Class
org.springframework.core.ResolvableType

Packages that use ResolvableType

Package	Description
org.springframework.aot.generate	Support classes for components that contribute generated code equivalent to a runtime behavior.
org.springframework.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.aot	AOT support for bean factories.
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	CBOR encoder and decoder support.
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.http.converter	Provides an HttpMessageConverter abstraction to convert between Java objects and HTTP input/output messages.
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.test.context.bean.override	Support case-by-case Bean overriding in Spring tests.
org.springframework.test.http	Test support for HTTP concepts.
org.springframework.validation	Provides data binding and validation functionality, for usage in business and/or UI layers.
org.springframework.web.bind.support	Support classes for web data binding.
org.springframework.web.client	Core package of the client-side web support.
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.reactive.function.client	Provides a reactive WebClient that builds on top of the org.springframework.http.client.reactive reactive HTTP adapter layer.
org.springframework.web.server	Core interfaces and classes for Spring's generic, reactive web support.
org.springframework.web.servlet.mvc.method.annotation	MVC infrastructure for annotation-based handler method processing, building on the org.springframework.web.method.annotation package.

Uses of ResolvableType in org.springframework.aot.generate

Methods in org.springframework.aot.generate with parameters of type ResolvableType

Modifier and Type	Method	Description
static AccessControl	AccessControl.forResolvableType(ResolvableType resolvableType)	Create an AccessControl for the given ResolvableType.

Uses of ResolvableType in org.springframework.beans

Methods in org.springframework.beans that return ResolvableType

Modifier and Type	Method	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	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	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

Modifier	Constructor	Description
	NoSuchBeanDefinitionException(ResolvableType type)	Create a new NoSuchBeanDefinitionException.
	NoSuchBeanDefinitionException(ResolvableType type, String message)	Create a new NoSuchBeanDefinitionException.
	NoUniqueBeanDefinitionException(ResolvableType type, String... beanNamesFound)	Create a new NoUniqueBeanDefinitionException.
	NoUniqueBeanDefinitionException(ResolvableType type, Collection<String> beanNamesFound)	Create a new NoUniqueBeanDefinitionException.

Uses of ResolvableType in org.springframework.beans.factory.aot

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

Modifier and Type	Method	Description
CodeWarnings	CodeWarnings.detectDeprecation(ResolvableType resolvableType)	Detect the presence of Deprecated on the signature of the specified ResolvableType.
org.springframework.javapoet.CodeBlock	BeanRegistrationCodeFragments.generateNewBeanDefinitionCode(GenerationContext generationContext, ResolvableType beanType, BeanRegistrationCode beanRegistrationCode)	Generate the code that defines the new bean definition instance.
org.springframework.javapoet.CodeBlock	BeanRegistrationCodeFragmentsDecorator.generateNewBeanDefinitionCode(GenerationContext generationContext, ResolvableType beanType, BeanRegistrationCode beanRegistrationCode)

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

Methods in org.springframework.beans.factory.config that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	BeanDefinition.getResolvableType()	Return a resolvable type for this bean definition, based on the bean class or other specific metadata.
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	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	Description
ResolvableType	RegisteredBean.getBeanType()	Return the ResolvableType of the bean.
ResolvableType	AbstractBeanDefinition.getResolvableType()	Return a resolvable type for this bean definition, based on the bean class or other specific metadata.
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	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	Description
String[]	DefaultListableBeanFactory.getBeanNamesForType(ResolvableType type)
String[]	DefaultListableBeanFactory.getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)
String[]	StaticListableBeanFactory.getBeanNamesForType(ResolvableType type)
String[]	StaticListableBeanFactory.getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit)
<T> ObjectProvider<T>	DefaultListableBeanFactory.getBeanProvider(ResolvableType requiredType)
<T> ObjectProvider<T>	DefaultListableBeanFactory.getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)
<T> ObjectProvider<T>	StaticListableBeanFactory.getBeanProvider(ResolvableType requiredType)
<T> ObjectProvider<T>	StaticListableBeanFactory.getBeanProvider(ResolvableType requiredType, boolean allowEagerInit)
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.
boolean	StaticListableBeanFactory.isTypeMatch(String name, ResolvableType typeToMatch)
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.

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

Modifier	Constructor	Description
	RootBeanDefinition(ResolvableType beanType)	Deprecated. as of 6.0.11, in favor of an extra RootBeanDefinition.setTargetType(ResolvableType) call

Uses of ResolvableType in org.springframework.context

Methods in org.springframework.context that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	PayloadApplicationEvent.getResolvableType()

Constructors in org.springframework.context with parameters of type ResolvableType

Modifier	Constructor	Description
	PayloadApplicationEvent(Object source, T payload, ResolvableType payloadType)	Create a new PayloadApplicationEvent based on the provided payload type.

Uses of ResolvableType in org.springframework.context.event

Methods in org.springframework.context.event with parameters of type ResolvableType

Modifier and Type	Method	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(Class<?> listenerType, ResolvableType eventType)	Filter a listener early through checking its generically declared event type before trying to instantiate it.
protected boolean	AbstractApplicationEventMulticaster.supportsEvent(ApplicationListener<?> listener, ResolvableType eventType, Class<?> sourceType)	Determine whether the given listener supports the given event.
boolean	ApplicationListenerMethodAdapter.supportsEventType(ResolvableType eventType)
boolean	GenericApplicationListener.supportsEventType(ResolvableType eventType)	Determine whether this listener actually supports the given event type.
boolean	GenericApplicationListenerAdapter.supportsEventType(ResolvableType eventType)
boolean	SourceFilteringListener.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	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 typeHint)	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	Description
static final ResolvableType	ResolvableType.NONE	ResolvableType returned when no value is available.

Methods in org.springframework.core that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	ResolvableType.as(Class<?> type)	Return this type as a ResolvableType of the specified class.
ResolvableType	ResolvableType.asCollection()	Convenience method to return this type as a resolvable Collection type.
ResolvableType	ResolvableType.asMap()	Convenience method to return this type as a resolvable Map type.
static ResolvableType	ResolvableType.forArrayComponent(ResolvableType componentType)	Return a ResolvableType as an array of the specified componentType.
static ResolvableType	ResolvableType.forClass(Class<?> clazz)	Return a ResolvableType for the specified Class, using the full generic type information for assignability checks.
static ResolvableType	ResolvableType.forClass(Class<?> baseType, Class<?> implementationClass)	Return a ResolvableType for the specified base type (interface or base class) with a given implementation class.
static ResolvableType	ResolvableType.forClassWithGenerics(Class<?> clazz, Class<?>... generics)	Return a ResolvableType for the specified Class with pre-declared generics.
static ResolvableType	ResolvableType.forClassWithGenerics(Class<?> clazz, ResolvableType... generics)	Return a ResolvableType for the specified Class with pre-declared generics.
static ResolvableType	ResolvableType.forConstructorParameter(Constructor<?> constructor, int parameterIndex)	Return a ResolvableType for the specified Constructor parameter.
static ResolvableType	ResolvableType.forConstructorParameter(Constructor<?> constructor, int parameterIndex, Class<?> implementationClass)	Return a ResolvableType for the specified Constructor parameter with a given implementation.
static ResolvableType	ResolvableType.forField(Field field)	Return a ResolvableType for the specified Field.
static ResolvableType	ResolvableType.forField(Field field, int nestingLevel)	Return a ResolvableType for the specified Field with the given nesting level.
static ResolvableType	ResolvableType.forField(Field field, int nestingLevel, Class<?> implementationClass)	Return a ResolvableType for the specified Field with a given implementation and the given nesting level.
static ResolvableType	ResolvableType.forField(Field field, Class<?> implementationClass)	Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	ResolvableType.forField(Field field, ResolvableType implementationType)	Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	ResolvableType.forInstance(Object instance)	Return a ResolvableType for the specified instance.
static ResolvableType	ResolvableType.forMethodParameter(Method method, int parameterIndex)	Return a ResolvableType for the specified Method parameter.
static ResolvableType	ResolvableType.forMethodParameter(Method method, int parameterIndex, Class<?> implementationClass)	Return a ResolvableType for the specified Method parameter with a given implementation.
static ResolvableType	ResolvableType.forMethodParameter(MethodParameter methodParameter)	Return a ResolvableType for the specified MethodParameter.
static ResolvableType	ResolvableType.forMethodParameter(MethodParameter methodParameter, Type targetType)	Return a ResolvableType for the specified MethodParameter, overriding the target type to resolve with a specific given type.
static ResolvableType	ResolvableType.forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)	Return a ResolvableType for the specified MethodParameter with a given implementation type.
static ResolvableType	ResolvableType.forMethodReturnType(Method method)	Return a ResolvableType for the specified Method return type.
static ResolvableType	ResolvableType.forMethodReturnType(Method method, Class<?> implementationClass)	Return a ResolvableType for the specified Method return type.
static ResolvableType	ResolvableType.forRawClass(Class<?> clazz)	Return a ResolvableType for the specified Class, doing assignability checks against the raw class only (analogous to Class.isAssignableFrom(java.lang.Class<?>), which this serves as a wrapper for).
static ResolvableType	ResolvableType.forType(Type type)	Return a ResolvableType for the specified Type.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType owner)	Return a ResolvableType for the specified Type backed by the given owner type.
static ResolvableType	ResolvableType.forType(ParameterizedTypeReference<?> typeReference)	Return a ResolvableType for the specified ParameterizedTypeReference.
ResolvableType	ResolvableType.getComponentType()	Return the ResolvableType representing the component type of the array or NONE if this type does not represent an array.
ResolvableType	ResolvableType.getGeneric(int... indexes)	Return a ResolvableType representing the generic parameter for the given indexes.
ResolvableType[]	ResolvableType.getGenerics()	Return an array of ResolvableType ResolvableTypes representing the generic parameters of this type.
ResolvableType[]	ResolvableType.getInterfaces()	Return a ResolvableType array representing the direct interfaces implemented by this type.
ResolvableType	ResolvableType.getNested(int nestingLevel)	Return a ResolvableType for the specified nesting level.
ResolvableType	ResolvableType.getNested(int nestingLevel, Map<Integer,Integer> typeIndexesPerLevel)	Return a ResolvableType for the specified nesting level.
ResolvableType	ResolvableTypeProvider.getResolvableType()	Return the ResolvableType describing this instance (or null if some sort of default should be applied instead).
ResolvableType	ResolvableType.getSuperType()	Return a ResolvableType representing the direct supertype of this type.

Methods in org.springframework.core with parameters of type ResolvableType

Modifier and Type	Method	Description
boolean	ResolvableType.equalsType(ResolvableType otherType)	Check for type-level equality with another ResolvableType.
static ResolvableType	ResolvableType.forArrayComponent(ResolvableType componentType)	Return a ResolvableType as an array of the specified componentType.
static ResolvableType	ResolvableType.forClassWithGenerics(Class<?> clazz, ResolvableType... generics)	Return a ResolvableType for the specified Class with pre-declared generics.
static ResolvableType	ResolvableType.forField(Field field, ResolvableType implementationType)	Return a ResolvableType for the specified Field with a given implementation.
static ResolvableType	ResolvableType.forMethodParameter(MethodParameter methodParameter, ResolvableType implementationType)	Return a ResolvableType for the specified MethodParameter with a given implementation type.
static ResolvableType	ResolvableType.forType(Type type, ResolvableType owner)	Return a ResolvableType for the specified Type backed by the given owner type.
boolean	ResolvableType.isAssignableFrom(ResolvableType other)	Determine whether this ResolvableType is assignable from the specified other type.
boolean	ResolvableType.isAssignableFromResolvedPart(ResolvableType other)	Determine whether this ResolvableType is assignable from the specified other type, as far as the other type is actually resolvable.

Uses of ResolvableType in org.springframework.core.codec

Methods in org.springframework.core.codec with parameters of type ResolvableType

Modifier and Type	Method	Description
boolean	AbstractDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	CharBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	DataBufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	Decoder.canDecode(ResolvableType elementType, MimeType mimeType)	Whether the decoder supports the given target element type and the MIME type of the source stream.
boolean	Netty5BufferDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	NettyByteBufDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	StringDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteArrayEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ByteBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	CharSequenceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	DataBufferEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	Encoder.canEncode(ResolvableType elementType, MimeType mimeType)	Whether the encoder supports the given source element type and the MIME type for the output stream.
boolean	Netty5BufferEncoder.canEncode(ResolvableType type, MimeType mimeType)
boolean	NettyByteBufEncoder.canEncode(ResolvableType type, MimeType mimeType)
boolean	ResourceEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ResourceRegionEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
final reactor.core.publisher.Flux<T>	AbstractCharSequenceDecoder.decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
final T	AbstractCharSequenceDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	AbstractDataBufferDecoder.decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
byte[]	ByteArrayDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
ByteBuffer	ByteBufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	DataBufferDecoder.decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferDecoder.decode(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	Decoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Decode a DataBuffer input stream into a Flux of T.
default T	Decoder.decode(DataBuffer buffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)	Decode a data buffer to an Object of type T.
io.netty5.buffer.Buffer	Netty5BufferDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
io.netty.buffer.ByteBuf	NettyByteBufDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<Resource>	ResourceDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
Resource	ResourceDecoder.decode(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected T	AbstractDataBufferDecoder.decodeDataBuffer(DataBuffer buffer, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Deprecated. as of 5.2, please implement Decoder.decode(DataBuffer, ResolvableType, MimeType, Map) instead
reactor.core.publisher.Mono<T>	AbstractDataBufferDecoder.decodeToMono(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	AbstractDecoder.decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	Decoder.decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Decode a DataBuffer input stream into a Mono of T.
final reactor.core.publisher.Flux<DataBuffer>	AbstractSingleValueEncoder.encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected abstract reactor.core.publisher.Flux<DataBuffer>	AbstractSingleValueEncoder.encode(T t, DataBufferFactory dataBufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)	Encode T to an output DataBuffer stream.
reactor.core.publisher.Flux<DataBuffer>	ByteArrayEncoder.encode(Publisher<? extends byte[]> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ByteBufferEncoder.encode(Publisher<? extends ByteBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	CharSequenceEncoder.encode(Publisher<? extends CharSequence> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	DataBufferEncoder.encode(Publisher<? extends DataBuffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	Encoder.encode(Publisher<? extends T> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)	Encode a stream of Objects of type T into a DataBuffer output stream.
reactor.core.publisher.Flux<DataBuffer>	Netty5BufferEncoder.encode(Publisher<? extends io.netty5.buffer.Buffer> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	NettyByteBufEncoder.encode(Publisher<? extends io.netty.buffer.ByteBuf> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected reactor.core.publisher.Flux<DataBuffer>	ResourceEncoder.encode(Resource resource, DataBufferFactory bufferFactory, ResolvableType type, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	ResourceRegionEncoder.encode(Publisher<? extends ResourceRegion> input, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	ByteArrayEncoder.encodeValue(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	ByteBufferEncoder.encodeValue(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	CharSequenceEncoder.encodeValue(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	DataBufferEncoder.encodeValue(DataBuffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
default DataBuffer	Encoder.encodeValue(T value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)	Encode an Object of type T to a data buffer.
DataBuffer	Netty5BufferEncoder.encodeValue(io.netty5.buffer.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	NettyByteBufEncoder.encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
default List<MimeType>	Decoder.getDecodableMimeTypes(ResolvableType targetType)	Return the list of MIME types supported by this Decoder for the given type of element.
default List<MimeType>	Encoder.getEncodableMimeTypes(ResolvableType elementType)	Return the list of MIME types supported by this Encoder for the given type of element.

Uses of ResolvableType in org.springframework.core.convert

Methods in org.springframework.core.convert that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	TypeDescriptor.getResolvableType()	Return the underlying ResolvableType.

Constructors in org.springframework.core.convert with parameters of type ResolvableType

Modifier	Constructor	Description
	TypeDescriptor(ResolvableType resolvableType, Class<?> type, Annotation[] annotations)	Create a new type descriptor from a ResolvableType.

Uses of ResolvableType in org.springframework.http.codec

Methods in org.springframework.http.codec with parameters of type ResolvableType

Modifier and Type	Method	Description
boolean	KotlinSerializationBinaryDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	KotlinSerializationStringDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	KotlinSerializationBinaryEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	KotlinSerializationStringEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	DecoderHttpMessageReader.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	ServerSentEventHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
protected final boolean	KotlinSerializationSupport.canSerialize(ResolvableType type, MimeType mimeType)	Indicates whether the given type can be serialized using Kotlin serialization.
boolean	EncoderHttpMessageWriter.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	ResourceHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	ServerSentEventHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
reactor.core.publisher.Flux<Object>	KotlinSerializationBinaryDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<Object>	KotlinSerializationStringDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<Object>	KotlinSerializationBinaryDecoder.decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Mono<Object>	KotlinSerializationStringDecoder.decodeToMono(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	KotlinSerializationBinaryEncoder.encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<DataBuffer>	KotlinSerializationStringEncoder.encode(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected reactor.core.publisher.Flux<DataBuffer>	KotlinSerializationStringEncoder.encodeNonStream(Publisher<?> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
protected DataBuffer	KotlinSerializationStringEncoder.encodeStreamingValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints, byte[] prefix, byte[] suffix)
DataBuffer	KotlinSerializationBinaryEncoder.encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
DataBuffer	KotlinSerializationStringEncoder.encodeValue(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)
List<MimeType>	KotlinSerializationBinaryDecoder.getDecodableMimeTypes(ResolvableType targetType)
List<MimeType>	KotlinSerializationStringDecoder.getDecodableMimeTypes(ResolvableType targetType)
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.
List<MimeType>	KotlinSerializationBinaryEncoder.getEncodableMimeTypes(ResolvableType elementType)
List<MimeType>	KotlinSerializationStringEncoder.getEncodableMimeTypes(ResolvableType elementType)
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 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>	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>	ResourceHttpMessageReader.getReadHints(ResolvableType elementType, ReactiveHttpInputMessage message)
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 actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)
reactor.core.publisher.Flux<T>	DecoderHttpMessageReader.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)
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>	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.Mono<T>	DecoderHttpMessageReader.readMono(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response, Map<String,Object> hints)
reactor.core.publisher.Mono<T>	DecoderHttpMessageReader.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)
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>	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)
protected final kotlinx.serialization.KSerializer<Object>	KotlinSerializationSupport.serializer(ResolvableType resolvableType)	Returns the serializer that can (de)serialize instances of the given type.
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)
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>	FormHttpMessageWriter.write(Publisher<? extends MultiValueMap<String,String>> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, 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.
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>	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>	ResourceHttpMessageWriter.write(Publisher<? extends Resource> inputStream, 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>	ServerSentEventHttpMessageWriter.write(Publisher<?> input, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String,Object> hints)

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	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	Description
boolean	AbstractJackson2Decoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	AbstractJackson2Encoder.canEncode(ResolvableType elementType, MimeType mimeType)
protected ObjectReader	AbstractJackson2Decoder.customizeReader(ObjectReader reader, ResolvableType elementType, Map<String,Object> hints)	Subclasses can use this method to customize ObjectReader used for reading values.
protected ObjectWriter	AbstractJackson2Encoder.customizeWriter(ObjectWriter writer, MimeType mimeType, ResolvableType elementType, Map<String,Object> hints)	Subclasses can use this method to customize the ObjectWriter used for writing values.
protected ObjectWriter	Jackson2JsonEncoder.customizeWriter(ObjectWriter writer, MimeType mimeType, ResolvableType elementType, Map<String,Object> hints)
reactor.core.publisher.Flux<Object>	AbstractJackson2Decoder.decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
Object	AbstractJackson2Decoder.decode(DataBuffer dataBuffer, ResolvableType targetType, 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.encodeNonStream(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)
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	Description
boolean	DefaultPartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	MultipartHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	PartEventHttpMessageReader.canRead(ResolvableType elementType, MediaType mediaType)
boolean	MultipartHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	PartEventHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
boolean	PartHttpMessageWriter.canWrite(ResolvableType elementType, MediaType mediaType)
reactor.core.publisher.Flux<Part>	DefaultPartHttpMessageReader.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.Flux<PartEvent>	PartEventHttpMessageReader.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<MultiValueMap<String,Part>>	MultipartHttpMessageReader.readMono(ResolvableType elementType, ReactiveHttpInputMessage inputMessage, Map<String,Object> hints)
reactor.core.publisher.Mono<PartEvent>	PartEventHttpMessageReader.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>	PartEventHttpMessageWriter.write(Publisher<? extends PartEvent> partDataStream, 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	Description
boolean	ProtobufDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ProtobufJsonDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	ProtobufEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
boolean	ProtobufJsonEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
reactor.core.publisher.Flux<com.google.protobuf.Message>	ProtobufDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
com.google.protobuf.Message	ProtobufDecoder.decode(DataBuffer dataBuffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)
reactor.core.publisher.Flux<com.google.protobuf.Message>	ProtobufJsonDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)
com.google.protobuf.Message	ProtobufJsonDecoder.decode(DataBuffer dataBuffer, ResolvableType targetType, 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.Mono<com.google.protobuf.Message>	ProtobufJsonDecoder.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)
reactor.core.publisher.Flux<DataBuffer>	ProtobufJsonEncoder.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)
DataBuffer	ProtobufJsonEncoder.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	Description
boolean	Jaxb2XmlDecoder.canDecode(ResolvableType elementType, MimeType mimeType)
boolean	Jaxb2XmlEncoder.canEncode(ResolvableType elementType, MimeType mimeType)
reactor.core.publisher.Flux<Object>	Jaxb2XmlDecoder.decode(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)
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.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.http.converter

Methods in org.springframework.http.converter with parameters of type ResolvableType

Modifier and Type	Method	Description
boolean	AbstractKotlinSerializationHttpMessageConverter.canRead(ResolvableType type, MediaType mediaType)
boolean	AbstractSmartHttpMessageConverter.canRead(ResolvableType type, MediaType mediaType)
boolean	SmartHttpMessageConverter.canRead(ResolvableType type, MediaType mediaType)	Indicates whether the given type can be read by this converter.
boolean	AbstractKotlinSerializationHttpMessageConverter.canWrite(ResolvableType type, Class<?> clazz, MediaType mediaType)
boolean	AbstractSmartHttpMessageConverter.canWrite(ResolvableType type, Class<?> clazz, MediaType mediaType)
boolean	SmartHttpMessageConverter.canWrite(ResolvableType targetType, Class<?> valueClass, MediaType mediaType)	Indicates whether the given class can be written by this converter.
final Object	AbstractKotlinSerializationHttpMessageConverter.read(ResolvableType type, HttpInputMessage inputMessage, Map<String,Object> hints)
T	SmartHttpMessageConverter.read(ResolvableType type, HttpInputMessage inputMessage, Map<String,Object> hints)	Read an object of the given type from the given input message, and returns it.
final void	AbstractSmartHttpMessageConverter.write(T t, ResolvableType type, MediaType contentType, HttpOutputMessage outputMessage, Map<String,Object> hints)	This implementation sets the default headers by calling AbstractHttpMessageConverter.addDefaultHeaders(org.springframework.http.HttpHeaders, T, org.springframework.http.MediaType), and then calls AbstractSmartHttpMessageConverter.writeInternal(T, org.springframework.http.HttpOutputMessage).
void	SmartHttpMessageConverter.write(T t, ResolvableType type, MediaType contentType, HttpOutputMessage outputMessage, Map<String,Object> hints)	Write a given object to the given output message.
protected final void	AbstractKotlinSerializationHttpMessageConverter.writeInternal(Object object, ResolvableType type, HttpOutputMessage outputMessage, Map<String,Object> hints)
protected abstract void	AbstractSmartHttpMessageConverter.writeInternal(T t, ResolvableType type, HttpOutputMessage outputMessage, Map<String,Object> hints)	Abstract template method that writes the actual body.

Uses of ResolvableType in org.springframework.jndi.support

Methods in org.springframework.jndi.support with parameters of type ResolvableType

Modifier and Type	Method	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	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.test.context.bean.override

Methods in org.springframework.test.context.bean.override that return ResolvableType

Modifier and Type	Method	Description
final ResolvableType	BeanOverrideHandler.getBeanType()	Get the bean type to override.

Constructors in org.springframework.test.context.bean.override with parameters of type ResolvableType

Modifier	Constructor	Description
protected	BeanOverrideHandler(Field field, ResolvableType beanType, String beanName, String contextName, BeanOverrideStrategy strategy)	Construct a new BeanOverrideHandler from the supplied values.
protected	BeanOverrideHandler(Field field, ResolvableType beanType, String beanName, BeanOverrideStrategy strategy)	Deprecated, for removal: This API element is subject to removal in a future version. As of Spring Framework 6.2.6, in favor of BeanOverrideHandler(Field, ResolvableType, String, String, BeanOverrideStrategy)

Uses of ResolvableType in org.springframework.test.http

Methods in org.springframework.test.http with parameters of type ResolvableType

Modifier and Type	Method	Description
<T> T	HttpMessageContentConverter.convert(HttpInputMessage message, MediaType mediaType, ResolvableType targetType)	Convert the given HttpInputMessage whose content must match the given MediaType to the requested targetType.
<T> T	HttpMessageContentConverter.convertViaJson(Object value, ResolvableType targetType)	Convert the given raw value to the given targetType by writing it first to JSON and reading it back.

Uses of ResolvableType in org.springframework.validation

Methods in org.springframework.validation that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	DataBinder.getTargetType()	Return the configured type for the target object.

Methods in org.springframework.validation with parameters of type ResolvableType

Modifier and Type	Method	Description
void	DataBinder.setTargetType(ResolvableType targetType)	Set the type for the target object.

Uses of ResolvableType in org.springframework.web.bind.support

Methods in org.springframework.web.bind.support with parameters of type ResolvableType

Modifier and Type	Method	Description
final WebDataBinder	DefaultDataBinderFactory.createBinder(NativeWebRequest webRequest, Object target, String objectName, ResolvableType type)	Variant of WebDataBinderFactory.createBinder(NativeWebRequest, Object, String) with a ResolvableType for which the DataBinder is created.
default WebDataBinder	WebDataBinderFactory.createBinder(NativeWebRequest webRequest, Object target, String objectName, ResolvableType targetType)	Variant of WebDataBinderFactory.createBinder(NativeWebRequest, Object, String) with a ResolvableType for which the DataBinder is created.

Uses of ResolvableType in org.springframework.web.client

Methods in org.springframework.web.client that return types with arguments of type ResolvableType

Modifier and Type	Method	Description
protected Function<ResolvableType,?>	DefaultResponseErrorHandler.initBodyConvertFunction(ClientHttpResponse response, byte[] body)	Return a function for decoding the error content.

Method parameters in org.springframework.web.client with type arguments of type ResolvableType

Modifier and Type	Method	Description
void	RestClientResponseException.setBodyConvertFunction(Function<ResolvableType,?> bodyConvertFunction)	Provide a function to use to decode the response error content via RestClientResponseException.getResponseBodyAs(Class).

Uses of ResolvableType in org.springframework.web.reactive

Methods in org.springframework.web.reactive that return ResolvableType

Modifier and Type	Method	Description
ResolvableType	HandlerResult.getReturnType()	Return the type of the value returned from the handler -- for example, the return type declared on a controller method's signature.

Methods in org.springframework.web.reactive with parameters of type ResolvableType

Modifier and Type	Method	Description
WebExchangeDataBinder	BindingContext.createDataBinder(ServerWebExchange exchange, Object target, String name, ResolvableType targetType)	Create a binder with a target object and a targetType.

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

Methods in org.springframework.web.reactive.function that return ResolvableType

Modifier and Type	Method	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

Modifier	Constructor	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.reactive.function.client

Method parameters in org.springframework.web.reactive.function.client with type arguments of type ResolvableType

Modifier and Type	Method	Description
void	WebClientResponseException.setBodyDecodeFunction(Function<ResolvableType,?> decoderFunction)	Provide a function to find a decoder the given target type.

Uses of ResolvableType in org.springframework.web.server

Methods in org.springframework.web.server that return ResolvableType

Modifier and Type	Method	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

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

Uses of ResolvableType in org.springframework.web.servlet.mvc.method.annotation

Methods in org.springframework.web.servlet.mvc.method.annotation that return ResolvableType

Modifier and Type	Method	Description
protected ResolvableType	AbstractMessageConverterMethodArgumentResolver.getNestedTypeIfNeeded(ResolvableType type)	Return the generic type of the returnType (or of the nested type if it is an HttpEntity or/and an Optional).

Methods in org.springframework.web.servlet.mvc.method.annotation with parameters of type ResolvableType

Modifier and Type	Method	Description
protected ResolvableType	AbstractMessageConverterMethodArgumentResolver.getNestedTypeIfNeeded(ResolvableType type)	Return the generic type of the returnType (or of the nested type if it is an HttpEntity or/and an Optional).