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.cloud.gateway.sample.ThrottleGatewayFilter.java

@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {

    TokenBucket tokenBucket = TokenBuckets.builder().withCapacity(capacity)
            .withFixedIntervalRefillStrategy(refillTokens, refillPeriod, refillUnit).build();

    // TODO: get a token bucket for a key
    log.debug("TokenBucket capacity: " + tokenBucket.getCapacity());
    boolean consumed = tokenBucket.tryConsume();
    if (consumed) {
        return chain.filter(exchange);
    }//from ww w.  j  a v  a2s.  c  o m
    exchange.getResponse().setStatusCode(HttpStatus.TOO_MANY_REQUESTS);
    return exchange.getResponse().setComplete();
}

From source file:org.springframework.cloud.gateway.support.ServerWebExchangeUtils.java

public static boolean setResponseStatus(ServerWebExchange exchange, HttpStatus httpStatus) {
    boolean response = exchange.getResponse().setStatusCode(httpStatus);
    if (!response && logger.isWarnEnabled()) {
        logger.warn("Unable to set status code to " + httpStatus + ". Response already committed.");
    }/* w  ww .  j a v  a 2 s  . c  o  m*/
    return response;
}

From source file:org.springframework.cloud.sleuth.instrument.web.TraceWebFilter.java

@Override
public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
    if (tracer().currentSpan() != null) {
        // clear any previous trace
        tracer().withSpanInScope(null);/*from  w w  w  .  jav  a2s  . com*/
    }
    String uri = exchange.getRequest().getPath().pathWithinApplication().value();
    if (log.isDebugEnabled()) {
        log.debug("Received a request to uri [" + uri + "]");
    }
    Span spanFromAttribute = getSpanFromAttribute(exchange);
    final String CONTEXT_ERROR = "sleuth.webfilter.context.error";
    return chain.filter(exchange).compose(f -> f.then(Mono.subscriberContext())
            .onErrorResume(t -> Mono.subscriberContext().map(c -> c.put(CONTEXT_ERROR, t))).flatMap(c -> {
                // reactivate span from context
                Span span = spanFromContext(c);
                Mono<Void> continuation;
                Throwable t = null;
                if (c.hasKey(CONTEXT_ERROR)) {
                    t = c.get(CONTEXT_ERROR);
                    continuation = Mono.error(t);
                } else {
                    continuation = Mono.empty();
                }
                String httpRoute = null;
                Object attribute = exchange.getAttribute(HandlerMapping.BEST_MATCHING_HANDLER_ATTRIBUTE);
                if (attribute instanceof HandlerMethod) {
                    HandlerMethod handlerMethod = (HandlerMethod) attribute;
                    addClassMethodTag(handlerMethod, span);
                    addClassNameTag(handlerMethod, span);
                    Object pattern = exchange.getAttribute(HandlerMapping.BEST_MATCHING_PATTERN_ATTRIBUTE);
                    httpRoute = pattern != null ? pattern.toString() : "";
                }
                addResponseTagsForSpanWithoutParent(exchange, exchange.getResponse(), span);
                DecoratedServerHttpResponse delegate = new DecoratedServerHttpResponse(exchange.getResponse(),
                        exchange.getRequest().getMethodValue(), httpRoute);
                handler().handleSend(delegate, t, span);
                if (log.isDebugEnabled()) {
                    log.debug("Handled send of " + span);
                }
                return continuation;
            }).subscriberContext(c -> {
                Span span;
                if (c.hasKey(Span.class)) {
                    Span parent = c.get(Span.class);
                    span = tracer().nextSpan(TraceContextOrSamplingFlags.create(parent.context())).start();
                    if (log.isDebugEnabled()) {
                        log.debug("Found span in reactor context" + span);
                    }
                } else {
                    if (spanFromAttribute != null) {
                        span = spanFromAttribute;
                        if (log.isDebugEnabled()) {
                            log.debug("Found span in attribute " + span);
                        }
                    } else {
                        span = handler().handleReceive(extractor(), exchange.getRequest().getHeaders(),
                                exchange.getRequest());
                        if (log.isDebugEnabled()) {
                            log.debug("Handled receive of span " + span);
                        }
                    }
                    exchange.getAttributes().put(TRACE_REQUEST_ATTR, span);
                }
                return c.put(Span.class, span);
            }));
}

