Jak Mogę Zip i rozpakować ciąg za pomocą gzipoutputstream, który jest kompatybilny with.Net?

Cokolwiek to było skompresowane "Hello" do BQAAAB+LC... jest szczególnie słabą implementacją gzipper. Rozszerzył "Hello" znacznie bardziej niż to konieczne, używając dynamicznego bloku zamiast statycznego bloku w formacie deflate. Po usunięciu czterobajtowego prefiksu do strumienia gzip (który zawsze zaczyna się od hex 1F 8b), "Hello" zostało rozszerzone do 123 bajtów. W świecie kompresji jest to uważane za przestępstwo.

Metoda kompresji, na którą narzekasz, działa prawidłowo i prawidłowo. Generuje statyczny blok o łącznej wartości 25 bajtów. Format gzip ma dziesięciobajtowy nagłówek i ośmiobajtowy zwiastun nad głową, pozostawiając pięciobajtowe wejście zakodowane w siedmiu bajtach. Tak lepiej.

Strumienie, które nie są ściśliwe, zostaną rozszerzone, ale nie powinno to być zbyt duże. Format deflate używany przez gzip doda pięć bajtów do każdego 16K do 64K dla niezrozumiałych danych.

Aby uzyskać rzeczywistą kompresję, ogólnie trzeba daj kompresorowi o wiele więcej do pracy z tymi pięcioma bajtami, aby mógł znaleźć powtarzające się ciągi i stronnicze statystyki w kompresowalnych danych. Rozumiem, że robiłaś tylko testy z krótkim sznurkiem. Ale w rzeczywistej aplikacji nigdy nie używałbyś kompresora ogólnego przeznaczenia z tak krótkimi ciągami, ponieważ zawsze lepiej byłoby po prostu wysłać ciąg.

W metodzie Decompress() pierwsze 4 bajty dekodowanego wejścia Base64 są pomijane przed przekazaniem do GZipInputStream. W tym konkretnym przypadku te bajty są 05 00 00 00. Tak więc w metodzie Compress() bajty te muszą być wstawione z powrotem tuż przed kodowaniem Base64.

Jeśli to zrobię, Compress() zwróci następujące polecenie:

BQAAAB+LCAAAAAAAAADLSM3JyQcAhqYQNgUAAAA=

Wiem, że to nie jest dokładnie to samo, co twoje oczekiwanie, czyli:

BQAAAB+LCAAAAAAABADtvQdgHEmWJSYvbcp7f0r1StfgdKEIgGATJNiQQBDswYjN5pLsHWlHIymrKoHKZVZlXWYWQMztnbz33nvvvffee++997o7nU4n99//P1xmZAFs9s5K2smeIYCqyB8/fnwfPyLmeVlW/w+GphA2BQAAAA==

Ale, jeśli mój wynik jest podłączony z powrotem do Decompress(), I myślę, że nadal dostaniesz "Hello". Spróbuj. Różnica może być spowodowana różnym poziomem kompresji, z którym otrzymałeś oryginalny ciąg.

Więc jakie są tajemnicze przedrostki bajtów 05 00 00 00? Zgodnie z ta odpowiedź może to być Długość skompresowanego ciągu znaków, tak aby program wiedział, jak długi powinien być dekompresowany bufor bajtowy. W tym przypadku jednak to się nie zgadza.

To jest zmodyfikowany kod dla compress ():

public static String Compress(String text) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    // TODO: Should be computed instead of being hard-coded
    baos.write(new byte[]{0x05, 0, 0, 0}, 0, 4);

    GZIPOutputStream gzos = new GZIPOutputStream(baos);
    gzos.write(text.getBytes());
    gzos.close();

    return Base64.encode(baos.toByteArray());
}

Aktualizacja:

Powodem, dla którego łańcuchy wyjściowe w Androidzie i kodzie.NET nie pasują, jest to, że implementacja. NET GZip wykonuje szybszą kompresję (a tym samym większą wydajność). Można to sprawdzić na pewno, patrząc na surowe wartości bajtów Base64:

. NET:

1F8B 0800 0000 0000 0400 EDBD 0760 1C49
9625 262F 6DCA 7B7F 4AF5 4AD7 E074 A108
8060 1324 D890 4010 ECC1 88CD E692 EC1D
6947 2329 AB2A 81CA 6556 655D 6616 40CC
ED9D BCF7 DE7B EFBD F7DE 7BEF BDF7 BA3B
9D4E 27F7 DFFF 3F5C 6664 016C F6CE 4ADA
C99E 2180 AAC8 1F3F 7E7C 1F3F 22E6 7959
56FF 0F86 A610 3605 0000 00

