org.springframework.web.reactive.function.client

Interface WebClient.RequestHeadersSpec<S extends WebClient.RequestHeadersSpec<S>>

Type Parameters:

S - a self reference to the spec type

All Known Subinterfaces:

WebClient.RequestBodySpec, WebClient.RequestBodyUriSpec, WebClient.RequestHeadersUriSpec<S>

Enclosing interface:

WebClient

public static interface WebClient.RequestHeadersSpec<S extends WebClient.RequestHeadersSpec<S>>

Contract for specifying request headers leading up to the exchange.

Method Summary

Modifier and Type	Method and Description
S	accept(MediaType... acceptableMediaTypes) Set the list of acceptable media types, as specified by the Accept header.
S	acceptCharset(Charset... acceptableCharsets) Set the list of acceptable charsets, as specified by the Accept-Charset header.
S	attribute(String name, Object value) Set the attribute with the given name to the given value.
S	attributes(Consumer<Map<String,Object>> attributesConsumer) Provides access to every attribute declared so far with the possibility to add, replace, or remove values.
S	context(Function<reactor.util.context.Context,reactor.util.context.Context> contextModifier) Provide a function to populate the Reactor Context.
S	cookie(String name, String value) Add a cookie with the given name and value.
S	cookies(Consumer<MultiValueMap<String,String>> cookiesConsumer) Provides access to every cookie declared so far with the possibility to add, replace, or remove values.
reactor.core.publisher.Mono<ClientResponse>	exchange() Deprecated. since 5.3 due to the possibility to leak memory and/or connections; please, use exchangeToMono(Function), exchangeToFlux(Function); consider also using retrieve() which provides access to the response status and headers via ResponseEntity along with error status handling.
<V> reactor.core.publisher.Flux<V>	exchangeToFlux(Function<ClientResponse,? extends reactor.core.publisher.Flux<V>> responseHandler) An alternative to retrieve() that provides more control via access to the ClientResponse.
<V> reactor.core.publisher.Mono<V>	exchangeToMono(Function<ClientResponse,? extends reactor.core.publisher.Mono<V>> responseHandler) An alternative to retrieve() that provides more control via access to the ClientResponse.
S	header(String headerName, String... headerValues) Add the given, single header value under the given name.
S	headers(Consumer<HttpHeaders> headersConsumer) Provides access to every header declared so far with the possibility to add, replace, or remove values.
S	httpRequest(Consumer<ClientHttpRequest> requestConsumer) Callback for access to the ClientHttpRequest that in turn provides access to the native request of the underlying HTTP library.
S	ifModifiedSince(ZonedDateTime ifModifiedSince) Set the value of the If-Modified-Since header.
S	ifNoneMatch(String... ifNoneMatches) Set the values of the If-None-Match header.
WebClient.ResponseSpec	retrieve() Proceed to declare how to extract the response.

Method Detail

accept

S accept(MediaType... acceptableMediaTypes)

Set the list of acceptable media types, as specified by the Accept header.

Parameters:

acceptableMediaTypes - the acceptable media types

Returns:

this builder

acceptCharset

S acceptCharset(Charset... acceptableCharsets)

Set the list of acceptable charsets, as specified by the Accept-Charset header.

Parameters:

acceptableCharsets - the acceptable charsets

Returns:

this builder

cookie

S cookie(String name,
         String value)

Add a cookie with the given name and value.

Parameters:

name - the cookie name

value - the cookie value

Returns:

this builder

cookies

S cookies(Consumer<MultiValueMap<String,String>> cookiesConsumer)

Provides access to every cookie declared so far with the possibility to add, replace, or remove values.

Parameters:

cookiesConsumer - the consumer to provide access to

Returns:

this builder

ifModifiedSince

S ifModifiedSince(ZonedDateTime ifModifiedSince)

Set the value of the If-Modified-Since header.

The date should be specified as the number of milliseconds since January 1, 1970 GMT.

Parameters:

ifModifiedSince - the new value of the header

Returns:

this builder

ifNoneMatch

S ifNoneMatch(String... ifNoneMatches)

Set the values of the If-None-Match header.

Parameters:

ifNoneMatches - the new value of the header

Returns:

this builder

header

S header(String headerName,
         String... headerValues)

Add the given, single header value under the given name.

Parameters:

headerName - the header name

headerValues - the header value(s)

Returns:

this builder

headers

S headers(Consumer<HttpHeaders> headersConsumer)

Provides access to every header declared so far with the possibility to add, replace, or remove values.

Parameters:

headersConsumer - the consumer to provide access to

Returns:

this builder

attribute

S attribute(String name,
            Object value)

Set the attribute with the given name to the given value.

Parameters:

name - the name of the attribute to add

value - the value of the attribute to add

Returns:

this builder

attributes

S attributes(Consumer<Map<String,Object>> attributesConsumer)

Provides access to every attribute declared so far with the possibility to add, replace, or remove values.

Parameters:

attributesConsumer - the consumer to provide access to

Returns:

this builder

