Uses of Class
org.springframework.core.ResolvableType
Package
Description
Support classes for components that contribute generated code equivalent to a
runtime behavior.
This package contains interfaces and classes for manipulating Java beans.
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
AOT support for bean factories.
SPI interfaces and configuration-related convenience classes for bean factories.
Classes supporting the
org.springframework.beans.factory
package.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.
Support classes for application events, like standard context events.
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
Type conversion system API.
JSON encoder and decoder support.
Multipart support.
Provides an encoder and a decoder for
Google Protocol Buffers.
XML encoder and decoder support.
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
Support for the RSocket protocol.
Core package of the client-side web support.
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.Provides a foundation for both the reactive client and server subpackages.
Provides a reactive
WebClient
that builds on top of the
org.springframework.http.client.reactive
reactive HTTP adapter layer.Core interfaces and classes for Spring's generic, reactive web support.
Support for creating a client proxy for an HTTP service annotated with
HttpExchange
methods.-
Uses of ResolvableType in org.springframework.aot.generate
Modifier and TypeMethodDescriptionstatic AccessControl
AccessControl.forResolvableType
(ResolvableType resolvableType) Create anAccessControl
for the givenResolvableType
. -
Uses of ResolvableType in org.springframework.beans
Modifier and TypeMethodDescriptionabstract ResolvableType
AbstractNestablePropertyAccessor.PropertyHandler.getResolvableType()
-
Uses of ResolvableType in org.springframework.beans.factory
Modifier and TypeMethodDescriptionNoSuchBeanDefinitionException.getResolvableType()
Return the requiredResolvableType
of the missing bean, if it was a lookup by type that failed.Modifier and TypeMethodDescriptionstatic 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 ofgetObjectType
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 ofgetObjectType
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.ModifierConstructorDescriptionCreate a newNoSuchBeanDefinitionException
.NoSuchBeanDefinitionException
(ResolvableType type, String message) Create a newNoSuchBeanDefinitionException
.NoUniqueBeanDefinitionException
(ResolvableType type, String... beanNamesFound) Create a newNoUniqueBeanDefinitionException
.NoUniqueBeanDefinitionException
(ResolvableType type, Collection<String> beanNamesFound) Create a newNoUniqueBeanDefinitionException
. -
Uses of ResolvableType in org.springframework.beans.factory.aot
Modifier and TypeMethodDescriptionorg.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
Modifier and TypeMethodDescriptionBeanDefinition.getResolvableType()
Return a resolvable type for this bean definition, based on the bean class or other specific metadata.DependencyDescriptor.getResolvableType()
Build aResolvableType
object for the wrapped parameter/field.Modifier and TypeMethodDescriptionDependencyDescriptor.resolveNotUnique
(ResolvableType type, Map<String, Object> matchingBeans) Resolve the specified not-unique scenario: by default, throwing aNoUniqueBeanDefinitionException
. -
Uses of ResolvableType in org.springframework.beans.factory.support
Modifier and TypeMethodDescriptionRegisteredBean.getBeanType()
Return theResolvableType
of the bean.AbstractBeanDefinition.getResolvableType()
Return a resolvable type for this bean definition.RootBeanDefinition.getResolvableType()
Return aResolvableType
for this bean definition, either from runtime-cached type information or from configuration-timeRootBeanDefinition.setTargetType(ResolvableType)
orAbstractBeanDefinition.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.Modifier and TypeMethodDescriptionString[]
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 ofAbstractBeanFactory.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 newBeanDefinitionBuilder
used to construct aRootBeanDefinition
.void
RootBeanDefinition.setTargetType
(ResolvableType targetType) Specify a generics-containing target type of this bean definition, if known in advance.ModifierConstructorDescriptionRootBeanDefinition
(ResolvableType beanType) Create a new RootBeanDefinition for a singleton. -
Uses of ResolvableType in org.springframework.context
ModifierConstructorDescriptionPayloadApplicationEvent
(Object source, T payload, ResolvableType payloadType) Create a new PayloadApplicationEvent. -
Uses of ResolvableType in org.springframework.context.event
Modifier and TypeMethodDescriptionprotected 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
Modifier and TypeMethodDescriptionString[]
AbstractApplicationContext.getBeanNamesForType
(ResolvableType type) String[]
AbstractApplicationContext.getBeanNamesForType
(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) <T> ObjectProvider<T>
AbstractApplicationContext.getBeanProvider
(ResolvableType requiredType) <T> ObjectProvider<T>
AbstractApplicationContext.getBeanProvider
(ResolvableType requiredType, boolean allowEagerInit) boolean
AbstractApplicationContext.isTypeMatch
(String name, ResolvableType typeToMatch) protected void
AbstractApplicationContext.publishEvent
(Object event, ResolvableType eventType) Publish the given event to all listeners. -
Uses of ResolvableType in org.springframework.core
Modifier and TypeFieldDescriptionstatic final ResolvableType
ResolvableType.NONE
ResolvableType
returned when no value is available.Modifier and TypeMethodDescriptionReturn this type as aResolvableType
of the specified class.ResolvableType.asCollection()
Convenience method to return this type as a resolvableCollection
type.ResolvableType.asMap()
Convenience method to return this type as a resolvableMap
type.static ResolvableType
ResolvableType.forArrayComponent
(ResolvableType componentType) Return aResolvableType
as an array of the specifiedcomponentType
.static ResolvableType
Return aResolvableType
for the specifiedClass
, using the full generic type information for assignability checks.static ResolvableType
Return aResolvableType
for the specified base type (interface or base class) with a given implementation class.static ResolvableType
ResolvableType.forClassWithGenerics
(Class<?> clazz, Class<?>... generics) Return aResolvableType
for the specifiedClass
with pre-declared generics.static ResolvableType
ResolvableType.forClassWithGenerics
(Class<?> clazz, ResolvableType... generics) Return aResolvableType
for the specifiedClass
with pre-declared generics.static ResolvableType
ResolvableType.forConstructorParameter
(Constructor<?> constructor, int parameterIndex) Return aResolvableType
for the specifiedConstructor
parameter.static ResolvableType
ResolvableType.forConstructorParameter
(Constructor<?> constructor, int parameterIndex, Class<?> implementationClass) Return aResolvableType
for the specifiedConstructor
parameter with a given implementation.static ResolvableType
Return aResolvableType
for the specifiedField
.static ResolvableType
Return aResolvableType
for the specifiedField
with the given nesting level.static ResolvableType
Return aResolvableType
for the specifiedField
with a given implementation and the given nesting level.static ResolvableType
Return aResolvableType
for the specifiedField
with a given implementation.static ResolvableType
ResolvableType.forField
(Field field, ResolvableType implementationType) Return aResolvableType
for the specifiedField
with a given implementation.static ResolvableType
ResolvableType.forInstance
(Object instance) Return aResolvableType
for the specified instance.static ResolvableType
ResolvableType.forMethodParameter
(Method method, int parameterIndex) Return aResolvableType
for the specifiedMethod
parameter.static ResolvableType
ResolvableType.forMethodParameter
(Method method, int parameterIndex, Class<?> implementationClass) Return aResolvableType
for the specifiedMethod
parameter with a given implementation.static ResolvableType
ResolvableType.forMethodParameter
(MethodParameter methodParameter) Return aResolvableType
for the specifiedMethodParameter
.static ResolvableType
ResolvableType.forMethodParameter
(MethodParameter methodParameter, Type targetType) Return aResolvableType
for the specifiedMethodParameter
, overriding the target type to resolve with a specific given type.static ResolvableType
ResolvableType.forMethodParameter
(MethodParameter methodParameter, ResolvableType implementationType) Return aResolvableType
for the specifiedMethodParameter
with a given implementation type.static ResolvableType
ResolvableType.forMethodReturnType
(Method method) Return aResolvableType
for the specifiedMethod
return type.static ResolvableType
ResolvableType.forMethodReturnType
(Method method, Class<?> implementationClass) Return aResolvableType
for the specifiedMethod
return type.static ResolvableType
ResolvableType.forRawClass
(Class<?> clazz) Return aResolvableType
for the specifiedClass
, doing assignability checks against the raw class only (analogous toClass.isAssignableFrom(java.lang.Class<?>)
, which this serves as a wrapper for).static ResolvableType
Return aResolvableType
for the specifiedType
.static ResolvableType
ResolvableType.forType
(Type type, ResolvableType owner) Return aResolvableType
for the specifiedType
backed by the given owner type.static ResolvableType
ResolvableType.forType
(ParameterizedTypeReference<?> typeReference) Return aResolvableType
for the specifiedParameterizedTypeReference
.ResolvableType.getComponentType()
Return the ResolvableType representing the component type of the array orNONE
if this type does not represent an array.ResolvableType.getGeneric
(int... indexes) Return aResolvableType
representing the generic parameter for the given indexes.ResolvableType.getGenerics()
Return an array ofResolvableTypes
representing the generic parameters of this type.ResolvableType.getInterfaces()
Return aResolvableType
array representing the direct interfaces implemented by this type.ResolvableType.getNested
(int nestingLevel) Return aResolvableType
for the specified nesting level.Return aResolvableType
for the specified nesting level.ResolvableTypeProvider.getResolvableType()
Return theResolvableType
describing this instance (ornull
if some sort of default should be applied instead).ResolvableType.getSuperType()
Return aResolvableType
representing the direct supertype of this type.Modifier and TypeMethodDescriptionstatic ResolvableType
ResolvableType.forArrayComponent
(ResolvableType componentType) Return aResolvableType
as an array of the specifiedcomponentType
.static ResolvableType
ResolvableType.forClassWithGenerics
(Class<?> clazz, ResolvableType... generics) Return aResolvableType
for the specifiedClass
with pre-declared generics.static ResolvableType
ResolvableType.forField
(Field field, ResolvableType implementationType) Return aResolvableType
for the specifiedField
with a given implementation.static ResolvableType
ResolvableType.forMethodParameter
(MethodParameter methodParameter, ResolvableType implementationType) Return aResolvableType
for the specifiedMethodParameter
with a given implementation type.static ResolvableType
ResolvableType.forType
(Type type, ResolvableType owner) Return aResolvableType
for the specifiedType
backed by the given owner type.boolean
ResolvableType.isAssignableFrom
(ResolvableType other) Determine whether thisResolvableType
is assignable from the specified other type. -
Uses of ResolvableType in org.springframework.core.codec
Modifier and TypeMethodDescriptionboolean
AbstractDecoder.canDecode
(ResolvableType elementType, MimeType mimeType) boolean
ByteArrayDecoder.canDecode
(ResolvableType elementType, MimeType mimeType) boolean
ByteBufferDecoder.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) 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) 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) 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 aDataBuffer
input stream into a Flux ofT
.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) ResourceDecoder.decode
(DataBuffer dataBuffer, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) reactor.core.publisher.Flux<String>
StringDecoder.decode
(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) StringDecoder.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.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 aDataBuffer
input stream into a Mono ofT
.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) EncodeT
to an outputDataBuffer
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 typeT
into aDataBuffer
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) ByteArrayEncoder.encodeValue
(byte[] bytes, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) ByteBufferEncoder.encodeValue
(ByteBuffer byteBuffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) CharSequenceEncoder.encodeValue
(CharSequence charSequence, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) 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.Netty5BufferEncoder.encodeValue
(io.netty5.buffer.Buffer buffer, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) NettyByteBufEncoder.encodeValue
(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) Decoder.getDecodableMimeTypes
(ResolvableType targetType) Return the list of MIME types supported by this Decoder for the given type of element.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
Modifier and TypeMethodDescriptionTypeDescriptor.getResolvableType()
Return the underlyingResolvableType
.ModifierConstructorDescriptionTypeDescriptor
(ResolvableType resolvableType, Class<?> type, Annotation[] annotations) Create a new type descriptor from aResolvableType
. -
Uses of ResolvableType in org.springframework.http.codec
Modifier and TypeMethodDescriptionboolean
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) KotlinSerializationBinaryEncoder.encodeValue
(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) KotlinSerializationStringEncoder.encodeValue
(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) KotlinSerializationBinaryDecoder.getDecodableMimeTypes
(ResolvableType targetType) KotlinSerializationStringDecoder.getDecodableMimeTypes
(ResolvableType targetType) 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.KotlinSerializationBinaryEncoder.getEncodableMimeTypes
(ResolvableType elementType) KotlinSerializationStringEncoder.getEncodableMimeTypes
(ResolvableType elementType) 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.DecoderHttpMessageReader.getReadableMediaTypes
(ResolvableType elementType) HttpMessageReader.getReadableMediaTypes
(ResolvableType elementType) Return the list of media types supported by this Reader for the given type of element.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.DecoderHttpMessageReader.getReadHints
(ResolvableType elementType, ReactiveHttpInputMessage message) Get additional hints for decoding based on the input HTTP message.ResourceHttpMessageReader.getReadHints
(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response) ResourceHttpMessageReader.getReadHints
(ResolvableType elementType, ReactiveHttpInputMessage message) EncoderHttpMessageWriter.getWritableMediaTypes
(ResolvableType elementType) HttpMessageWriter.getWritableMediaTypes
(ResolvableType elementType) Return the list of media types supported by this Writer for the given type of element.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 toHttpMessageReader.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 toHttpMessageReader.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 toHttpMessageWriter.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
Modifier and TypeMethodDescriptionreactor.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
Modifier and TypeMethodDescriptionboolean
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 customizeObjectReader
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 theObjectWriter
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) 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) AbstractJackson2Encoder.encodeValue
(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) AbstractJackson2Decoder.getDecodableMimeTypes
(ResolvableType targetType) AbstractJackson2Decoder.getDecodeHints
(ResolvableType actualType, ResolvableType elementType, ServerHttpRequest request, ServerHttpResponse response) AbstractJackson2Encoder.getEncodableMimeTypes
(ResolvableType elementType) AbstractJackson2Encoder.getEncodeHints
(ResolvableType actualType, ResolvableType elementType, MediaType mediaType, ServerHttpRequest request, ServerHttpResponse response) Jackson2CodecSupport.getHints
(ResolvableType resolvableType) 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 throughJackson2CodecSupport.registerObjectMappersForType(Class, Consumer)
. -
Uses of ResolvableType in org.springframework.http.codec.multipart
Modifier and TypeMethodDescriptionboolean
DefaultPartHttpMessageReader.canRead
(ResolvableType elementType, MediaType mediaType) boolean
MultipartHttpMessageReader.canRead
(ResolvableType elementType, MediaType mediaType) boolean
PartEventHttpMessageReader.canRead
(ResolvableType elementType, MediaType mediaType) boolean
MultipartWriterSupport.canWrite
(ResolvableType elementType, MediaType mediaType) boolean
PartEventHttpMessageWriter.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
Modifier and TypeMethodDescriptionboolean
ProtobufDecoder.canDecode
(ResolvableType elementType, MimeType mimeType) boolean
ProtobufEncoder.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.Mono<com.google.protobuf.Message>
ProtobufDecoder.decodeToMono
(Publisher<DataBuffer> inputStream, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) reactor.core.publisher.Flux<DataBuffer>
ProtobufEncoder.encode
(Publisher<? extends com.google.protobuf.Message> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String, Object> hints) ProtobufEncoder.encodeValue
(com.google.protobuf.Message message, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) reactor.core.publisher.Mono<Void>
ProtobufHttpMessageWriter.write
(Publisher<? extends com.google.protobuf.Message> inputStream, ResolvableType elementType, MediaType mediaType, ReactiveHttpOutputMessage message, Map<String, Object> hints) -
Uses of ResolvableType in org.springframework.http.codec.xml
Modifier and TypeMethodDescriptionboolean
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) 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) Jaxb2XmlEncoder.encodeValue
(Object value, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String, Object> hints) -
Uses of ResolvableType in org.springframework.jndi.support
Modifier and TypeMethodDescription<T> ObjectProvider<T>
SimpleJndiBeanFactory.getBeanProvider
(ResolvableType requiredType) boolean
SimpleJndiBeanFactory.isTypeMatch
(String name, ResolvableType typeToMatch) -
Uses of ResolvableType in org.springframework.messaging.rsocket
Modifier and TypeMethodDescriptiondefault <T> Decoder<T>
RSocketStrategies.decoder
(ResolvableType elementType, MimeType mimeType) Find a compatible Decoder for the given element type.default <T> Encoder<T>
RSocketStrategies.encoder
(ResolvableType elementType, MimeType mimeType) Find a compatible Encoder for the given element type. -
Uses of ResolvableType in org.springframework.web.client
Modifier and TypeMethodDescriptionprotected Function<ResolvableType,
?> DefaultResponseErrorHandler.initBodyConvertFunction
(ClientHttpResponse response, byte[] body) Return a function for decoding the error content.Modifier and TypeMethodDescriptionvoid
RestClientResponseException.setBodyConvertFunction
(Function<ResolvableType, ?> bodyConvertFunction) Provide a function to use to decode the response error content viaRestClientResponseException.getResponseBodyAs(Class)
. -
Uses of ResolvableType in org.springframework.web.reactive
Modifier and TypeMethodDescriptionHandlerResult.getReturnType()
Return the type of the value returned from the handler -- e.g. -
Uses of ResolvableType in org.springframework.web.reactive.function
Modifier and TypeMethodDescriptionUnsupportedMediaTypeException.getBodyType()
Return the body type in the context of which this exception was generated.ModifierConstructorDescriptionUnsupportedMediaTypeException
(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
Modifier and TypeMethodDescriptionvoid
WebClientResponseException.setBodyDecodeFunction
(Function<ResolvableType, ?> decoderFunction) Provide a function to find a decoder the given target type. -
Uses of ResolvableType in org.springframework.web.server
Modifier and TypeMethodDescriptionUnsupportedMediaTypeStatusException.getBodyType()
Return the body type in the context of which this exception was generated.ModifierConstructorDescriptionUnsupportedMediaTypeStatusException
(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.service.invoker
Modifier and TypeMethodDescription<T,
P extends Publisher<T>>
HttpRequestValues.BuilderHttpRequestValues.Builder.addRequestPart
(String name, P publisher, ResolvableType type) Variant ofHttpRequestValues.Builder.addRequestPart(String, Object)
that allows the part value to be produced by aPublisher
.
Decoder.decode(DataBuffer, ResolvableType, MimeType, Map)
instead