Example usage for org.springframework.http.server ServletServerHttpResponse ServletServerHttpResponse

List of usage examples for org.springframework.http.server ServletServerHttpResponse ServletServerHttpResponse

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

Introduction

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

Prototype

public ServletServerHttpResponse(HttpServletResponse servletResponse)

Source Link

Document

Construct a new instance of the ServletServerHttpResponse based on the given HttpServletResponse .

Usage

From source file:com.yang.oa.commons.exception.RestExceptionHandler.java

@SuppressWarnings("unchecked")
private ModelAndView handleResponseBody(Object body, ServletWebRequest webRequest)
        throws ServletException, IOException {

    HttpInputMessage inputMessage = new ServletServerHttpRequest(webRequest.getRequest());

    List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
    if (acceptedMediaTypes.isEmpty()) {
        acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
    }/*from w w w  . j  a v a  2s . c  o  m*/

    MediaType.sortByQualityValue(acceptedMediaTypes);

    HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse());

    Class<?> bodyType = body.getClass();

    List<HttpMessageConverter<?>> converters = this.allMessageConverters;

    if (converters != null) {
        for (MediaType acceptedMediaType : acceptedMediaTypes) {
            for (HttpMessageConverter messageConverter : converters) {
                if (messageConverter.canWrite(bodyType, acceptedMediaType)) {
                    messageConverter.write(body, acceptedMediaType, outputMessage);
                    //return empty model and view to short circuit the iteration and to let
                    //Spring know that we've rendered the view ourselves:
                    return new ModelAndView();
                }
            }
        }
    }

    return null;
}

From source file:org.jlot.web.api.error.RestExceptionHandler.java

@SuppressWarnings({ "unchecked", "rawtypes", "resource" })
private ModelAndView handleResponseBody(Object body, ServletWebRequest webRequest)
        throws ServletException, IOException {

    HttpInputMessage inputMessage = new ServletServerHttpRequest(webRequest.getRequest());

    List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
    if (acceptedMediaTypes.isEmpty()) {
        acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
    }/* ww  w.j av  a  2  s .  com*/

    MediaType.sortByQualityValue(acceptedMediaTypes);

    HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse());

    Class<?> bodyType = body.getClass();

    List<HttpMessageConverter<?>> converters = this.allMessageConverters;

    if (converters != null) {
        for (MediaType acceptedMediaType : acceptedMediaTypes) {
            for (HttpMessageConverter messageConverter : converters) {
                if (messageConverter.canWrite(bodyType, acceptedMediaType)) {
                    messageConverter.write(body, acceptedMediaType, outputMessage);
                    // return empty model and view to short circuit the
                    // iteration and to let
                    // Spring know that we've rendered the view ourselves:

                    return new ModelAndView();
                }
            }
        }
    }

    if (logger.isWarnEnabled()) {
        logger.warn("Could not find HttpMessageConverter that supports return type [" + bodyType + "] and "
                + acceptedMediaTypes);
    }
    return null;
}

From source file:com.sti.rest.error.RestExceptionHandler.java

@SuppressWarnings({ "unchecked", "resource" })
private ModelAndView handleResponseBody(Object body, ServletWebRequest webRequest)
        throws ServletException, IOException {

    HttpInputMessage inputMessage = new ServletServerHttpRequest(webRequest.getRequest());

    List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
    if (acceptedMediaTypes.isEmpty()) {
        acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
    }// w  w w.jav a 2  s.  c  om

    MediaType.sortByQualityValue(acceptedMediaTypes);

    HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse());

    Class<?> bodyType = body.getClass();

    List<HttpMessageConverter<?>> converters = this.allMessageConverters;

    if (converters != null) {
        for (MediaType acceptedMediaType : acceptedMediaTypes) {
            for (@SuppressWarnings("rawtypes")
            HttpMessageConverter messageConverter : converters) {
                if (messageConverter.canWrite(bodyType, acceptedMediaType)) {
                    messageConverter.write(body, acceptedMediaType, outputMessage);
                    //return empty model and view to short circuit the iteration and to let
                    //Spring know that we've rendered the view ourselves:
                    return new ModelAndView();
                }
            }
        }
    }

    if (logger.isWarnEnabled()) {
        logger.warn("Could not find HttpMessageConverter that supports return type [" + bodyType + "] and "
                + acceptedMediaTypes);
    }

    return null;
}

From source file:morph.plugin.views.annotation.AnnotationMethodHandlerAdapter.java

/**
 * Template method for creating a new HttpOuputMessage instance.
 * <p>The default implementation creates a standard {@link ServletServerHttpResponse}.
 * This can be overridden for custom {@code HttpOutputMessage} implementations
 * @param servletResponse current HTTP response
 * @return the HttpInputMessage instance to use
 * @throws Exception in case of errors/*from  w  ww . java 2s  . c o m*/
 */
protected HttpOutputMessage createHttpOutputMessage(HttpServletResponse servletResponse) throws Exception {
    return new ServletServerHttpResponse(servletResponse);
}

From source file:org.infoscoop.api.oauth2.provider.ISOAuth2ExceptionRenderer.java

private HttpOutputMessage createHttpOutputMessage(NativeWebRequest webRequest) throws Exception {
    HttpServletResponse servletResponse = (HttpServletResponse) webRequest.getNativeResponse();
    return new ServletServerHttpResponse(servletResponse);
}

From source file:org.springframework.boot.actuate.endpoint.mvc.EndpointHandlerAdapter.java

