org.springframework.web.reactive.function

## Class BodyInserters

- java.lang.Object
- - org.springframework.web.reactive.function.BodyInserters

-     public abstract class BodyInserters
      extends Object

  Static factory methods for `BodyInserter` implementations.
  Since:
    5.0
  Author:
    Arjen Poutsma, Rossen Stoyanchev, Sebastien Deleuze

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static interface` | `BodyInserters.FormInserter<T>` Extension of `BodyInserter` that allows for adding form data or multipart form data.
    `static interface` | `BodyInserters.MultipartInserter` Extension of `BodyInserters.FormInserter` that allows for adding asynchronous parts.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `BodyInserters()`

  - ### Method Summary

    All Methods Static Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T> BodyInserter<T,ReactiveHttpOutputMessage>` | `empty()` Inserter that does not write.
    `static <T extends Publisher<DataBuffer>> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromDataBuffers(T publisher)` Inserter to write the given `Publisher<DataBuffer>` to the body.
    `static BodyInserters.FormInserter<String>` | `fromFormData(MultiValueMap<String,String> formData)` Return a `BodyInserters.FormInserter` to write the given `MultiValueMap` as URL-encoded form data.
    `static BodyInserters.FormInserter<String>` | `fromFormData(String name, String value)` Return a `BodyInserters.FormInserter` to write the given key-value pair as URL-encoded form data.
    `static <T,P extends Publisher<T>> BodyInserters.MultipartInserter` | `fromMultipartAsyncData(String name, P publisher, Class<T> elementClass)` Return a `BodyInserters.MultipartInserter` to write the given asynchronous parts, as multipart data.
    `static <T,P extends Publisher<T>> BodyInserters.MultipartInserter` | `fromMultipartAsyncData(String name, P publisher, ParameterizedTypeReference<T> typeReference)` Variant of `fromMultipartAsyncData(String, Publisher, Class)` that accepts a `ParameterizedTypeReference` for the element type, which allows specifying generic type information.
    `static BodyInserters.MultipartInserter` | `fromMultipartData(MultiValueMap<String,?> multipartData)` Return a `BodyInserters.MultipartInserter` to write the given `MultiValueMap` as multipart data.
    `static BodyInserters.MultipartInserter` | `fromMultipartData(String name, Object value)` Return a `BodyInserters.MultipartInserter` to write the given parts, as multipart data.
    `static <T> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromObject(T body)` Deprecated. As of Spring Framework 5.2, in favor of `fromValue(Object)`
    `static <T> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromProducer(T producer, Class<?> elementClass)` Inserter to write the given producer of value(s) which must be a `Publisher` or another producer adaptable to a `Publisher` via `ReactiveAdapterRegistry`.
    `static <T> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromProducer(T producer, ParameterizedTypeReference<?> elementTypeRef)` Inserter to write the given producer of value(s) which must be a `Publisher` or another producer adaptable to a `Publisher` via `ReactiveAdapterRegistry`.
    `static <T,P extends Publisher<T>> BodyInserter<P,ReactiveHttpOutputMessage>` | `fromPublisher(P publisher, Class<T> elementClass)` Inserter to write the given `Publisher`.
    `static <T,P extends Publisher<T>> BodyInserter<P,ReactiveHttpOutputMessage>` | `fromPublisher(P publisher, ParameterizedTypeReference<T> elementTypeRef)` Inserter to write the given `Publisher`.
    `static <T extends Resource> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromResource(T resource)` Inserter to write the given `Resource`.
    `static <T,S extends Publisher<ServerSentEvent<T>>> BodyInserter<S,ServerHttpResponse>` | `fromServerSentEvents(S eventsPublisher)` Inserter to write the given `ServerSentEvent` publisher.
    `static <T> BodyInserter<T,ReactiveHttpOutputMessage>` | `fromValue(T body)` Inserter to write the given value.

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

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

