Comment vérifier si l'InputStream est Gzippé ?

Question

Existe-t-il un moyen de vérifier si l'InputStream a été gzippé ? Voici le code :

public static InputStream decompressStream(InputStream input) {
    try {
        GZIPInputStream gs = new GZIPInputStream(input);
        return gs;
    } catch (IOException e) {
        logger.info("Input stream not in the GZIP format, using standard format");
        return input;
    }
}

J'ai essayé de cette façon mais cela ne fonctionne pas comme prévu - les valeurs lues à partir du flux sont invalides. EDITION : J'ai ajouté la méthode que j'utilise pour compresser les données :

public static byte[] compress(byte[] content) {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    try {
        GZIPOutputStream gs = new GZIPOutputStream(baos);
        gs.write(content);
        gs.close();
    } catch (IOException e) {
        logger.error("Fatal error occured while compressing data");
        throw new RuntimeException(e);
    }
    double ratio = (1.0f * content.length / baos.size());
    if (ratio > 1) {
        logger.info("Compression ratio equals " + ratio);
        return baos.toByteArray();
    }
    logger.info("Compression not needed");
    return content;

}

Answer 1

Ce n'est pas infaillible, mais c'est probablement le plus simple et il ne repose sur aucune donnée externe. Comme tous les formats décents, GZip commence aussi par un nombre magique qui peut être vérifié rapidement sans avoir à lire tout le flux.

public static InputStream decompressStream(InputStream input) {
     PushbackInputStream pb = new PushbackInputStream( input, 2 ); //we need a pushbackstream to look ahead
     byte [] signature = new byte[2];
     int len = pb.read( signature ); //read the signature
     pb.unread( signature, 0, len ); //push back the signature to the stream
     if( signature[ 0 ] == (byte) 0x1f && signature[ 1 ] == (byte) 0x8b ) //check if matches standard gzip magic number
       return new GZIPInputStream( pb );
     else 
       return pb;
}

(Source du chiffre magique : Spécification du format de fichier GZip )

Mise à jour : Je viens de découvrir qu'il existe également une constante appelée GZIP_MAGIC sur GZipInputStream qui contient cette valeur, donc si vous vraiment si vous le souhaitez, vous pouvez utiliser les deux octets inférieurs.

Answer 2

L'InputStream provient de HttpURLConnection#getInputStream()

Dans ce cas, vous devez vérifier si HTTP Content-Encoding l'en-tête de réponse est égal à gzip .

URLConnection connection = url.openConnection();
InputStream input = connection.getInputStream();

if ("gzip".equals(connection.getContentEncoding())) {
    input = new GZIPInputStream(input);
}

// ...

Tout ceci est clairement spécifié dans Spécification HTTP .

---

Mise à jour En ce qui concerne la façon dont vous avez compressé la source du flux, ce contrôle du ratio est assez... insensé. Débarrassez-vous-en. La même longueur ne signifie pas nécessairement que les octets sont les mêmes. Laissez-le toujours retourner le flux gzippé afin que vous puissiez toujours s'attend à un flux gzippé et applique simplement GZIPInputStream sans contrôles méchants.

Answer 3

J'ai trouvé ceci exemple utile qui fournit une implémentation propre de isCompressed() :

/*
 * Determines if a byte array is compressed. The java.util.zip GZip
 * implementation does not expose the GZip header so it is difficult to determine
 * if a string is compressed.
 * 
 * @param bytes an array of bytes
 * @return true if the array is compressed or false otherwise
 * @throws java.io.IOException if the byte array couldn't be read
 */
 public boolean isCompressed(byte[] bytes)
 {
      if ((bytes == null) || (bytes.length < 2))
      {
           return false;
      }
      else
      {
            return ((bytes[0] == (byte) (GZIPInputStream.GZIP_MAGIC)) && (bytes[1] == (byte) (GZIPInputStream.GZIP_MAGIC >> 8)));
      }
 }

Je l'ai testé avec succès :

@Test
public void testIsCompressed() {
    assertFalse(util.isCompressed(originalBytes));
    assertTrue(util.isCompressed(compressed));
}

Answer 4

Je pense que c'est le moyen le plus simple de vérifier si un tableau d'octets est formaté par gzip ou non, il ne dépend d'aucune entité HTTP ou du support de type mime.

public static boolean isGzipStream(byte[] bytes) {
      int head = ((int) bytes[0] & 0xff) | ((bytes[1] << 8) & 0xff00);
      return (GZIPInputStream.GZIP_MAGIC == head);
}

Answer 5

Ce n'est pas exactement ce que vous demandez mais cela pourrait être une approche alternative si vous utilisez HttpClient :

private static InputStream getInputStream(HttpEntity entity) throws IOException {
  Header encoding = entity.getContentEncoding(); 
  if (encoding != null) {
     if (encoding.getValue().equals("gzip") || encoding.getValue().equals("zip") ||      encoding.getValue().equals("application/x-gzip-compressed")) {
        return new GZIPInputStream(entity.getContent());
     }
  }
  return entity.getContent();
}