json压缩与解压

一、概述

在现代应用开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式被广泛使用。然而，在网络传输或者数据存储的过程中，如何有效地压缩和解压JSON数据，是很多开发者需要解决的问题。

部分数据如下所示：

{
  "33828": {
    "code": "33828",
    "name": "萤",
    "order": "7298",
    "strokeSum": "11"
  },
  "22920": {
    "code": "22920",
    "name": "妈",
    "order": "1051",
    "strokeSum": "6"
  },
  "20718": {
    "code": "20718",
    "name": "僮",
    "order": "13341",
    "strokeSum": "14"
  },
  "30615": {
    "code": "30615",
    "name": "瞗",
    "order": "15845",
    "strokeSum": "16"
  },
  "36969": {
    "code": "36969",
    "name": "適",
    "order": "13506",
    "strokeSum": "14"
  }
}

二、常规压缩json

2.1 去除冗余字符（单行压缩）

将JSON压缩成一行，去掉换行和空格字符后的json文件大小为：1.39Mb，只之前的2.13Mb小了整整0.74Mb，这个在移动端是很可观的优化！

2.2 缩短键名（减少重复冗余）

json是key-value结构，如果定义好规范，则可以将key尽量缩短，甚至是无意义的字母，但前提是文档一定要写清楚，避免不必要的麻烦。

比如之前的key-value结构如下所示：

{
  "33828": {
    "code": "33828",
    "name": "萤",
    "order": "7298",
    "strokeSum": "11"
  },
  "22920": {
    "code": "22920",
    "name": "妈",
    "order": "1051",
    "strokeSum": "6"
  },
  "20718": {
    "code": "20718",
    "name": "僮",
    "order": "13341",
    "strokeSum": "14"
  },
  "30615": {
    "code": "30615",
    "name": "瞗",
    "order": "15845",
    "strokeSum": "16"
  },
  "36969": {
    "code": "36969",
    "name": "適",
    "order": "13506",
    "strokeSum": "14"
  }
}

现在我们将key进行优化，使用

c 代替 code
n 代替 name
o 代替 order
s 代替 strokeSum

将JSON的key进行缩短优化后的json文件大小为：1.77Mb，只之前的2.13Mb小了整整0.36Mb，这个在移动端是很可观的优化！

然后再将缩短key之后的文件，压缩成一行，去掉换行和空格字符。再看一看文件大小为1.04Mb，比最开始的原始数据2.13Mb小了整整1.09Mb！

当然这样key的名字变化了，对应解析Json的java实体bean也要修改一下。

因为我使用的是jackson来进行json解析的，所以使用注解@JsonProperty来表示一下修改的json文件对应原来的java bean里面的属性，这样解析的时候就不会出错了。

2.3 常规总结

经过上面的常规操作，我们的json文件大小减少到了1.04Mb，比最开始的原始数据2.13Mb，小了整整1.09Mb，

压缩率为51.174%，压缩后体积为原来的48.826%

已经算很给力了，但是这个json文件还是有1.04Mb啊，是否还可以进行压缩呢？答案是肯定的。

三、常用压缩算法

3.1 Deflater与Inflater

Deflater是同时使用了LZ77算法与哈夫曼编码的一个无损数据压缩算法。

我们可以使用java提供的Deflater和Inflater类对json进行压缩和解压缩，下面是工具类

import android.support.annotation.Nullable;
import android.util.Base64;

import java.io.ByteArrayOutputStream;
import java.util.zip.DataFormatException;
import java.util.zip.Deflater;
import java.util.zip.Inflater;

/**
 * DeflaterUtils 压缩字符串
 */