From source file:org.springframework.web.cors.reactive.DefaultCorsProcessor.java

@Override
public boolean process(@Nullable CorsConfiguration config, ServerWebExchange exchange) {

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

    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    }//from  ww  w. j  av  a2s  . c o m

    if (responseHasCors(response)) {
        logger.debug("Skip CORS: response already contains \"Access-Control-Allow-Origin\" header");
        return true;
    }

    if (CorsUtils.isSameOrigin(request)) {
        logger.debug("Skip CORS: request is from same origin");
        return true;
    }

    boolean preFlightRequest = CorsUtils.isPreFlightRequest(request);
    if (config == null) {
        if (preFlightRequest) {
            rejectRequest(response);
            return false;
        } else {
            return true;
        }
    }

    return handleInternal(exchange, config, preFlightRequest);
}

From source file:org.springframework.web.cors.reactive.DefaultCorsProcessor.java

/**
 * Handle the given request.//from w  ww .  j  a  va2  s.  c  om
 */
protected boolean handleInternal(ServerWebExchange exchange, CorsConfiguration config,
        boolean preFlightRequest) {

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

    response.getHeaders().addAll(HttpHeaders.VARY, Arrays.asList(HttpHeaders.ORIGIN,
            HttpHeaders.ACCESS_CONTROL_REQUEST_METHOD, HttpHeaders.ACCESS_CONTROL_REQUEST_HEADERS));

    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    if (allowOrigin == null) {
        logger.debug("Rejecting CORS request because '" + requestOrigin + "' origin is not allowed");
        rejectRequest(response);
        return false;
    }

    HttpMethod requestMethod = getMethodToUse(request, preFlightRequest);
    List<HttpMethod> allowMethods = checkMethods(config, requestMethod);
    if (allowMethods == null) {
        logger.debug("Rejecting CORS request because '" + requestMethod + "' request method is not allowed");
        rejectRequest(response);
        return false;
    }

    List<String> requestHeaders = getHeadersToUse(request, preFlightRequest);
    List<String> allowHeaders = checkHeaders(config, requestHeaders);
    if (preFlightRequest && allowHeaders == null) {
        logger.debug("Rejecting CORS request because '" + requestHeaders + "' request headers are not allowed");
        rejectRequest(response);
        return false;
    }

    responseHeaders.setAccessControlAllowOrigin(allowOrigin);

    if (preFlightRequest) {
        responseHeaders.setAccessControlAllowMethods(allowMethods);
    }

    if (preFlightRequest && !allowHeaders.isEmpty()) {
        responseHeaders.setAccessControlAllowHeaders(allowHeaders);
    }

    if (!CollectionUtils.isEmpty(config.getExposedHeaders())) {
        responseHeaders.setAccessControlExposeHeaders(config.getExposedHeaders());
    }

    if (Boolean.TRUE.equals(config.getAllowCredentials())) {
        responseHeaders.setAccessControlAllowCredentials(true);
    }

    if (preFlightRequest && config.getMaxAge() != null) {
        responseHeaders.setAccessControlMaxAge(config.getMaxAge());
    }

    return true;
}

From source file:org.springframework.web.reactive.resource.AppCacheManifestTransformer.java

@Override
public Mono<Resource> transform(ServerWebExchange exchange, Resource inputResource,
        ResourceTransformerChain chain) {

    return chain.transform(exchange, inputResource).flatMap(outputResource -> {
        String name = outputResource.getFilename();
        if (!this.fileExtension.equals(StringUtils.getFilenameExtension(name))) {
            return Mono.just(outputResource);
        }/*www .j ava2s.  c  o  m*/
        DataBufferFactory bufferFactory = exchange.getResponse().bufferFactory();
        Flux<DataBuffer> flux = DataBufferUtils.read(outputResource, bufferFactory, StreamUtils.BUFFER_SIZE);
        return DataBufferUtils.join(flux).flatMap(dataBuffer -> {
            CharBuffer charBuffer = DEFAULT_CHARSET.decode(dataBuffer.asByteBuffer());
            DataBufferUtils.release(dataBuffer);
            String content = charBuffer.toString();
            return transform(content, outputResource, chain, exchange);
        });
    });
}