context

S context(Function<reactor.util.context.Context,reactor.util.context.Context> contextModifier)

Provide a function to populate the Reactor Context. In contrast to attributes which apply only to the current request, the Reactor Context transparently propagates to the downstream processing chain which may include other nested or successive calls over HTTP or via other reactive clients.

Parameters:

contextModifier - the function to modify the context with

Since:

5.3.1

httpRequest

S httpRequest(Consumer<ClientHttpRequest> requestConsumer)

Callback for access to the ClientHttpRequest that in turn provides access to the native request of the underlying HTTP library. This could be useful for setting advanced, per-request options that exposed by the underlying library.

Parameters:

requestConsumer - a consumer to access the ClientHttpRequest with

Returns:

ResponseSpec to specify how to decode the body

Since:

5.3

retrieve

WebClient.ResponseSpec retrieve()

Proceed to declare how to extract the response. For example to extract a ResponseEntity with status, headers, and body:

 Mono<ResponseEntity<Person>> entityMono = client.get()
     .uri("/persons/1")
     .accept(MediaType.APPLICATION_JSON)
     .retrieve()
     .toEntity(Person.class);
 

Or if interested only in the body:

 Mono<Person> entityMono = client.get()
     .uri("/persons/1")
     .accept(MediaType.APPLICATION_JSON)
     .retrieve()
     .bodyToMono(Person.class);
 

By default, 4xx and 5xx responses result in a WebClientResponseException. To customize error handling, use onStatus handlers.

exchangeToMono

<V> reactor.core.publisher.Mono<V> exchangeToMono(Function<ClientResponse,? extends reactor.core.publisher.Mono<V>> responseHandler)

An alternative to retrieve() that provides more control via access to the ClientResponse. This can be useful for advanced scenarios, for example to decode the response differently depending on the response status:

 Mono<Object> entityMono = client.get()
     .uri("/persons/1")
     .accept(MediaType.APPLICATION_JSON)
     .exchangeToMono(response -> {
         if (response.statusCode().equals(HttpStatus.OK)) {
             return response.bodyToMono(Person.class);
         }
         else if (response.statusCode().is4xxClientError()) {
             return response.bodyToMono(ErrorContainer.class);
         }
         else {
             return Mono.error(response.createException());
         }
     });
 

Note: After the returned Mono completes, the response body is automatically released if it hasn't been consumed. If the response content is needed, the provided function must declare how to decode it.

Type Parameters:

V - the type of Object the response will be transformed to

Parameters:

responseHandler - the function to handle the response with

Returns:

a Mono produced from the response

Since:

5.3

exchangeToFlux

<V> reactor.core.publisher.Flux<V> exchangeToFlux(Function<ClientResponse,? extends reactor.core.publisher.Flux<V>> responseHandler)

An alternative to retrieve() that provides more control via access to the ClientResponse. This can be useful for advanced scenarios, for example to decode the response differently depending on the response status:

 Mono<Object> entityMono = client.get()
     .uri("/persons")
     .accept(MediaType.APPLICATION_JSON)
     .exchangeToFlux(response -> {
         if (response.statusCode().equals(HttpStatus.OK)) {
             return response.bodyToFlux(Person.class);
         }
         else if (response.statusCode().is4xxClientError()) {
             return response.bodyToMono(ErrorContainer.class).flux();
         }
         else {
             return Flux.error(response.createException());
         }
     });
 

Note: After the returned Flux completes, the response body is automatically released if it hasn't been consumed. If the response content is needed, the provided function must declare how to decode it.

Type Parameters:

V - the type of Objects the response will be transformed to

Parameters:

responseHandler - the function to handle the response with

Returns:

a Flux of Objects produced from the response

Since:

5.3

exchange

@Deprecated
reactor.core.publisher.Mono<ClientResponse> exchange()

Deprecated. since 5.3 due to the possibility to leak memory and/or connections; please, use exchangeToMono(Function), exchangeToFlux(Function); consider also using retrieve() which provides access to the response status and headers via ResponseEntity along with error status handling.

Perform the HTTP request and return a ClientResponse with the response status and headers. You can then use methods of the response to consume the body:

 Mono<Person> mono = client.get()
     .uri("/persons/1")
     .accept(MediaType.APPLICATION_JSON)
     .exchange()
     .flatMap(response -> response.bodyToMono(Person.class));

 Flux<Person> flux = client.get()
     .uri("/persons")
     .accept(MediaType.APPLICATION_STREAM_JSON)
     .exchange()
     .flatMapMany(response -> response.bodyToFlux(Person.class));
 

NOTE: Unlike retrieve(), when using exchange(), it is the responsibility of the application to consume any response content regardless of the scenario (success, error, unexpected data, etc). Not doing so can cause a memory leak. See ClientResponse for a list of all the available options for consuming the body. Generally prefer using retrieve() unless you have a good reason to use exchange() which does allow to check the response status and headers before deciding how or if to consume the response.

Returns:

a Mono for the response

See Also:

retrieve()