public class DeflaterUtils {
    /**
     * 压缩
     * 
     * Deflater 压缩等级：0 ~ 9 压缩等级 低到高
     * public static final int BEST_COMPRESSION = 9;     最佳压缩的压缩级别。
     * public static final int BEST_SPEED = 1;           压缩级别最快的压缩。
     * public static final int DEFAULT_COMPRESSION = -1; 默认压缩级别。
     * public static final int DEFAULT_STRATEGY = 0;     默认压缩策略。
     * public static final int DEFLATED = 8;             压缩算法的压缩方法(目前唯一支持的压缩方法)。
     * public static final int FILTERED = 1;             压缩策略最适用于大部分数值较小且数据分布随机分布的数据。
     * public static final int FULL_FLUSH = 3;           压缩刷新模式，用于清除所有待处理的输出并重置拆卸器。
     * public static final int HUFFMAN_ONLY = 2;         仅用于霍夫曼编码的压缩策略。
     * public static final int NO_COMPRESSION = 0;       不压缩的压缩级别。
     * public static final int NO_FLUSH = 0;             用于实现最佳压缩结果的压缩刷新模式。
     * public static final int SYNC_FLUSH = 2;  用于清除所有未决输出的压缩刷新模式;可能会降低某些压缩算法的压缩率。
     */
    public static String zipString(String unzipString) {
        //使用指定的压缩级别创建一个新的压缩器。
        Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
        //设置压缩输入数据。
        deflater.setInput(unzipString.getBytes());
        //当被调用时，表示压缩应该以输入缓冲区的当前内容结束。
        deflater.finish();

        final byte[] bytes = new byte[256];
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(256);

        while (!deflater.finished()) {
            //压缩输入数据并用压缩数据填充指定的缓冲区。
            int length = deflater.deflate(bytes);
            if (length == 0) {
                break;
            }
            outputStream.write(bytes, 0, length);
        }
        try {
            outputStream.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        //关闭压缩器并丢弃任何未处理的输入。
        deflater.end();
        return Base64.encodeToString(outputStream.toByteArray(), Base64.NO_PADDING);
    }

    /**
     * 解压缩
     */
    @Nullable
    public static String unzipString(String zipString) {
        byte[] decode = Base64.decode(zipString, Base64.NO_PADDING);
        //创建一个新的解压缩器
        Inflater inflater = new Inflater();
        //设置解压缩的输入数据。
        inflater.setInput(decode);

        final byte[] bytes = new byte[256];
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(256);
        try {
            //finished() 如果已到达压缩数据流的末尾，则返回true。
            while (!inflater.finished()) {
                //将字节解压缩到指定的缓冲区中。
                int length = inflater.inflate(bytes);
                outputStream.write(bytes, 0, length);
            }
        } catch (DataFormatException e) {
            e.printStackTrace();
            return null;
        } finally {
            //关闭解压缩器并丢弃任何未处理的输入。
            inflater.end();
        }
        return outputStream.toString();
    }
}

3.1.1 压缩json

然后我们先将原始的stroke.json数据压缩成deFlaterStrokeJson.json。

//原始文件   stroke.json
String strokeJson = LocalFileUtils.getStringFormAsset(context, "stroke.json");
mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
// 使用 Deflater  加密
String deFlaterStrokeJson = DeflaterUtils.zipString(strokeJson);
writeFile(deFlaterStrokeJson,"deFlaterStrokeJson.json");

其中writeFile方法是写入到sdcard的方法。

private static void writeFile(String mapperJson, String fileName) {
    Writer write = null;
    try {
        File file = new File(Environment.getExternalStorageDirectory(), fileName);
        Log.d(TAG, "file.exists():" + file.exists() + " file.getAbsolutePath():" + file.getAbsolutePath());
        // 如果父目录不存在，创建父目录
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        // 如果已存在,删除旧文件
        if (file.exists()) {
            file.delete();
        }
        file.createNewFile();
        // 将格式化后的字符串写入文件
        write = new OutputStreamWriter(new FileOutputStream(file), "UTF-8");
        write.write(mapperJson);
        write.flush();
        write.close();
    } catch (Exception e) {
        Log.e(TAG, "e = " + Log.getStackTraceString(e));
    } finally {
        if (write != null){
            try {
                write.close();
            } catch (IOException e) {
                Log.e(TAG, "e = " + Log.getStackTraceString(e));
            }
        }
    }
}

运行完毕之后，将sdcard中的deFlaterStrokeJson.json导出来，放到assets目录下，以备后续解析使用。

使用Deflater压缩json，压缩后大小为 387KB，比上一次的1067KB，又少了很多很多。

经过Deflater压缩和Base64编码之后的deFlaterStrokeJson.json文件，如下所示：

3.1.2 解压json

关压缩还不行，我们得使用压缩后的json文件数据啊，因此我们还需要将压缩后的json数据进行解压，操作如下所示：

//使用 Inflater 解密
String deFlaterStrokeJson = LocalFileUtils.getStringFormAsset(context, "deFlaterStrokeJson.json");
String strokeJson = DeflaterUtils.unzipString(deFlaterStrokeJson);
mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);

解压之后运行一切正常！完美！

3.1.3 小结

经过上面的常规操作，我们的json文件大小减少到了387KB，比刚才未使用压缩算法的原始数据1067KB，小了整整680KB，

压缩率为63.73%，压缩后体积为原来的36.27%

优化步骤	体积
1.未处理的原始json	2.13MB
2.将JSON压缩成一行，去掉换行和空格字符	1.39MB
3.将JSON的key进行缩短	1.04MB
4.使用Deflater压缩json,Base64编码	0.38MB

3.2 Gzip

