Come decodificare Gzip corpo della richiesta compresso in Spring MVC

Question

Ho un cliente che invia i dati con

CONTENT-ENCODING deflate 

devo codice come questo

@RequestMapping(value = "/connect", method = RequestMethod.POST) 
@ResponseBody 
public Map onConnect(@RequestBody String body){} 

Attualmente 'corpo' stampa il confuso, compressa dati. C'è un modo per far sì che Spring MVC lo comprima automaticamente?

Answer 1

Non lo gestisci in primavera. Invece si utilizza un filtro in modo che i dati arrivino in primavera già sgonfiati.

Speriamo che questi due collegamenti possano iniziare.

• http://www.javablog.fr/javaweb-gzip-compression-protocol-http-filter-gzipresponsewrapper-gzipresponsewrapper.html
• http://srlawr.blogspot.com/2011/09/creating-custom-filter-in-spring.html

Answer 2

questo dovrebbe essere gestito dal server, non l'applicazione.

Per quanto ne so, Tomcat non lo supporta, anche se potresti probabilmente scrivere un filtro.

Un modo comune per gestire ciò consiste nel mettere Tomcat (o qualsiasi altro contenitore Java che si sta utilizzando) dietro un server Apache configurato per gestire corpi di richieste compressi.

Answer 3

Avrai bisogno di scrivere il tuo filtro per decomprimere il corpo di richieste gzip. Sine leggerai l'intero flusso di input da richiesta, è necessario sovrascrivere anche il metodo di parsing dei parametri. Questo è il filtro che sto usando nel mio codice. Supporta solo richieste POST con gzip, ma è possibile aggiornarlo per utilizzare altri tipi di richieste, se necessario. attenti anche per analizzare i parametri che sto usando biblioteca guava, si può afferrare la vostra da qui: http://central.maven.org/maven2/com/google/guava/guava/

public class GzipBodyDecompressFilter extends Filter { 

@Override 
public void init(FilterConfig filterConfig) throws ServletException { 

} 
/** 
* Analyzes servlet request for possible gzipped body. 
* When Content-Encoding header has "gzip" value and request method is POST we read all the 
* gzipped stream and is it haz any data unzip it. In case when gzip Content-Encoding header 
* specified but body is not actually in gzip format we will throw ZipException. 
* 
* @param servletRequest servlet request 
* @param servletResponse servlet response 
* @param chain   filter chain 
* @throws IOException  throws when fails 
* @throws ServletException thrown when fails 
*/ 
@Override 
public final void doFilter(final ServletRequest servletRequest, 
          final ServletResponse servletResponse, 
          final FilterChain chain) throws IOException, ServletException { 
    HttpServletRequest request = (HttpServletRequest) servletRequest; 
    HttpServletResponse response = (HttpServletResponse) servletResponse; 
    boolean isGzipped = request.getHeader(HttpHeaders.CONTENT_ENCODING) != null 
      && request.getHeader(HttpHeaders.CONTENT_ENCODING).contains("gzip"); 
    boolean requestTypeSupported = HttpMethods.POST.equals(request.getMethod()); 
    if (isGzipped && !requestTypeSupported) { 
     throw new IllegalStateException(request.getMethod() 
       + " is not supports gzipped body of parameters." 
       + " Only POST requests are currently supported."); 
    } 
    if (isGzipped && requestTypeSupported) { 
     request = new GzippedInputStreamWrapper((HttpServletRequest) servletRequest); 
    } 
    chain.doFilter(request, response); 

} 

/** 
* @inheritDoc 
*/ 
@Override 
public final void destroy() { 
} 

/** 
* Wrapper class that detects if the request is gzipped and ungzipps it. 
*/ 
final class GzippedInputStreamWrapper extends HttpServletRequestWrapper { 
    /** 
    * Default encoding that is used when post parameters are parsed. 
    */ 
    public static final String DEFAULT_ENCODING = "ISO-8859-1"; 

    /** 
    * Serialized bytes array that is a result of unzipping gzipped body. 
    */ 
    private byte[] bytes; 

    /** 
    * Constructs a request object wrapping the given request. 
    * In case if Content-Encoding contains "gzip" we wrap the input stream into byte array 
    * to original input stream has nothing in it but hew wrapped input stream always returns 
    * reproducible ungzipped input stream. 
    * 
    * @param request request which input stream will be wrapped. 
    * @throws java.io.IOException when input stream reqtieval failed. 
    */ 
    public GzippedInputStreamWrapper(final HttpServletRequest request) throws IOException { 
     super(request); 
     try { 
      final InputStream in = new GZIPInputStream(request.getInputStream()); 
      bytes = ByteStreams.toByteArray(in); 
     } catch (EOFException e) { 
      bytes = new byte[0]; 
     } 
    } 


    /** 
    * @return reproduceable input stream that is either equal to initial servlet input 
    * stream(if it was not zipped) or returns unzipped input stream. 
    * @throws IOException if fails. 
    */ 
    @Override 
    public ServletInputStream getInputStream() throws IOException { 
     final ByteArrayInputStream sourceStream = new ByteArrayInputStream(bytes); 
     return new ServletInputStream() { 
      public int read() throws IOException { 
       return sourceStream.read(); 
      } 

      public void close() throws IOException { 
       super.close(); 
       sourceStream.close(); 
      } 
     }; 
    } 

    /** 
    * Need to override getParametersMap because we initially read the whole input stream and 
    * servlet container won't have access to the input stream data. 
    * 
    * @return parsed parameters list. Parameters get parsed only when Content-Type 
    * "application/x-www-form-urlencoded" is set. 
    */ 
    @Override 
    public Map getParameterMap() { 
     String contentEncodingHeader = getHeader(HttpHeaders.CONTENT_TYPE); 
     if (!Strings.isNullOrEmpty(contentEncodingHeader) 
       && contentEncodingHeader.contains("application/x-www-form-urlencoded")) { 
      Map params = new HashMap(super.getParameterMap()); 
      try { 
       params.putAll(parseParams(new String(bytes))); 
      } catch (UnsupportedEncodingException e) { 
       e.printStackTrace(); 
      } 
      return params; 
     } else { 
      return super.getParameterMap(); 
     } 
    } 

    /** 
    * parses params from the byte input stream. 
    * 
    * @param body request body serialized to string. 
    * @return parsed parameters map. 
    * @throws UnsupportedEncodingException if encoding provided is not supported. 
    */ 
    private Map<String, String[]> parseParams(final String body) 
      throws UnsupportedEncodingException { 
     String characterEncoding = getCharacterEncoding(); 
     if (null == characterEncoding) { 
      characterEncoding = DEFAULT_ENCODING; 
     } 
     final Multimap<String, String> parameters = ArrayListMultimap.create(); 
     for (String pair : body.split("&")) { 
      if (Strings.isNullOrEmpty(pair)) { 
       continue; 
      } 
      int idx = pair.indexOf("="); 

      String key = null; 
      if (idx > 0) { 
       key = URLDecoder.decode(pair.substring(0, idx), characterEncoding); 
      } else { 
       key = pair; 
      } 
      String value = null; 
      if (idx > 0 && pair.length() > idx + 1) { 
       value = URLDecoder.decode(pair.substring(idx + 1), characterEncoding); 
      } else { 
       value = null; 
      } 
      parameters.put(key, value); 
     } 
     return Maps.transformValues(parameters.asMap(), 
       new Function<Collection<String>, String[]>() { 
        @Nullable 
        @Override 
        public String[] apply(final Collection<String> input) { 
         return Iterables.toArray(input, String.class); 
        } 
       }); 
    } 
} 

}