Develop Reference

Spring webclient onErrorReturn for specific type of exception

I wanted to return a fallback value from webclient after retries for only specific type of exception. I tried the below code but it doesnt return the fallback value.
public Mono<String> getEmployee(String request) {
return WebClient.create()
.get()
.uri("/accounts/" + request)
.exchangeToMono(clientResponse -> {
if (clientResponse.statusCode().value() == HttpStatus.INTERNAL_SERVER_ERROR.value()) {
throw new IllegalStateException();
}
if (clientResponse.statusCode().value() == HttpStatus.OK.value()) {
return clientResponse
.bodyToMono(String.class);
}
return Mono.error(new IllegalCallerException());
})
.retryWhen(Retry.max(3).filter(throwable -> throwable instanceof IllegalStateException))
.onErrorReturn(IllegalStateException.class, "TECHNICAL_ERROR")
.log();
}
As you see above, when Http status is 500, i wanted to retry only for IllegalStateException for 3 times and return fallback value when exception type is IllegalStateException. I used onErrorReturn with fallback value and specific error to match. But above code doesn't work, it retries for 3 times but fallback value is not returned.

In cases like that the best option for finding an issue is checking the instance of errors in debugger.
After all of retry tries are exhausted RetryExhaustedException will be throwed
Simple example for visualization:
Mono.error(new IllegalStateException("example"))
.retryWhen(Retry.max(-1))
.doOnError(throwable -> {
assert Objects.equals(throwable.getClass().getSimpleName(), "RetryExhaustedException");
})
.subscribe();
Summary:
Your retry mechanism works but after there are exhausted it is not IllegalStateExcpetion
If you want to handle logic on IllegalStateException later you can use onErtryExhaustedThrow method like:
.retryWhen(Retry.max(3)
.filter(throwable -> throwable instanceof IllegalStateException)
.onRetryExhaustedThrow((retrySpec, retrySignal) -> new IllegalStateException()))

You should do the following. I have similar code in our service and it is working as expected.
public Mono<String> getEmployee(String request) {
return WebClient.create()
.get()
.uri("/accounts/" + request)
.retrieve()
.onStatus(HttpStatus::is5xxServerError, res -> {
return Mono.error(new IllegalStateException());
})
.bodyToMono(String.class)
.retryWhen(
Retry.max(3)
.filter(IllegalStateException.class::isInstance)
.onRetryExhaustedThrow((retrySpec, retrySignal) -> new MaxRetryAchievedException("Max retried"))
).onErrorReturn(MaxRetryAchievedException.class, "Techinal Error")
.log();
}
public class MaxRetryAchievedException extends RuntimeException {
public MaxRetryAchievedException(String message) {
super(message);
}
}

Retry only when 5xx error is encountered Spring boot WebClient

I have followed few suggestions around to make a retry attempt only when I get 5xx error and straight away throw exception otherwise. But the code example I got doesn't seems to be working. It's not retrying for any of the exceptions (be it 4xx or 5xx).
Here is my code
public Mono<String> call(String input) {
log.info("Sending echo call for: {}", input);
return webClient.get()
.uri(format("/echo/%s", input))
.accept(MediaType.APPLICATION_JSON).acceptCharset(StandardCharsets.UTF_8)
.retrieve()
.onStatus(HttpStatus::is5xxServerError,
response -> Mono.error(new ServiceException("Server error", response.rawStatusCode())))
.bodyToMono(String.class)
.timeout(ofMillis(60_000L))
.retryWhen(
backoff(3L, ofSeconds(4L))
.jitter(0d)
.filter(ServiceException.class::isInstance)
.doAfterRetry(retrySignal -> log.info("Retry call: " + retrySignal))
.onRetryExhaustedThrow((retryBackoffSpec, retrySignal) -> retrySignal.failure())
)
.doOnError(throwable -> log.error("Call failure: {}", throwable.getMessage()))
.doOnSuccess(response -> log.info("Success: {}", response));
}
Anyone can help me figure out what's wrong with the code or can suggest an alternative approach. Thanks a lot!

