org.springframework.http.codec.xml

## Class XmlEventDecoder

- java.lang.Object
- - org.springframework.core.codec.AbstractDecoder<XMLEvent>
  - - org.springframework.http.codec.xml.XmlEventDecoder

- All Implemented Interfaces:
    Decoder<XMLEvent>

      public class XmlEventDecoder
      extends AbstractDecoder<XMLEvent>

  Decodes a `DataBuffer` stream into a stream of `XMLEvents`.

  Given the following XML:

       <root>
           <child>foo</child>
           <child>bar</child>
       </root>

  this decoder will produce a `Flux` with the following events:
  1. `StartDocument`
  2. `StartElement` `root`
  3. `StartElement` `child`
  4. `Characters` `foo`
  5. `EndElement` `child`
  6. `StartElement` `child`
  7. `Characters` `bar`
  8. `EndElement` `child`
  9. `EndElement` `root`

  Note that this decoder is not registered by default but is used internally by other decoders which are registered by default.

  Since:
    5.0
  Author:
    Arjen Poutsma, Sam Brannen

- - ### Field Summary

    - ### Fields inherited from class org.springframework.core.codec.AbstractDecoder

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `XmlEventDecoder()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `reactor.core.publisher.Flux<XMLEvent>` | `decode(Publisher<DataBuffer> input, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Decode a `DataBuffer` input stream into a Flux of `T`.
    `int` | `getMaxInMemorySize()` Return the `configured` byte count limit.
    `void` | `setMaxInMemorySize(int byteCount)` Set the max number of bytes that can be buffered by this decoder.

    - ### Methods inherited from class org.springframework.core.codec.AbstractDecoder

      `canDecode, decodeToMono, getDecodableMimeTypes, getLogger, setLogger`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### Methods inherited from interface org.springframework.core.codec.Decoder

      `decode, getDecodableMimeTypes`

- - ### Constructor Detail

    - #### XmlEventDecoder

          public XmlEventDecoder()

  - ### 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 the entire input when decoding as a whole, or when using async parsing via Aalto XML, it is size one top-level XML tree. 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

    - #### decode

          public reactor.core.publisher.Flux<XMLEvent> decode(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`.
      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 decode
      Returns:
        the output stream with decoded elements