Example usage for org.springframework.web.server ServerWebExchange getResponse

List of usage examples for org.springframework.web.server ServerWebExchange getResponse

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.web.server.*
  5. ServerWebExchange
  6. getResponse

Introduction

In this page you can find the example usage for org.springframework.web.server ServerWebExchange getResponse.

Prototype

ServerHttpResponse getResponse();

Source Link

Document

Return the current HTTP response.

Usage

From source file:org.springframework.boot.autoconfigure.web.reactive.error.AbstractErrorWebExceptionHandler.java

@Override
public Mono<Void> handle(ServerWebExchange exchange, Throwable throwable) {
    if (exchange.getResponse().isCommitted() || isDisconnectedClientError(throwable)) {
        return Mono.error(throwable);
    }//from   w ww.  j  av  a2  s.c o  m
    this.errorAttributes.storeErrorInformation(throwable, exchange);
    ServerRequest request = ServerRequest.create(exchange, this.messageReaders);
    return getRoutingFunction(this.errorAttributes).route(request).switchIfEmpty(Mono.error(throwable))
            .flatMap((handler) -> handler.handle(request))
            .doOnNext((response) -> logError(request, response, throwable))
            .flatMap((response) -> write(exchange, response));
}

From source file:org.springframework.boot.autoconfigure.web.reactive.error.AbstractErrorWebExceptionHandler.java

private Mono<? extends Void> write(ServerWebExchange exchange, ServerResponse response) {
    // force content-type since writeTo won't overwrite response header values
    exchange.getResponse().getHeaders().setContentType(response.headers().getContentType());
    return response.writeTo(exchange, new ResponseContext());
}

From source file:org.springframework.cloud.function.web.RequestProcessor.java

private Publisher<?> body(Object handler, ServerWebExchange exchange) {
    ResolvableType elementType = ResolvableType.forClass(this.inspector.getInputType(handler));
    ResolvableType actualType = elementType;
    Class<?> resolvedType = elementType.resolve();
    ReactiveAdapter adapter = (resolvedType != null ? getAdapterRegistry().getAdapter(resolvedType) : null);

    ServerHttpRequest request = exchange.getRequest();
    ServerHttpResponse response = exchange.getResponse();

    MediaType contentType = request.getHeaders().getContentType();
    MediaType mediaType = (contentType != null ? contentType : MediaType.APPLICATION_OCTET_STREAM);

    if (logger.isDebugEnabled()) {
        logger.debug(exchange.getLogPrefix() + (contentType != null ? "Content-Type:" + contentType
                : "No Content-Type, using " + MediaType.APPLICATION_OCTET_STREAM));
    }// w ww  .  j  av  a2 s.c o m
    boolean isBodyRequired = (adapter != null && !adapter.supportsEmpty());

    MethodParameter bodyParam = new MethodParameter(handlerMethod(handler), 0);
    for (HttpMessageReader<?> reader : getMessageReaders()) {
        if (reader.canRead(elementType, mediaType)) {
            Map<String, Object> readHints = Hints.from(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix());
            if (adapter != null && adapter.isMultiValue()) {
                if (logger.isDebugEnabled()) {
                    logger.debug(exchange.getLogPrefix() + "0..N [" + elementType + "]");
                }
                Flux<?> flux = reader.read(actualType, elementType, request, response, readHints);
                flux = flux.onErrorResume(ex -> Flux.error(handleReadError(bodyParam, ex)));
                if (isBodyRequired) {
                    flux = flux.switchIfEmpty(Flux.error(() -> handleMissingBody(bodyParam)));
                }
                return Mono.just(adapter.fromPublisher(flux));
            } else {
                // Single-value (with or without reactive type wrapper)
                if (logger.isDebugEnabled()) {
                    logger.debug(exchange.getLogPrefix() + "0..1 [" + elementType + "]");
                }
                Mono<?> mono = reader.readMono(actualType, elementType, request, response, readHints);
                mono = mono.onErrorResume(ex -> Mono.error(handleReadError(bodyParam, ex)));
                if (isBodyRequired) {
                    mono = mono.switchIfEmpty(Mono.error(() -> handleMissingBody(bodyParam)));
                }
                return (adapter != null ? Mono.just(adapter.fromPublisher(mono)) : Mono.from(mono));
            }
        }
    }

    return Mono.error(new UnsupportedMediaTypeStatusException(mediaType,
            Arrays.asList(MediaType.APPLICATION_JSON), elementType));
}