Please try this, it should work.
final WebClient webClient = WebClient.builder().build();
final Mono<String> body = webClient
.get()
.uri("URL")
.retrieve()
.bodyToMono(String.class)
.retryWhen(Retry
.backoff(3, Duration.ofSeconds(2))
.filter(this::is5xxServerError)
);
System.out.println(body.block());
private boolean is5xxServerError(Throwable throwable) {
return throwable instanceof WebClientResponseException &&
((WebClientResponseException) throwable).getStatusCode().is5xxServerError();
}

"IllegalStateException: Only one connection receive subscriber allowed" when response body is empty

I have a Spring Boot 2.3.1 project, in which I use WebClient to call a remote service.
The remote service is not very reliable and tends to return 500 errors, with and without response bodies. My goal is throw a custom exception that contains the response body (or a default message) so that I can log it, and here's my code :
webClient.get()
.uri(targetServiceUri)
.retrieve()
.onStatus(HttpStatus::is5xxServerError, clientResponse ->
clientResponse.bodyToMono(String.class)
.flatMap(error ->
Mono.error(new MyCustomServiceException(error))
)
)
.toEntity(String.class)
.block();
I have 2 tests using wiremock, the first one works :
#Test
void shouldThrowCustomExceptionWhenServiceReturns500ServerErrorWithNoBody() {
setStubForInValidCheckCall(HttpStatus.INTERNAL_SERVER_ERROR,"{'Error':'invalid request'}");
Throwable thrown =
catchThrowable(() -> myClient.performComplianceCheck(getCompany()));
assertThat(thrown)
.isInstanceOf(MyCustomServiceException.class)
.hasMessageContaining("{'Error':'invalid request'}");
}
private void setStubForInValidCheckCall(HttpStatus httpStatus, String body) {
var response= aResponse().withStatus(httpStatus.value());
if(body!=null){
response=response.withBody(body);
}
stubFor(
get(urlPathMatching("/targetCompliance"))
.willReturn(response));
}
However, the second test in which the response is 500 but there's no body (or if it's an empty string), fails with "java.lang.IllegalStateException: Only one connection receive subscriber allowed.
#Test
void shouldThrowCustomExceptionWhenServiceReturns500ServerErrorWithNoBody() {
setStubForInValidCheckCall(HttpStatus.INTERNAL_SERVER_ERROR,null);
Throwable thrown =
catchThrowable(() -> myClient.performComplianceCheck(getCompany()));
assertThat(thrown)
.isInstanceOf(MyCustomServiceException.class)
.hasMessageContaining("service returned status 500");
}
I am struggling to understand why this happens, and how to fix it..
is it "normal" ? or am I missing something obvious (is it a problem with my test ?) ?

I have found a workaround, but it doesn't feel "webFlux-y" at all, and I still don't understand why the Only one connection receive subscriber allowed was happening :
try {
ResponseEntity<String> responseEntity =
webClient.get()
.uri(targetServiceUri)
.retrieve()
.toEntity(String.class)
.block();
}
catch (WebClientException e) {
if(e instanceof InternalServerError){
var internalServerError=(InternalServerError) e;
if(internalServerError.getStatusCode().is5xxServerError()){
var respBody=internalServerError.getResponseBodyAsString();
if(StringUtils.isEmpty(respBody)){
respBody=MY_STANDARD_MESSAGE +internalServerError.getRawStatusCode() ;
}
throw new MyCustomServiceException(respBody);
}
}
}

Getting the response body in error case with Spring WebClient

