java.lang.Object
- org.springframework.http.codec.json.Jackson2CodecSupport
- - org.springframework.http.codec.json.AbstractJackson2Decoder

All Implemented Interfaces:
Decoder<Object>, HttpMessageDecoder<Object>
Direct Known Subclasses:
Jackson2CborDecoder, Jackson2JsonDecoder, Jackson2SmileDecoder
```
public abstract class AbstractJackson2Decoder
extends Jackson2CodecSupport
implements HttpMessageDecoder<Object>
```
Abstract base class for Jackson 2.9 decoding, leveraging non-blocking parsing.
Compatible with Jackson 2.9.7 and higher.
Since:
5.0
Author:
Sebastien Deleuze, Rossen Stoyanchev, Arjen Poutsma
See Also:
Add support for non-blocking ("async") JSON parsing

Field Summary
- Fields inherited from class org.springframework.http.codec.json.Jackson2CodecSupport
  JSON_VIEW_HINT, logger

Constructor Summary
Constructors
Modifier Constructor Description
protected AbstractJackson2Decoder(ObjectMapper mapper, MimeType... mimeTypes)
Constructor with a Jackson ObjectMapper to use.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`canDecode(ResolvableType elementType, MimeType mimeType)`	Whether the decoder supports the given target element type and the MIME type of the source stream.
`reactor.core.publisher.Flux<Object>`	`decode(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`	Decode a `DataBuffer` input stream into a Flux of `T`.
`Object`	`decode(DataBuffer dataBuffer, ResolvableType targetType, MimeType mimeType, Map<String,Object> hints)`	Decode a data buffer to an Object of type T.
`reactor.core.publisher.Mono<Object>`	`decodeToMono(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`	Decode a `DataBuffer` input stream into a Mono of `T`.
`protected <A extends Annotation> A`	`getAnnotation(MethodParameter parameter, Class<A> annotType)`
`List<MimeType>`	`getDecodableMimeTypes()`	Return the list of MIME types this decoder supports.
`Map<String,Object>`	`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.
`int`	`getMaxInMemorySize()`	Return the `configured` byte count limit.
`protected reactor.core.publisher.Flux<DataBuffer>`	`processInput(org.reactivestreams.Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)`	Process the input publisher into a flux.
`void`	`setMaxInMemorySize(int byteCount)`	Set the max number of bytes that can be buffered by this decoder.

Methods inherited from class org.springframework.http.codec.json.Jackson2CodecSupport
getHints, getJavaType, getMimeTypes, getObjectMapper, getParameter, supportsMimeType

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - AbstractJackson2Decoder
```
protected AbstractJackson2Decoder(ObjectMapper mapper,
                                  MimeType... mimeTypes)
```
    Constructor with a Jackson ObjectMapper to use.
- Method Detail
  - setMaxInMemorySize
```
public void setMaxInMemorySize(int byteCount)
```
    Set the max number of bytes that can be buffered by this decoder. This is either the size of the entire input when decoding as a whole, or the size of one top-level JSON object within a JSON stream. When the limit is exceeded, DataBufferLimitException is raised.
    By default this is set to 256K.
    Parameters:
    byteCount - the max number of bytes to buffer, or -1 for unlimited
    Since:
    5.1.11
  - getMaxInMemorySize
```
public int getMaxInMemorySize()
```
    Return the configured byte count limit.
    Since:
    5.1.11
  - canDecode
```
public boolean canDecode(ResolvableType elementType,
                         @Nullable
                         MimeType mimeType)
```
    Description copied from interface: Decoder
    Whether the decoder supports the given target element type and the MIME type of the source stream.
    Specified by:
    canDecode in interface Decoder<Object>
    Parameters:
    elementType - the target element type for the output stream
    mimeType - the mime type associated with the stream to decode (can be null if not specified)
    Returns:
    true if supported, false otherwise
  - decode
```
public reactor.core.publisher.Flux<Object> decode(org.reactivestreams.Publisher<DataBuffer> input,
                                                  ResolvableType elementType,
                                                  @Nullable
                                                  MimeType mimeType,
                                                  @Nullable
                                                  Map<String,Object> hints)