From source file:org.springframework.cloud.gateway.filter.factory.RetryGatewayFilterFactory.java

@Override
public GatewayFilter apply(RetryConfig retryConfig) {
    retryConfig.validate();//from ww  w .  ja v  a  2  s .c  om

    Repeat<ServerWebExchange> statusCodeRepeat = null;
    if (!retryConfig.getStatuses().isEmpty() || !retryConfig.getSeries().isEmpty()) {
        Predicate<RepeatContext<ServerWebExchange>> repeatPredicate = context -> {
            ServerWebExchange exchange = context.applicationContext();
            if (exceedsMaxIterations(exchange, retryConfig)) {
                return false;
            }

            HttpStatus statusCode = exchange.getResponse().getStatusCode();

            boolean retryableStatusCode = retryConfig.getStatuses().contains(statusCode);

            if (!retryableStatusCode && statusCode != null) { // null status code
                // might mean a
                // network exception?
                // try the series
                retryableStatusCode = retryConfig.getSeries().stream()
                        .anyMatch(series -> statusCode.series().equals(series));
            }

            trace("retryableStatusCode: %b, statusCode %s, configured statuses %s, configured series %s",
                    retryableStatusCode, statusCode, retryConfig.getStatuses(), retryConfig.getSeries());

            HttpMethod httpMethod = exchange.getRequest().getMethod();
            boolean retryableMethod = retryConfig.getMethods().contains(httpMethod);

            trace("retryableMethod: %b, httpMethod %s, configured methods %s", retryableMethod, httpMethod,
                    retryConfig.getMethods());
            return retryableMethod && retryableStatusCode;
        };

        statusCodeRepeat = Repeat.onlyIf(repeatPredicate)
                .doOnRepeat(context -> reset(context.applicationContext()));
    }

    // TODO: support timeout, backoff, jitter, etc... in Builder

    Retry<ServerWebExchange> exceptionRetry = null;
    if (!retryConfig.getExceptions().isEmpty()) {
        Predicate<RetryContext<ServerWebExchange>> retryContextPredicate = context -> {
            if (exceedsMaxIterations(context.applicationContext(), retryConfig)) {
                return false;
            }

            for (Class<? extends Throwable> clazz : retryConfig.getExceptions()) {
                if (clazz.isInstance(context.exception())) {
                    trace("exception is retryable %s, configured exceptions",
                            context.exception().getClass().getName(), retryConfig.getExceptions());
                    return true;
                }
            }
            trace("exception is not retryable %s, configured exceptions",
                    context.exception().getClass().getName(), retryConfig.getExceptions());
            return false;
        };
        exceptionRetry = Retry.onlyIf(retryContextPredicate)
                .doOnRetry(context -> reset(context.applicationContext())).retryMax(retryConfig.getRetries());
    }

    return apply(statusCodeRepeat, exceptionRetry);
}

From source file:org.springframework.cloud.gateway.filter.factory.RetryGatewayFilterFactory.java

public void reset(ServerWebExchange exchange) {
    // TODO: what else to do to reset SWE?
    Set<String> addedHeaders = exchange.getAttributeOrDefault(CLIENT_RESPONSE_HEADER_NAMES,
            Collections.emptySet());
    addedHeaders.forEach(header -> exchange.getResponse().getHeaders().remove(header));
    exchange.getAttributes().remove(GATEWAY_ALREADY_ROUTED_ATTR);
}

From source file:org.springframework.cloud.gateway.filter.GatewayMetricsFilter.java

private void endTimerRespectingCommit(ServerWebExchange exchange, Sample sample) {

    ServerHttpResponse response = exchange.getResponse();
    if (response.isCommitted()) {
        endTimerInner(exchange, sample);
    } else {//w ww. ja va 2  s.  c o m
        response.beforeCommit(() -> {
            endTimerInner(exchange, sample);
            return Mono.empty();
        });
    }
}

