@Override @SuppressWarnings("resource") public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { mavContainer.setRequestHandled(true); Assert.isInstanceOf(HttpHeaders.class, returnValue); HttpHeaders headers = (HttpHeaders) returnValue; if (!headers.isEmpty()) { HttpServletResponse servletResponse = webRequest.getNativeResponse(HttpServletResponse.class); ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(servletResponse); outputMessage.getHeaders().putAll(headers); outputMessage.getBody(); // flush headers } }
private boolean isResourceNotModified(ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) { List<String> ifNoneMatch = inputMessage.getHeaders().getIfNoneMatch(); long ifModifiedSince = inputMessage.getHeaders().getIfModifiedSince(); String eTag = addEtagPadding(outputMessage.getHeaders().getETag()); long lastModified = outputMessage.getHeaders().getLastModified(); boolean notModified = false; if (!ifNoneMatch.isEmpty() && (inputMessage.getHeaders().containsKey(HttpHeaders.IF_UNMODIFIED_SINCE) || inputMessage.getHeaders().containsKey(HttpHeaders.IF_MATCH))) { // invalid conditional request, do not process } else if (lastModified != -1 && StringUtils.hasLength(eTag)) { notModified = isETagNotModified(ifNoneMatch, eTag) && isTimeStampNotModified(ifModifiedSince, lastModified); } else if (lastModified != -1) { notModified = isTimeStampNotModified(ifModifiedSince, lastModified); } else if (StringUtils.hasLength(eTag)) { notModified = isETagNotModified(ifNoneMatch, eTag); } return notModified; }
@Before public void setup() throws Exception { MockitoAnnotations.initMocks(this); this.server = new HttpTunnelServer(this.serverConnection); given(this.serverConnection.open(anyInt())).willAnswer(new Answer<ByteChannel>() { @Override public ByteChannel answer(InvocationOnMock invocation) throws Throwable { MockServerChannel channel = HttpTunnelServerTests.this.serverChannel; channel.setTimeout((Integer) invocation.getArguments()[0]); return channel; } }); this.servletRequest = new MockHttpServletRequest(); this.servletRequest.setAsyncSupported(true); this.servletResponse = new MockHttpServletResponse(); this.request = new ServletServerHttpRequest(this.servletRequest); this.response = new ServletServerHttpResponse(this.servletResponse); this.serverChannel = new MockServerChannel(); }
@Test public void handledByDispatcher() throws Exception { HttpServletRequest request = new MockHttpServletRequest("GET", "/hello"); HttpServletResponse response = new MockHttpServletResponse(); willReturn(true).given(this.dispatcher).handle(any(ServerHttpRequest.class), any(ServerHttpResponse.class)); this.filter.doFilter(request, response, this.chain); verifyZeroInteractions(this.chain); verify(this.dispatcher).handle(this.serverRequestCaptor.capture(), this.serverResponseCaptor.capture()); ServerHttpRequest dispatcherRequest = this.serverRequestCaptor.getValue(); ServletServerHttpRequest actualRequest = (ServletServerHttpRequest) dispatcherRequest; ServerHttpResponse dispatcherResponse = this.serverResponseCaptor.getValue(); ServletServerHttpResponse actualResponse = (ServletServerHttpResponse) dispatcherResponse; assertThat(actualRequest.getServletRequest()).isEqualTo(request); assertThat(actualResponse.getServletResponse()).isEqualTo(response); }
@Test public void handledByDispatcher() throws Exception { HttpServletRequest request = new MockHttpServletRequest("GET", "/hello"); HttpServletResponse response = new MockHttpServletResponse(); willReturn(true).given(this.dispatcher).handle(any(ServerHttpRequest.class), any(ServerHttpResponse.class)); this.filter.doFilter(request, response, this.chain); verifyZeroInteractions(this.chain); verify(this.dispatcher).handle(this.serverRequestCaptor.capture(), this.serverResponseCaptor.capture()); ServerHttpRequest dispatcherRequest = this.serverRequestCaptor.getValue(); ServletServerHttpRequest actualRequest = (ServletServerHttpRequest) dispatcherRequest; ServerHttpResponse dispatcherResponse = this.serverResponseCaptor.getValue(); ServletServerHttpResponse actualResponse = (ServletServerHttpResponse) dispatcherResponse; assertThat(actualRequest.getServletRequest(), equalTo(request)); assertThat(actualResponse.getServletResponse(), equalTo(response)); }
/** * Render model and view. * * @param model the model * @param response the response */ public static void render(final Object model, final HttpServletResponse response) { try { final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter(); jsonConverter.setPrettyPrint(true); final MediaType jsonMimeType = MediaType.APPLICATION_JSON; jsonConverter.write(model, jsonMimeType, new ServletServerHttpResponse(response)); } catch (final Exception e) { throw new RuntimeException(e); } }
/** * Render model and view. * * @param model the model * @param response the response */ public static void render(final Object model, final HttpServletResponse response) { try { final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter(); jsonConverter.setPrettyPrint(true); final MediaType jsonMimeType = MediaType.APPLICATION_JSON; jsonConverter.write(model, jsonMimeType, new ServletServerHttpResponse(response)); } catch (final Exception e) { throw Throwables.propagate(e); } }
@Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { mavContainer.setRequestHandled(true); HttpServletResponse servletResponse = webRequest.getNativeResponse(HttpServletResponse.class); ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(servletResponse); outputMessage.getBody(); HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class); WxRequest wxRequest = WxWebUtils.getWxRequestFromRequest(request); wxAsyncMessageTemplate.send(wxRequest, returnValue); }
@Override public void onAuthenticationFailure( final HttpServletRequest request, final HttpServletResponse response, final AuthenticationException exception) throws IOException { try (ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response)) { httpResponse.setStatusCode(HttpStatus.FORBIDDEN); messageConverter.write(createResponse(exception), MediaType.APPLICATION_JSON, httpResponse); } }
/** * 以json视图返回 * * @param model * @param response * @return */ public static ModelAndView render(Object model, HttpServletResponse response, boolean jsonSafe) { MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter(); try { Object json = jsonSafe ? StringUtils.join(GlobalConstant.JSON_SAFE_PREFIX, model) : model; if(model instanceof ResultInfo) { json = ((ResultInfo) model).toJson(); } jsonConverter.write(json, MediaType.APPLICATION_JSON, new ServletServerHttpResponse(response)); } catch (IOException e) { log.error("Write response data [{}] as json view error!", model, e); } return null; }
@SuppressWarnings({ "unchecked", "rawtypes", "resource" }) private ModelAndView handleResponseBody(Object returnValue, 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); } MediaType.sortByQualityValue(acceptedMediaTypes); HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse()); Class<?> returnValueType = returnValue.getClass(); if (this.messageConverters != null) { for (MediaType acceptedMediaType : acceptedMediaTypes) { for (HttpMessageConverter messageConverter : this.messageConverters) { if (messageConverter.canWrite(returnValueType, acceptedMediaType)) { messageConverter.write(returnValue, acceptedMediaType, outputMessage); return new ModelAndView(); } } } } if (logger.isWarnEnabled()) { logger.warn("Could not find HttpMessageConverter that supports return type [" + returnValueType + "] and " + acceptedMediaTypes); } return null; }
/** * Writes the given return value to the given web request. Delegates to * {@link #writeWithMessageConverters(Object, MethodParameter, ServletServerHttpRequest, ServletServerHttpResponse)} */ protected <T> void writeWithMessageConverters(T returnValue, MethodParameter returnType, NativeWebRequest webRequest) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException { ServletServerHttpRequest inputMessage = createInputMessage(webRequest); ServletServerHttpResponse outputMessage = createOutputMessage(webRequest); writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage); }
@Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { mavContainer.setRequestHandled(true); if (returnValue == null) { return; } ServletServerHttpRequest inputMessage = createInputMessage(webRequest); ServletServerHttpResponse outputMessage = createOutputMessage(webRequest); Assert.isInstanceOf(HttpEntity.class, returnValue); HttpEntity<?> responseEntity = (HttpEntity<?>) returnValue; HttpHeaders entityHeaders = responseEntity.getHeaders(); if (!entityHeaders.isEmpty()) { outputMessage.getHeaders().putAll(entityHeaders); } Object body = responseEntity.getBody(); if (responseEntity instanceof ResponseEntity) { outputMessage.setStatusCode(((ResponseEntity<?>) responseEntity).getStatusCode()); if (HttpMethod.GET == inputMessage.getMethod() && isResourceNotModified(inputMessage, outputMessage)) { outputMessage.setStatusCode(HttpStatus.NOT_MODIFIED); // Ensure headers are flushed, no body should be written. outputMessage.flush(); // Skip call to converters, as they may update the body. return; } } // Try even with null body. ResponseBodyAdvice could get involved. writeWithMessageConverters(body, returnType, inputMessage, outputMessage); // Ensure headers are flushed even if no body was written. outputMessage.flush(); }
@Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { if (returnValue == null) { mavContainer.setRequestHandled(true); return; } 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; } } ServletRequest request = webRequest.getNativeRequest(ServletRequest.class); ShallowEtagHeaderFilter.disableContentCaching(request); Assert.isInstanceOf(StreamingResponseBody.class, returnValue); StreamingResponseBody streamingBody = (StreamingResponseBody) returnValue; Callable<Void> callable = new StreamingResponseBodyTask(outputMessage.getBody(), streamingBody); WebAsyncUtils.getAsyncManager(webRequest).startCallableProcessing(callable, mavContainer); }
@Before public void setup() { this.body = "body"; this.contentType = MediaType.TEXT_PLAIN; this.converterType = StringHttpMessageConverter.class; this.paramType = new MethodParameter(ClassUtils.getMethod(this.getClass(), "handle", String.class), 0); this.returnType = new MethodParameter(ClassUtils.getMethod(this.getClass(), "handle", String.class), -1); this.request = new ServletServerHttpRequest(new MockHttpServletRequest()); this.response = new ServletServerHttpResponse(new MockHttpServletResponse()); }
@SuppressWarnings("unchecked") @Override protected void beforeBodyWriteInternal(MappingJacksonValue bodyContainer, MediaType contentType, MethodParameter returnType, ServerHttpRequest request, ServerHttpResponse response) { int status = ((ServletServerHttpResponse) response).getServletResponse().getStatus(); response.setStatusCode(HttpStatus.OK); Map<String, Object> map = new LinkedHashMap<>(); map.put("status", status); map.put("message", bodyContainer.getValue()); bodyContainer.setValue(map); }
@Override public void upgrade(ServerHttpRequest request, ServerHttpResponse response, String selectedProtocol, List<WebSocketExtension> selectedExtensions, Principal user, WebSocketHandler wsHandler, Map<String, Object> attributes) throws HandshakeFailureException { Assert.isInstanceOf(ServletServerHttpRequest.class, request); HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest(); Assert.isInstanceOf(ServletServerHttpResponse.class, response); HttpServletResponse servletResponse = ((ServletServerHttpResponse) response).getServletResponse(); Assert.isTrue(this.factory.isUpgradeRequest(servletRequest, servletResponse), "Not a WebSocket handshake"); JettyWebSocketSession session = new JettyWebSocketSession(attributes, user); JettyWebSocketHandlerAdapter handlerAdapter = new JettyWebSocketHandlerAdapter(wsHandler, session); WebSocketHandlerContainer container = new WebSocketHandlerContainer(handlerAdapter, selectedProtocol, selectedExtensions); try { wsContainerHolder.set(container); this.factory.acceptWebSocket(servletRequest, servletResponse); } catch (IOException ex) { throw new HandshakeFailureException( "Response update failed during upgrade to WebSocket: " + request.getURI(), ex); } finally { wsContainerHolder.remove(); } }
@Override public void handleRequest(HttpServletRequest servletRequest, HttpServletResponse servletResponse) throws ServletException, IOException { ServerHttpRequest request = new ServletServerHttpRequest(servletRequest); ServerHttpResponse response = new ServletServerHttpResponse(servletResponse); try { this.sockJsService.handleRequest(request, response, getSockJsPath(servletRequest), this.webSocketHandler); } catch (Throwable ex) { throw new SockJsException("Uncaught failure in SockJS request, uri=" + request.getURI(), ex); } }
@Test // SPR-11919 @SuppressWarnings("unchecked") public void handleInfoGetWildflyNPE() throws Exception { HttpServletResponse mockResponse = mock(HttpServletResponse.class); ServletOutputStream ous = mock(ServletOutputStream.class); given(mockResponse.getHeaders(HttpHeaders.ACCESS_CONTROL_ALLOW_ORIGIN)).willThrow(NullPointerException.class); given(mockResponse.getOutputStream()).willReturn(ous); this.response = new ServletServerHttpResponse(mockResponse); handleRequest("GET", "/echo/info", HttpStatus.OK); verify(mockResponse, times(1)).getOutputStream(); }
@Before public void setup() { super.setUp(); this.frameFormat = new DefaultSockJsFrameFormat("%s"); this.servletResponse = new MockHttpServletResponse(); this.response = new ServletServerHttpResponse(this.servletResponse); this.servletRequest = new MockHttpServletRequest(); this.servletRequest.setAsyncSupported(true); this.request = new ServletServerHttpRequest(this.servletRequest); }
@Override public boolean processRequest(CorsConfiguration config, HttpServletRequest request, HttpServletResponse response) throws IOException { if (!CorsUtils.isCorsRequest(request)) { return true; } ServletServerHttpResponse serverResponse = new ServletServerHttpResponse(response); ServletServerHttpRequest serverRequest = new ServletServerHttpRequest(request); if (WebUtils.isSameOrigin(serverRequest)) { logger.debug("Skip CORS processing, request is a same-origin one"); return true; } if (responseHasCors(serverResponse)) { logger.debug("Skip CORS processing, response already contains \"Access-Control-Allow-Origin\" header"); 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); }
@Before public void setUp() { ConversionService conversionService = new DefaultConversionService(); this.converter = new ObjectToStringHttpMessageConverter(conversionService); this.servletResponse = new MockHttpServletResponse(); this.response = new ServletServerHttpResponse(this.servletResponse); }
@Override public void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception { mavContainer.setRequestHandled(true); HttpServletResponse httpServletResponse = webRequest.getNativeResponse(HttpServletResponse.class); httpServletResponse.setContentType(CONTENT_TYPE); ServletServerHttpResponse outputMessage = new ServletServerHttpResponse(httpServletResponse); JsonResponse jsonResponse = new JsonResponse(returnValue); outputMessage.getBody().write(StringUtils.toBytes(JsonUtils.toJson(jsonResponse))); outputMessage.getBody().flush(); }
@SuppressWarnings({ "rawtypes", "unchecked", "resource" }) private ModelAndView handleResponseBody(Object body, ServletWebRequest webRequest) throws HttpMessageNotWritableException, IOException { HttpInputMessage inputMessage = new ServletServerHttpRequest(webRequest.getRequest()); List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept(); if (acceptedMediaTypes.isEmpty()) { acceptedMediaTypes = Collections.singletonList(MediaType.ALL); } MediaType.sortByQualityValue(acceptedMediaTypes); HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse()); Class<?> bodyType = body.getClass(); List<HttpMessageConverter<?>> converters = this.messageConverters; 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; }
private void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws IOException, ServletException { ServerHttpRequest serverRequest = new ServletServerHttpRequest(request); ServerHttpResponse serverResponse = new ServletServerHttpResponse(response); if (!this.dispatcher.handle(serverRequest, serverResponse)) { chain.doFilter(request, response); } }
@Test public void sendClassLoaderFiles() throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); ClassLoaderFiles files = new ClassLoaderFiles(); files.addFile("name", new ClassLoaderFile(Kind.ADDED, new byte[0])); byte[] bytes = serialize(files); request.setContent(bytes); this.server.handle(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response)); verify(this.delegate).updateAndRestart(this.filesCaptor.capture()); assertThat(this.filesCaptor.getValue().getFile("name")).isNotNull(); assertThat(response.getStatus()).isEqualTo(200); }
@Test public void sendNoContent() throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); this.server.handle(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response)); verifyZeroInteractions(this.delegate); assertThat(response.getStatus()).isEqualTo(500); }
@Test public void sendBadData() throws Exception { MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); request.setContent(new byte[] { 0, 0, 0 }); this.server.handle(new ServletServerHttpRequest(request), new ServletServerHttpResponse(response)); verifyZeroInteractions(this.delegate); assertThat(response.getStatus()).isEqualTo(500); }
@Test public void assignTo() throws Exception { ByteBuffer data = ByteBuffer.wrap("hello".getBytes()); HttpTunnelPayload payload = new HttpTunnelPayload(2, data); MockHttpServletResponse servletResponse = new MockHttpServletResponse(); HttpOutputMessage response = new ServletServerHttpResponse(servletResponse); payload.assignTo(response); assertThat(servletResponse.getHeader("x-seq")).isEqualTo("2"); assertThat(servletResponse.getContentAsString()).isEqualTo("hello"); }
@Before public void setup() { this.servletRequest = new MockHttpServletRequest(); this.servletResponse = new MockHttpServletResponse(); this.request = new ServletServerHttpRequest(this.servletRequest); this.response = new ServletServerHttpResponse(this.servletResponse); }
@Before public void setup() { MockitoAnnotations.initMocks(this); this.request = new MockHttpServletRequest(); this.response = new MockHttpServletResponse(); this.serverRequest = new ServletServerHttpRequest(this.request); this.serverResponse = new ServletServerHttpResponse(this.response); }
/** * 将指定的 model 以 JSON 格式输出到 HTTP 响应中。 * * @param model * 数据对象 * @param request * Spring ServletWebRequest * @param mediaType * 输出响应的 MIME 类型 * @return 返回 null */ public static ModelAndView render(Object model, ServletWebRequest request, MediaType mediaType) { MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter(); try { jsonConverter.write(model, mediaType, new ServletServerHttpResponse(request.getResponse())); } catch (HttpMessageNotWritableException | IOException e) { logger.error("Render jsonView error", e); } return null; }