```
    Description copied from interface: Decoder
    Decode a DataBuffer input stream into a Flux of T.
    Specified by:
    decode in interface Decoder<Object>
    Parameters:
    input - the DataBuffer input stream to decode
    elementType - the expected type of elements in the output stream; this type must have been previously passed to the Decoder.canDecode(org.springframework.core.ResolvableType, org.springframework.util.MimeType) method and it must have returned true.
    mimeType - the MIME type associated with the input stream (optional)
    hints - additional information about how to do encode
    Returns:
    the output stream with decoded elements
  - processInput
```
protected reactor.core.publisher.Flux<DataBuffer> processInput(org.reactivestreams.Publisher<DataBuffer> input,
                                                               ResolvableType elementType,
                                                               @Nullable
                                                               MimeType mimeType,
                                                               @Nullable
                                                               Map<String,Object> hints)
```
    Process the input publisher into a flux. Default implementation returns Flux.from(Publisher), but subclasses can choose to customize this behavior.
    Parameters:
    input - the DataBuffer input stream to process
    elementType - the expected type of elements in the output stream
    mimeType - the MIME type associated with the input stream (optional)
    hints - additional information about how to do encode
    Returns:
    the processed flux
    Since:
    5.1.14
  - decodeToMono
```
public reactor.core.publisher.Mono<Object> decodeToMono(org.reactivestreams.Publisher<DataBuffer> input,
                                                        ResolvableType elementType,
                                                        @Nullable
                                                        MimeType mimeType,
                                                        @Nullable
                                                        Map<String,Object> hints)
```
    Description copied from interface: Decoder
    Decode a DataBuffer input stream into a Mono of T.
    Specified by:
    decodeToMono in interface Decoder<Object>
    Parameters:
    input - the DataBuffer input stream to decode
    elementType - the expected type of elements in the output stream; this type must have been previously passed to the Decoder.canDecode(org.springframework.core.ResolvableType, org.springframework.util.MimeType) method and it must have returned true.
    mimeType - the MIME type associated with the input stream (optional)
    hints - additional information about how to do encode
    Returns:
    the output stream with the decoded element
  - decode
```
public Object decode(DataBuffer dataBuffer,
                     ResolvableType targetType,
                     @Nullable
                     MimeType mimeType,
                     @Nullable
                     Map<String,Object> hints)
              throws DecodingException
```
    Description copied from interface: Decoder
    Decode a data buffer to an Object of type T. This is useful for scenarios, that distinct messages (or events) are decoded and handled individually, in fully aggregated form.
    Specified by:
    decode in interface Decoder<Object>
    Parameters:
    dataBuffer - the DataBuffer to decode
    targetType - the expected output type
    mimeType - the MIME type associated with the data
    hints - additional information about how to do encode
    Returns:
    the decoded value, possibly null
    Throws:
    DecodingException
  - getDecodeHints
```
public Map<String,Object> getDecodeHints(ResolvableType actualType,
                                               ResolvableType elementType,
                                               ServerHttpRequest request,
                                               ServerHttpResponse response)
```
    Description copied from interface: HttpMessageDecoder
    Get decoding hints based on the server request or annotations on the target controller method parameter.
    Specified by:
    getDecodeHints in interface HttpMessageDecoder<Object>
    Parameters:
    actualType - the actual target type to decode to, possibly a reactive wrapper and sourced from MethodParameter, i.e. providing access to method parameter annotations
    elementType - the element type within Flux/Mono that we're trying to decode to
    request - the current request
    response - the current response
    Returns:
    a Map with hints, possibly empty
  - getDecodableMimeTypes
```
public List<MimeType> getDecodableMimeTypes()
```
    Description copied from interface: Decoder
    Return the list of MIME types this decoder supports.
    Specified by:
    getDecodableMimeTypes in interface Decoder<Object>
  - getAnnotation
```
protected <A extends Annotation> A getAnnotation(MethodParameter parameter,
                                                 Class<A> annotType)
```
    Specified by:
    getAnnotation in class Jackson2CodecSupport

Class AbstractJackson2Decoder

Field Summary

Fields inherited from class org.springframework.http.codec.json.Jackson2CodecSupport

Constructor Summary

Method Summary

Methods inherited from class org.springframework.http.codec.json.Jackson2CodecSupport

Methods inherited from class java.lang.Object

Constructor Detail

AbstractJackson2Decoder

Method Detail

setMaxInMemorySize

getMaxInMemorySize

canDecode

decode

processInput

decodeToMono

decode

getDecodeHints

getDecodableMimeTypes

getAnnotation