I am trying to replace the existing client code with RestTemplate with a WebClient. For that reason, most of the calls need to be blocking, so that the main portion of the application does not need to change. When it comes to error handling this poses a bit of a problem. There are several cases that have to be covered:
In a successful case the response contains a JSON object of type A
In an error case (HTTP status 4xx or 5xx) the response may contain a JSON object of type B
On certain requests with response status 404 I need to return an empty List matching the type of a successful response
In order to produce the correct error (Exception) the error response needs to be considered. So far I am unable to get my hands on the error body.
I am using this RestController method to produce the error response:
#GetMapping("/error/404")
#ResponseStatus(HttpStatus.NOT_FOUND)
public ResponseEntity error404() {
return ResponseEntity
.status(HttpStatus.NOT_FOUND)
.body(new ErrorResponse());
}
With this response object:
public class ErrorResponse {
private String message = "Error message";
public String getMessage() {
return message;
}
}
The WebClient is defined as follows:
WebClient.builder()
.baseUrl("http://localhost:8081")
.clientConnector(connector)
.defaultHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.build();
With the connector being of type CloseableHttpAsyncClient (Apache Http client5).
From my test application I make the call like this:
public String get(int httpStatus) {
try {
return webClient.get()
.uri("/error/" + httpStatus)
.retrieve()
.onStatus(HttpStatus::isError, clientResponse -> {
clientResponse.bodyToMono(String.class).flatMap(responseBody -> {
log.error("Body from within flatMap within onStatus: {}", responseBody);
return Mono.just(responseBody);
});
return Mono.error(new RuntimeException("Resolved!"));
})
.bodyToMono(String.class)
.flatMap(clientResponse -> {
log.warn("Body from within flatMap: {}", clientResponse);
return Mono.just(clientResponse);
})
.block();
} catch (Exception ex) {
log.error("Caught Error: ", ex);
return ex.getMessage();
}
}
What I get is the RuntimeException from the onStatus return and of course the caught exception in the end.
I am missing the processing from the bodyToMono from within the onStatus. My suspicion is that this is not executed due to the blocking nature, as the response body is dealt with the bodyToMono after the onStatus.
When commenting out the onStatus I would expect that we log the warning in the flatMap, which does not happen either.
In the end I would like to define the handling of errors as a filter so that the code does not need to be repeated on every call, but I need to get the error response body, so that the exception can be populated with the correct data.
How can I retrieve the error response in a synchronous WebClient call?
This question is similar to Spring Webflux : Webclient : Get body on error, which has no accepted answer and some of the suggested approaches use methods that are no deprecated.

Here is one approach to handle error responses:
use onStatus to capture error http status
deserialize error response clientResponse.bodyToMono(ErrorResponse.class)
generate new error signal based on the error response Mono.error(new RuntimeException(error.getMessage())). Example uses RuntimeException but I would suggest to use custom exception to simplify error handling downstream.
webClient.get()
.uri("/error/" + httpStatus)
.retrieve()
.onStatus(HttpStatus::isError, clientResponse ->
clientResponse.bodyToMono(ErrorResponse.class)
.flatMap(error ->
Mono.error(new RuntimeException(error.getMessage()))
)
)
.bodyToMono(Response.class)
You don't really need try-catch. If you block the above code would return Response in case of the non-error response and throws exception with custom message in case of error response.
Update
Here is a full test using WireMock
class WebClientErrorHandlingTest {
private WireMockServer wireMockServer;
#BeforeEach
void init() {
wireMockServer = new WireMockServer(wireMockConfig().dynamicPort());
wireMockServer.start();
WireMock.configureFor(wireMockServer.port());
}
#Test
void test() {
stubFor(post("/test")
.willReturn(aResponse()
.withHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE)
.withStatus(400)
.withBody("{\"message\":\"Request error\",\"errorCode\":\"10000\"}")
)
);
WebClient webClient = WebClient.create("http://localhost:" + wireMockServer.port());
Mono<Response> request = webClient.post()
.uri("/test")
.retrieve()
.onStatus(HttpStatus::isError, clientResponse ->
clientResponse.bodyToMono(ErrorResponse.class)
.flatMap(error ->
Mono.error(new RuntimeException(error.getMessage() + ": " + error.getErrorCode()))
)
)
.bodyToMono(Response.class);
RuntimeException ex = assertThrows(RuntimeException.class, () -> request.block());
assertEquals("Request error: 10000", ex.getMessage());
}
#Data
private static class ErrorResponse {
private String message;
private int errorCode;
}
#Data
private static class Response {
private String result;
}
}

Spring Gatewayfilter (AUTH) How to Catch Error 500 and return the response from Auth-Service

