org.springframework.web.reactive.function.server

## Interface ServerResponse.BodyBuilder

All Superinterfaces:
  ServerResponse.HeadersBuilder<ServerResponse.BodyBuilder>

Enclosing interface:
  ServerResponse

    public static interface ServerResponse.BodyBuilder
    extends ServerResponse.HeadersBuilder<ServerResponse.BodyBuilder>

Defines a builder that adds a body to the response.

### Method Summary

All Methods Instance Methods Abstract Methods Deprecated Methods
`reactor.core.publisher.Mono<ServerResponse>` `body(BodyInserter<?,? super org.springframework.http.server.reactive.ServerHttpResponse> inserter)` Set the body of the response to the given `BodyInserter` and return it.
`reactor.core.publisher.Mono<ServerResponse>` `body(Object producer, Class<?> elementClass)` Variant of `body(Publisher, Class)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.
`reactor.core.publisher.Mono<ServerResponse>` `body(Object producer, org.springframework.core.ParameterizedTypeReference<?> elementTypeRef)` Variant of `body(Publisher, ParameterizedTypeReference)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.
`<T,P extends org.reactivestreams.Publisher<T>> reactor.core.publisher.Mono<ServerResponse>` `body(P publisher, Class<T> elementClass)` Set the body from the given `Publisher`.
`<T,P extends org.reactivestreams.Publisher<T>> reactor.core.publisher.Mono<ServerResponse>` `body(P publisher, org.springframework.core.ParameterizedTypeReference<T> elementTypeRef)` Variant of `body(Publisher, Class)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.
`reactor.core.publisher.Mono<ServerResponse>` `bodyValue(Object body)` Set the body of the response to the given `Object` and return it.
`ServerResponse.BodyBuilder` `contentLength(long contentLength)` Set the length of the body in bytes, as specified by the `Content-Length` header.
`ServerResponse.BodyBuilder` `contentType(org.springframework.http.MediaType contentType)` Set the media type of the body, as specified by the `Content-Type` header.
`ServerResponse.BodyBuilder` `hint(String key, Object value)` Add a serialization hint like `Jackson2CodecSupport.JSON_VIEW_HINT` to customize how the body will be serialized.
`ServerResponse.BodyBuilder` `hints(Consumer<Map<String,Object>> hintsConsumer)` Customize the serialization hints with the given consumer.
`reactor.core.publisher.Mono<ServerResponse>` `render(String name, Map<String,?> model)` Render the template with the given `name` using the given `model`.
`reactor.core.publisher.Mono<ServerResponse>` `render(String name, Object... modelAttributes)` Render the template with the given `name` using the given `modelAttributes`.
`reactor.core.publisher.Mono<ServerResponse>` `syncBody(Object body)` Deprecated. as of Spring Framework 5.2 in favor of `bodyValue(Object)`

### Methods inherited from interface org.springframework.web.reactive.function.server.ServerResponse.HeadersBuilder

`allow, allow, build, build, build, cacheControl, cookie, cookies, eTag, header, headers, lastModified, lastModified, location, varyBy`

### Method Detail

#### contentLength

    ServerResponse.BodyBuilder contentLength(long contentLength)

Set the length of the body in bytes, as specified by the `Content-Length` header.

Parameters:
  `contentLength` - the content length
Returns:
  this builder
See Also:
  `HttpHeaders.setContentLength(long)`

#### contentType

    ServerResponse.BodyBuilder contentType(org.springframework.http.MediaType contentType)

Set the media type of the body, as specified by the `Content-Type` header.

Parameters:
  `contentType` - the content type
Returns:
  this builder
See Also:
  `HttpHeaders.setContentType(MediaType)`

#### hint

    ServerResponse.BodyBuilder hint(String key,
                                    Object value)

Add a serialization hint like `Jackson2CodecSupport.JSON_VIEW_HINT` to customize how the body will be serialized.

Parameters:
  `key` - the hint key
  `value` - the hint value

#### hints

    ServerResponse.BodyBuilder hints(Consumer<Map<String,Object>> hintsConsumer)

Customize the serialization hints with the given consumer.

Parameters:
  `hintsConsumer` - a function that consumes the hints
Returns:
  this builder
Since:
  5.1.6

#### bodyValue

    reactor.core.publisher.Mono<ServerResponse> bodyValue(Object body)

Set the body of the response to the given `Object` and return it. This is a shortcut for using a `body(BodyInserter)` with a value inserter.

Parameters:
  `body` - the body of the response
Returns:
  the built response
Throws:
  `IllegalArgumentException` - if `body` is a `Publisher` or producer known to `ReactiveAdapterRegistry`
Since:
  5.2

#### body

    <T,P extends org.reactivestreams.Publisher<T>> reactor.core.publisher.Mono<ServerResponse> body(P publisher,
                                                                                                    Class<T> elementClass)

Set the body from the given `Publisher`. Shortcut for `body(BodyInserter)` with a Publisher inserter.

Type Parameters:
  `T` - the type of the elements contained in the publisher
  `P` - the type of the `Publisher`
Parameters:
  `publisher` - the `Publisher` to write to the response
  `elementClass` - the type of elements published
Returns:
  the built response

#### body

    <T,P extends org.reactivestreams.Publisher<T>> reactor.core.publisher.Mono<ServerResponse> body(P publisher,
                                                                                                    org.springframework.core.ParameterizedTypeReference<T> elementTypeRef)

Variant of `body(Publisher, Class)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.

