Example usage for org.springframework.http.server ServerHttpResponse flush

List of usage examples for org.springframework.http.server ServerHttpResponse flush

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.http.server.*
  5. ServerHttpResponse
  6. flush

Introduction

In this page you can find the example usage for org.springframework.http.server ServerHttpResponse flush.

Prototype

@Override
void flush() throws IOException;

Source Link

Document

Ensure that the headers and the content of the response are written out.

Usage

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

/**
 * Handle the given request.//  w  w w. j  ava 2  s .  c  om
 */
protected boolean handleInternal(ServerHttpRequest request, ServerHttpResponse response,
        CorsConfiguration config, boolean preFlightRequest) throws IOException {

    String requestOrigin = request.getHeaders().getOrigin();
    String allowOrigin = checkOrigin(config, requestOrigin);
    HttpHeaders responseHeaders = response.getHeaders();

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

    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());
    }

    response.flush();
    return true;
}

From source file:org.springframework.web.servlet.mvc.method.annotation.ResponseBodyEmitterReturnValueHandler.java

@Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
        ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

    if (returnValue == null) {
        mavContainer.setRequestHandled(true);
        return;/*  ww  w.  j a  v  a 2  s.  c o  m*/
    }

    HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
    Assert.state(response != null, "No HttpServletResponse");
    ServerHttpResponse outputMessage = new ServletServerHttpResponse(response);

    if (returnValue instanceof ResponseEntity) {
        ResponseEntity<?> responseEntity = (ResponseEntity<?>) returnValue;
        response.setStatus(responseEntity.getStatusCodeValue());
        outputMessage.getHeaders().putAll(responseEntity.getHeaders());
        returnValue = responseEntity.getBody();
        returnType = returnType.nested();
        if (returnValue == null) {
            mavContainer.setRequestHandled(true);
            outputMessage.flush();
            return;
        }
    }

    ServletRequest request = webRequest.getNativeRequest(ServletRequest.class);
    Assert.state(request != null, "No ServletRequest");

    ResponseBodyEmitter emitter;
    if (returnValue instanceof ResponseBodyEmitter) {
        emitter = (ResponseBodyEmitter) returnValue;
    } else {
        emitter = this.reactiveHandler.handleValue(returnValue, returnType, mavContainer, webRequest);
        if (emitter == null) {
            // Not streaming..
            return;
        }
    }
    emitter.extendResponse(outputMessage);

    // At this point we know we're streaming..
    ShallowEtagHeaderFilter.disableContentCaching(request);

    // Commit the response and wrap to ignore further header changes
    outputMessage.getBody();
    outputMessage.flush();
    outputMessage = new StreamingServletServerHttpResponse(outputMessage);

    DeferredResult<?> deferredResult = new DeferredResult<>(emitter.getTimeout());
    WebAsyncUtils.getAsyncManager(webRequest).startDeferredResultProcessing(deferredResult, mavContainer);

    HttpMessageConvertingHandler handler = new HttpMessageConvertingHandler(outputMessage, deferredResult);
    emitter.initialize(handler);
}

From source file:org.springframework.web.socket.server.DefaultHandshakeHandler.java

