Java JSON全解析6种主流方案深度对比与实战指南
作者：Tech_Jia_Hui
本文介绍了Java中六种主流的JSON解析库：Jackson、Gson、FastJSON、JsonPath、org.json和手动解析,每种库都有其适用的场景和特点,文章还提供了每种库的基础转换和高级功能的实战代码示例,感兴趣的朋友跟随小编一起看看吧
一、Jackson：企业级项目的“标配之选”
Jackson是Java生态中最主流的JSON解析库，Spring Boot默认集成Jackson作为内置解析工具，其强大的功能和优异的性能使其成为企业级项目的首选。
实战代码
1. 基础转换（对象与JSON互转）
import com.fasterxml.jackson.databind.ObjectMapper;
// 定义实体类
class User {
private Integer id;
private String name;
private String email;
// 必须提供无参构造函数（Jackson反射依赖）
public User() {}
// Getter和Setter省略
}
public class JacksonDemo {
public static void main(String[] args) throws Exception {
ObjectMapper objectMapper = new ObjectMapper();
String jsonStr = "{\"id\":1,\"name\":\"张三\",\"email\":\"zhangsan@example.com\"}";
// JSON转对象（反序列化）
User user = objectMapper.readValue(jsonStr, User.class);
System.out.println("反序列化结果：" + user.getName());
// 对象转JSON（序列化）
User newUser = new User();
newUser.setId(2);
newUser.setName("李四");
newUser.setEmail("lisi@example.com");
String newJsonStr = objectMapper.writeValueAsString(newUser);
System.out.println("序列化结果：" + newJsonStr);
}
}2. 高级功能（注解控制）
import com.fasterxml.jackson.annotation.*;
import java.util.Date;
class AdvancedUser {
@JsonProperty("user_id") // JSON字段名映射（解决驼峰与下划线冲突）
private Integer id;
@JsonIgnore // 序列化时忽略该字段
private String password;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") // 日期格式化
private Date createTime;
// Getter和Setter省略
}
// 序列化示例
AdvancedUser user = new AdvancedUser();
user.setId(3);
user.setPassword("123456");
user.setCreateTime(new Date());
String json = new ObjectMapper().writeValueAsString(user);
// 输出：{"user_id":3,"createTime":"2025-08-01 15:30:00"}适用场景
- 企业级应用、Spring Boot项目；
- 复杂对象转换、需要精细控制序列化行为的场景；
- 高并发、大数据量的JSON处理场景。
二、Gson：轻量级项目的“易用之选”
Gson是Google开源的JSON解析库，以简洁的API设计和极低的学习成本著称，适合中小型项目和快速开发场景。
实战代码
1. 基础转换
import com.google.gson.Gson;
import java.util.List;
public class GsonDemo {
public static void main(String[] args) {
Gson gson = new Gson();
String jsonStr = "{\"id\":1,\"name\":\"王五\",\"age\":25}";
// JSON转对象
User user = gson.fromJson(jsonStr, User.class);
System.out.println("反序列化结果：" + user.getAge());
// 对象转JSON
String newJsonStr = gson.toJson(user);
System.out.println("序列化结果：" + newJsonStr);
// 泛型对象转换（List为例）
String listJson = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";
List<User> userList = gson.fromJson(listJson, new com.google.gson.reflect.TypeToken<List<User>>() {}.getType());
System.out.println("List反序列化大小：" + userList.size());
}
}2. 高级功能（注解与自定义适配器）
import com.google.gson.annotations.Expose;
import com.google.gson.GsonBuilder;
class GsonUser {
@Expose(serialize = true, deserialize = true) // 序列化和反序列化都生效
private Integer id;
@Expose(serialize = false) // 仅反序列化，不序列化
private String tempField;
// Getter和Setter省略
}
// 自定义适配器（处理日期格式）
class DateAdapter implements com.google.gson.TypeAdapter<Date> {
private SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
@Override
public void write(com.google.gson.stream.JsonWriter out, Date value) throws IOException {
out.value(sdf.format(value));
}
@Override
public Date read(com.google.gson.stream.JsonReader in) throws IOException {
try {
return sdf.parse(in.nextString());
} catch (ParseException e) {
return null;
}
}
}
// 使用示例
Gson gson = new GsonBuilder()
.registerTypeAdapter(Date.class, new DateAdapter()) // 注册适配器
.excludeFieldsWithoutExposeAnnotation() // 只序列化带@Expose注解的字段
.create();适用场景
- 中小型项目、快速开发需求；
- 简单JSON转换场景（无复杂字段控制需求）；
- 对库体积敏感的场景（如移动端Java应用）。
三、FastJSON：高性能场景的“极速之选”
FastJSON是阿里巴巴开源的JSON解析库，以极致的解析速度闻名，适合大数据量、高并发场景的JSON处理。
实战代码
1. 基础转换
import com.alibaba.fastjson.JSON;
import java.util.List;
public class FastJsonDemo {
public static void main(String[] args) {
String jsonStr = "{\"id\":1,\"name\":\"赵六\",\"address\":\"北京\"}";
// JSON转对象
User user = JSON.parseObject(jsonStr, User.class);
System.out.println("反序列化结果：" + user.getAddress());
// 对象转JSON
String newJsonStr = JSON.toJSONString(user);
System.out.println("序列化结果：" + newJsonStr);
// JSON转List
String listJson = "[{\"id\":1,\"name\":\"张三\"},{\"id\":2,\"name\":\"李四\"}]";
List<User> userList = JSON.parseArray(listJson, User.class);
System.out.println("List反序列化大小：" + userList.size());
}
}2. 高级功能（动态字段与格式化）
import com.alibaba.fastjson.serializer.SerializerFeature;
// 动态字段解析（JSON转Map）
String dynamicJson = "{\"id\":1,\"name\":\"孙七\",\"score\":90.5}";
Map<String, Object> map = JSON.parseObject(dynamicJson, Map.class);
System.out.println("动态字段score：" + map.get("score"));
// 格式化输出（美化JSON）
User user = new User();
user.setId(2);
user.setName("周八");
String prettyJson = JSON.toJSONString(user, SerializerFeature.PrettyFormat);
System.out.println("美化后的JSON：" + prettyJson);
// 日期格式化
JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
String dateJson = JSON.toJSONString(new Date(), SerializerFeature.WriteDateUseDateFormat);
System.out.println("日期格式化结果：" + dateJson);适用场景
- 高并发、大数据量的JSON处理（如日志解析、批量数据同步）；
- 动态字段较多的场景（如第三方接口返回不固定字段）；
- 对解析速度有极致要求的场景。
四、JsonPath：嵌套JSON的“字段提取神器”
JsonPath是一款专注于JSON字段提取的工具，通过类似XPath的路径表达式，可快速从复杂嵌套JSON中提取目标字段，无需完整反序列化为Java对象。
实战代码
import com.jayway.jsonpath.JsonPath;
import java.util.List;
public class JsonPathDemo {
public static void main(String[] args) {
// 复杂嵌套JSON
String complexJson = """
{
"store": {
"book": [
{"title": "Java编程思想", "price": 108, "category": "编程"},
{"title": "深入理解Java虚拟机", "price": 89, "category": "编程"},
{"title": "三体", "price": 39, "category": "科幻"}
],
"address": {
"city": "北京",
"street": "科技园路"
}
}
}
""";
// 1. 提取单个字段（商店城市）
String city = JsonPath.read(complexJson, "$.store.address.city");
System.out.println("商店城市：" + city);
// 2. 提取数组所有元素的某个字段（所有书籍标题）
List<String> bookTitles = JsonPath.read(complexJson, "$.store.book[*].title");
System.out.println("所有书籍标题：" + bookTitles);
// 3. 条件过滤（价格大于80的书籍）
List<Object> expensiveBooks = JsonPath.read(complexJson, "$.store.book[?(@.price > 80)]");
System.out.println("价格大于80的书籍：" + expensiveBooks);
// 4. 提取数组指定索引元素（第一本书的价格）
Double firstBookPrice = JsonPath.read(complexJson, "$.store.book[0].price");
System.out.println("第一本书价格：" + firstBookPrice);
}
}适用场景
- 仅需提取JSON中部分字段（无需完整转换）；
- 复杂嵌套JSON的字段查询（如第三方接口返回的深层嵌套数据）；
- 动态筛选JSON数组中的元素。
五、org.json：简单场景的“轻量工具”
org.json是Java原生风格的JSON工具类，无需复杂依赖，仅提供基础的JSON构造和字段提取功能，适合简单场景的快速开发。
实战代码
import org.json.JSONArray;
import org.json.JSONObject;
public class OrgJsonDemo {
public static void main(String[] args) {
// 1. 解析JSON字符串
String jsonStr = "{\"id\":1,\"name\":\"吴九\",\"hobbies\":[\"篮球\",\"读书\"]}";
JSONObject jsonObject = new JSONObject(jsonStr);
// 提取字段
String name = jsonObject.getString("name");
JSONArray hobbies = jsonObject.getJSONArray("hobbies");
System.out.println("姓名：" + name + "，爱好：" + hobbies.get(0));
// 2. 构造JSON
JSONObject newJsonObject = new JSONObject();
newJsonObject.put("id", 2);
newJsonObject.put("name", "郑十");
newJsonObject.put("age", 30);
// 构造JSON数组
JSONArray skills = new JSONArray();
skills.put("Java");
skills.put("MySQL");
newJsonObject.put("skills", skills);
System.out.println("构造的JSON：" + newJsonObject.toString());
}
}适用场景
- 简单JSON的构造或字段提取（如配置文件读取）；
- 无需依赖第三方库的场景（如小型工具类、嵌入式应用）；
- 快速原型开发，无需复杂JSON处理功能。
六、手动解析：特殊场景的“灵活方案”
手动解析是指不依赖第三方库，通过字符串处理、正则表达式等方式解析JSON，灵活性最高，但开发成本和维护成本也最高。
实战代码（简单JSON手动解析）
import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class ManualParseDemo {
public static void main(String[] args) {
String jsonStr = "{\"id\":1,\"name\":\"手动解析\",\"value\":\"test\"}";
Map<String, String> resultMap = parseJson(jsonStr);
System.out.println("id：" + resultMap.get("id"));
System.out.println("name：" + resultMap.get("name"));
}
// 简单JSON手动解析（仅支持字符串和数字字段）
private static Map<String, String> parseJson(String json) {
Map<String, String> map = new HashMap<>();
// 正则表达式匹配 "key":"value" 或 "key":number
Pattern pattern = Pattern.compile("\"(.*?)\":\"?(.*?)\"?(,|})");
Matcher matcher = pattern.matcher(json.replaceAll("\\s+", "")); // 去除空格
while (matcher.find()) {
String key = matcher.group(1);
String value = matcher.group(2);
map.put(key, value);
}
return map;
}
}适用场景
- 非标准JSON数据（如字段无引号、格式不规则）；
- 对依赖库有严格限制的场景；
- 简单且固定格式的JSON，无需引入第三方库。
到此这篇关于Java JSON解析全攻略：6种主流方案深度对比与实战指南的文章就介绍到这了,更多相关Java JSON解析内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！