Type Parameters:
  `T` - the type of the elements contained in the publisher
  `P` - the type of the `Publisher`
Parameters:
  `publisher` - the `Publisher` to use to write the response
  `elementTypeRef` - the type of elements produced
Returns:
  the built response

#### body

    reactor.core.publisher.Mono<ServerResponse> body(Object producer,
                                                     Class<?> elementClass)

Variant of `body(Publisher, Class)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.

Parameters:
  `producer` - the producer to write to the request
  `elementClass` - the type of elements produced
Returns:
  the built response
Since:
  5.2

#### body

    reactor.core.publisher.Mono<ServerResponse> body(Object producer,
                                                     org.springframework.core.ParameterizedTypeReference<?> elementTypeRef)

Variant of `body(Publisher, ParameterizedTypeReference)` that allows using any producer that can be resolved to `Publisher` via `ReactiveAdapterRegistry`.

Parameters:
  `producer` - the producer to write to the response
  `elementTypeRef` - the type of elements produced
Returns:
  the built response
Since:
  5.2

#### body

    reactor.core.publisher.Mono<ServerResponse> body(BodyInserter<?,? super org.springframework.http.server.reactive.ServerHttpResponse> inserter)

Set the body of the response to the given `BodyInserter` and return it.

Parameters:
  `inserter` - the `BodyInserter` that writes to the response
Returns:
  the built response

#### syncBody

    @Deprecated
    reactor.core.publisher.Mono<ServerResponse> syncBody(Object body)

Deprecated. as of Spring Framework 5.2 in favor of `bodyValue(Object)`
Set the response body to the given `Object` and return it. As of 5.2 this method delegates to `bodyValue(Object)`.

#### render

    reactor.core.publisher.Mono<ServerResponse> render(String name,
                                                       Object... modelAttributes)

Render the template with the given `name` using the given `modelAttributes`. The model attributes are mapped under a generated name.

Note: Empty `Collections` are not added to the model when using this method because we cannot correctly determine the true convention name.

Parameters:
  `name` - the name of the template to be rendered
  `modelAttributes` - the modelAttributes used to render the template
Returns:
  the built response

#### render

    reactor.core.publisher.Mono<ServerResponse> render(String name,
                                                       Map<String,?> model)

Render the template with the given `name` using the given `model`.

Parameters:
  `name` - the name of the template to be rendered
  `model` - the model used to render the template
Returns:
  the built response