From source file:org.springframework.web.reactive.resource.CssLinkResourceTransformer.java

@Override
public Mono<Resource> transform(ServerWebExchange exchange, Resource inputResource,
        ResourceTransformerChain transformerChain) {

    return transformerChain.transform(exchange, inputResource).flatMap(ouptputResource -> {
        String filename = ouptputResource.getFilename();
        if (!"css".equals(StringUtils.getFilenameExtension(filename))
                || inputResource instanceof GzipResourceResolver.GzippedResource) {
            return Mono.just(ouptputResource);
        }/*from   w  ww. ja va  2 s. co  m*/

        if (logger.isTraceEnabled()) {
            logger.trace("Transforming resource: " + ouptputResource);
        }

        DataBufferFactory bufferFactory = exchange.getResponse().bufferFactory();
        Flux<DataBuffer> flux = DataBufferUtils.read(ouptputResource, bufferFactory, StreamUtils.BUFFER_SIZE);
        return DataBufferUtils.join(flux).flatMap(dataBuffer -> {
            CharBuffer charBuffer = DEFAULT_CHARSET.decode(dataBuffer.asByteBuffer());
            DataBufferUtils.release(dataBuffer);
            String cssContent = charBuffer.toString();
            return transformContent(cssContent, ouptputResource, transformerChain, exchange);
        });
    });
}

From source file:org.springframework.web.reactive.resource.ResourceWebHandler.java

/**
 * Processes a resource request.//  w w  w.  j  a va  2s.  c  om
 * <p>Checks for the existence of the requested resource in the configured list of locations.
 * If the resource does not exist, a {@code 404} response will be returned to the client.
 * If the resource exists, the request will be checked for the presence of the
 * {@code Last-Modified} header, and its value will be compared against the last-modified
 * timestamp of the given resource, returning a {@code 304} status code if the
 * {@code Last-Modified} value  is greater. If the resource is newer than the
 * {@code Last-Modified} value, or the header is not present, the content resource
 * of the resource will be written to the response with caching headers
 * set to expire one year in the future.
 */
@Override
public Mono<Void> handle(ServerWebExchange exchange) {
    return getResource(exchange).switchIfEmpty(Mono.defer(() -> {
        logger.trace("No matching resource found - returning 404");
        return Mono.error(NOT_FOUND_EXCEPTION);
    })).flatMap(resource -> {
        try {
            if (HttpMethod.OPTIONS.matches(exchange.getRequest().getMethodValue())) {
                exchange.getResponse().getHeaders().add("Allow", "GET,HEAD,OPTIONS");
                return Mono.empty();
            }

            // Supported methods and required session
            HttpMethod httpMethod = exchange.getRequest().getMethod();
            if (!SUPPORTED_METHODS.contains(httpMethod)) {
                return Mono.error(new MethodNotAllowedException(exchange.getRequest().getMethodValue(),
                        SUPPORTED_METHODS));
            }

            // Header phase
            if (exchange.checkNotModified(Instant.ofEpochMilli(resource.lastModified()))) {
                logger.trace("Resource not modified - returning 304");
                return Mono.empty();
            }

            // Apply cache settings, if any
            if (getCacheControl() != null) {
                String value = getCacheControl().getHeaderValue();
                if (value != null) {
                    exchange.getResponse().getHeaders().setCacheControl(value);
                }
            }

            // Check the media type for the resource
            MediaType mediaType = MediaTypeFactory.getMediaType(resource).orElse(null);
            if (mediaType != null) {
                if (logger.isTraceEnabled()) {
                    logger.trace("Determined media type '" + mediaType + "' for " + resource);
                }
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace("No media type found " + "for " + resource
                            + " - not sending a content-type header");
                }
            }

            // Content phase
            if (HttpMethod.HEAD.matches(exchange.getRequest().getMethodValue())) {
                setHeaders(exchange, resource, mediaType);
                exchange.getResponse().getHeaders().set(HttpHeaders.ACCEPT_RANGES, "bytes");
                logger.trace("HEAD request - skipping content");
                return Mono.empty();
            }

            setHeaders(exchange, resource, mediaType);
            ResourceHttpMessageWriter writer = getResourceHttpMessageWriter();
            Assert.state(writer != null, "No ResourceHttpMessageWriter");
            return writer.write(Mono.just(resource), null, ResolvableType.forClass(Resource.class), mediaType,
                    exchange.getRequest(), exchange.getResponse(), Collections.emptyMap());
        } catch (IOException ex) {
            return Mono.error(ex);
        }
    });
}

