Android应用与Go后端数据传输中的数据压缩策略

package main

import (
    "bytes"
    "compress/gzip"
    "fmt"
    "io/ioutil"
    "log"
)

// CompressDataWithGzip 使用Gzip压缩字节数组
func CompressDataWithGzip(data []byte) ([]byte, error) {
    var b bytes.Buffer
    gzWriter := gzip.NewWriter(&b)
    _, err := gzWriter.Write(data)
    if err != nil {
        return nil, fmt.Errorf("写入数据失败: %w", err)
    }
    err = gzWriter.Close() // 必须关闭Writer以刷新所有待处理的压缩数据
    if err != nil {
        return nil, fmt.Errorf("关闭Gzip writer失败: %w", err)
    }
    return b.Bytes(), nil
}

func main() {
    originalData := []byte("这是一个需要被压缩的文本数据，它包含一些重复的模式，适合Gzip压缩。")
    fmt.Printf("原始数据大小: %d 字节\n", len(originalData))

    compressedData, err := CompressDataWithGzip(originalData)
    if err != nil {
        log.Fatalf("压缩数据失败: %v", err)
    }
    fmt.Printf("压缩后数据大小: %d 字节\n", len(compressedData))

    // 在实际应用中，compressedData 会通过网络发送到Android客户端
    // 例如：http.ResponseWriter.Write(compressedData)
}

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.zip.GZIPInputStream;

public class GzipDecompressor {

    /**
     * 使用Gzip解压缩字节数组
     * @param compressedData 接收到的压缩数据
     * @return 解压缩后的原始数据
     * @throws IOException 如果解压缩过程中发生I/O错误
     */
    public static byte[] decompress(byte[] compressedData) throws IOException {
        if (compressedData == null || compressedData.length == 0) {
            return new byte[0];
        }

        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        GZIPInputStream gis = null;
        try {
            gis = new GZIPInputStream(new ByteArrayInputStream(compressedData));
            byte[] buffer = new byte[1024]; // 缓冲区大小
            int len;
            while ((len = gis.read(buffer)) != -1) {
                bos.write(buffer, 0, len);
            }
        } finally {
            // 确保流被关闭，防止资源泄露
            if (gis != null) {
                try {
                    gis.close();
                } catch (IOException e) {
                    // 记录关闭流时的错误，但不影响主逻辑
                    System.err.println("关闭GZIPInputStream失败: " + e.getMessage());
                }
            }
            try {
                bos.close();
            } catch (IOException e) {
                System.err.println("关闭ByteArrayOutputStream失败: " + e.getMessage());
            }
        }
        return bos.toByteArray();
    }

    public static void main(String[] args) {
        // 假设这是从服务器接收到的Gzip压缩数据
        // byte[] receivedCompressedData = ...;

        // 模拟一个压缩数据（实际中会通过网络接收）
        String originalString = "这是一个需要被压缩的文本数据，它包含一些重复的模式，适合Gzip压缩。";
        byte[] simulatedCompressedData = null;
        try {
            // 模拟Go服务器端的压缩过程来获取模拟的压缩数据
            // 实际应用中，客户端直接接收服务器发送的compressedData
            java.io.ByteArrayOutputStream byteOut = new java.io.ByteArrayOutputStream();
            java.util.zip.GZIPOutputStream gzipOut = new java.util.zip.GZIPOutputStream(byteOut);
            gzipOut.write(originalString.getBytes("UTF-8"));
            gzipOut.close();
            simulatedCompressedData = byteOut.toByteArray();
            System.out.println("模拟压缩数据大小: " + simulatedCompressedData.length + " 字节");

            // 客户端解压缩
            byte[] decompressedData = decompress(simulatedCompressedData);
            String decompressedString = new String(decompressedData, "UTF-8");
            System.out.println("解压缩后数据: " + decompressedString);
            System.out.println("解压缩成功: " + originalString.equals(decompressedString));

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}