Java ContentCachingResponseWrapper类代码示例

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
        throws ServletException, IOException {
    ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(request);
    ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(response);

    try {
        filterChain.doFilter(requestWrapper, responseWrapper);
    } finally {
        String requestBody = new String(requestWrapper.getContentAsByteArray());
        log.info("Request body: {}", requestBody);

        String responseBody = new String(responseWrapper.getContentAsByteArray());
        log.info("Response body: {}", responseBody);

        // Do not forget this line after reading response content or actual response will be empty!
        responseWrapper.copyBodyToResponse();
    }
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
/**
 * 提取请求结果
 * @param request
 * @param loggingContext
 * @return
 */
protected Object extractResponseResult(HttpServletResponse response, LoggingContext loggingContext) throws Exception {
	MediaType contentType = loggingContext.getHttpAccessLog().getResponseContentType();
	if(contentType != null){
		if(isContentCachingResponse(response)){
			String charset = response.getCharacterEncoding();
			if(StringUtils.isEmpty(charset)){
				charset = StringUtils.defaultIfEmpty(contentType.getCharset().name(), GlobalConstants.SYSTEM_DEFAULT_CHARSET);
			}
			ContentCachingResponseWrapper responseToUse = (ContentCachingResponseWrapper) response;
			byte[] bytes = responseToUse.getContentAsByteArray();
			if(bytes != null){
				return IOUtils.toString(bytes, charset);
			}
		}
	}
	return null;
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
private void updateResponse(String requestURI, ContentCachingResponseWrapper responseWrapper) throws IOException {
	try {
		HttpServletResponse rawResponse = (HttpServletResponse) responseWrapper.getResponse();
		byte[] body = responseWrapper.getContentAsByteArray();
		ServletOutputStream outputStream = rawResponse.getOutputStream();
		if (rawResponse.isCommitted()) {
			if (body.length > 0) {
				StreamUtils.copy(body, outputStream);
			}
		} else {
			if (body.length > 0) {
				rawResponse.setContentLength(body.length);
				StreamUtils.copy(body, rawResponse.getOutputStream());
			}
		}
		finishResponse(outputStream, body);
	} catch (Exception ex) {
		logger.error("请求地址为" + requestURI + "的连接返回报文失败,原因是{}", ex.getMessage());
	}
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
	long begintime = DateUtils.currentTimeMillis();
	JsonContentCachingRequestWrapper requestWrapper = new JsonContentCachingRequestWrapper(request);
	ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(response);
	filterChain.doFilter(requestWrapper, responseWrapper);
	long timecost = DateUtils.getTimeMillisConsume(begintime);
	String requestURI = request.getRequestURI();
	String ip = request.getRemoteAddr();
	String requestParam = convertString(requestWrapper.getContentAsByteArray());
	updateResponse(requestURI, responseWrapper);
	if (isNotJsonContentType(responseWrapper.getContentType())) {
		logger.debug("ip:{} 调用接口,请求地址为:{}, 请求参数为:{},[{}]ms", ip, requestURI, requestParam, timecost);
	} else {
		String result = convertString(responseWrapper.getContentAsByteArray());
		logger.debug("ip:{} 调用接口,请求地址为:{}, 请求参数为:{},返回值是{},[{}]ms", ip, requestURI, requestParam, result, timecost);
	}
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
private static String getResponseContent(HttpServletResponse response) {
    if (response instanceof ContentCachingResponseWrapper) {
        return new String(((ContentCachingResponseWrapper) response).getContentAsByteArray());
    }
    if (response instanceof HttpServletResponseWrapper
        && ((HttpServletResponseWrapper) response).getResponse() instanceof ContentCachingResponseWrapper) {
        return new String(((ContentCachingResponseWrapper) ((HttpServletResponseWrapper) response)
            .getResponse()).getContentAsByteArray());
    }
    log.warn("Empty response content because of unsupported response class {}", response.getClass());
    return "";
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
/**
 * wrap the {@link HttpServletResponse} in a {@link ContentCachingResponseWrapper} if it is not already one.
 * 
 * @param httpServletResponse
 * @return
 */
protected ContentCachingResponseWrapper wrapResponseIfNeeded(HttpServletResponse httpServletResponse) {
	if (!(httpServletResponse instanceof ContentCachingResponseWrapper)) {
		return new ContentCachingResponseWrapper(httpServletResponse);
	} else {
		return (ContentCachingResponseWrapper) httpServletResponse;
	}
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
protected boolean isContentCachingResponse(ServletResponse response) {
	if(response instanceof ContentCachingResponseWrapper){
		return true;
	}else if(response instanceof HttpServletResponseWrapper) {
		HttpServletResponseWrapper responseToUse = (HttpServletResponseWrapper) response;
		return isContentCachingResponse(responseToUse.getResponse());
	}
	return false;
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
/**
 * 获取ContentCachingResponseWrapper
 * (考虑到Wrapper是可以重复的,故需要递归获取)
 * @param response
 * @return
 */
protected ContentCachingResponseWrapper getContentCachingResponseWrapper(ServletResponse response) {
	if(response instanceof ContentCachingResponseWrapper){
		return (ContentCachingResponseWrapper) response;
	}else if(response instanceof HttpServletResponseWrapper) {
		HttpServletResponseWrapper responseToUse = (HttpServletResponseWrapper) response;
		return getContentCachingResponseWrapper(responseToUse.getResponse());
	}
	return null;
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Override
protected void doFilterInternal(HttpServletRequest request,
                                HttpServletResponse response,
                                FilterChain filterChain) throws ServletException, IOException {
    ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper(request);
    ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(response);
    try {
        filterChain.doFilter(requestWrapper, responseWrapper);
    } finally {
        responseWrapper.copyBodyToResponse();
    }
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void doFilterInternal_NoCacheRequestAndResponse_CallWithCacheRequestAndResponse() throws Exception {
	HttpServletRequest request = new MockHttpServletRequest();
	HttpServletResponse response = new MockHttpServletResponse();
	FilterChain filterChain = spy(new MockFilterChain());

	FILTER.doFilterInternal(request, response, filterChain);

	Mockito.verify(filterChain).doFilter(isA(ContentCachingRequestWrapper.class), isA
			(ContentCachingResponseWrapper.class));
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void doFilterInternal_CacheRequestAndNoCacheResponse_CallWithCacheRequestAndResponse() throws Exception {
	HttpServletRequest cacheRequest = new ContentCachingRequestWrapper(new MockHttpServletRequest());
	HttpServletResponse response = new MockHttpServletResponse();
	FilterChain filterChain = spy(new MockFilterChain());

	ArgumentCaptor<HttpServletRequest> requestCaptor = ArgumentCaptor.forClass(HttpServletRequest.class);

	FILTER.doFilterInternal(cacheRequest, response, filterChain);

	Mockito.verify(filterChain).doFilter(requestCaptor.capture(), isA(ContentCachingResponseWrapper.class));
	assertThat(requestCaptor.getValue(), is(cacheRequest));
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void doFilterInternal_NoCacheRequestAndCacheResponse_CallWithCacheRequestAndResponse() throws Exception {
	HttpServletRequest request = new MockHttpServletRequest();
	HttpServletResponse cacheResponse = new ContentCachingResponseWrapper(new MockHttpServletResponse());
	FilterChain filterChain = spy(new MockFilterChain());

	ArgumentCaptor<HttpServletResponse> responseCaptor = ArgumentCaptor.forClass(HttpServletResponse.class);

	FILTER.doFilterInternal(request, cacheResponse, filterChain);

	Mockito.verify(filterChain).doFilter(isA(ContentCachingRequestWrapper.class), responseCaptor.capture());
	assertThat(responseCaptor.getValue(), is(cacheResponse));
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void buildResponseLog_WithNoBody_ReturnStringResponseWithUriAndEmptyBody() {
	MockHttpServletResponse response = new MockHttpServletResponse();

	String log = FILTER.buildResponseLog(new ContentCachingResponseWrapper(response));

	assertThat(log, is("Server responded with a response\n > 200\n[empty]"));
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void buildResponseLog_WithCorrectBody_ReturnStringResponseWithUriAndBody() throws IOException {
	MockHttpServletResponse response = new MockHttpServletResponse();

	ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper(response);
	responseWrapper.getWriter().print("test");

	String log = FILTER.buildResponseLog(responseWrapper);

	assertThat(log, is("Server responded with a response\n > 200\ntest"));
}
 

import org.springframework.web.util.ContentCachingResponseWrapper; //导入依赖的package包/类
@Test
public void buildResponseLog_WithUnreadableBody_ReturnStringResponseWithUriAndUnknownBody() throws IOException {
	MockHttpServletResponse response = new MockHttpServletResponse();

	ContentCachingResponseWrapper responseWrapper = spy(new ContentCachingResponseWrapper(response));
	responseWrapper.getWriter().print("test");
	//noinspection InjectedReferences
	responseWrapper.setCharacterEncoding("notExistThisEncoding");

	String log = FILTER.buildResponseLog(responseWrapper);

	assertThat(log, is("Server responded with a response\n > 200\n[unknown]"));
}