Moja wersja Androida:

1F8B 0800 0000 0000 0000 CB48 CDC9 C907
0086 A610 3605 0000 00

Teraz, jeśli sprawdzimy format pliku GZip , widzimy, że zarówno. NET, jak i Android wersje są w większości identyczne w początkowym nagłówku i końcowych polach CRC32 & Size. Jedyne różnice znajdują się w poniższych polach:

• XFL = 04 (kompresor zastosował najszybszy algorytm) w przypadku. NET, podczas gdy w Androidzie jest to 00
• rzeczywiste skompresowane bloki

Z pola XFL jasno wynika, że algorytm kompresji. NET generuje dłuższą wydajność.

W rzeczywistości, kiedy tworzymy plik binarny z tymi wartościami surowych danych, a następnie po rozpakowaniu ich za pomocą gunzip, zarówno wersja. Net, jak i Android dawały dokładnie to samo wyjście jako "hello".

Więc nie musisz się martwić o różne wyniki.

Wypróbowałem Twój kod w moim projekcie i znalazłem błąd kodowania w metodzie compress na Androida:

byte[] blockcopy = ByteBuffer
        .allocate(4)
        .order(java.nio.ByteOrder.LITTLE_ENDIAN)
        .putInt(str.length())
        .array();
ByteArrayOutputStream os = new ByteArrayOutputStream(str.length());
GZIPOutputStream gos = new GZIPOutputStream(os);
gos.write(str.getBytes());

W powyższym kodzie należy użyć poprawionego kodowania i wypełnić długość bajtów, a nie długość łańcucha:

byte[] data = str.getBytes("UTF-8");

byte[] blockcopy = ByteBuffer
        .allocate(4)
        .order(java.nio.ByteOrder.LITTLE_ENDIAN)
        .putInt(data.length)
            .array();

ByteArrayOutputStream os = new ByteArrayOutputStream( data.length );    
GZIPOutputStream gos = new GZIPOutputStream(os);
gos.write( data );

Zwariowałem z tym problemem. Na koniec, w moim przypadku (. Net 4) nie było konieczne dodawanie tych dodatkowych 4 bajtów na początku dla zgodności. Net.

To działa po prostu tak:

Android Compress:

public static byte[] compress(String string) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    byte[] compressed = os.toByteArray();
    os.close();
    return compressed;
}

. Net Decompress

public static byte[] DecompressViD(byte[] gzip)
    {
        // Create a GZIP stream with decompression mode.
        // ... Then create a buffer and write into while reading from the GZIP stream.
        using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
        {
            const int size = 4096;
            byte[] buffer = new byte[size];
            using (MemoryStream memory = new MemoryStream())
            {
                int count = 0;
                do
                {
                    count = stream.Read(buffer, 0, size);
                    if (count > 0)
                    {
                        memory.Write(buffer, 0, count);
                    }
                }
                while (count > 0);
                return memory.ToArray();
            }
        }
    }

Ok, nienawidzę dzwonienia, gdy jest mnóstwo istniejących odpowiedzi, ale niestety większość z nich jest po prostu zła z różnych powodów: {]}

• istnieją różnice między algorytmami GZIP w. NET Framework. Jeśli używasz.NET 4.5 większość skarg, które widzisz w różnych odpowiedziach, po prostu nie dotyczy ciebie (raczej tych, którzy używają 2.0 lub 3.5). Jeśli zdecydujesz się na "poprawione" wersje kodu, będziesz w stanie zepsuć kompresję/dekompresję.
• Java używa bajtów niepodpisanych[], . NET używa signed byte[]. Może to powodować problemy podczas transportu w zależności od tego, jak dokładnie transportujesz ten bajt[].
• użyłem Base64 do transportu bajtów [], co może wprowadzić jeszcze więcej problemów. Istnieje wiele innych powodów, ale pomińmy dalsze marudzenie i przejdźmy do kodu...

Jeśli używasz. NET Framework 4.5 oto Klasa C#, której potrzebujesz (Base64 jako bonus):

