我要评论前言
在 java 开发中，解析 json 是一个非常常见的需求。
不管是和前端交互、调用第三方接口，还是处理配置文件，几乎都绕不开 json。
这篇文章总结了6种主流的 json 解析方法，希望对你会有所帮助。
1. 使用 jackson：业界标配
功能特点
- 强大的序列化和反序列化：支持将 json 字符串转为 java 对象，也支持将 java 对象转换为 json。
- 支持复杂结构：处理嵌套对象、数组、泛型等场景非常轻松。
- 支持注解：如
@jsonignore、@jsonproperty等，能精细控制序列化与反序列化的行为。 - 性能高：jackson 的性能非常出色，是很多企业级项目的首选。
代码示例
1. json 转对象（反序列化）
import com.fasterxml.jackson.databind.objectmapper;
public class jacksonexample {
public static void main(string[] args) throws exception {
string json = "{"id":1,"name":"张三"}";
objectmapper objectmapper = new objectmapper();
user user = objectmapper.readvalue(json, user.class);
system.out.println(user.getname()); // 输出：张三
}
}
class user {
private int id;
private string name;
// getters 和 setters 省略
}
2. 对象转 json（序列化）
user user = new user();
user.setid(1);
user.setname("李四");
objectmapper objectmapper = new objectmapper();
string json = objectmapper.writevalueasstring(user);
system.out.println(json); // 输出：{"id":1,"name":"李四"}
高级功能
- 日期格式化：
@jsonformat(pattern = "yyyy-mm-dd") - 忽略字段：
@jsonignore - 重命名字段：
@jsonproperty("custom_name")
优缺点
| 优点 | 缺点 |
|---|---|
| 功能全面，支持复杂场景 | 配置较多，学习成本稍高 |
| 性能高，社区活跃，企业级项目首选 | 过于强大，部分功能用不上 |
| 丰富的注解支持，便于控制序列化行为 | 库体积较大，对于小型项目略显笨重 |
2. 使用 gson：轻量好用
功能特点
- 轻量级：gson 的设计非常简洁，代码量少，适合中小型项目。
- 支持泛型：可以轻松解析带泛型的 json。
- 注解控制：支持通过注解控制序列化行为，如
@expose。 - 易扩展：通过自定义序列化器和反序列化器，可以处理复杂的场景。
代码示例
1. json 转对象
import com.google.gson.gson;
public class gsonexample {
public static void main(string[] args) {
string json = "{"id":1,"name":"王五"}";
gson gson = new gson();
user user = gson.fromjson(json, user.class);
system.out.println(user.getname()); // 输出：王五
}
}
2. 对象转 json
user user = new user();
user.setid(2);
user.setname("赵六");
gson gson = new gson();
string json = gson.tojson(user);
system.out.println(json); // 输出：{"id":2,"name":"赵六"}
高级功能
忽略字段：@expose
@expose private string name;
自定义序列化器/反序列化器：
gson gson = new gsonbuilder()
.registertypeadapter(customclass.class, new customserializer())
.create();
优缺点
| 优点 | 缺点 |
|---|---|
| 轻量级，简单易用，适合中小型项目 | 性能稍逊于 jackson |
| 学习曲线平滑，新手容易上手 | 功能不如 jackson 丰富 |
| 提供良好的扩展能力 | 复杂对象处理起来较为麻烦 |
3. 使用 fastjson：高性能
功能特点
- 性能优异：fastjson 的解析速度非常快，适合大数据量场景。
- 支持动态字段：可以轻松处理动态 json 数据。
- 强大的类型支持：支持嵌套对象、泛型、数组等复杂结构。
- 注解控制：类似 jackson 和 gson，支持注解控制字段的序列化和反序列化。
代码示例
1. json 转对象
import com.alibaba.fastjson.json;
public class fastjsonexample {
public static void main(string[] args) {
string json = "{"id":1,"name":"小明"}";
user user = json.parseobject(json, user.class);
system.out.println(user.getname()); // 输出：小明
}
}
2. 对象转 json
user user = new user();
user.setid(3);
user.setname("小红");
string json = json.tojsonstring(user);
system.out.println(json); // 输出：{"id":3,"name":"小红"}
高级功能
自动驼峰转下划线：
json.deffault_date_format = "yyyy-mm-dd hh:mm:ss";
动态字段解析：
map<string, object> map = json.parseobject(json, map.class);
优缺点
| 优点 | 缺点 |
|---|---|
| 性能极高，解析速度快 | 曾有历史安全漏洞的争议 |
| 支持复杂的动态字段解析 | 社区活跃度稍逊于 jackson 和 gson |
| 功能全面，适合大规模数据处理场景 | 配置选项和 api 比较多，稍显复杂 |
4. 使用 jsonpath：快速提取嵌套字段
功能特点
- 高效字段提取：通过路径表达式（类似 xpath）快速提取嵌套字段。
- 灵活性强：支持动态字段和条件过滤。
- 轻量级：专注于字段提取，功能简单明确。
代码示例
import com.jayway.jsonpath.jsonpath;
public class jsonpathexample {
public static void main(string[] args) {
string json = """
{
"store": {
"book": [
{"title": "书1", "price": 10},
{"title": "书2", "price": 20}
]
}
}
""";
// 提取第一个书籍的标题
string title = jsonpath.read(json, "$.store.book[0].title");
system.out.println(title); // 输出：书1
// 提取所有书籍价格
list<integer> prices = jsonpath.read(json, "$.store.book[*].price");
system.out.println(prices); // 输出：[10, 20]
}
}
优缺点
| 优点 | 缺点 |
|---|---|
| 字段提取简洁高效 | 不支持序列化和反序列化 |
| 动态字段处理能力强 | 依赖 jsonpath 语法 |
| 适合快速提取嵌套字段 | 不适合全量 json 转换 |
5. 使用 org.json：轻量工具类
功能特点
- 轻量级：核心是一个工具类，适合简单场景。
- 构造和解析简单：适合快速创建 json 或提取字段。
- 灵活性一般：不支持复杂对象映射。
代码示例
import org.json.jsonobject;
public class orgjsonexample {
public static void main(string[] args) {
string json = "{"id":1,"name":"张三"}";
// 提取字段
jsonobject jsonobject = new jsonobject(json);
system.out.println(jsonobject.getstring("name")); // 输出：张三
// 构造 json
jsonobject newjson = new jsonobject();
newjson.put("id", 2);
newjson.put("name", "李四");
system.out.println(newjson.tostring()); // 输出：{"id":2,"name":"李四"}
}
}
优缺点
| 优点 | 缺点 |
|---|---|
| 轻量级，适合简单场景 | 不支持复杂嵌套对象 |
| 使用简单，学习成本低 | 功能简单，扩展性差 |
6. 手动解析 json：灵活度最高
功能特点
- 完全自由：不依赖第三方库，自己解析 json。
- 动态处理：适合不规则字段结构的 json。
- 代码复杂度高：适合特殊场景。
代码示例
import com.fasterxml.jackson.core.type.typereference;
import com.fasterxml.jackson.databind.objectmapper;
import java.util.map;
public class manualparsing {
public static void main(string[] args) throws exception {
string json = "{"id":1,"name":"动态字段"}";
objectmapper objectmapper = new objectmapper();
map<string, object> map = objectmapper.readvalue(json, new typereference<map<string, object>>() {});
system.out.println(map.get("name")); // 输出：动态字段
}
}
优缺点
| 优点 | 缺点 |
|---|---|
| 灵活性高，适合动态字段 | 代码复杂度高，不易维护 |
| 不依赖第三方库 | 性能和效率低于专业 json 库 |
总结
最后给大家对比一下文章中提到的6种方法各自的优缺点：
| 方法 | 适用场景 | 优点 | 缺点 |
|---|---|---|---|
| jackson | 企业级项目，复杂序列化和反序列化场景 | 功能强大，性能优异，支持复杂结构 | 配置复杂，学习曲线高 |
| gson | 中小型项目，简单的 json 转换场景 | 轻量级，简单易用 | 功能有限，性能略逊 |
| fastjson | 高性能需求，大数据量的动态解析 | 性能极高，功能丰富 | 曾有安全漏洞争议，社区支持稍逊 jackson |
| jsonpath | 嵌套结构复杂、动态字段提取场景 | 字段提取语法简单，灵活性强 | 不支持序列化和反序列化 |
| org.json | 快速解析或构造 json 场景 | 轻量级，适合简单场景 | 功能单一，扩展性差 |
| 手动解析 | 动态 json 或字段不固定的场景 | 自由度高，灵活性强 | 代码复杂，效率低于专业工具 |
工具千千万，场景最重要！
选对了工具，才能省时省力，少踩坑多摸鱼。
以上就是java解析json的六种方案的详细内容，更多关于java解析json的资料请关注代码网其它相关文章！
发表评论