Http Servlet demande de perdre params de corps POST après l'avoir lu une fois

Je sais je suis en retard, mais cette question est toujours d'actualité pour moi et ce de manière post a été un des grands succès dans Google. Je vais de l'avant et l'après ma solution dans l'espoir que quelqu'un d'autre peut sauver quelques heures.

Dans mon cas, j'ai besoin d'enregistrer toutes les requêtes et les réponses à leur corps. À l'aide de Spring Framework, la réponse est en fait assez simple, il suffit d'utiliser ContentCachingRequestWrapper et 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

        }

    }

}

Le seul moyen serait pour vous de consommer l'intégralité du flux d'entrée de vous-même dans le filtre, prenez ce que vous voulez d'elle, et puis créer un nouveau InputStream pour le contenu que vous lisez, et les mettre InputStream dans un ServletRequestWrapper (ou HttpServletRequestWrapper).

L'inconvénient est que vous aurez à analyser la charge utile de vous-même, la norme ne fait pas que de la capacité disponible pour vous.

Addenda --

Comme je l'ai dit, vous avez besoin de regarder HttpServletRequestWrapper.

Dans un filtre, vous continuez le long en appelant FilterChain.doFilter(request, response).

Trivial de filtres, de la demande et de la réponse sont les mêmes que ceux transmis au filtre. Qui n'a pas à être le cas. Vous pouvez les remplacer par celles de vos propres demandes et des réponses.

HttpServletRequestWrapper est spécialement conçu pour faciliter cela. Vous transmettre la demande d'origine, et puis vous pouvez intercepter tous les appels. Vous créer votre propre sous-classe de ce, et de remplacer la méthode getInputStream avec l'un de vos propres. Vous ne pouvez pas modifier le flux d'entrée de la demande initiale, de sorte qu'au lieu que vous avez ce wrapper et de retour de votre propre flux d'entrée.

Le cas le plus simple est de consommer les demandes initiales de flux d'entrée dans un tampon d'octets, de faire ce qui, de magie que vous voulez, puis créer un nouveau ByteArrayInputStream à partir de la mémoire tampon. C'est ce qui est retourné dans votre enveloppe, qui est passé à la FilterChain.méthode doFilter.

Vous aurez besoin à la sous-classe ServletInputStream et de faire un autre wrapper pour votre ByteArrayInputStream, mais ce n'est pas une grosse affaire soit.

C'est donc essentiellement Lathy de la réponse, MAIS mis à jour pour les nouvelles exigences pour ServletInputStream.

À savoir (pour ServletInputStream), on a à mettre en œuvre:

public abstract boolean isFinished();
public abstract boolean isReady();
public abstract void setReadListener(ReadListener var1);

C'est le édités Lathy l'objet

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()));
}
}

et quelque part (??) J'ai trouvé ce qui est une première classe de la classe et qui traite de la "extra" les méthodes.

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;
}
}
};

En fin de compte, j'essayais juste de le journal de la demande. Et la-dessus frankensteined ensemble des morceaux m'ont aidé à créer le ci-dessous.

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;
}
}

Veuillez prendre ce code avec un grain de sel.

Le PLUS important "test" est si un POSTE travaille avec une charge utile. C'est ce qui va exposer la "double lecture" questions de.

pseudo exemple de code

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;
}
}

Vous pouvez remplacer "MyCustomObject" avec ole plaine "Objet" si vous voulez juste tester.

Cette réponse est frankensteined de plusieurs forces d'opérations spéciales des postes et des exemples..mais il a fallu un certain temps pour tirer tous ensemble, donc j'espère que ça aide un futur lecteur.

Veuillez upvote Lathy réponse avant le mien. Je n'aurais pas pu arrivé jusqu'ici sans elle.

Ci-dessous est l'une ou plusieurs des exceptions que je suis tout en travaillant cela.

getReader() a déjà été appelée pour cette demande

Ressemble à certains des endroits que j'ai "emprunté" de sont ici:

http://slackspace.de/articles/log-request-body-with-spring-boot/

https://github.com/c0nscience/spring-web-logging/blob/master/src/main/java/org/zalando/springframework/web/logging/LoggingFilter.java

https://howtodoinjava.com/servlets/httpservletrequestwrapper-example-read-request-body/

https://www.oodlestechnologies.com/blogs/How-to-create-duplicate-object-of-httpServletRequest-object

https://github.com/c0nscience/spring-web-logging/blob/master/src/main/java/org/zalando/springframework/web/logging/LoggingFilter.java

Juste d'écraser des getInputStream() n'a pas fonctionné dans mon cas. Mon serveur de mise en œuvre semble pour analyser les paramètres sans appel de cette méthode. Je n'ai pas trouvé d'autre moyen, mais re-mettre en œuvre les quatre getParameter* méthodes. Voici le code de getParameterMap (Client Http Apache et Google Goyave bibliothèque utilisée):

@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;
}

La méthode getContentAsByteArray() du Ressort de la classe ContentCachingRequestWrapper lit le corps plusieurs fois, mais les méthodes getInputStream() et getReader (de la même classe, ne lisez pas le corps plusieurs fois:

"Cette classe met en cache le corps de la requête par la consommation de la InputStream. Si nous lisons la InputStream dans l'un des filtres, puis d'autres filtres dans le filtre de la chaîne ne peut pas lire plus. En raison de cette limitation, cette classe n'est pas adapté à toutes les situations."

Dans mon cas plus général de la solution qui a résolu ce problème a été d'ajouter à la suite de trois classes de mon Ressort de démarrage du projet (et les dépendances nécessaires à la pom fichier):

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);
}
}

J'ai également ajouté les dépendances suivantes pour 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>

Un tuturial et le code source complet est disponible ici:
https://www.baeldung.com/spring-reading-httpservletrequest-multiple-times

vous pouvez utiliser le filtre de servlet de la chaîne, mais au lieu d'utiliser celui d'origine, vous pouvez créer votre propre demande yourownrequests s'étend HttpServletRequestWrapper.