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

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

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

Introduction

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

Prototype

HttpHeaders getHeaders();

Source Link

Document

Return the headers of this message.

Usage

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

@Override
public final boolean doHandshake(ServerHttpRequest request, ServerHttpResponse response,
        WebSocketHandler wsHandler, Map<String, Object> attributes) throws HandshakeFailureException {

    WebSocketHttpHeaders headers = new WebSocketHttpHeaders(request.getHeaders());
    if (logger.isTraceEnabled()) {
        logger.trace("Processing request " + request.getURI() + " with headers=" + headers);
    }/*w ww .  j  a v a 2s .  com*/
    try {
        if (!HttpMethod.GET.equals(request.getMethod())) {
            response.setStatusCode(HttpStatus.METHOD_NOT_ALLOWED);
            response.getHeaders().setAllow(Collections.singleton(HttpMethod.GET));
            if (logger.isErrorEnabled()) {
                logger.error("Handshake failed due to unexpected HTTP method: " + request.getMethod());
            }
            return false;
        }
        if (!"WebSocket".equalsIgnoreCase(headers.getUpgrade())) {
            handleInvalidUpgradeHeader(request, response);
            return false;
        }
        if (!headers.getConnection().contains("Upgrade") && !headers.getConnection().contains("upgrade")) {
            handleInvalidConnectHeader(request, response);
            return false;
        }
        if (!isWebSocketVersionSupported(headers)) {
            handleWebSocketVersionNotSupported(request, response);
            return false;
        }
        if (!isValidOrigin(request)) {
            response.setStatusCode(HttpStatus.FORBIDDEN);
            return false;
        }
        String wsKey = headers.getSecWebSocketKey();
        if (wsKey == null) {
            if (logger.isErrorEnabled()) {
                logger.error("Missing \"Sec-WebSocket-Key\" header");
            }
            response.setStatusCode(HttpStatus.BAD_REQUEST);
            return false;
        }
    } catch (IOException ex) {
        throw new HandshakeFailureException(
                "Response update failed during upgrade to WebSocket, uri=" + request.getURI(), ex);
    }

    String subProtocol = selectProtocol(headers.getSecWebSocketProtocol(), wsHandler);
    List<WebSocketExtension> requested = headers.getSecWebSocketExtensions();
    List<WebSocketExtension> supported = this.requestUpgradeStrategy.getSupportedExtensions(request);
    List<WebSocketExtension> extensions = filterRequestedExtensions(request, requested, supported);
    Principal user = determineUser(request, wsHandler, attributes);

    if (logger.isTraceEnabled()) {
        logger.trace("Upgrading to WebSocket, subProtocol=" + subProtocol + ", extensions=" + extensions);
    }
    this.requestUpgradeStrategy.upgrade(request, response, subProtocol, extensions, user, wsHandler,
            attributes);
    return true;
}

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

protected void handleWebSocketVersionNotSupported(ServerHttpRequest request, ServerHttpResponse response) {
    if (logger.isErrorEnabled()) {
        String version = request.getHeaders().getFirst("Sec-WebSocket-Version");
        logger.error("Handshake failed due to unsupported WebSocket version: " + version
                + ". Supported versions: " + Arrays.toString(getSupportedVersions()));
    }/*from  w ww  .  j av a2s  .  co m*/
    response.setStatusCode(HttpStatus.UPGRADE_REQUIRED);
    response.getHeaders().put(WebSocketHttpHeaders.SEC_WEBSOCKET_VERSION,
            Arrays.asList(StringUtils.arrayToCommaDelimitedString(getSupportedVersions())));
}

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

/**
 * TODO//from w  w  w  .  ja va 2  s . c  om
 *
 * @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();
    }
}

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

protected void addCorsHeaders(ServerHttpRequest request, ServerHttpResponse response,
        HttpMethod... httpMethods) {/*from  w  w w. ja v a2 s . c  o m*/

    String origin = request.getHeaders().getFirst("origin");
    origin = ((origin == null) || origin.equals("null")) ? "*" : origin;

    response.getHeaders().add("Access-Control-Allow-Origin", origin);
    response.getHeaders().add("Access-Control-Allow-Credentials", "true");

    List<String> accessControllerHeaders = request.getHeaders().get("Access-Control-Request-Headers");
    if (accessControllerHeaders != null) {
        for (String header : accessControllerHeaders) {
            response.getHeaders().add("Access-Control-Allow-Headers", header);
        }
    }

    if (!ObjectUtils.isEmpty(httpMethods)) {
        response.getHeaders().add("Access-Control-Allow-Methods",
                StringUtils.arrayToDelimitedString(httpMethods, ", "));
        response.getHeaders().add("Access-Control-Max-Age", String.valueOf(ONE_YEAR));
    }
}

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

protected void addCacheHeaders(ServerHttpResponse response) {
    response.getHeaders().setCacheControl("public, max-age=" + ONE_YEAR);
    response.getHeaders().setExpires(new Date().getTime() + ONE_YEAR * 1000);
}

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

protected void addNoCacheHeaders(ServerHttpResponse response) {
    response.getHeaders().setCacheControl("no-store, no-cache, must-revalidate, max-age=0");
}

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

protected void sendMethodNotAllowed(ServerHttpResponse response, List<HttpMethod> httpMethods)
        throws IOException {
    logger.debug("Sending Method Not Allowed (405)");
    response.setStatusCode(HttpStatus.METHOD_NOT_ALLOWED);
    response.getHeaders().setAllow(new HashSet<HttpMethod>(httpMethods));
}

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

/**
 * This method determines the SockJS path and handles SockJS static URLs.
 * Session URLs and raw WebSocket requests are delegated to abstract methods.
 *///from w w  w.  j av a  2s . c o  m
