Package | Description |
---|---|
org.springframework.beans |
This package contains interfaces and classes for manipulating Java beans.
|
org.springframework.beans.factory |
The core package implementing Spring's lightweight Inversion of Control (IoC) container.
|
org.springframework.beans.factory.config |
SPI interfaces and configuration-related convenience classes for bean factories.
|
org.springframework.beans.factory.support |
Classes supporting the
org.springframework.beans.factory package. |
org.springframework.context |
This package builds on the beans package to add support for
message sources and for the Observer design pattern, and the
ability for application objects to obtain resources using a
consistent API.
|
org.springframework.context.event |
Support classes for application events, like standard context events.
|
org.springframework.context.support |
Classes supporting the org.springframework.context package,
such as abstract base classes for ApplicationContext
implementations and a MessageSource implementation.
|
org.springframework.core |
Provides basic classes for exception handling and version detection,
and other core helpers that are not specific to any part of the framework.
|
org.springframework.core.codec | |
org.springframework.core.convert |
Type conversion system API.
|
org.springframework.http.codec | |
org.springframework.http.codec.cbor | |
org.springframework.http.codec.json |
JSON encoder and decoder support.
|
org.springframework.http.codec.multipart |
Multipart support.
|
org.springframework.http.codec.protobuf |
Provides an encoder and a decoder for
Google Protocol Buffers.
|
org.springframework.http.codec.xml |
XML encoder and decoder support.
|
org.springframework.jndi.support |
Support classes for JNDI usage,
including a JNDI-based BeanFactory implementation.
|
org.springframework.messaging.rsocket |
Support for the RSocket protocol.
|
org.springframework.web.reactive |
Top-level package for the
spring-webflux module that contains
DispatcherHandler , the main entry
point for WebFlux server endpoint processing including key contracts used to
map requests to handlers, invoke them, and process the result. |
org.springframework.web.reactive.function |
Provides a foundation for both the reactive client and server subpackages.
|
org.springframework.web.server |
Core interfaces and classes for Spring's generic, reactive web support.
|
Modifier and Type | Method and Description |
---|---|
abstract ResolvableType |
AbstractNestablePropertyAccessor.PropertyHandler.getResolvableType() |
Modifier and Type | Method and Description |
---|---|
ResolvableType |
NoSuchBeanDefinitionException.getResolvableType()
Return the required
ResolvableType of the missing bean, if it was a lookup
by type that failed. |
Modifier and Type | Method and Description |
---|---|
static String[] |
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf,
ResolvableType type)
Get all bean names for the given type, including those defined in ancestor
factories.
|
static String[] |
BeanFactoryUtils.beanNamesForTypeIncludingAncestors(ListableBeanFactory lbf,
ResolvableType type,
boolean includeNonSingletons,
boolean allowEagerInit)
Get all bean names for the given type, including those defined in ancestor
factories.
|
String[] |
ListableBeanFactory.getBeanNamesForType(ResolvableType type)
Return the names of beans matching the given type (including subclasses),
judging from either bean definitions or the value of
getObjectType
in the case of FactoryBeans. |
String[] |
ListableBeanFactory.getBeanNamesForType(ResolvableType type,
boolean includeNonSingletons,
boolean allowEagerInit)
Return the names of beans matching the given type (including subclasses),
judging from either bean definitions or the value of
getObjectType
in the case of FactoryBeans. |
<T> ObjectProvider<T> |
BeanFactory.getBeanProvider(ResolvableType requiredType)
Return a provider for the specified bean, allowing for lazy on-demand retrieval
of instances, including availability and uniqueness options.
|
<T> ObjectProvider<T> |
ListableBeanFactory.getBeanProvider(ResolvableType requiredType,
boolean allowEagerInit)
Return a provider for the specified bean, allowing for lazy on-demand retrieval
of instances, including availability and uniqueness options.
|
boolean |
BeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch)
Check whether the bean with the given name matches the specified type.
|
Constructor and Description |
---|
NoSuchBeanDefinitionException(ResolvableType type)
Create a new
NoSuchBeanDefinitionException . |
NoSuchBeanDefinitionException(ResolvableType type,
String message)
Create a new
NoSuchBeanDefinitionException . |
NoUniqueBeanDefinitionException(ResolvableType type,
Collection<String> beanNamesFound)
Create a new
NoUniqueBeanDefinitionException . |
NoUniqueBeanDefinitionException(ResolvableType type,
String... beanNamesFound)
Create a new
NoUniqueBeanDefinitionException . |
Modifier and Type | Method and Description |
---|---|
ResolvableType |
DependencyDescriptor.getResolvableType()
Build a
ResolvableType object for the wrapped parameter/field. |
ResolvableType |
BeanDefinition.getResolvableType()
Return a resolvable type for this bean definition,
based on the bean class or other specific metadata.
|
Modifier and Type | Method and Description |
---|---|
Object |
DependencyDescriptor.resolveNotUnique(ResolvableType type,
Map<String,Object> matchingBeans)
Resolve the specified not-unique scenario: by default,
throwing a
NoUniqueBeanDefinitionException . |
Modifier and Type | Method and Description |
---|---|
ResolvableType |
RootBeanDefinition.getResolvableType()
Return a
ResolvableType for this bean definition,
either from runtime-cached type information or from configuration-time
RootBeanDefinition.setTargetType(ResolvableType) or AbstractBeanDefinition.setBeanClass(Class) ,
also considering resolved factory method definitions. |
ResolvableType |
AbstractBeanDefinition.getResolvableType()
Return a resolvable type for this bean definition.
|
protected ResolvableType |
GenericTypeAwareAutowireCandidateResolver.getReturnTypeForFactoryMethod(RootBeanDefinition rbd,
DependencyDescriptor descriptor) |
protected ResolvableType |
AbstractAutowireCapableBeanFactory.getTypeForFactoryBean(String beanName,
RootBeanDefinition mbd,
boolean allowInit)
This implementation attempts to query the FactoryBean's generic parameter metadata
if present to determine the object type.
|
protected ResolvableType |
AbstractBeanFactory.getTypeForFactoryBean(String beanName,
RootBeanDefinition mbd,
boolean allowInit)
Determine the bean type for the given FactoryBean definition, as far as possible.
|
Modifier and Type | Method and Description |
---|---|
String[] |
StaticListableBeanFactory.getBeanNamesForType(ResolvableType type) |
String[] |
DefaultListableBeanFactory.getBeanNamesForType(ResolvableType type) |
String[] |
StaticListableBeanFactory.getBeanNamesForType(ResolvableType type,
boolean includeNonSingletons,
boolean allowEagerInit) |
String[] |
DefaultListableBeanFactory.getBeanNamesForType(ResolvableType type,
boolean includeNonSingletons,
boolean allowEagerInit) |
<T> ObjectProvider<T> |
StaticListableBeanFactory.getBeanProvider(ResolvableType requiredType) |
<T> ObjectProvider<T> |
DefaultListableBeanFactory.getBeanProvider(ResolvableType requiredType) |
<T> ObjectProvider<T> |
StaticListableBeanFactory.getBeanProvider(ResolvableType requiredType,
boolean allowEagerInit) |
<T> ObjectProvider<T> |
DefaultListableBeanFactory.getBeanProvider(ResolvableType requiredType,
boolean allowEagerInit) |
boolean |
StaticListableBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
boolean |
AbstractBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
protected boolean |
AbstractBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch,
boolean allowFactoryBeanInit)
Internal extended variant of
AbstractBeanFactory.isTypeMatch(String, ResolvableType)
to check whether the bean with the given name matches the specified type. |
void |
RootBeanDefinition.setTargetType(ResolvableType targetType)
Specify a generics-containing target type of this bean definition, if known in advance.
|
Modifier and Type | Method and Description |
---|---|
ResolvableType |
PayloadApplicationEvent.getResolvableType() |
Modifier and Type | Method and Description |
---|---|
protected Collection<ApplicationListener<?>> |
AbstractApplicationEventMulticaster.getApplicationListeners(ApplicationEvent event,
ResolvableType eventType)
Return a Collection of ApplicationListeners matching the given
event type.
|
void |
SimpleApplicationEventMulticaster.multicastEvent(ApplicationEvent event,
ResolvableType eventType) |
void |
ApplicationEventMulticaster.multicastEvent(ApplicationEvent event,
ResolvableType eventType)
Multicast the given application event to appropriate listeners.
|
protected boolean |
AbstractApplicationEventMulticaster.supportsEvent(ApplicationListener<?> listener,
ResolvableType eventType,
Class<?> sourceType)
Determine whether the given listener supports the given event.
|
protected boolean |
AbstractApplicationEventMulticaster.supportsEvent(Class<?> listenerType,
ResolvableType eventType)
Filter a listener early through checking its generically declared event
type before trying to instantiate it.
|
boolean |
SourceFilteringListener.supportsEventType(ResolvableType eventType) |
boolean |
GenericApplicationListener.supportsEventType(ResolvableType eventType)
Determine whether this listener actually supports the given event type.
|
boolean |
GenericApplicationListenerAdapter.supportsEventType(ResolvableType eventType) |
boolean |
ApplicationListenerMethodAdapter.supportsEventType(ResolvableType eventType) |
Modifier and Type | Method and Description |
---|---|
String[] |
AbstractApplicationContext.getBeanNamesForType(ResolvableType type) |
String[] |
AbstractApplicationContext.getBeanNamesForType(ResolvableType type,
boolean includeNonSingletons,
boolean allowEagerInit) |
<T> ObjectProvider<T> |
AbstractApplicationContext.getBeanProvider(ResolvableType requiredType) |
<T> ObjectProvider<T> |
AbstractApplicationContext.getBeanProvider(ResolvableType requiredType,
boolean allowEagerInit) |
boolean |
AbstractApplicationContext.isTypeMatch(String name,
ResolvableType typeToMatch) |
protected void |
AbstractApplicationContext.publishEvent(Object event,
ResolvableType eventType)
Publish the given event to all listeners.
|
Modifier and Type | Field and Description |
---|---|
static ResolvableType |
ResolvableType.NONE
ResolvableType returned when no value is available. |
Modifier and Type | Method and Description |
---|---|
ResolvableType |
ResolvableType.as(Class<?> type)
Return this type as a
ResolvableType of the specified class. |
ResolvableType |
ResolvableType.asCollection()
Convenience method to return this type as a resolvable
Collection type. |
ResolvableType |
ResolvableType.asMap()
Convenience method to return this type as a resolvable
Map type. |
static ResolvableType |
ResolvableType.forArrayComponent(ResolvableType componentType)
Return a
ResolvableType as a array of the specified componentType . |
static ResolvableType |
ResolvableType.forClass(Class<?> clazz)
Return a
ResolvableType for the specified Class ,
using the full generic type information for assignability checks. |
static ResolvableType |
ResolvableType.forClass(Class<?> baseType,
Class<?> implementationClass)
Return a
ResolvableType for the specified base type
(interface or base class) with a given implementation class. |
static ResolvableType |
ResolvableType.forClassWithGenerics(Class<?> clazz,
Class<?>... generics)
Return a
ResolvableType for the specified Class with pre-declared generics. |
static ResolvableType |
ResolvableType.forClassWithGenerics(Class<?> clazz,
ResolvableType... generics)
Return a
ResolvableType for the specified Class with pre-declared generics. |
static ResolvableType |
ResolvableType.forConstructorParameter(Constructor<?> constructor,
int parameterIndex)
Return a
ResolvableType for the specified Constructor parameter. |
static ResolvableType |
ResolvableType.forConstructorParameter(Constructor<?> constructor,
int parameterIndex,
Class<?> implementationClass)
Return a
ResolvableType for the specified Constructor parameter
with a given implementation. |
static ResolvableType |
ResolvableType.forField(Field field)
Return a
ResolvableType for the specified Field . |
static ResolvableType |
ResolvableType.forField(Field field,
Class<?> implementationClass)
Return a
ResolvableType for the specified Field with a given
implementation. |
static ResolvableType |
ResolvableType.forField(Field field,
int nestingLevel)
Return a
ResolvableType for the specified Field with the
given nesting level. |
static ResolvableType |
ResolvableType.forField(Field field,
int nestingLevel,
Class<?> implementationClass)
Return a
ResolvableType for the specified Field with a given
implementation and the given nesting level. |
static ResolvableType |
ResolvableType.forField(Field field,
ResolvableType implementationType)
Return a
ResolvableType for the specified Field with a given
implementation. |
static ResolvableType |
ResolvableType.forInstance(Object instance)
Return a
ResolvableType for the specified instance. |
static ResolvableType |
ResolvableType.forMethodParameter(Method method,
int parameterIndex)
Return a
ResolvableType for the specified Method parameter. |
static ResolvableType |
ResolvableType.forMethodParameter(Method method,
int parameterIndex,
Class<?> implementationClass)
Return a
ResolvableType for the specified Method parameter with a
given implementation. |
static ResolvableType |
ResolvableType.forMethodParameter(MethodParameter methodParameter)
Return a
ResolvableType for the specified MethodParameter . |
static ResolvableType |
ResolvableType.forMethodParameter(MethodParameter methodParameter,
ResolvableType implementationType)
Return a
ResolvableType for the specified MethodParameter with a
given implementation type. |
static ResolvableType |
ResolvableType.forMethodParameter(MethodParameter methodParameter,
Type targetType)
Return a
ResolvableType for the specified MethodParameter ,
overriding the target type to resolve with a specific given type. |
static ResolvableType |
ResolvableType.forMethodReturnType(Method method)
Return a
ResolvableType for the specified Method return type. |
static ResolvableType |
ResolvableType.forMethodReturnType(Method method,
Class<?> implementationClass)
Return a
ResolvableType for the specified Method return type. |
static ResolvableType |
ResolvableType.forRawClass(Class<?> clazz)
Return a
ResolvableType for the specified Class ,
doing assignability checks against the raw class only (analogous to
Class.isAssignableFrom(java.lang.Class<?>) , which this serves as a wrapper for. |
static ResolvableType |
ResolvableType.forType(ParameterizedTypeReference<?> typeReference)
Return a
ResolvableType for the specified ParameterizedTypeReference . |
static ResolvableType |
ResolvableType.forType(Type type)
Return a
ResolvableType for the specified Type . |
static ResolvableType |
ResolvableType.forType(Type type,
ResolvableType owner)
Return a
ResolvableType for the specified Type backed by the given
owner type. |
ResolvableType |
ResolvableType.getComponentType()
Return the ResolvableType representing the component type of the array or
NONE if this type does not represent an array. |
ResolvableType |
ResolvableType.getGeneric(int... indexes)
Return a
ResolvableType representing the generic parameter for the
given indexes. |
ResolvableType[] |
ResolvableType.getGenerics()
Return an array of
ResolvableTypes representing the generic parameters of
this type. |
ResolvableType[] |
ResolvableType.getInterfaces()
Return a
ResolvableType array representing the direct interfaces
implemented by this type. |
ResolvableType |
ResolvableType.getNested(int nestingLevel)
Return a
ResolvableType for the specified nesting level. |
ResolvableType |
ResolvableType.getNested(int nestingLevel,
Map<Integer,Integer> typeIndexesPerLevel)
Return a
ResolvableType for the specified nesting level. |
ResolvableType |
ResolvableTypeProvider.getResolvableType()
Return the
ResolvableType describing this instance
(or null if some sort of default should be applied instead). |
ResolvableType |
ResolvableType.getSuperType()
Return a
ResolvableType representing the direct supertype of this type. |
Modifier and Type | Method and Description |
---|---|
static ResolvableType |
ResolvableType.forArrayComponent(ResolvableType componentType)
Return a
ResolvableType as a array of the specified componentType . |
static ResolvableType |
ResolvableType.forClassWithGenerics(Class<?> clazz,
ResolvableType... generics)
Return a
ResolvableType for the specified Class with pre-declared generics. |
static ResolvableType |
ResolvableType.forField(Field field,
ResolvableType implementationType)
Return a
ResolvableType for the specified Field with a given
implementation. |
static ResolvableType |
ResolvableType.forMethodParameter(MethodParameter methodParameter,
ResolvableType implementationType)
Return a
ResolvableType for the specified MethodParameter with a
given implementation type. |
static ResolvableType |
ResolvableType.forType(Type type,
ResolvableType owner)
Return a
ResolvableType for the specified Type backed by the given
owner type. |
boolean |
ResolvableType.isAssignableFrom(ResolvableType other)
Determine whether this
ResolvableType is assignable from the
specified other type. |
Modifier and Type | Method and Description |
---|---|
boolean |
ByteArrayDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
StringDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
DataBufferDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
Decoder.canDecode(ResolvableType elementType,
MimeType mimeType)
Whether the decoder supports the given target element type and the MIME
type of the source stream.
|
boolean |
NettyByteBufDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ByteBufferDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ResourceDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
AbstractDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
CharSequenceEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
NettyByteBufEncoder.canEncode(ResolvableType type,
MimeType mimeType) |
boolean |
ByteBufferEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ResourceRegionEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
DataBufferEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ByteArrayEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
AbstractEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ResourceEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
Encoder.canEncode(ResolvableType elementType,
MimeType mimeType)
Whether the encoder supports the given source element type and the MIME
type for the output stream.
|
byte[] |
ByteArrayDecoder.decode(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
String |
StringDecoder.decode(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
DataBufferDecoder.decode(DataBuffer buffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
default T |
Decoder.decode(DataBuffer buffer,
ResolvableType targetType,
MimeType mimeType,
Map<String,Object> hints)
Decode a data buffer to an Object of type T.
|
io.netty.buffer.ByteBuf |
NettyByteBufDecoder.decode(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
ByteBuffer |
ByteBufferDecoder.decode(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
Resource |
ResourceDecoder.decode(DataBuffer dataBuffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<T> |
AbstractDataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<String> |
StringDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
DataBufferDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<T> |
Decoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints)
Decode a
DataBuffer input stream into a Flux of T . |
reactor.core.publisher.Flux<Resource> |
ResourceDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
protected T |
AbstractDataBufferDecoder.decodeDataBuffer(DataBuffer buffer,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints)
Deprecated.
as of 5.2, please implement
Decoder.decode(DataBuffer, ResolvableType, MimeType, Map) instead |
reactor.core.publisher.Mono<T> |
AbstractDataBufferDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<T> |
Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints)
Decode a
DataBuffer input stream into a Mono of T . |
reactor.core.publisher.Mono<T> |
AbstractDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
ByteArrayEncoder.encode(org.reactivestreams.Publisher<? extends byte[]> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
NettyByteBufEncoder.encode(org.reactivestreams.Publisher<? extends io.netty.buffer.ByteBuf> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
ByteBufferEncoder.encode(org.reactivestreams.Publisher<? extends ByteBuffer> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
CharSequenceEncoder.encode(org.reactivestreams.Publisher<? extends CharSequence> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
DataBufferEncoder.encode(org.reactivestreams.Publisher<? extends DataBuffer> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
ResourceRegionEncoder.encode(org.reactivestreams.Publisher<? extends ResourceRegion> input,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
AbstractSingleValueEncoder.encode(org.reactivestreams.Publisher<? extends T> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
Encoder.encode(org.reactivestreams.Publisher<? extends T> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints)
Encode a stream of Objects of type
T into a DataBuffer
output stream. |
protected reactor.core.publisher.Flux<DataBuffer> |
ResourceEncoder.encode(Resource resource,
DataBufferFactory bufferFactory,
ResolvableType type,
MimeType mimeType,
Map<String,Object> hints) |
protected abstract reactor.core.publisher.Flux<DataBuffer> |
AbstractSingleValueEncoder.encode(T t,
DataBufferFactory dataBufferFactory,
ResolvableType type,
MimeType mimeType,
Map<String,Object> hints)
Encode
T to an output DataBuffer stream. |
DataBuffer |
ByteArrayEncoder.encodeValue(byte[] bytes,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
NettyByteBufEncoder.encodeValue(io.netty.buffer.ByteBuf byteBuf,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
ByteBufferEncoder.encodeValue(ByteBuffer byteBuffer,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
CharSequenceEncoder.encodeValue(CharSequence charSequence,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
DataBufferEncoder.encodeValue(DataBuffer buffer,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
default DataBuffer |
Encoder.encodeValue(T value,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints)
Encode an Object of type T to a data buffer.
|
default List<MimeType> |
Decoder.getDecodableMimeTypes(ResolvableType targetType)
Return the list of MIME types supported by this Decoder for the given type
of element.
|
default List<MimeType> |
Encoder.getEncodableMimeTypes(ResolvableType elementType)
Return the list of MIME types supported by this Encoder for the given type
of element.
|
Modifier and Type | Method and Description |
---|---|
ResolvableType |
TypeDescriptor.getResolvableType()
Return the underlying
ResolvableType . |
Constructor and Description |
---|
TypeDescriptor(ResolvableType resolvableType,
Class<?> type,
Annotation[] annotations)
Create a new type descriptor from a
ResolvableType . |
Modifier and Type | Method and Description |
---|---|
boolean |
DecoderHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
HttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType)
Whether the given object type is supported by this reader.
|
boolean |
ServerSentEventHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
FormHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
ServerSentEventHttpMessageWriter.canWrite(ResolvableType elementType,
MediaType mediaType) |
boolean |
FormHttpMessageWriter.canWrite(ResolvableType elementType,
MediaType mediaType) |
boolean |
EncoderHttpMessageWriter.canWrite(ResolvableType elementType,
MediaType mediaType) |
boolean |
ResourceHttpMessageWriter.canWrite(ResolvableType elementType,
MediaType mediaType) |
boolean |
HttpMessageWriter.canWrite(ResolvableType elementType,
MediaType mediaType)
Whether the given object type is supported by this writer.
|
Map<String,Object> |
HttpMessageDecoder.getDecodeHints(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response)
Get decoding hints based on the server request or annotations on the
target controller method parameter.
|
default Map<String,Object> |
HttpMessageEncoder.getEncodeHints(ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response)
Get decoding hints based on the server request or annotations on the
target controller method parameter.
|
List<MediaType> |
DecoderHttpMessageReader.getReadableMediaTypes(ResolvableType elementType) |
default List<MediaType> |
HttpMessageReader.getReadableMediaTypes(ResolvableType elementType)
Return the list of media types supported by this Reader for the given type
of element.
|
protected Map<String,Object> |
DecoderHttpMessageReader.getReadHints(ResolvableType elementType,
ReactiveHttpInputMessage message)
Get additional hints for decoding based on the input HTTP message.
|
protected Map<String,Object> |
ResourceHttpMessageReader.getReadHints(ResolvableType elementType,
ReactiveHttpInputMessage message) |
protected Map<String,Object> |
DecoderHttpMessageReader.getReadHints(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response)
Get additional hints for decoding for example based on the server request
or annotations from controller method parameters.
|
protected Map<String,Object> |
ResourceHttpMessageReader.getReadHints(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response) |
List<MediaType> |
EncoderHttpMessageWriter.getWritableMediaTypes(ResolvableType elementType) |
default List<MediaType> |
HttpMessageWriter.getWritableMediaTypes(ResolvableType elementType)
Return the list of media types supported by this Writer for the given type
of element.
|
protected Map<String,Object> |
EncoderHttpMessageWriter.getWriteHints(ResolvableType streamType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response)
Get additional hints for encoding for example based on the server request
or annotations from controller method parameters.
|
reactor.core.publisher.Flux<T> |
DecoderHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Flux<T> |
HttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints)
Read from the input message and decode to a stream of objects.
|
reactor.core.publisher.Flux<Object> |
ServerSentEventHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Flux<MultiValueMap<String,String>> |
FormHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Flux<T> |
DecoderHttpMessageReader.read(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints) |
default reactor.core.publisher.Flux<T> |
HttpMessageReader.read(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints)
Server-side only alternative to
HttpMessageReader.read(ResolvableType, ReactiveHttpInputMessage, Map)
with additional context available. |
reactor.core.publisher.Mono<T> |
DecoderHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<T> |
HttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints)
Read from the input message and decode to a single object.
|
reactor.core.publisher.Mono<Object> |
ServerSentEventHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<MultiValueMap<String,String>> |
FormHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<T> |
DecoderHttpMessageReader.readMono(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints) |
default reactor.core.publisher.Mono<T> |
HttpMessageReader.readMono(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints)
Server-side only alternative to
HttpMessageReader.readMono(ResolvableType, ReactiveHttpInputMessage, Map)
with additional, context available. |
reactor.core.publisher.Mono<Void> |
ServerSentEventHttpMessageWriter.write(org.reactivestreams.Publisher<?> input,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
ServerSentEventHttpMessageWriter.write(org.reactivestreams.Publisher<?> input,
ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
FormHttpMessageWriter.write(org.reactivestreams.Publisher<? extends MultiValueMap<String,String>> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
ResourceHttpMessageWriter.write(org.reactivestreams.Publisher<? extends Resource> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
ResourceHttpMessageWriter.write(org.reactivestreams.Publisher<? extends Resource> inputStream,
ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
EncoderHttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
HttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints)
Write an given stream of object to the output message.
|
reactor.core.publisher.Mono<Void> |
EncoderHttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream,
ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints) |
default reactor.core.publisher.Mono<Void> |
HttpMessageWriter.write(org.reactivestreams.Publisher<? extends T> inputStream,
ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response,
Map<String,Object> hints)
Server-side only alternative to
HttpMessageWriter.write(Publisher, ResolvableType, MediaType, ReactiveHttpOutputMessage, Map)
with additional context available. |
Modifier and Type | Method and Description |
---|---|
reactor.core.publisher.Flux<Object> |
Jackson2CborDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
Jackson2CborEncoder.encode(org.reactivestreams.Publisher<?> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
Modifier and Type | Method and Description |
---|---|
boolean |
KotlinSerializationJsonDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
AbstractJackson2Decoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
AbstractJackson2Encoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
boolean |
KotlinSerializationJsonEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
protected ObjectWriter |
AbstractJackson2Encoder.customizeWriter(ObjectWriter writer,
MimeType mimeType,
ResolvableType elementType,
Map<String,Object> hints) |
protected ObjectWriter |
Jackson2JsonEncoder.customizeWriter(ObjectWriter writer,
MimeType mimeType,
ResolvableType elementType,
Map<String,Object> hints) |
Object |
AbstractJackson2Decoder.decode(DataBuffer dataBuffer,
ResolvableType targetType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<Object> |
KotlinSerializationJsonDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<Object> |
AbstractJackson2Decoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Object> |
KotlinSerializationJsonDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Object> |
AbstractJackson2Decoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
AbstractJackson2Encoder.encode(org.reactivestreams.Publisher<?> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
KotlinSerializationJsonEncoder.encode(org.reactivestreams.Publisher<?> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
AbstractJackson2Encoder.encodeValue(Object value,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
KotlinSerializationJsonEncoder.encodeValue(Object value,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
List<MimeType> |
AbstractJackson2Decoder.getDecodableMimeTypes(ResolvableType targetType) |
Map<String,Object> |
AbstractJackson2Decoder.getDecodeHints(ResolvableType actualType,
ResolvableType elementType,
ServerHttpRequest request,
ServerHttpResponse response) |
List<MimeType> |
AbstractJackson2Encoder.getEncodableMimeTypes(ResolvableType elementType) |
Map<String,Object> |
AbstractJackson2Encoder.getEncodeHints(ResolvableType actualType,
ResolvableType elementType,
MediaType mediaType,
ServerHttpRequest request,
ServerHttpResponse response) |
protected Map<String,Object> |
Jackson2CodecSupport.getHints(ResolvableType resolvableType) |
protected List<MimeType> |
Jackson2CodecSupport.getMimeTypes(ResolvableType elementType) |
protected MethodParameter |
Jackson2CodecSupport.getParameter(ResolvableType type) |
protected reactor.core.publisher.Flux<DataBuffer> |
Jackson2JsonDecoder.processInput(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
protected reactor.core.publisher.Flux<DataBuffer> |
AbstractJackson2Decoder.processInput(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints)
Process the input publisher into a flux.
|
protected ObjectMapper |
Jackson2CodecSupport.selectObjectMapper(ResolvableType targetType,
MimeType targetMimeType)
Select an ObjectMapper to use, either the main ObjectMapper or another
if the handling for the given Class has been customized through
Jackson2CodecSupport.registerObjectMappersForType(Class, Consumer) . |
Modifier and Type | Method and Description |
---|---|
boolean |
DefaultPartHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
SynchronossPartHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
MultipartHttpMessageReader.canRead(ResolvableType elementType,
MediaType mediaType) |
boolean |
MultipartWriterSupport.canWrite(ResolvableType elementType,
MediaType mediaType) |
reactor.core.publisher.Flux<Part> |
DefaultPartHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Flux<Part> |
SynchronossPartHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Flux<MultiValueMap<String,Part>> |
MultipartHttpMessageReader.read(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Part> |
DefaultPartHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Part> |
SynchronossPartHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage message,
Map<String,Object> hints) |
reactor.core.publisher.Mono<MultiValueMap<String,Part>> |
MultipartHttpMessageReader.readMono(ResolvableType elementType,
ReactiveHttpInputMessage inputMessage,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
MultipartHttpMessageWriter.write(org.reactivestreams.Publisher<? extends MultiValueMap<String,?>> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage outputMessage,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
PartHttpMessageWriter.write(org.reactivestreams.Publisher<? extends Part> parts,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage outputMessage,
Map<String,Object> hints) |
Modifier and Type | Method and Description |
---|---|
boolean |
ProtobufDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
ProtobufEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
com.google.protobuf.Message |
ProtobufDecoder.decode(DataBuffer dataBuffer,
ResolvableType targetType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<com.google.protobuf.Message> |
ProtobufDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<com.google.protobuf.Message> |
ProtobufDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<DataBuffer> |
ProtobufEncoder.encode(org.reactivestreams.Publisher<? extends com.google.protobuf.Message> inputStream,
DataBufferFactory bufferFactory,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
DataBuffer |
ProtobufEncoder.encodeValue(com.google.protobuf.Message message,
DataBufferFactory bufferFactory,
ResolvableType valueType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Void> |
ProtobufHttpMessageWriter.write(org.reactivestreams.Publisher<? extends com.google.protobuf.Message> inputStream,
ResolvableType elementType,
MediaType mediaType,
ReactiveHttpOutputMessage message,
Map<String,Object> hints) |
Modifier and Type | Method and Description |
---|---|
boolean |
Jaxb2XmlDecoder.canDecode(ResolvableType elementType,
MimeType mimeType) |
boolean |
Jaxb2XmlEncoder.canEncode(ResolvableType elementType,
MimeType mimeType) |
Object |
Jaxb2XmlDecoder.decode(DataBuffer dataBuffer,
ResolvableType targetType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<XMLEvent> |
XmlEventDecoder.decode(org.reactivestreams.Publisher<DataBuffer> input,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Flux<Object> |
Jaxb2XmlDecoder.decode(org.reactivestreams.Publisher<DataBuffer> inputStream,
ResolvableType elementType,
MimeType mimeType,
Map<String,Object> hints) |
reactor.core.publisher.Mono<Object> |
Jaxb2XmlDecoder.decodeToMono(org.reactivestreams.Publisher<DataBuffer> 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) |
Modifier and Type | Method and Description |
---|---|
<T> ObjectProvider<T> |
SimpleJndiBeanFactory.getBeanProvider(ResolvableType requiredType) |
boolean |
SimpleJndiBeanFactory.isTypeMatch(String name,
ResolvableType typeToMatch) |
Modifier and Type | Method and Description |
---|---|
default <T> Decoder<T> |
RSocketStrategies.decoder(ResolvableType elementType,
MimeType mimeType)
Find a compatible Decoder for the given element type.
|
default <T> Encoder<T> |
RSocketStrategies.encoder(ResolvableType elementType,
MimeType mimeType)
Find a compatible Encoder for the given element type.
|
Modifier and Type | Method and Description |
---|---|
ResolvableType |
HandlerResult.getReturnType()
Return the type of the value returned from the handler -- e.g.
|
Modifier and Type | Method and Description |
---|---|
ResolvableType |
UnsupportedMediaTypeException.getBodyType()
Return the body type in the context of which this exception was generated.
|
Constructor and Description |
---|
UnsupportedMediaTypeException(MediaType contentType,
List<MediaType> supportedTypes,
ResolvableType bodyType)
Constructor for when trying to encode from or decode to a specific Java type.
|
Modifier and Type | Method and Description |
---|---|
ResolvableType |
UnsupportedMediaTypeStatusException.getBodyType()
Return the body type in the context of which this exception was generated.
|
Constructor and Description |
---|
UnsupportedMediaTypeStatusException(MediaType contentType,
List<MediaType> supportedTypes,
ResolvableType bodyType)
Constructor for when trying to encode from or decode to a specific Java type.
|
UnsupportedMediaTypeStatusException(MediaType contentType,
List<MediaType> supportedTypes,
ResolvableType bodyType,
HttpMethod method)
Constructor for when trying to encode from or decode to a specific Java type.
|