Is there a way to catch the 500 Error and return the auth/userservice response instead of throwing?
eg. "Token invalid" / "Token expired" - the userservice already provides the correct response
#Override
public GatewayFilter apply(Config config) {
return (exchange, chain) -> {
String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
String[] parts = authHeader.split(" ");
return webClientBuilder.build()
.post()
.uri("http://USER-SERVICE/user/validateToken?token=" + parts[1])
.retrieve()
.bodyToMono(UserDto.class)
.map(userDto -> {
exchange.getRequest()
.mutate()
.header("X-auth-user-id", String.valueOf(userDto.getId()));
return exchange;
}).flatMap(chain::filter);
};
}
On successful auth, it works like a charm. But i want to get the response from my userservice if anything goes wrong.
I havent worked with webclient before... its driving me crazy.
Edit: I also tried to get the response before to test it, unsuccessful. I used a Dto which should reflect the Error Response from my userservice.
var test = webClientBuilder.build()
.post()
.uri("http://USER-SERVICE/user/validateToken?token=" + parts[1])
.retrieve()
.bodyToMono(ApiExceptionDto.class);
var y = test.subscribe(p -> {
System.out.println(p.getMessage());
});
I just get a
reactor.core.Exceptions$ErrorCallbackNotImplemented: org.springframework.web.reactive.function.client.WebClientResponseException$NotFound: 404 Not Found from POST http://192.168.0.69:9001/user/validateToken?token=xx
Caused by: org.springframework.web.reactive.function.client.WebClientResponseException$NotFound: 404 Not Found from POST http://192.168.0.69:9001/user/validateToken?token=xx
at org.springframework.web.reactive.function.client.WebClientResponseException.create(WebClientResponseException.java:202) ~[spring-webflux-5.3.9.jar:5.3.9]
Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException:
Error has been observed at the following site(s):
|_ checkpoint ⇢ 404 from POST http://USER-SERVICE/user/validateToken?token=xx [DefaultWebClient]
The Expected Response: (Postman)
POST : http://192.168.0.69:9001/user/validateToken?token=xx
{
"message": "The token was expected to have 3 parts, but got 1.",
"status": "NOT_FOUND",
"time": "Wed, 18 Aug 2021 01:05:21 GMT",
"path": "/user/validateToken"
}

I'll found a better solution, which will be more accurate:
#Override
public GatewayFilter apply(Config config) {
return (exchange, chain) -> {
String authHeader = exchange.getRequest().getHeaders().getFirst("Authorization");
String[] parts = authHeader.split(" ");
return webClientBuilder.build()
.post()
.uri("http://USER-SERVICE/user/validateToken?token=" + parts[1])
.retrieve()
.bodyToMono(UserDto.class)
.onErrorResume(e -> Mono.just(new RuntimeException())
.map(userDto -> {
exchange.getRequest()
.mutate()
.header("X-auth-user-id", String.valueOf(userDto.getId()));
return exchange;
}).flatMap(chain::filter);
};
}
It's after bodyToMono() and before map(). In onErrorResume() you will throw a new exception, if your downstream service will report any error (code >= 300). If you subclass RuntimeException and annotate it with HttpStatus.UNAUTHORIZED your client will receive the correct status and can react to it.

Guess i did it.
If someone has improvements to offer i would appreciate any input.
return webClientBuilder.build()
.post()
.uri("http://USER-SERVICE/user/validateToken?token=" + parts[1])
.exchangeToMono(clientResponse -> {
if (clientResponse.statusCode().isError()) {
return clientResponse.bodyToMono(AuthResponseDto.class);
}
return clientResponse.bodyToMono(UserDto.class);
}).flatMap(dto -> {
if (dto.getClass() != UserDto.class) {
AuthResponseDto authResponseDto = (AuthResponseDto) dto;
// returns the response to from userservice
return writeResponse(exchange.getResponse(), ApiExceptionDto.builder()
.message(authResponseDto.getMessage())
.status(authResponseDto.getStatus())
.time(Instant.now())
.path(authResponseDto.getPath())
.build()
.getJsonAsBytes());
}
return chain.filter(exchange);
});