@Override @Nullable public HttpStatus getStatusCode() { return this.statusCode != null ? HttpStatus.resolve(this.statusCode) : null; }
/** * Return the enum constant of this type with the specified numeric value. * @param statusCode the numeric value of the enum to be returned * @return the enum constant with the specified numeric value * @throws IllegalArgumentException if this enum has no constant for the specified numeric value */ public static HttpStatus valueOf(int statusCode) { HttpStatus status = resolve(statusCode); if (status == null) { throw new IllegalArgumentException("No matching constant for [" + statusCode + "]"); } return status; }
@Override public HttpStatus getStatusCode() { HttpStatus httpStatus = super.getStatusCode(); return httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.getStatus()); }
private <T> ResponseEntity<T> createEntity(T body, HttpHeaders headers, int status) { HttpStatus resolvedStatus = HttpStatus.resolve(status); return resolvedStatus != null ? new ResponseEntity<>(body, headers, resolvedStatus) : ResponseEntity.status(status).headers(headers).body(body); }
@Override @SuppressWarnings("ConstantConditions") public HttpStatus getStatusCode() { HttpStatus httpStatus = super.getStatusCode(); if (httpStatus == null) { HttpResponseStatus status = this.response.status(); httpStatus = status != null ? HttpStatus.resolve(status.code()) : null; } return httpStatus; }
@Override public HttpStatus getStatusCode() { HttpStatus httpStatus = super.getStatusCode(); return httpStatus != null ? httpStatus : HttpStatus.resolve(this.response.getStatus()); }
@Override public HttpStatus getStatusCode() { HttpStatus httpStatus = super.getStatusCode(); return httpStatus != null ? httpStatus : HttpStatus.resolve(this.exchange.getStatusCode()); }
private <T> ResponseEntity<T> createEntity(HttpHeaders headers, int status) { HttpStatus resolvedStatus = HttpStatus.resolve(status); return resolvedStatus != null ? new ResponseEntity<>(headers, resolvedStatus) : ResponseEntity.status(status).headers(headers).build(); }
@Override @SuppressWarnings("ConstantConditions") public HttpStatus getStatusCode() { HttpStatus httpStatus = super.getStatusCode(); if (httpStatus == null) { HttpResponseStatus status = this.response.status(); httpStatus = status != null ? HttpStatus.resolve(status.code()) : null; } return httpStatus; }
/** * Delegates to {@link #hasError(HttpStatus)} (for a standard status enum value) or * {@link #hasError(int)} (for an unknown status code) with the response status code. * @see ClientHttpResponse#getRawStatusCode() * @see #hasError(HttpStatus) * @see #hasError(int) */ @Override public boolean hasError(ClientHttpResponse response) throws IOException { int rawStatusCode = response.getRawStatusCode(); HttpStatus statusCode = HttpStatus.resolve(rawStatusCode); return (statusCode != null ? hasError(statusCode) : hasError(rawStatusCode)); }
private <T extends Publisher<?>> T handleBody(ClientResponse response, T bodyPublisher, Function<Mono<? extends Throwable>, T> errorFunction) { if (HttpStatus.resolve(response.rawStatusCode()) != null) { for (StatusHandler handler : this.statusHandlers) { if (handler.test(response.statusCode())) { HttpRequest request = this.requestSupplier.get(); Mono<? extends Throwable> exMono = handler.apply(response, request); exMono = exMono.flatMap(ex -> drainBody(response, ex)); exMono = exMono.onErrorResume(ex -> drainBody(response, ex)); return errorFunction.apply(exMono); } } return bodyPublisher; } else { return errorFunction.apply(createResponseException(response, this.requestSupplier.get())); } }
private void logResponse(ClientHttpResponse response, String logPrefix) { LogFormatUtils.traceDebug(logger, traceOn -> { int code = response.getRawStatusCode(); HttpStatus status = HttpStatus.resolve(code); return logPrefix + "Response " + (status != null ? status : code) + (traceOn ? ", headers=" + formatHeaders(response.getHeaders()) : ""); }); }
/** * Handle the given response, performing appropriate logging and * invoking the {@link ResponseErrorHandler} if necessary. * <p>Can be overridden in subclasses. * @param url the fully-expanded URL to connect to * @param method the HTTP method to execute (GET, POST, etc.) * @param response the resulting {@link ClientHttpResponse} * @throws IOException if propagated from {@link ResponseErrorHandler} * @since 4.1.6 * @see #setErrorHandler */ protected void handleResponse(URI url, HttpMethod method, ClientHttpResponse response) throws IOException { ResponseErrorHandler errorHandler = getErrorHandler(); boolean hasError = errorHandler.hasError(response); if (logger.isDebugEnabled()) { try { int code = response.getRawStatusCode(); HttpStatus status = HttpStatus.resolve(code); logger.debug("Response " + (status != null ? status : code)); } catch (IOException ex) { // ignore } } if (hasError) { errorHandler.handleError(url, method, response); } }
private void writeStatusAndHeaders(ServerHttpResponse response) { if (response instanceof AbstractServerHttpResponse) { ((AbstractServerHttpResponse) response).setStatusCodeValue(this.statusCode); } else { HttpStatus status = HttpStatus.resolve(this.statusCode); if (status == null) { throw new IllegalStateException( "Unresolvable HttpStatus for general ServerHttpResponse: " + this.statusCode); } response.setStatusCode(status); } copy(this.headers, response.getHeaders()); copy(this.cookies, response.getCookies()); }
/** * Indicates whether the response has a message body. * <p>Implementation returns {@code false} for: * <ul> * <li>a response status of {@code 1XX}, {@code 204} or {@code 304}</li> * <li>a {@code Content-Length} header of {@code 0}</li> * </ul> * @return {@code true} if the response has a message body, {@code false} otherwise * @throws IOException in case of I/O errors */ public boolean hasMessageBody() throws IOException { HttpStatus status = HttpStatus.resolve(getRawStatusCode()); if (status != null && (status.is1xxInformational() || status == HttpStatus.NO_CONTENT || status == HttpStatus.NOT_MODIFIED)) { return false; } if (getHeaders().getContentLength() == 0) { return false; } return true; }
/** * Determine the HTTP status of the given response. * @param response the response to inspect * @return the associated HTTP status * @throws IOException in case of I/O errors * @throws UnknownHttpStatusCodeException in case of an unknown status code * that cannot be represented with the {@link HttpStatus} enum * @since 4.3.8 * @deprecated as of 5.0, in favor of {@link #handleError(ClientHttpResponse, HttpStatus)} */ @Deprecated protected HttpStatus getHttpStatusCode(ClientHttpResponse response) throws IOException { HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode()); if (statusCode == null) { throw new UnknownHttpStatusCodeException(response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), getResponseBody(response), getCharset(response)); } return statusCode; }
/** * Delegates to {@link #handleError(ClientHttpResponse, HttpStatus)} with the * response status code. * @throws UnknownHttpStatusCodeException in case of an unresolvable status code * @see #handleError(ClientHttpResponse, HttpStatus) */ @Override public void handleError(ClientHttpResponse response) throws IOException { HttpStatus statusCode = HttpStatus.resolve(response.getRawStatusCode()); if (statusCode == null) { throw new UnknownHttpStatusCodeException(response.getRawStatusCode(), response.getStatusText(), response.getHeaders(), getResponseBody(response), getCharset(response)); } handleError(response, statusCode); }
.map(MimeType::getCharset) .orElse(StandardCharsets.ISO_8859_1); if (HttpStatus.resolve(response.rawStatusCode()) != null) { return WebClientResponseException.create( response.statusCode().value(),
@Test public void shouldSupportUnknownStatusCode() { int errorStatus = 555; assertNull(HttpStatus.resolve(errorStatus)); String errorMessage = "Something went wrong"; prepareResponse(response -> response.setResponseCode(errorStatus) .setHeader("Content-Type", "text/plain").setBody(errorMessage)); Mono<ClientResponse> result = this.webClient.get() .uri("/unknownPage") .exchange(); StepVerifier.create(result) .consumeNextWith(response -> assertEquals(555, response.rawStatusCode())) .expectComplete() .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/unknownPage", request.getPath()); }); }
@Test public void shouldGetErrorSignalWhenRetrievingUnknownStatusCode() { int errorStatus = 555; assertNull(HttpStatus.resolve(errorStatus)); String errorMessage = "Something went wrong"; prepareResponse(response -> response.setResponseCode(errorStatus) .setHeader("Content-Type", "text/plain").setBody(errorMessage)); Mono<String> result = this.webClient.get() .uri("/unknownPage") .retrieve() .bodyToMono(String.class); StepVerifier.create(result) .expectErrorSatisfies(throwable -> { assertTrue(throwable instanceof UnknownHttpStatusCodeException); UnknownHttpStatusCodeException ex = (UnknownHttpStatusCodeException) throwable; assertEquals("Unknown status code ["+errorStatus+"]", ex.getMessage()); assertEquals(errorStatus, ex.getRawStatusCode()); assertEquals("", ex.getStatusText()); assertEquals(MediaType.TEXT_PLAIN, ex.getHeaders().getContentType()); assertEquals(errorMessage, ex.getResponseBodyAsString()); }) .verify(Duration.ofSeconds(3)); expectRequestCount(1); expectRequest(request -> { assertEquals("*/*", request.getHeader(HttpHeaders.ACCEPT)); assertEquals("/unknownPage", request.getPath()); }); }