@Override
public final boolean doHandshake(ServerHttpRequest request, ServerHttpResponse response,
        WebSocketHandler webSocketHandler) throws IOException, HandshakeFailureException {

    logger.debug("Starting handshake for " + request.getURI());

    if (!HttpMethod.GET.equals(request.getMethod())) {
        response.setStatusCode(HttpStatus.METHOD_NOT_ALLOWED);
        response.getHeaders().setAllow(Collections.singleton(HttpMethod.GET));
        logger.debug("Only HTTP GET is allowed, current method is " + request.getMethod());
        return false;
    }//from   w ww .  jav a2s . c  o  m
    if (!"WebSocket".equalsIgnoreCase(request.getHeaders().getUpgrade())) {
        handleInvalidUpgradeHeader(request, response);
        return false;
    }
    if (!request.getHeaders().getConnection().contains("Upgrade")
            && !request.getHeaders().getConnection().contains("upgrade")) {
        handleInvalidConnectHeader(request, response);
        return false;
    }
    if (!isWebSocketVersionSupported(request)) {
        handleWebSocketVersionNotSupported(request, response);
        return false;
    }
    if (!isValidOrigin(request)) {
        response.setStatusCode(HttpStatus.FORBIDDEN);
        return false;
    }
    String wsKey = request.getHeaders().getSecWebSocketKey();
    if (wsKey == null) {
        logger.debug("Missing \"Sec-WebSocket-Key\" header");
        response.setStatusCode(HttpStatus.BAD_REQUEST);
        return false;
    }

    String selectedProtocol = selectProtocol(request.getHeaders().getSecWebSocketProtocol());
    // TODO: select extensions

    logger.debug("Upgrading HTTP request");

    response.setStatusCode(HttpStatus.SWITCHING_PROTOCOLS);
    response.getHeaders().setUpgrade("WebSocket");
    response.getHeaders().setConnection("Upgrade");
    response.getHeaders().setSecWebSocketProtocol(selectedProtocol);
    response.getHeaders().setSecWebSocketAccept(getWebSocketKeyHash(wsKey));
    // TODO: response.getHeaders().setSecWebSocketExtensions(extensions);

    response.flush();

    if (logger.isTraceEnabled()) {
        logger.trace("Upgrading with " + webSocketHandler);
    }

    this.requestUpgradeStrategy.upgrade(request, response, selectedProtocol, webSocketHandler);

    return true;
}

From source file:org.springframework.web.socket.sockjs.AbstractSockJsService.java

/**
 * TODO/*www  .  j  ava  2s  . co  m*/
 *
 * @param request
 * @param response
 * @param sockJsPath
 *
 * @throws Exception
 */
@Override
public final void handleRequest(ServerHttpRequest request, ServerHttpResponse response,
        WebSocketHandler handler) throws IOException, TransportErrorException {

    String sockJsPath = getSockJsPath(request);
    if (sockJsPath == null) {
        logger.warn("Could not determine SockJS path for URL \"" + request.getURI().getPath()
                + ". Consider setting validSockJsPrefixes.");
        response.setStatusCode(HttpStatus.NOT_FOUND);
        return;
    }

    logger.debug(request.getMethod() + " with SockJS path [" + sockJsPath + "]");

    try {
        request.getHeaders();
    } catch (IllegalArgumentException ex) {
        // Ignore invalid Content-Type (TODO)
    }

    try {
        if (sockJsPath.equals("") || sockJsPath.equals("/")) {
            response.getHeaders().setContentType(new MediaType("text", "plain", Charset.forName("UTF-8")));
            response.getBody().write("Welcome to SockJS!\n".getBytes("UTF-8"));
            return;
        } else if (sockJsPath.equals("/info")) {
            this.infoHandler.handle(request, response);
            return;
        } else if (sockJsPath.matches("/iframe[0-9-.a-z_]*.html")) {
            this.iframeHandler.handle(request, response);
            return;
        } else if (sockJsPath.equals("/websocket")) {
            handleRawWebSocketRequest(request, response, handler);
            return;
        }

        String[] pathSegments = StringUtils.tokenizeToStringArray(sockJsPath.substring(1), "/");
        if (pathSegments.length != 3) {
            logger.warn("Expected \"/{server}/{session}/{transport}\" but got \"" + sockJsPath + "\"");
            response.setStatusCode(HttpStatus.NOT_FOUND);
            return;
        }

        String serverId = pathSegments[0];
        String sessionId = pathSegments[1];
        String transport = pathSegments[2];

        if (!validateRequest(serverId, sessionId, transport)) {
            response.setStatusCode(HttpStatus.NOT_FOUND);
            return;
        }

        handleTransportRequest(request, response, sessionId, TransportType.fromValue(transport), handler);
    } finally {
        response.flush();
    }
}