@Override
public final void handleRequest(ServerHttpRequest request, ServerHttpResponse response,
        @Nullable String sockJsPath, WebSocketHandler wsHandler) throws SockJsException {

    if (sockJsPath == null) {
        if (logger.isWarnEnabled()) {
            logger.warn("Expected SockJS path. Failing request: " + request.getURI());
        }
        response.setStatusCode(HttpStatus.NOT_FOUND);
        return;
    }

    try {
        request.getHeaders();
    } catch (InvalidMediaTypeException ex) {
        // As per SockJS protocol content-type can be ignored (it's always json)
    }

    String requestInfo = (logger.isDebugEnabled() ? request.getMethod() + " " + request.getURI() : null);

    try {
        if (sockJsPath.equals("") || sockJsPath.equals("/")) {
            if (requestInfo != null) {
                logger.debug("Processing transport request: " + requestInfo);
            }
            response.getHeaders().setContentType(new MediaType("text", "plain", StandardCharsets.UTF_8));
            response.getBody().write("Welcome to SockJS!\n".getBytes(StandardCharsets.UTF_8));
        }

        else if (sockJsPath.equals("/info")) {
            if (requestInfo != null) {
                logger.debug("Processing transport request: " + requestInfo);
            }
            this.infoHandler.handle(request, response);
        }

        else if (sockJsPath.matches("/iframe[0-9-.a-z_]*.html")) {
            if (!this.allowedOrigins.isEmpty() && !this.allowedOrigins.contains("*")) {
                if (requestInfo != null) {
                    logger.debug("Iframe support is disabled when an origin check is required. "
                            + "Ignoring transport request: " + requestInfo);
                }
                response.setStatusCode(HttpStatus.NOT_FOUND);
                return;
            }
            if (this.allowedOrigins.isEmpty()) {
                response.getHeaders().add(XFRAME_OPTIONS_HEADER, "SAMEORIGIN");
            }
            if (requestInfo != null) {
                logger.debug("Processing transport request: " + requestInfo);
            }
            this.iframeHandler.handle(request, response);
        }

        else if (sockJsPath.equals("/websocket")) {
            if (isWebSocketEnabled()) {
                if (requestInfo != null) {
                    logger.debug("Processing transport request: " + requestInfo);
                }
                handleRawWebSocketRequest(request, response, wsHandler);
            } else if (requestInfo != null) {
                logger.debug("WebSocket disabled. Ignoring transport request: " + requestInfo);
            }
        }

        else {
            String[] pathSegments = StringUtils.tokenizeToStringArray(sockJsPath.substring(1), "/");
            if (pathSegments.length != 3) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Invalid SockJS path '" + sockJsPath + "' - required to have 3 path segments");
                }
                if (requestInfo != null) {
                    logger.debug("Ignoring transport request: " + requestInfo);
                }
                response.setStatusCode(HttpStatus.NOT_FOUND);
                return;
            }

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

            if (!isWebSocketEnabled() && transport.equals("websocket")) {
                if (requestInfo != null) {
                    logger.debug("WebSocket disabled. Ignoring transport request: " + requestInfo);
                }
                response.setStatusCode(HttpStatus.NOT_FOUND);
                return;
            } else if (!validateRequest(serverId, sessionId, transport) || !validatePath(request)) {
                if (requestInfo != null) {
                    logger.debug("Ignoring transport request: " + requestInfo);
                }
                response.setStatusCode(HttpStatus.NOT_FOUND);
                return;
            }

            if (requestInfo != null) {
                logger.debug("Processing transport request: " + requestInfo);
            }
            handleTransportRequest(request, response, wsHandler, sessionId, transport);
        }
        response.close();
    } catch (IOException ex) {
        throw new SockJsException("Failed to write to the response", null, ex);
    }
}

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

protected void sendMethodNotAllowed(ServerHttpResponse response, HttpMethod... httpMethods) {
    logger.warn("Sending Method Not Allowed (405)");
    response.setStatusCode(HttpStatus.METHOD_NOT_ALLOWED);
    response.getHeaders().setAllow(new HashSet<>(Arrays.asList(httpMethods)));
}

From source file:org.springframework.web.socket.sockjs.transport.AbstractHttpReceivingTransportHandler.java

protected void handleRequestInternal(ServerHttpRequest request, ServerHttpResponse response,
        AbstractSockJsSession session) throws TransportErrorException {

    String[] messages = null;/*  www . j a va 2  s  .c o  m*/
    try {
        messages = readMessages(request);
    } catch (JsonMappingException ex) {
        logger.error("Failed to read message: " + ex.getMessage());
        sendInternalServerError(response, "Payload expected.", session.getId());
        return;
    } catch (IOException ex) {
        logger.error("Failed to read message: " + ex.getMessage());
        sendInternalServerError(response, "Broken JSON encoding.", session.getId());
        return;
    } catch (Throwable t) {
        logger.error("Failed to read message: " + t.getMessage());
        sendInternalServerError(response, "Failed to process messages", session.getId());
        return;
    }

    if (messages == null) {
        sendInternalServerError(response, "Payload expected.", session.getId());
        return;
    }

    if (logger.isTraceEnabled()) {
        logger.trace("Received message(s): " + Arrays.asList(messages));
    }

    response.setStatusCode(getResponseStatus());
    response.getHeaders().setContentType(new MediaType("text", "plain", Charset.forName("UTF-8")));

    try {
        session.delegateMessages(messages);
    } catch (Throwable t) {
        ExceptionWebSocketHandlerDecorator.tryCloseWithError(session, t, logger);
        throw new TransportErrorException("Unhandled WebSocketHandler error in " + this, t, session.getId());
    }
}