Often encounter the need to handle http requests and response body scenarios.
One of the bigger problems here is that once the requestBody or responseBody stream of a servlet has been read, it cannot be read again.
For this problem, Spring itself provides a solution, namely.
Write a filter.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
public abstract class HttpBodyRecorderFilter extends OncePerRequestFilter {
private static final int DEFAULT_MAX_PAYLOAD_LENGTH = 1024 * 512;
private int maxPayloadLength = DEFAULT_MAX_PAYLOAD_LENGTH;
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
boolean isFirstRequest = !isAsyncDispatch(request);
HttpServletRequest requestToUse = request;
if (isFirstRequest && !(request instanceof ContentCachingRequestWrapper)
&& (request.getMethod().equals(HttpMethod.PUT.name())
|| request.getMethod().equals(HttpMethod.POST.name()))) {
requestToUse = new ContentCachingRequestWrapper(request);
}
HttpServletResponse responseToUse = response;
if (!(response instanceof ContentCachingResponseWrapper) && (request.getMethod().equals(HttpMethod.PUT.name())
|| request.getMethod().equals(HttpMethod.POST.name()))) {
responseToUse = new ContentCachingResponseWrapper(response);
}
boolean hasException = false;
try {
filterChain.doFilter(requestToUse, responseToUse);
} catch (final Exception e) {
hasException = true;
throw e;
} finally {
int code = hasException ? 500 : response.getStatus();
if (!isAsyncStarted(requestToUse) && (this.codeMatched(code, AdvancedHunterConfigManager.recordCode()))) {
recordBody(createRequest(requestToUse), createResponse(responseToUse));
} else {
writeResponseBack(responseToUse);
}
}
}
protected String createRequest(HttpServletRequest request) {
String payload = "";
ContentCachingRequestWrapper wrapper = WebUtils.getNativeRequest(request, ContentCachingRequestWrapper.class);
if (wrapper != null) {
byte[] buf = wrapper.getContentAsByteArray();
payload = genPayload(payload, buf, wrapper.getCharacterEncoding());
}
return payload;
}
protected String createResponse(HttpServletResponse resp) {
String response = "";
ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(resp, ContentCachingResponseWrapper.class);
if (wrapper != null) {
byte[] buf = wrapper.getContentAsByteArray();
try {
wrapper.copyBodyToResponse();
} catch (IOException e) {
e.printStackTrace();
}
response = genPayload(response, buf, wrapper.getCharacterEncoding());
}
return response;
}
protected void writeResponseBack(HttpServletResponse resp) {
ContentCachingResponseWrapper wrapper = WebUtils.getNativeResponse(resp, ContentCachingResponseWrapper.class);
if (wrapper != null) {
try {
wrapper.copyBodyToResponse();
} catch (IOException e) {
LOG.error("Fail to write response body back", e);
}
}
}
private String genPayload(String payload, byte[] buf, String characterEncoding) {
if (buf.length > 0 && buf.length < getMaxPayloadLength()) {
try {
payload = new String(buf, 0, buf.length, characterEncoding);
} catch (UnsupportedEncodingException ex) {
payload = "[unknown]";
}
}
return payload;
}
public int getMaxPayloadLength() {
return maxPayloadLength;
}
private boolean codeMatched(int responseStatus, String statusCode) {
if (statusCode.matches("^[0-9,]*$")) {
String[] filteredCode = statusCode.split(",");
return Stream.of(filteredCode).map(Integer::parseInt).collect(Collectors.toList()).contains(responseStatus);
} else {
return false;
}
}
protected abstract void recordBody(String payload, String response);
protected abstract String recordCode();
}
|
Now you can customize a filter to inherit from HttpBodyRecorderFilter and override the recordBody method to customize your own processing logic.
In addition, the recordCode method can be used to define when the request response code is how much to record the body, for example, it can be defined to record the body only when it encounters 400 or 500, for error detection.
The filter matching rules are relatively simple, if we want to match like springmvc, we can use AntPathMatcher.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
class PatternMappingFilterProxy implements Filter {
private final Filter delegate;
private final List<String> pathUrlPatterns = new ArrayList();
private PathMatcher pathMatcher;
public PatternMappingFilterProxy(Filter delegate, String... urlPatterns) {
Assert.notNull(delegate, "A delegate Filter is required");
this.delegate = delegate;
int length = urlPatterns.length;
pathMatcher = new AntPathMatcher();
for (int index = 0; index < length; ++index) {
String urlPattern = urlPatterns[index];
this.pathUrlPatterns.add(urlPattern);
}
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)
throws IOException, ServletException {
HttpServletRequest httpRequest = (HttpServletRequest) request;
String path = httpRequest.getRequestURI();
if (this.matches(path)) {
this.delegate.doFilter(request, response, filterChain);
} else {
filterChain.doFilter(request, response);
}
}
private boolean matches(String requestPath) {
for (String pattern : pathUrlPatterns) {
if (pathMatcher.match(pattern, requestPath)) {
return true;
}
}
return false;
}
@Override
public void init(FilterConfig filterConfig) throws ServletException {
this.delegate.init(filterConfig);
}
@Override
public void destroy() {
this.delegate.destroy();
}
public List<String> getPathUrlPatterns() {
return pathUrlPatterns;
}
public void setPathUrlPatterns(List<String> urlPatterns) {
pathUrlPatterns.clear();
pathUrlPatterns.addAll(urlPatterns);
}
}
|
In this way, PatternMappingFilterProxy decorates the real HttpBodyRecorderFilter and supports passing in urlPatterns to achieve ant style matching like springmvc. For example, for the following handler, you can set the urlPattern to /test/{id:[0-9]+}.
1
2
3
4
5
6
|
@PostMapping("/test/{id}")
public Object test(@PathVariable(value = "id",required = true) final Integer index) {
//do something
}
|
Reference https://fredal.xin/http-body-recorder