org.springframework.core.codec

## Class NettyByteBufEncoder

- java.lang.Object
- - org.springframework.core.codec.AbstractEncoder<io.netty.buffer.ByteBuf>
  - - org.springframework.core.codec.NettyByteBufEncoder

- All Implemented Interfaces:
    Encoder<io.netty.buffer.ByteBuf>

      public class NettyByteBufEncoder
      extends AbstractEncoder<io.netty.buffer.ByteBuf>

  Encoder for `ByteBufs`.
  Since:
    5.3
  Author:
    Vladislav Kisel

- - ### Field Summary

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

      `logger`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `NettyByteBufEncoder()`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `canEncode(ResolvableType type, MimeType mimeType)` Whether the encoder supports the given source element type and the MIME type for the output stream.
    `reactor.core.publisher.Flux<DataBuffer>` | `encode(Publisher<? extends io.netty.buffer.ByteBuf> inputStream, DataBufferFactory bufferFactory, ResolvableType elementType, MimeType mimeType, Map<String,Object> hints)` Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
    `DataBuffer` | `encodeValue(io.netty.buffer.ByteBuf byteBuf, DataBufferFactory bufferFactory, ResolvableType valueType, MimeType mimeType, Map<String,Object> hints)` Encode an Object of type T to a data buffer.

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

      `getEncodableMimeTypes, 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.Encoder

      `getEncodableMimeTypes`

- - ### Constructor Detail

    - #### NettyByteBufEncoder

          public NettyByteBufEncoder()

  - ### Method Detail

    - #### canEncode

          public boolean canEncode(ResolvableType type,
                                   @Nullable
                                   MimeType mimeType)

      Description copied from interface: `Encoder`
      Whether the encoder supports the given source element type and the MIME type for the output stream.
      Specified by:
        `canEncode` in interface `Encoder<io.netty.buffer.ByteBuf>`
      Overrides:
        `canEncode` in class `AbstractEncoder<io.netty.buffer.ByteBuf>`
      Parameters:
        `type` - the type of elements in the source stream
        `mimeType` - the MIME type for the output stream (can be `null` if not specified)
      Returns:
        `true` if supported, `false` otherwise

    - #### encode

          public reactor.core.publisher.Flux<DataBuffer> encode(Publisher<? extends io.netty.buffer.ByteBuf> inputStream,
                                                                DataBufferFactory bufferFactory,
                                                                ResolvableType elementType,
                                                                @Nullable
                                                                MimeType mimeType,
                                                                @Nullable
                                                                Map<String,Object> hints)

      Description copied from interface: `Encoder`
      Encode a stream of Objects of type `T` into a `DataBuffer` output stream.
      Parameters:
        `inputStream` - the input stream of Objects to encode. If the input should be encoded as a single value rather than as a stream of elements, an instance of `Mono` should be used.
        `bufferFactory` - for creating output stream `DataBuffer`'s
        `elementType` - the expected type of elements in the input stream; this type must have been previously passed to the `Encoder.canEncode(org.springframework.core.ResolvableType, org.springframework.util.MimeType)` method and it must have returned `true`.
        `mimeType` - the MIME type for the output content (optional)
        `hints` - additional information about how to encode
      Returns:
        the output stream

    - #### encodeValue

          public DataBuffer encodeValue(io.netty.buffer.ByteBuf byteBuf,
                                        DataBufferFactory bufferFactory,
                                        ResolvableType valueType,
                                        @Nullable
                                        MimeType mimeType,
                                        @Nullable
                                        Map<String,Object> hints)

      Description copied from interface: `Encoder`
      Encode an Object of type T to a data buffer. This is useful for scenarios, that distinct messages (or events) are encoded and handled individually, in fully aggregated form.

      By default this method raises `UnsupportedOperationException` and it is expected that some encoders cannot produce a single buffer or cannot do so synchronously (e.g. encoding a `Resource`).

      Parameters:
        `byteBuf` - the value to be encoded
        `bufferFactory` - for creating the output `DataBuffer`
        `valueType` - the type for the value being encoded
        `mimeType` - the MIME type for the output content (optional)
        `hints` - additional information about how to encode
      Returns:
        the encoded content