Javaサーブレットフィルタで2つのhttpリクエストパラメータにアクセスしようとしていますが、ここでは何も新しいことはありませんが、パラメータがすでに消費されていることに驚きました。このため、フィルターチェーンでは使用できなくなりました。
これは、パラメータがPOSTリクエスト本文（フォーム送信など）に含まれている場合にのみ発生するようです。
パラメータを読み取り、それらを消費しない方法はありますか？
これまでのところ、私はこの参照のみを見つけました：request.getParameterを使用するサーブレットフィルターはフォームデータを失います。
ありがとう！
回答:
余談ですが、この問題を解決する別の方法は、フィルターチェーンを使用せず、代わりに、解析されたリクエスト本文で動作できるアスペクトを使用して、独自のインターセプターコンポーネントを構築することです。また、リクエストInputStreamを独自のモデルオブジェクトに一度だけ変換するため、より効率的になる可能性があります。
ただし、特にリクエストがフィルタチェーンを移動するときに、リクエストの本文を複数回読み取ることは合理的だと思います。私は通常、サービスコンポーネントから切り離された、HTTPレイヤーで保持したい特定の操作にフィルターチェーンを使用します。
Will Hartungが提案したように、私はこれを拡張HttpServletRequestWrapperし、リクエストInputStreamを消費し、基本的にバイトをキャッシュすることで実現しました。
public class MultiReadHttpServletRequest extends HttpServletRequestWrapper {
private ByteArrayOutputStream cachedBytes;
public MultiReadHttpServletRequest(HttpServletRequest request) {
super(request);
}
@Override
public ServletInputStream getInputStream() throws IOException {
if (cachedBytes == null)
cacheInputStream();
return new CachedServletInputStream();
}
@Override
public BufferedReader getReader() throws IOException{
return new BufferedReader(new InputStreamReader(getInputStream()));
}
private void cacheInputStream() throws IOException {
/* Cache the inputstream in order to read it multiple times. For
* convenience, I use apache.commons IOUtils
*/
cachedBytes = new ByteArrayOutputStream();
IOUtils.copy(super.getInputStream(), cachedBytes);
}
/* An inputstream which reads the cached request body */
public class CachedServletInputStream extends ServletInputStream {
private ByteArrayInputStream input;
public CachedServletInputStream() {
/* create a new input stream from the cached request body */
input = new ByteArrayInputStream(cachedBytes.toByteArray());
}
@Override
public int read() throws IOException {
return input.read();
}
}
}
これで、元のリクエストをフィルターチェーンに渡す前にラップすることで、リクエストの本文を複数回読み取ることができます。
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
/* wrap the request in order to read the inputstream multiple times */
MultiReadHttpServletRequest multiReadRequest = new MultiReadHttpServletRequest((HttpServletRequest) request);
/* here I read the inputstream and do my thing with it; when I pass the
* wrapped request through the filter chain, the rest of the filters, and
* request handlers may read the cached inputstream
*/
doMyThing(multiReadRequest.getInputStream());
//OR
anotherUsage(multiReadRequest.getReader());
chain.doFilter(multiReadRequest, response);
}
}
このソリューションではgetParameterXXX、基になる呼び出しがgetInputStream()であるため、メソッドを介してリクエストの本文を複数回読み取ることもできます。これはもちろん、キャッシュされたリクエストを読み取りますInputStream。
編集
新しいバージョンのServletInputStreamインターフェースの場合。などのようないくつかのメソッドの実装を提供する必要があります。以下のコメントで提供されているようにisReady、setReadListenerこの質問を参照してください。
getInputStream上と呼ばれている私の本があるので、ラッパーServletRequest私は、フィルタチェインに渡すことのインスタンス。それでも疑問がある場合は、のソースコードServletRequestWrapperとServletRequestインターフェイスをお読みください。
isReady()。isFinished()およびsetReadListener()実装する必要があります非ブロックIOに対処します。私はReadListenerは空白のまますることができ思っていますが、確かではないについて何をすべきかisFinished()、および/またはisReady()。
私は遅れていることを知っていますが、この質問はまだ私に関連していて、このSO投稿はGoogleのトップヒットの1つでした。他の誰かが数時間を節約できることを期待して、私は先に進んで私の解決策を投稿します。
私の場合、すべてのリクエストとレスポンスを彼らの体で記録する必要がありました。Spring Frameworkを使用すると、答えは実際には非常に単純です。ContentCachingRequestWrapperとContentCachingResponseWrapperを使用するだけです。
import org.springframework.web.util.ContentCachingRequestWrapper;
import org.springframework.web.util.ContentCachingResponseWrapper;
import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
public class LoggingFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void destroy() {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException {
ContentCachingRequestWrapper requestWrapper = new ContentCachingRequestWrapper((HttpServletRequest) request);
ContentCachingResponseWrapper responseWrapper = new ContentCachingResponseWrapper((HttpServletResponse) response);
try {
chain.doFilter(requestWrapper, responseWrapper);
} finally {
String requestBody = new String(requestWrapper.getContentAsByteArray());
String responseBody = new String(responseWrapper.getContentAsByteArray());
// Do not forget this line after reading response content or actual response will be empty!
responseWrapper.copyBodyToResponse();
// Write request and response body, headers, timestamps etc. to log files
}
}
}
requestBodyとresponseBodyした空の文字列
chain.doFilter(request, response);代わりにやっていたchain.doFilter(requestWrapper, responseWrapper);
ContentCaching*Wrapperクラスは「キャッシング」の方法を介して行われるので、入力ストリームを消費する高価な価格ていgetContentAsByteArrayますが、このクラスは、（私のユースケースである）フィルタ・チェーン内の他のフィルタによって必要とされる可能性があります入力ストリームをキャッシュされていませんが。Imho、これはコンテンツキャッシングクラスの予期しない動作であるため、Spring Team jira.spring.io/browse/SPR-16028
AbstractRequestLoggingFilterほとんどの作業はすでにSpringによって行われており、1つまたは2つの単純なメソッドをオーバーライドするだけでよいSpringから使用できます。
spring-web-4.3.12.RELEASE。ソースを確認したところ、変数cachedContentはリクエストパラメータやリクエストinputStreamなどのさまざまなコンテンツを格納するために使用されていることがわかりました。getContentAsByteArray()単独で呼び出すと空になります。リクエスト本文を取得するには、を呼び出す必要がありますgetInputStream()。ただし、これにより、inputStreamは他のフィルターやハンドラーで使用できなくなります。
上記の回答は非常に役に立ちましたが、それでも私の経験にはいくつかの問題がありました。tomcat 7サーブレット3.0では、getParamterとgetParamterValuesも上書きする必要がありました。ここでの解決策には、get-queryパラメーターとpost-bodyの両方が含まれます。生の文字列を簡単に取得できます。
他のソリューションと同様に、Apachecommons-ioとGooglesGuavaを使用します。
このソリューションでは、getParameter *メソッドはIOExceptionをスローしませんが、IOExceptionをスローする可能性のあるsuper.getInputStream（）（本体を取得するため）を使用します。私はそれをキャッチしてruntimeExceptionをスローします。あまり良くありません。
import com.google.common.collect.Iterables;
import com.google.common.collect.ObjectArrays;
import org.apache.commons.io.IOUtils;
import org.apache.http.NameValuePair;
import org.apache.http.client.utils.URLEncodedUtils;
import org.apache.http.entity.ContentType;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
/**
* Purpose of this class is to make getParameter() return post data AND also be able to get entire
* body-string. In native implementation any of those two works, but not both together.
*/
public class MultiReadHttpServletRequest extends HttpServletRequestWrapper {
public static final String UTF8 = "UTF-8";
public static final Charset UTF8_CHARSET = Charset.forName(UTF8);
private ByteArrayOutputStream cachedBytes;
private Map<String, String[]> parameterMap;
public MultiReadHttpServletRequest(HttpServletRequest request) {
super(request);
}
public static void toMap(Iterable<NameValuePair> inputParams, Map<String, String[]> toMap) {
for (NameValuePair e : inputParams) {
String key = e.getName();
String value = e.getValue();
if (toMap.containsKey(key)) {
String[] newValue = ObjectArrays.concat(toMap.get(key), value);
toMap.remove(key);
toMap.put(key, newValue);
} else {
toMap.put(key, new String[]{value});
}
}
}
@Override
public ServletInputStream getInputStream() throws IOException {
if (cachedBytes == null) cacheInputStream();
return new CachedServletInputStream();
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(getInputStream()));
}
private void cacheInputStream() throws IOException {
/* Cache the inputStream in order to read it multiple times. For
* convenience, I use apache.commons IOUtils
*/
cachedBytes = new ByteArrayOutputStream();
IOUtils.copy(super.getInputStream(), cachedBytes);
}
@Override
public String getParameter(String key) {
Map<String, String[]> parameterMap = getParameterMap();
String[] values = parameterMap.get(key);
return values != null && values.length > 0 ? values[0] : null;
}
@Override
public String[] getParameterValues(String key) {
Map<String, String[]> parameterMap = getParameterMap();
return parameterMap.get(key);
}
@Override
public Map<String, String[]> getParameterMap() {
if (parameterMap == null) {
Map<String, String[]> result = new LinkedHashMap<String, String[]>();
decode(getQueryString(), result);
decode(getPostBodyAsString(), result);
parameterMap = Collections.unmodifiableMap(result);
}
return parameterMap;
}
private void decode(String queryString, Map<String, String[]> result) {
if (queryString != null) toMap(decodeParams(queryString), result);
}
private Iterable<NameValuePair> decodeParams(String body) {
Iterable<NameValuePair> params = URLEncodedUtils.parse(body, UTF8_CHARSET);
try {
String cts = getContentType();
if (cts != null) {
ContentType ct = ContentType.parse(cts);
if (ct.getMimeType().equals(ContentType.APPLICATION_FORM_URLENCODED.getMimeType())) {
List<NameValuePair> postParams = URLEncodedUtils.parse(IOUtils.toString(getReader()), UTF8_CHARSET);
params = Iterables.concat(params, postParams);
}
}
} catch (IOException e) {
throw new IllegalStateException(e);
}
return params;
}
public String getPostBodyAsString() {
try {
if (cachedBytes == null) cacheInputStream();
return cachedBytes.toString(UTF8);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(e);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/* An inputStream which reads the cached request body */
public class CachedServletInputStream extends ServletInputStream {
private ByteArrayInputStream input;
public CachedServletInputStream() {
/* create a new input stream from the cached request body */
input = new ByteArrayInputStream(cachedBytes.toByteArray());
}
@Override
public int read() throws IOException {
return input.read();
}
}
@Override
public String toString() {
String query = dk.bnr.util.StringUtil.nullToEmpty(getQueryString());
StringBuilder sb = new StringBuilder();
sb.append("URL='").append(getRequestURI()).append(query.isEmpty() ? "" : "?" + query).append("', body='");
sb.append(getPostBodyAsString());
sb.append("'");
return sb.toString();
}
}
decode(getPostBodyAsString(), result);でするのgetParameterMap()ですか？これにより、key = request body、value = nullのパラメーターが作成されますが、これはかなり奇妙なことです。
super.getParameterMap()あなたにgetParameterMap？それは<String, String[]>とにかくあなたに地図を与えるでしょう。
唯一の方法は、入力ストリーム全体をフィルターで自分で消費し、そこから必要なものを取得して、読み取ったコンテンツの新しいInputStreamを作成し、そのInputStreamをServletRequestWrapper（またはHttpServletRequestWrapper）に配置することです。
欠点は、ペイロードを自分で解析する必要があることです。標準では、その機能を利用できません。
補遺-
私が言ったように、あなたはHttpServletRequestWrapperを見る必要があります。
フィルタでは、FilterChain.doFilter（request、response）を呼び出して続行します。
些細なフィルターの場合、要求と応答はフィルターに渡されるものと同じです。そうである必要はありません。それらを独自の要求や応答に置き換えることができます。
HttpServletRequestWrapperは、これを容易にするために特別に設計されています。元のリクエストを渡すと、すべての通話を傍受できます。これの独自のサブクラスを作成し、getInputStreamメソッドを独自のサブクラスに置き換えます。元のリクエストの入力ストリームを変更することはできないため、代わりにこのラッパーを使用して、独自の入力ストリームを返します。
最も単純なケースは、元の要求入力ストリームをバイトバッファーに消費し、必要な魔法を実行してから、そのバッファーから新しいByteArrayInputStreamを作成することです。これはラッパーで返されるものであり、FilterChain.doFilterメソッドに渡されます。
ServletInputStreamをサブクラス化し、ByteArrayInputStreamの別のラッパーを作成する必要がありますが、それも大したことではありません。
私も同じ問題を抱えていました。以下のコードはもっと単純で、私にとってはうまく機能していると思います。
public class MultiReadHttpServletRequest extends HttpServletRequestWrapper {
private String _body;
public MultiReadHttpServletRequest(HttpServletRequest request) throws IOException {
super(request);
_body = "";
BufferedReader bufferedReader = request.getReader();
String line;
while ((line = bufferedReader.readLine()) != null){
_body += line;
}
}
@Override
public ServletInputStream getInputStream() throws IOException {
final ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(_body.getBytes());
return new ServletInputStream() {
public int read() throws IOException {
return byteArrayInputStream.read();
}
};
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(this.getInputStream()));
}
}
フィルタJavaクラスでは、
HttpServletRequest properRequest = ((HttpServletRequest) req);
MultiReadHttpServletRequest wrappedRequest = new MultiReadHttpServletRequest(properRequest);
req = wrappedRequest;
inputJson = IOUtils.toString(req.getReader());
System.out.println("body"+inputJson);
ご不明な点がございましたらお知らせください
したがって、これは基本的にLathyの回答ですが、ServletInputStreamの新しい要件に合わせて更新されています。
つまり（ServletInputStreamの場合）、以下を実装する必要があります。
public abstract boolean isFinished();
public abstract boolean isReady();
public abstract void setReadListener(ReadListener var1);
これは編集されたLathyのオブジェクトです
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
public class RequestWrapper extends HttpServletRequestWrapper {
private String _body;
public RequestWrapper(HttpServletRequest request) throws IOException {
super(request);
_body = "";
BufferedReader bufferedReader = request.getReader();
String line;
while ((line = bufferedReader.readLine()) != null){
_body += line;
}
}
@Override
public ServletInputStream getInputStream() throws IOException {
CustomServletInputStream kid = new CustomServletInputStream(_body.getBytes());
return kid;
}
@Override
public BufferedReader getReader() throws IOException {
return new BufferedReader(new InputStreamReader(this.getInputStream()));
}
}
そしてどこか（??）私はこれを見つけました（これは「余分な」メソッドを扱うファーストクラスのクラスです。
import javax.servlet.ReadListener;
import javax.servlet.ServletInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
public class CustomServletInputStream extends ServletInputStream {
private byte[] myBytes;
private int lastIndexRetrieved = -1;
private ReadListener readListener = null;
public CustomServletInputStream(String s) {
try {
this.myBytes = s.getBytes("UTF-8");
} catch (UnsupportedEncodingException ex) {
throw new IllegalStateException("JVM did not support UTF-8", ex);
}
}
public CustomServletInputStream(byte[] inputBytes) {
this.myBytes = inputBytes;
}
@Override
public boolean isFinished() {
return (lastIndexRetrieved == myBytes.length - 1);
}
@Override
public boolean isReady() {
// This implementation will never block
// We also never need to call the readListener from this method, as this method will never return false
return isFinished();
}
@Override
public void setReadListener(ReadListener readListener) {
this.readListener = readListener;
if (!isFinished()) {
try {
readListener.onDataAvailable();
} catch (IOException e) {
readListener.onError(e);
}
} else {
try {
readListener.onAllDataRead();
} catch (IOException e) {
readListener.onError(e);
}
}
}
@Override
public int read() throws IOException {
int i;
if (!isFinished()) {
i = myBytes[lastIndexRetrieved + 1];
lastIndexRetrieved++;
if (isFinished() && (readListener != null)) {
try {
readListener.onAllDataRead();
} catch (IOException ex) {
readListener.onError(ex);
throw ex;
}
}
return i;
} else {
return -1;
}
}
};
最終的に、私はリクエストをログに記録しようとしていました。そして、上記のフランケンシュタインの作品は、私が以下を作成するのに役立ちました。
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.Principal;
import java.util.Enumeration;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.io.IOUtils;
//one or the other based on spring version
//import org.springframework.boot.autoconfigure.web.ErrorAttributes;
import org.springframework.boot.web.servlet.error.ErrorAttributes;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.ServletRequestAttributes;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.filter.OncePerRequestFilter;
/**
* A filter which logs web requests that lead to an error in the system.
*/
@Component
public class LogRequestFilter extends OncePerRequestFilter implements Ordered {
// I tried apache.commons and slf4g loggers. (one or the other in these next 2 lines of declaration */
//private final static org.apache.commons.logging.Log logger = org.apache.commons.logging.LogFactory.getLog(LogRequestFilter.class);
private static final org.slf4j.Logger logger = org.slf4j.LoggerFactory.getLogger(LogRequestFilter.class);
// put filter at the end of all other filters to make sure we are processing after all others
private int order = Ordered.LOWEST_PRECEDENCE - 8;
private ErrorAttributes errorAttributes;
@Override
public int getOrder() {
return order;
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
throws ServletException, IOException {
String temp = ""; /* for a breakpoint, remove for production/real code */
/* change to true for easy way to comment out this code, remove this if-check for production/real code */
if (false) {
filterChain.doFilter(request, response);
return;
}
/* make a "copy" to avoid issues with body-can-only-read-once issues */
RequestWrapper reqWrapper = new RequestWrapper(request);
int status = HttpStatus.INTERNAL_SERVER_ERROR.value();
// pass through filter chain to do the actual request handling
filterChain.doFilter(reqWrapper, response);
status = response.getStatus();
try {
Map<String, Object> traceMap = getTrace(reqWrapper, status);
// body can only be read after the actual request handling was done!
this.getBodyFromTheRequestCopy(reqWrapper, traceMap);
/* now do something with all the pieces of information gatherered */
this.logTrace(reqWrapper, traceMap);
} catch (Exception ex) {
logger.error("LogRequestFilter FAILED: " + ex.getMessage(), ex);
}
}
private void getBodyFromTheRequestCopy(RequestWrapper rw, Map<String, Object> trace) {
try {
if (rw != null) {
byte[] buf = IOUtils.toByteArray(rw.getInputStream());
//byte[] buf = rw.getInputStream();
if (buf.length > 0) {
String payloadSlimmed;
try {
String payload = new String(buf, 0, buf.length, rw.getCharacterEncoding());
payloadSlimmed = payload.trim().replaceAll(" +", " ");
} catch (UnsupportedEncodingException ex) {
payloadSlimmed = "[unknown]";
}
trace.put("body", payloadSlimmed);
}
}
} catch (IOException ioex) {
trace.put("body", "EXCEPTION: " + ioex.getMessage());
}
}
private void logTrace(HttpServletRequest request, Map<String, Object> trace) {
Object method = trace.get("method");
Object path = trace.get("path");
Object statusCode = trace.get("statusCode");
logger.info(String.format("%s %s produced an status code '%s'. Trace: '%s'", method, path, statusCode,
trace));
}
protected Map<String, Object> getTrace(HttpServletRequest request, int status) {
Throwable exception = (Throwable) request.getAttribute("javax.servlet.error.exception");
Principal principal = request.getUserPrincipal();
Map<String, Object> trace = new LinkedHashMap<String, Object>();
trace.put("method", request.getMethod());
trace.put("path", request.getRequestURI());
if (null != principal) {
trace.put("principal", principal.getName());
}
trace.put("query", request.getQueryString());
trace.put("statusCode", status);
Enumeration headerNames = request.getHeaderNames();
while (headerNames.hasMoreElements()) {
String key = (String) headerNames.nextElement();
String value = request.getHeader(key);
trace.put("header:" + key, value);
}
if (exception != null && this.errorAttributes != null) {
trace.put("error", this.errorAttributes
.getErrorAttributes((WebRequest) new ServletRequestAttributes(request), true));
}
return trace;
}
}
このコードを一粒の塩と一緒に取ってください。
最も重要な「テスト」は、POSTがペイロードで機能するかどうかです。これは、「二重読み取り」の問題を明らかにするものです。
疑似サンプルコード
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("myroute")
public class MyController {
@RequestMapping(method = RequestMethod.POST, produces = "application/json")
@ResponseBody
public String getSomethingExample(@RequestBody MyCustomObject input) {
String returnValue = "";
return returnValue;
}
}
テストしたいだけの場合は、「MyCustomObject」をプレーンなole「Object」に置き換えることができます。
この回答は、いくつかの異なるSOFの投稿と例から得られたものですが、すべてをまとめるのに時間がかかったので、将来の読者に役立つことを願っています。
私の前にラシーの答えに賛成してください。それがなければ、ここまで到達できなかったでしょう。
以下は、これを解決している間に私が得た例外の1つ/いくつかです。
getReader（）は、このリクエストに対してすでに呼び出されています
私が「借りた」場所のいくつかはここにあるように見えます：
http://slackspace.de/articles/log-request-body-with-spring-boot/
https://howtodoinjava.com/servlets/httpservletrequestwrapper-example-read-request-body/
https://www.oodlestechnologies.com/blogs/How-to-create-duplicate-object-of-httpServletRequest-object
Springには、これに対するサポートが組み込まれていAbstractRequestLoggingFilterます。
@Bean
public Filter loggingFilter(){
final AbstractRequestLoggingFilter filter = new AbstractRequestLoggingFilter() {
@Override
protected void beforeRequest(final HttpServletRequest request, final String message) {
}
@Override
protected void afterRequest(final HttpServletRequest request, final String message) {
}
};
filter.setIncludePayload(true);
filter.setIncludeQueryString(false);
filter.setMaxPayloadLength(1000000);
return filter;
}
残念ながら、リクエストから直接ペイロードを読み取ることはできませんが、Stringメッセージパラメータにはペイロードが含まれるため、次のようにそこからペイロードを取得できます。
String body = message.substring(message.indexOf("{"), message.lastIndexOf("]"));
getInputStream()私の場合、上書きするだけではうまくいきませんでした。私のサーバー実装は、このメソッドを呼び出さずにパラメーターを解析しているようです。他の方法は見つかりませんでしたが、4つすべてのgetParameter *メソッドも再実装しました。getParameterMap（使用されているApacheHttpクライアントとGoogleGuavaライブラリ）のコードは次のとおりです。
@Override
public Map<String, String[]> getParameterMap() {
Iterable<NameValuePair> params = URLEncodedUtils.parse(getQueryString(), NullUtils.UTF8);
try {
String cts = getContentType();
if (cts != null) {
ContentType ct = ContentType.parse(cts);
if (ct.getMimeType().equals(ContentType.APPLICATION_FORM_URLENCODED.getMimeType())) {
List<NameValuePair> postParams = URLEncodedUtils.parse(IOUtils.toString(getReader()), NullUtils.UTF8);
params = Iterables.concat(params, postParams);
}
}
} catch (IOException e) {
throw new IllegalStateException(e);
}
Map<String, String[]> result = toMap(params);
return result;
}
public static Map<String, String[]> toMap(Iterable<NameValuePair> body) {
Map<String, String[]> result = new LinkedHashMap<>();
for (NameValuePair e : body) {
String key = e.getName();
String value = e.getValue();
if (result.containsKey(key)) {
String[] newValue = ObjectArrays.concat(result.get(key), value);
result.remove(key);
result.put(key, newValue);
} else {
result.put(key, new String[] {value});
}
}
return result;
}
リクエストを制御できる場合は、コンテンツタイプをbinary / octet-streamに設定できます。これにより、入力ストリームを消費せずにパラメーターを照会できます。
ただし、これは一部のアプリケーションサーバーに固有の場合があります。私はTomcatのみをテストしましたが、桟橋はhttps://stackoverflow.com/a/11434646/957103に従って同じように動作するようです。
SpringクラスContentCachingRequestWrapperのメソッドgetContentAsByteArray（）は本体を複数回読み取りますが、同じクラスのメソッドgetInputStream（）とgetReader（）は本体を複数回読み取りません。
「このクラスは、InputStreamを使用してリクエストの本文をキャッシュします。いずれかのフィルターでInputStreamを読み取ると、フィルターチェーン内の他の後続のフィルターはそれを読み取ることができなくなります。この制限のため、このクラスはすべてに適しているわけではありません。状況。」
私の場合、この問題を解決したより一般的な解決策は、次の3つのクラスをSpringブートプロジェクト（およびpomファイルに必要な依存関係）に追加することでした。
CachedBodyHttpServletRequest.java：
public class CachedBodyHttpServletRequest extends HttpServletRequestWrapper {
private byte[] cachedBody;
public CachedBodyHttpServletRequest(HttpServletRequest request) throws IOException {
super(request);
InputStream requestInputStream = request.getInputStream();
this.cachedBody = StreamUtils.copyToByteArray(requestInputStream);
}
@Override
public ServletInputStream getInputStream() throws IOException {
return new CachedBodyServletInputStream(this.cachedBody);
}
@Override
public BufferedReader getReader() throws IOException {
// Create a reader from cachedContent
// and return it
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(this.cachedBody);
return new BufferedReader(new InputStreamReader(byteArrayInputStream));
}
}
CachedBodyServletInputStream.java：
public class CachedBodyServletInputStream extends ServletInputStream {
private InputStream cachedBodyInputStream;
public CachedBodyServletInputStream(byte[] cachedBody) {
this.cachedBodyInputStream = new ByteArrayInputStream(cachedBody);
}
@Override
public boolean isFinished() {
try {
return cachedBodyInputStream.available() == 0;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return false;
}
@Override
public boolean isReady() {
return true;
}
@Override
public void setReadListener(ReadListener readListener) {
throw new UnsupportedOperationException();
}
@Override
public int read() throws IOException {
return cachedBodyInputStream.read();
}
}
ContentCachingFilter.java：
@Order(value = Ordered.HIGHEST_PRECEDENCE)
@Component
@WebFilter(filterName = "ContentCachingFilter", urlPatterns = "/*")
public class ContentCachingFilter extends OncePerRequestFilter {
@Override
protected void doFilterInternal(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, FilterChain filterChain) throws ServletException, IOException {
System.out.println("IN ContentCachingFilter ");
CachedBodyHttpServletRequest cachedBodyHttpServletRequest = new CachedBodyHttpServletRequest(httpServletRequest);
filterChain.doFilter(cachedBodyHttpServletRequest, httpServletResponse);
}
}
また、次の依存関係をpomに追加しました。
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.0.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.10.0</version>
</dependency>
チュートリアルと完全なソースコードはここにあります：https：//www.baeldung.com/spring-reading-httpservletrequest-multiple-times
サーブレットフィルタチェーンを使用できますが、代わりに元のフィルタチェーンを使用して、yourownrequestsがHttpServletRequestWrapperを拡張する独自のリクエストを作成できます。
まず第一に、フィルター内のパラメーターを読み取るべきではありません。通常、ヘッダーはフィルターで読み取られ、いくつかの認証タスクを実行します。CharStreamsを使用すると、FilterまたはInterceptorでHttpRequest本体を完全に読み取ることができると言っています。
String body = com.google.common.io.CharStreams.toString(request.getReader());
これは、後続の読み取りにはまったく影響しません。
request.getReader()すると、以降の読み取りで空の文字列のみを含むリーダーが返されます。