在我封装的http库里面，有对请求json数据进行Gzip压缩，对服务器返回的json数据进行Gzip解压。这里也来试一下Gzip压缩json。

编写一个Gzip压缩解压并使用Base64进行编码工具类

import android.text.TextUtils;
import android.util.Base64;
import android.util.Log;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.nio.charset.Charset;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;

/**
 * Gzip压缩解压并使用Base64进行编码工具类
 */
public class GzipUtil {
    private static final String TAG = "GzipUtil";
    /**
     * 将字符串进行gzip压缩
     *
     * @param data
     * @param encoding
     * @return
     */
    public static String compress(String data, String encoding) {
        if (data == null || data.length() == 0) {
            return null;
        }
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        GZIPOutputStream gzip;
        try {
            gzip = new GZIPOutputStream(out);
            gzip.write(data.getBytes(encoding));
            gzip.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return Base64.encodeToString(out.toByteArray(), Base64.NO_PADDING);
    }

    public static String uncompress(String data, String encoding) {
        if (TextUtils.isEmpty(data)) {
            return null;
        }
        byte[] decode = Base64.decode(data, Base64.NO_PADDING);
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        ByteArrayInputStream in = new ByteArrayInputStream(decode);
        GZIPInputStream gzipStream = null;
        try {
            gzipStream = new GZIPInputStream(in);
            byte[] buffer = new byte[256];
            int n;
            while ((n = gzipStream.read(buffer)) >= 0) {
                out.write(buffer, 0, n);
            }
        } catch (IOException e) {
            Log.e(TAG, "e = " + Log.getStackTraceString(e));
        } finally {
            try {
                out.close();
                if (gzipStream != null) {
                    gzipStream.close();
                }
            } catch (IOException e) {
                Log.e(TAG, "e = " + Log.getStackTraceString(e));
            }
        }
        return new String(out.toByteArray(), Charset.forName(encoding));
    }
}

3.2.1 压缩json

//原始文件   stroke.json
String strokeJson = LocalFileUtils.getStringFormAsset(context, "stroke.json");
mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);
// 使用 GZIP  压缩
String gzipStrokeJson = GzipUtil.compress(strokeJson,CHARSET_NAME);
writeFile(gzipStrokeJson,"gzipStrokeJson.json");

运行完毕之后，将sdcard中的gzipStrokeJson.json导出来，放到assets目录下，以备后续解析使用。

导出来的gzipStrokeJson.json文件为405kb，没有比刚才使用Deflater压缩json后大小为387KB优秀！

3.2.2 解压json

关压缩还不行，我们得使用压缩后的json文件数据啊，因此我们还需要将压缩后的json数据进行解压，操作如下所示：

//使用 GZIP 解压
String gzipStrokeJson = LocalFileUtils.getStringFormAsset(context, "gzipStrokeJson.json");
String strokeJson = GzipUtil.uncompress(gzipStrokeJson,CHARSET_NAME);
mapper = JSONUtil.toCollection(strokeJson, HashMap.class, String.class, Stroke.class);

解压之后，json解析一切正常！

3.2.3 小结

经过上面的常规操作，我们的json文件大小减少到了405kb，虽然比不上刚才的Deflater压缩：387KB，但是比刚才未使用压缩算法的原始数据1067KB，小了整整662KB，

压缩率为62.04%，压缩后体积为原来的37.95%，也是不错的！

四、其他压缩算法

除了上面的算法之外，我们还可以使用很多其他的压缩算法，进一步压缩json的体积。我们的原始json中还是有很多重复的key值可以进行优化的，下面的算法中有部分可以进行key优化！

常见的json压缩算法有CJSON与HPack，其原理都是将key和value进行抽离，节省掉部分的重复的key值造成的空间消耗。

4.1 CJSON

CJSON的压缩算法，主要是将资料抽离成Template与Value,节省掉重复的"Key值".

原始JSON：

[{
  "x": 100,
  "y": 100
}, {
  "x": 100,
  "y": 100,
  "width": 200,
  "height": 150
}, {}]

CJSON压缩后：

{
  "templates": [
    [0, "x", "y"],
    [1, "width", "height"]
  ],
  "values": [{
    "values": [1, 100, 100]
  }, {
    "values": [2, 100, 100, 200, 150]
  }, {}]
}

4.2 HPack

HPack的压缩算法，也是将Key, Value抽离，阵列中第一个值，就是HPack的Template，后面依序就是Value。

[{
  "name": "Andrea",
  "age": 31,
  "gender": "Male",
  "skilled": true
}, {
  "name": "Eva",
  "age": 27,
  "gender": "Female",
  "skilled": true
}, {
  "name": "Daniele",
  "age": 26,
  "gender": "Male",
  "skilled": false
}]