From source file:org.springframework.web.reactive.resource.ResourceWebHandler.java

/**
 * Set headers on the response. Called for both GET and HEAD requests.
 * @param exchange current exchange//  w  w  w  .  ja  v  a2s  .c o m
 * @param resource the identified resource (never {@code null})
 * @param mediaType the resource's media type (never {@code null})
 */
protected void setHeaders(ServerWebExchange exchange, Resource resource, @Nullable MediaType mediaType)
        throws IOException {

    HttpHeaders headers = exchange.getResponse().getHeaders();

    long length = resource.contentLength();
    headers.setContentLength(length);

    if (mediaType != null) {
        headers.setContentType(mediaType);
    }
    if (resource instanceof HttpResource) {
        HttpHeaders resourceHeaders = ((HttpResource) resource).getResponseHeaders();
        exchange.getResponse().getHeaders().putAll(resourceHeaders);
    }
}

From source file:org.springframework.web.reactive.result.HandlerResultHandlerSupport.java

/**
 * Select the best media type for the current request through a content
 * negotiation algorithm./*from www.  jav a2 s  .co m*/
 * @param exchange the current request
 * @param producibleTypesSupplier the media types that can be produced for the current request
 * @return the selected media type or {@code null}
 */
@Nullable
protected MediaType selectMediaType(ServerWebExchange exchange,
        Supplier<List<MediaType>> producibleTypesSupplier) {

    MediaType contentType = exchange.getResponse().getHeaders().getContentType();
    if (contentType != null && contentType.isConcrete()) {
        if (logger.isDebugEnabled()) {
            logger.debug(exchange.getLogPrefix() + "Found 'Content-Type:" + contentType + "' in response");
        }
        return contentType;
    }

    List<MediaType> acceptableTypes = getAcceptableTypes(exchange);
    List<MediaType> producibleTypes = getProducibleTypes(exchange, producibleTypesSupplier);

    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<>();
    for (MediaType acceptable : acceptableTypes) {
        for (MediaType producible : producibleTypes) {
            if (acceptable.isCompatibleWith(producible)) {
                compatibleMediaTypes.add(selectMoreSpecificMediaType(acceptable, producible));
            }
        }
    }

    List<MediaType> result = new ArrayList<>(compatibleMediaTypes);
    MediaType.sortBySpecificityAndQuality(result);

    MediaType selected = null;
    for (MediaType mediaType : result) {
        if (mediaType.isConcrete()) {
            selected = mediaType;
            break;
        } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION_ALL)) {
            selected = MediaType.APPLICATION_OCTET_STREAM;
            break;
        }
    }

    if (selected != null) {
        if (logger.isDebugEnabled()) {
            logger.debug(
                    "Using '" + selected + "' given " + acceptableTypes + " and supported " + producibleTypes);
        }
    } else if (logger.isDebugEnabled()) {
        logger.debug(exchange.getLogPrefix() + "No match for " + acceptableTypes + ", supported: "
                + producibleTypes);
    }

    return selected;
}