@SuppressWarnings("unchecked")
private void handle(HttpServletRequest request, HttpServletResponse response, Endpoint<?> endpoint)
        throws Exception {

    Object result = endpoint.invoke();
    Class<?> resultClass = result.getClass();

    List<MediaType> mediaTypes = getMediaTypes(request, endpoint, resultClass);
    MediaType selectedMediaType = selectMediaType(mediaTypes);

    ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(response);
    try {//from  w  w w  .j  av  a 2s. c  om
        if (selectedMediaType != null) {
            selectedMediaType = selectedMediaType.removeQualityValue();
            for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                if (messageConverter.canWrite(resultClass, selectedMediaType)) {
                    ((HttpMessageConverter<Object>) messageConverter).write(result, selectedMediaType,
                            outputMessage);
                    if (this.logger.isDebugEnabled()) {
                        this.logger.debug("Written [" + result + "] as \"" + selectedMediaType + "\" using ["
                                + messageConverter + "]");
                    }
                    return;
                }
            }
        }
        throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
    } finally {
        outputMessage.close();
    }
}

From source file:org.springframework.flex.security3.FlexAuthenticationEntryPoint.java

/**
 * If the incoming message is an {@link ActionMessage}, indicating a standard Flex Remoting or Messaging 
 * request, invokes Spring BlazeDS's {@link ExceptionTranslator}s with the {@link AuthenticationException} and 
 * sends the resulting {@link MessageException} as an AMF response to the client.
 * /*  ww  w. jav  a 2  s . c  o m*/
 * <p>If the request is unabled to be deserialized to AMF, if the resulting deserialized object is not an 
 * <code>ActionMessage</code>, or if no appropriate <code>ExceptionTranslator</code> is found, will simply 
 * delegate to the parent class to return a 403 response.
 */
public void commence(HttpServletRequest request, HttpServletResponse response,
        AuthenticationException authException) throws IOException, ServletException {

    if (CollectionUtils.isEmpty(this.exceptionTranslators)) {
        exceptionTranslators = Collections.singleton(DEFAULT_TRANSLATOR);
    }

    HttpInputMessage inputMessage = new ServletServerHttpRequest(request);
    HttpOutputMessage outputMessage = new ServletServerHttpResponse(response);

    if (!converter.canRead(Object.class, inputMessage.getHeaders().getContentType())) {
        super.commence(request, response, authException);
        return;
    }

    ActionMessage deserializedInput = null;
    try {
        deserializedInput = (ActionMessage) this.converter.read(ActionMessage.class, inputMessage);
    } catch (HttpMessageNotReadableException ex) {
        log.info("Authentication failure detected, but request could not be read as AMF.", ex);
        super.commence(request, response, authException);
        return;
    }

    if (deserializedInput instanceof ActionMessage) {
        for (ExceptionTranslator translator : this.exceptionTranslators) {
            if (translator.handles(authException.getClass())) {
                MessageException result = translator.translate(authException);
                ErrorMessage err = result.createErrorMessage();
                MessageBody body = (MessageBody) ((ActionMessage) deserializedInput).getBody(0);
                Message amfInputMessage = body.getDataAsMessage();
                err.setCorrelationId(amfInputMessage.getMessageId());
                err.setDestination(amfInputMessage.getDestination());
                err.setClientId(amfInputMessage.getClientId());
                ActionMessage responseMessage = new ActionMessage();
                responseMessage.setVersion(((ActionMessage) deserializedInput).getVersion());
                MessageBody responseBody = new MessageBody();
                responseMessage.addBody(responseBody);
                responseBody.setData(err);
                responseBody.setTargetURI(body.getResponseURI());
                responseBody.setReplyMethod(MessageIOConstants.STATUS_METHOD);
                converter.write(responseMessage, amfMediaType, outputMessage);
                response.flushBuffer();
                return;
            }
        }
    }
    super.commence(request, response, authException);
}

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

@Override
@SuppressWarnings("resource")
public boolean processRequest(@Nullable CorsConfiguration config, HttpServletRequest request,
        HttpServletResponse response) throws IOException {

    if (!CorsUtils.isCorsRequest(request)) {
        return true;
    }//from w w  w . java2  s. co m

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

    ServletServerHttpRequest serverRequest = new ServletServerHttpRequest(request);
    if (WebUtils.isSameOrigin(serverRequest)) {
        logger.debug("Skip CORS processing: request is from same origin");
        return true;
    }

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

    return handleInternal(serverRequest, serverResponse, config, preFlightRequest);
}

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;/*from w  ww . j a  v  a2s .  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.servlet.mvc.method.annotation.StreamingResponseBodyReturnValueHandler.java

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

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

    HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.class);
    ServerHttpResponse outputMessage = new ServletServerHttpResponse(response);

    if (ResponseEntity.class.isAssignableFrom(returnValue.getClass())) {
        ResponseEntity<?> responseEntity = (ResponseEntity<?>) returnValue;
        outputMessage.setStatusCode(responseEntity.getStatusCode());
        outputMessage.getHeaders().putAll(responseEntity.getHeaders());

        returnValue = responseEntity.getBody();
        if (returnValue == null) {
            mavContainer.setRequestHandled(true);
            return;
        }
    }

    Assert.isInstanceOf(StreamingResponseBody.class, returnValue);
    StreamingResponseBody streamingBody = (StreamingResponseBody) returnValue;

    Callable<Void> callable = new StreamingResponseBodyTask(outputMessage.getBody(), streamingBody);
    WebAsyncUtils.getAsyncManager(webRequest).startCallableProcessing(callable, mavContainer);
}