压缩之后的数据

[
  ["name", "age", "gender", "skilled"],
  ["Andrea", 31, "Male", true],
  ["Eva", 27, "Female", true],
  ["Daniele", 26, "Male", false]
]

两种方法都是主要讲json的键抽出来统一建成索引，只是最后的格式不同。

HPack简化后的格式比CJSON少了许多字符，所以HPack的压缩效率比较高。数据量越大，效果越明显，应用场景也更加有意义。

如果JSON内容太少，CJSON的资料可能反而会比较多。

更多参考：https://www.oschina.net/p/jsonhpack

五、JSON的替代品

虽然JSON是一种通用的数据交换格式，但由于其在某些情况下的性能限制，开发者开始探索更快的替代格式。我们来看以下其中的一些替代方案。

5.1 协议缓冲区(protobuf)

协议缓冲区（通常称为protobuf）是谷歌开发的一种二进制序列化格式。其设计宗旨是高效、紧凑和快速。Protobuf的二进制特性使其在序列化和反序列化时比JSON快得多。

何时使用：当你需要高性能数据交换时，尤其是在微服务架构、物联网应用或网络带宽有限的情况下，请考虑使用 protobuf。

5.2 MessagePack信息包

MessagePack是另一种二进制序列化格式，以速度快、结构紧凑而著称。其设计目的是在保持与各种编程语言兼容的同时，提高比JSON更高的效率。

何时使用：当你需要在速度和跨语言兼容性之间取得平衡时，MessagePack是一个不错的选择。它适用于实时应用程序和对减少数据量有重要要求的情况。

5.3 BSON(二进制JSON)

BSON或二进制JSON是一种从JSON衍生出来的二进制编码格式。它保留了JSON的灵活性，同时通过二进制编码提高了性能。BSON常用于MongoDB等数据库。

何时使用：如果你正在使用MongoDB，或者需要一种能在JSON和二进制效率之间架起桥梁的格式，那么BSON就是一个很有价值的选择。

5.4 Apache Avro

Apache Avro是一个数据序列化框架，专注于提供一种紧凑的二进制格式。它基于模式，可实现高效的数据编码和解码。

何时使用：Avro适用于模式演进非常重要的情况，如数据存储，以及需要在速度和数据结构灵活性之间取得平衡的情况。

与JSON相比，这些替代方案在性能上有不同程度的提升，具体选择取决于您的具体使用情况。通过考虑这些替代方案，您可以优化应用程序的数据交换流程，确保将速度和效率放在开发工作的首位。

六、总结与推荐方案

基础优化优先：所有场景均建议先执行“键名缩短 + 单行压缩”，无额外开发成本却能缩减50%体积。
本地存储推荐：优先选择Deflater算法，以387KB的极致压缩率节省存储和本地读取时间。
网络传输推荐：优先选择Gzip算法，兼顾压缩率与兼容性，可直接与HTTP协议的Gzip压缩对接。
海量重复键名推荐：HPack算法，压缩效率最优，适合JSON数组类数据的大规模传输。

posted @ 2025-12-03 17:38 夏尔_717 阅读(0) 评论(0) 收藏举报

刷新页面返回顶部

ciel_717

json压缩与解压

一、概述

二、常规压缩json

2.1 去除冗余字符（单行压缩）

2.2 缩短键名（减少重复冗余）

2.3 常规总结

三、常用压缩算法

3.1 Deflater与Inflater

3.1.1 压缩json

3.1.2 解压json

3.1.3 小结

3.2 Gzip

3.2.1 压缩json

3.2.2 解压json

3.2.3 小结

四、其他压缩算法

4.1 CJSON

4.2 HPack

五、JSON的替代品

5.1 协议缓冲区(protobuf)

5.2 MessagePack信息包

5.3 BSON(二进制JSON)

5.4 Apache Avro

六、总结与推荐方案

公告

ciel_717

json压缩与解压

一、概述

二、常规压缩json

2.1 去除冗余字符（单行压缩）

2.2 缩短键名（减少重复冗余）

2.3 常规总结

三、常用压缩算法

3.1 Deflater与Inflater

3.1.1 压缩json

3.1.2 解压json

3.1.3 小结

3.2 Gzip

3.2.1 压缩json

3.2.2 解压json

3.2.3 小结

四、 其他压缩算法

4.1 CJSON

4.2 HPack

五、JSON的替代品

5.1 协议缓冲区(protobuf)

5.2 MessagePack信息包

5.3 BSON(二进制JSON)

5.4 Apache Avro

六、总结与推荐方案

公告

四、其他压缩算法