From source file:org.springframework.cloud.gateway.filter.GatewayMetricsFilter.java

private void endTimerInner(ServerWebExchange exchange, Sample sample) {
    String outcome = "CUSTOM";
    String status = "CUSTOM";
    HttpStatus statusCode = exchange.getResponse().getStatusCode();
    if (statusCode != null) {
        outcome = statusCode.series().name();
        status = statusCode.name();//from   w  w  w.ja  va2 s .  c  om
    } else { // a non standard HTTPS status could be used. Let's be defensive here
        if (exchange.getResponse() instanceof AbstractServerHttpResponse) {
            Integer statusInt = ((AbstractServerHttpResponse) exchange.getResponse()).getStatusCodeValue();
            if (statusInt != null) {
                status = String.valueOf(statusInt);
            } else {
                status = "NA";
            }
        }
    }
    Route route = exchange.getAttribute(GATEWAY_ROUTE_ATTR);
    Tags tags = Tags.of("outcome", outcome, "status", status, "routeId", route.getId(), "routeUri",
            route.getUri().toString());
    if (log.isTraceEnabled()) {
        log.trace("Stopping timer 'gateway.requests' with tags " + tags);
    }
    sample.stop(meterRegistry.timer("gateway.requests", tags));
}

From source file:org.springframework.cloud.gateway.filter.NettyWriteResponseFilter.java

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_CONN_ATTR is not added
    // until the NettyRoutingFilter is run
    return chain.filter(exchange).then(Mono.defer(() -> {
        Connection connection = exchange.getAttribute(CLIENT_RESPONSE_CONN_ATTR);

        if (connection == null) {
            return Mono.empty();
        }/*from   w w w  .  j a v  a2  s .  c  om*/
        log.trace("NettyWriteResponseFilter start");
        ServerHttpResponse response = exchange.getResponse();

        NettyDataBufferFactory factory = (NettyDataBufferFactory) response.bufferFactory();
        // TODO: what if it's not netty

        final Flux<NettyDataBuffer> body = connection.inbound().receive().retain() // TODO:
                // needed?
                .map(factory::wrap);

        MediaType contentType = null;
        try {
            contentType = response.getHeaders().getContentType();
        } catch (Exception e) {
            log.trace("invalid media type", e);
        }
        return (isStreamingMediaType(contentType) ? response.writeAndFlushWith(body.map(Flux::just))
                : response.writeWith(body));
    }));
}

From source file:org.springframework.cloud.gateway.filter.WebClientWriteResponseFilter.java

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
    // NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_ATTR is not added
    // until the WebHandler is run
    return chain.filter(exchange).then(Mono.defer(() -> {
        ClientResponse clientResponse = exchange.getAttribute(CLIENT_RESPONSE_ATTR);
        if (clientResponse == null) {
            return Mono.empty();
        }// w  ww . j av  a2 s  .c  o m
        log.trace("WebClientWriteResponseFilter start");
        ServerHttpResponse response = exchange.getResponse();

        return response.writeWith(clientResponse.body(BodyExtractors.toDataBuffers()))
                .log("webClient response");
    }));
}

From source file:org.springframework.cloud.gateway.filter.WriteResponseFilter.java

@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
    // NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_ATTR is not added
    // until the WebHandler is run
    return chain.filter(exchange).then(() -> {
        HttpClientResponse clientResponse = getAttribute(exchange, CLIENT_RESPONSE_ATTR,
                HttpClientResponse.class);
        if (clientResponse == null) {
            return Mono.empty();
        }// ww  w .  j a v a  2 s .  co m
        log.trace("WriteResponseFilter start");
        ServerHttpResponse response = exchange.getResponse();

        NettyDataBufferFactory factory = (NettyDataBufferFactory) response.bufferFactory();
        //TODO: what if it's not netty

        final Flux<NettyDataBuffer> body = clientResponse.receive().retain() //TODO: needed?
                .map(factory::wrap);

        return response.writeWith(body);
    });
}