public class CompressString
{
    private static void CopyTo(Stream src, Stream dest)
    {
        byte[] bytes = new byte[4096];
        int cnt;

        while ((cnt = src.Read(bytes, 0, bytes.Length)) != 0)
        {
            dest.Write(bytes, 0, cnt);
        }
    }

    public static byte[] Zip(string str)
    {
        var bytes = Encoding.UTF8.GetBytes(str);

        using (var msi = new MemoryStream(bytes))
        using (var mso = new MemoryStream())
        {
            using (var gs = new GZipStream(mso, CompressionMode.Compress))
            {
                //msi.CopyTo(gs);
                CopyTo(msi, gs);
            }

            return mso.ToArray();
        }
    }

    public static string Unzip(byte[] bytes)
    {
        using (var msi = new MemoryStream(bytes))
        using (var mso = new MemoryStream())
        {
            using (var gs = new GZipStream(msi, CompressionMode.Decompress))
            {
                //gs.CopyTo(mso);
                CopyTo(gs, mso);
            }

            return Encoding.UTF8.GetString(mso.ToArray());
        }
    }

    // Base64
    public static string ZipBase64(string compress)
    {
        var bytes = Zip(compress);
        var encoded = Convert.ToBase64String(bytes, Base64FormattingOptions.None);
        return encoded;
    }

    public static string UnzipBase64(string compressRequest)
    {
        var bytes = Convert.FromBase64String(compressRequest);
        var unziped = Unzip(bytes);
        return unziped;
    }

    // Testing
    public static bool TestZip(String stringToTest)
    {
        byte[] compressed = Zip(stringToTest);
        Debug.WriteLine("Compressed to " + compressed.Length + " bytes");
        String decompressed = Unzip(compressed);
        Debug.WriteLine("Decompressed to: " + decompressed);

        return stringToTest == decompressed;
    }
}

A oto Klasa Android / Java, której potrzebujesz:

public class CompressString {
    public static byte[] compress(String string) {
        try {
            ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
            GZIPOutputStream gos = new GZIPOutputStream(os);
            gos.write(string.getBytes());
            gos.close();
            byte[] compressed = os.toByteArray();
            os.close();
            return compressed;
        } catch (IOException ex) {
            return null;
        }
    }

    public static String decompress(byte[] compressed) {
        try {
            final int BUFFER_SIZE = 32;
            ByteArrayInputStream is = new ByteArrayInputStream(compressed);
            GZIPInputStream gis = new GZIPInputStream(is, BUFFER_SIZE);
            StringBuilder string = new StringBuilder();
            byte[] data = new byte[BUFFER_SIZE];
            int bytesRead;
            while ((bytesRead = gis.read(data)) != -1) {
                string.append(new String(data, 0, bytesRead));
            }
            gis.close();
            is.close();
            return string.toString();
        } catch (IOException ex) {
            return null;
        }
    }    

    // Base64
    public static String compressBase64(String strToCompress) {
        byte[] compressed = compress(strToCompress);
        String encoded = android.util.Base64.encodeToString(compressed, android.util.Base64.NO_WRAP);
        return encoded;
    }

    public static String decompressBase64(String strEncoded) {
        byte[] decoded = android.util.Base64.decode(strEncoded, android.util.Base64.NO_WRAP);
        String decompressed = decompress(decoded);
        return decompressed;
    }


    // test
    public static boolean testCompression(String stringToTest) {
        byte[] compressed = compress(stringToTest);
        Log.d("compress-test", "Compressed to " + compressed.length + " bytes");
        String decompressed = decompress(compressed);
        Log.d("compress-test", "Decompressed to " + decompressed);

        return stringToTest == decompressed;
    }
}

Metoda Android decompress not ok

Android Compress - > OK:

public static byte[] compress(String string) throws IOException {
    ByteArrayOutputStream os = new ByteArrayOutputStream(string.length());
    GZIPOutputStream gos = new GZIPOutputStream(os);
    gos.write(string.getBytes());
    gos.close();
    byte[] compressed = os.toByteArray();
    os.close();
    return compressed;
}

. Net Decompress - > OK:

public static byte[] DecompressViD(byte[] gzip)
{
    // Create a GZIP stream with decompression mode.
    // ... Then create a buffer and write into while reading from the GZIP stream.
    using (GZipStream stream = new GZipStream(new MemoryStream(gzip), CompressionMode.Decompress))
    {
        const int size = 4096;
        byte[] buffer = new byte[size];
        using (MemoryStream memory = new MemoryStream())
        {
            int count = 0;
            do
            {
                count = stream.Read(buffer, 0, size);
                if (count > 0)
                {
                    memory.Write(buffer, 0, count);
                }
            }
            while (count > 0);
            return memory.ToArray();
        }
    }
}