- - ### Constructor Detail

    - #### BodyInserters

          public BodyInserters()

  - ### Method Detail

    - #### empty

          public static <T> BodyInserter<T,ReactiveHttpOutputMessage> empty()

      Inserter that does not write.
      Returns:
        the inserter

    - #### fromValue

          public static <T> BodyInserter<T,ReactiveHttpOutputMessage> fromValue(T body)

      Inserter to write the given value.

      Alternatively, consider using the `bodyValue(Object)` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the body
      Parameters:
        `body` - the value to write
      Returns:
        the inserter to write a single value
      Throws:
        `IllegalArgumentException` - if `body` is a `Publisher` or an instance of a type supported by `ReactiveAdapterRegistry.getSharedInstance()`, for which `fromPublisher(Publisher, Class)` or `fromProducer(Object, Class)` should be used.
      See Also:
        `fromPublisher(Publisher, Class)`, `fromProducer(Object, Class)`

    - #### fromObject

          @Deprecated
          public static <T> BodyInserter<T,ReactiveHttpOutputMessage> fromObject(T body)

      Deprecated. As of Spring Framework 5.2, in favor of `fromValue(Object)`
      Inserter to write the given object.

      Alternatively, consider using the `bodyValue(Object)` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the body
      Parameters:
        `body` - the body to write to the response
      Returns:
        the inserter to write a single object
      Throws:
        `IllegalArgumentException` - if `body` is a `Publisher` or an instance of a type supported by `ReactiveAdapterRegistry.getSharedInstance()`, for which `fromPublisher(Publisher, Class)` or `fromProducer(Object, Class)` should be used.
      See Also:
        `fromPublisher(Publisher, Class)`, `fromProducer(Object, Class)`

    - #### fromProducer

          public static <T> BodyInserter<T,ReactiveHttpOutputMessage> fromProducer(T producer,
                                                                                   Class<?> elementClass)

      Inserter to write the given producer of value(s) which must be a `Publisher` or another producer adaptable to a `Publisher` via `ReactiveAdapterRegistry`.

      Alternatively, consider using the `body` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the body
      Parameters:
        `producer` - the source of body value(s).
        `elementClass` - the class of values to be produced
      Returns:
        the inserter to write a producer
      Since:
        5.2

    - #### fromProducer

          public static <T> BodyInserter<T,ReactiveHttpOutputMessage> fromProducer(T producer,
                                                                                   ParameterizedTypeReference<?> elementTypeRef)

      Inserter to write the given producer of value(s) which must be a `Publisher` or another producer adaptable to a `Publisher` via `ReactiveAdapterRegistry`.

      Alternatively, consider using the `body` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the body
      Parameters:
        `producer` - the source of body value(s).
        `elementTypeRef` - the type of values to be produced
      Returns:
        the inserter to write a producer
      Since:
        5.2

    - #### fromPublisher

          public static <T,P extends Publisher<T>> BodyInserter<P,ReactiveHttpOutputMessage> fromPublisher(P publisher,
                                                                                                           Class<T> elementClass)

      Inserter to write the given `Publisher`.

      Alternatively, consider using the `body` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the elements contained in the publisher
        `P` - the `Publisher` type
      Parameters:
        `publisher` - the publisher to write with
        `elementClass` - the class of elements in the publisher
      Returns:
        the inserter to write a `Publisher`

    - #### fromPublisher

          public static <T,P extends Publisher<T>> BodyInserter<P,ReactiveHttpOutputMessage> fromPublisher(P publisher,
                                                                                                           ParameterizedTypeReference<T> elementTypeRef)

      Inserter to write the given `Publisher`.

      Alternatively, consider using the `body` shortcuts on `WebClient` and `ServerResponse`.

      Type Parameters:
        `T` - the type of the elements contained in the publisher
        `P` - the `Publisher` type
      Parameters:
        `publisher` - the publisher to write with
        `elementTypeRef` - the type of elements contained in the publisher
      Returns:
        the inserter to write a `Publisher`

    - #### fromResource

          public static <T extends Resource> BodyInserter<T,ReactiveHttpOutputMessage> fromResource(T resource)

      Inserter to write the given `Resource`.

      If the resource can be resolved to a file, it will be copied using zero-copy.

      Type Parameters:
        `T` - the type of the `Resource`
      Parameters:
        `resource` - the resource to write to the output message
      Returns:
        the inserter to write a `Publisher`

    - #### fromServerSentEvents

          public static <T,S extends Publisher<ServerSentEvent<T>>> BodyInserter<S,ServerHttpResponse> fromServerSentEvents(S eventsPublisher)

      Inserter to write the given `ServerSentEvent` publisher.

      Alternatively, you can provide event data objects via `fromPublisher(Publisher, Class)` or `fromProducer(Object, Class)`, and set the "Content-Type" to `text/event-stream`.

      Type Parameters:
        `T` - the type of the data elements in the `ServerSentEvent`
      Parameters:
        `eventsPublisher` - the `ServerSentEvent` publisher to write to the response body
      Returns:
        the inserter to write a `ServerSentEvent` publisher
      See Also:
        Server-Sent Events W3C recommendation

    - #### fromFormData

          public static BodyInserters.FormInserter<String> fromFormData(MultiValueMap<String,String> formData)

      Return a `BodyInserters.FormInserter` to write the given `MultiValueMap` as URL-encoded form data. The returned inserter allows for additional entries to be added via `BodyInserters.FormInserter.with(String, Object)`.

      Note that you can also use the `bodyValue(Object)` method in the request builders of both the `WebClient` and `WebTestClient`. In that case the setting of the request content type is also not required, just be sure the map contains String values only or otherwise it would be interpreted as a multipart request.

      Parameters:
        `formData` - the form data to write to the output message
      Returns:
        the inserter that allows adding more form data

    - #### fromFormData

          public static BodyInserters.FormInserter<String> fromFormData(String name,
                                                                        String value)

      Return a `BodyInserters.FormInserter` to write the given key-value pair as URL-encoded form data. The returned inserter allows for additional entries to be added via `BodyInserters.FormInserter.with(String, Object)`.
      Parameters:
        `name` - the key to add to the form
        `value` - the value to add to the form
      Returns:
        the inserter that allows adding more form data

    - #### fromMultipartData

          public static BodyInserters.MultipartInserter fromMultipartData(MultiValueMap<String,?> multipartData)

      Return a `BodyInserters.MultipartInserter` to write the given `MultiValueMap` as multipart data. Values in the map can be an Object or an `HttpEntity`.

      Note that you can also build the multipart data externally with `MultipartBodyBuilder`, and pass the resulting map directly to the `bodyValue(Object)` shortcut method in `WebClient`.

      Parameters:
        `multipartData` - the form data to write to the output message
      Returns:
        the inserter that allows adding more parts
      See Also:
        `MultipartBodyBuilder`

    - #### fromMultipartData

          public static BodyInserters.MultipartInserter fromMultipartData(String name,
                                                                          Object value)

      Return a `BodyInserters.MultipartInserter` to write the given parts, as multipart data. Values in the map can be an Object or an `HttpEntity`.

      Note that you can also build the multipart data externally with `MultipartBodyBuilder`, and pass the resulting map directly to the `bodyValue(Object)` shortcut method in `WebClient`.

      Parameters:
        `name` - the part name
        `value` - the part value, an Object or `HttpEntity`
      Returns:
        the inserter that allows adding more parts

    - #### fromMultipartAsyncData

          public static <T,P extends Publisher<T>> BodyInserters.MultipartInserter fromMultipartAsyncData(String name,
                                                                                                          P publisher,
                                                                                                          Class<T> elementClass)

      Return a `BodyInserters.MultipartInserter` to write the given asynchronous parts, as multipart data.

      Note that you can also build the multipart data externally with `MultipartBodyBuilder`, and pass the resulting map directly to the `bodyValue(Object)` shortcut method in `WebClient`.

      Parameters:
        `name` - the part name
        `publisher` - the publisher that forms the part value
        `elementClass` - the class contained in the `publisher`
      Returns:
        the inserter that allows adding more parts

    - #### fromMultipartAsyncData

          public static <T,P extends Publisher<T>> BodyInserters.MultipartInserter fromMultipartAsyncData(String name,
                                                                                                          P publisher,
                                                                                                          ParameterizedTypeReference<T> typeReference)

      Variant of `fromMultipartAsyncData(String, Publisher, Class)` that accepts a `ParameterizedTypeReference` for the element type, which allows specifying generic type information.

      Note that you can also build the multipart data externally with `MultipartBodyBuilder`, and pass the resulting map directly to the `bodyValue(Object)` shortcut method in `WebClient`.

      Parameters:
        `name` - the part name
        `publisher` - the publisher that forms the part value
        `typeReference` - the type contained in the `publisher`
      Returns:
        the inserter that allows adding more parts

    - #### fromDataBuffers

          public static <T extends Publisher<DataBuffer>> BodyInserter<T,ReactiveHttpOutputMessage> fromDataBuffers(T publisher)

      Inserter to write the given `Publisher<DataBuffer>` to the body.
      Type Parameters:
        `T` - the type of the publisher
      Parameters:
        `publisher` - the data buffer publisher to write
      Returns:
        the inserter to write directly to the body
      See Also:
        `ReactiveHttpOutputMessage.writeWith(Publisher)`