. Net Compress - > OK:

    public static string compress(string text)
    {
        byte[] buffer = Encoding.UTF8.GetBytes(text);
        MemoryStream ms = new MemoryStream();
        using (GZipStream zip = new GZipStream(ms, CompressionMode.Compress, true))
        {
            zip.Write(buffer, 0, buffer.Length);
        }

        ms.Position = 0;
        MemoryStream outStream = new MemoryStream();

        byte[] compressed = new byte[ms.Length];
        ms.Read(compressed, 0, compressed.Length);

        return Convert.ToBase64String(compressed);
    }

Android Decompress - > Not OK:

public static String decompress(String zipText) throws IOException {
    byte[] compressed = Base64.decode(zipText);

    GZIPInputStream os = new GZIPInputStream(new ByteArrayInputStream(compressed));

    GZIPInputStream gzipInputStream = new GZIPInputStream(os);

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    for (int value = 0; value != -1;) {
        value = gzipInputStream.read();
        if (value != -1) {
            baos.write(value);
        }
    }
    gzipInputStream.close();
    baos.close();

    return new String(baos.toByteArray(), "UTF-8");
}

Oto prosty przykład na początek.

public static void main(String[] args) throws IOException 
{
    byte[] buffer = new byte[4096];
    StringBuilder sb = new StringBuilder();

    //read file to compress

    String read = readFile( "spanish.xml", Charset.defaultCharset());

    if( read != null )
    {
        //compress file to output

        FileOutputStream fos = new FileOutputStream("spanish-new.xml");
        GZIPOutputStream gzos = new GZIPOutputStream(fos);
        gzos.write( read.getBytes());
        gzos.close();

        //uncompress and read back

        FileInputStream fis = new FileInputStream("spanish-new.xml");
        GZIPInputStream gzis = new GZIPInputStream(fis);

        int bytes = 0;

        while ((bytes = gzis.read(buffer)) != -1) {
            sb.append( new String( buffer ) );
        }
    }
}

static String readFile(String path, Charset encoding) throws IOException {
    byte[] encoded = Files.readAllBytes(Paths.get(path));
    return new String(encoded, encoding);
}

I do it so in Vb.net:

  Public Function zipString(ByVal Text As String) As String
    Dim res As String = ""
    Try

        Dim buffer As Byte() = System.Text.Encoding.UTF8.GetBytes(Text)
        Dim ms As New MemoryStream()
        Using zipStream As New System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Compress, True)
            zipStream.Write(buffer, 0, buffer.Length)
        End Using
        ms.Position = 0
        Dim outStream As New MemoryStream()
        Dim compressed As Byte() = New Byte(ms.Length - 1) {}
        ms.Read(compressed, 0, compressed.Length)
        Dim gzBuffer As Byte() = New Byte(compressed.Length + 3) {}
        System.Buffer.BlockCopy(compressed, 0, gzBuffer, 4, compressed.Length)
        System.Buffer.BlockCopy(BitConverter.GetBytes(buffer.Length), 0, gzBuffer, 0, 4)
        res = Convert.ToBase64String(gzBuffer)
    Catch ex As Exception
        Log("mdl.zipString: " & ex.Message)
    End Try
    Return res
End Function

Public Function unzipString(ByVal compressedText As String) As String
    Dim res As String = ""
    Try
        Dim gzBuffer As Byte() = Convert.FromBase64String(compressedText)
        Using ms As New MemoryStream()
            Dim msgLength As Integer = BitConverter.ToInt32(gzBuffer, 0)
            ms.Write(gzBuffer, 4, gzBuffer.Length - 4)
            Dim buffer As Byte() = New Byte(msgLength - 1) {}
            ms.Position = 0
            Using zipStream As New System.IO.Compression.GZipStream(ms, System.IO.Compression.CompressionMode.Decompress)
                zipStream.Read(buffer, 0, buffer.Length)
            End Using
            res = System.Text.Encoding.UTF8.GetString(buffer, 0, buffer.Length)
        End Using
    Catch ex As Exception
        Log("mdl.unzipString: " & ex.Message)
    End Try
    Return res
End Function